refactor: massive atcute migration

package.json

···
 		"fmt": "prettier --cache --write ."
 	},
 	"dependencies": {
-		"@atcute/bluemoji": "^2.0.0",
-		"@atcute/bluesky": "^2.1.1",
+		"@atcute/atproto": "^3.1.0",
+		"@atcute/bluemoji": "^3.1.0",
+		"@atcute/bluesky": "^3.1.0",
 		"@atcute/bluesky-richtext-parser": "^1.0.7",
 		"@atcute/bluesky-richtext-segmenter": "^2.0.3",
 		"@atcute/bluesky-search-parser": "^0.1.0",
 		"@atcute/cbor": "^2.2.4",
 		"@atcute/cid": "^2.2.3",
-		"@atcute/client": "^3.1.0",
+		"@atcute/client": "^4.0.3",
+		"@atcute/lexicons": "^1.0.4",
 		"@atcute/oauth-browser-client": "^1.0.25",
 		"@atcute/tid": "^1.0.2",
 		"@atlaskit/pragmatic-drag-and-drop": "1.6.0",
 		"@atlaskit/pragmatic-drag-and-drop-hitbox": "1.0.3",
 		"@floating-ui/dom": "^1.7.0",
 		"@floating-ui/utils": "^0.2.9",
+		"@kelinci/basa-lexicons": "^1.0.0",
 		"@mary/array-fns": "jsr:^0.1.4",
 		"@mary/async-iterator-fns": "jsr:^0.1.1",
 		"@mary/batch-fetch": "jsr:^0.1.0",
···
 		"vite": "^6.3.5",
 		"vite-plugin-pwa": "0.21.0",
 		"vite-plugin-solid": "^2.11.6",
-		"wrangler": "^4.17.0"
+		"wrangler": "^4.18.0"
 	},
 	"pnpm": {
 		"patchedDependencies": {

pnpm-lock.yaml

···
 
   .:
     dependencies:
+      '@atcute/atproto':
+        specifier: ^3.1.0
+        version: 3.1.0
       '@atcute/bluemoji':
-        specifier: ^2.0.0
-        version: 2.0.0(@atcute/bluesky@2.1.1(@atcute/client@3.1.0))(@atcute/client@3.1.0)
+        specifier: ^3.1.0
+        version: 3.1.0
       '@atcute/bluesky':
-        specifier: ^2.1.1
-        version: 2.1.1(@atcute/client@3.1.0)
+        specifier: ^3.1.0
+        version: 3.1.0
       '@atcute/bluesky-richtext-parser':
         specifier: ^1.0.7
         version: 1.0.7
···
         specifier: ^2.2.3
         version: 2.2.3
       '@atcute/client':
-        specifier: ^3.1.0
-        version: 3.1.0
+        specifier: ^4.0.3
+        version: 4.0.3
+      '@atcute/lexicons':
+        specifier: ^1.0.4
+        version: 1.0.4
       '@atcute/oauth-browser-client':
         specifier: ^1.0.25
         version: 1.0.25
···
       '@floating-ui/utils':
         specifier: ^0.2.9
         version: 0.2.9(patch_hash=1cf283fbaa686f96f7b3029bbc0955bff698af6f4a75ba6c276ad1a7a7c40aea)
+      '@kelinci/basa-lexicons':
+        specifier: ^1.0.0
+        version: 1.0.0
       '@mary/array-fns':
         specifier: jsr:^0.1.4
         version: '@jsr/mary__array-fns@0.1.4'
···
         version: 0.1.15
       autoprefixer:
         specifier: ^10.4.21
-        version: 10.4.21(postcss@8.5.3)
+        version: 10.4.21(postcss@8.5.4)
       babel-plugin-transform-typescript-const-enums:
         specifier: ^0.1.0
         version: 0.1.0(@babel/core@7.27.3)
···
         specifier: ^2.11.6
         version: 2.11.6(solid-js@1.9.7(patch_hash=9cf3f9930aa2f8d4e60502a75153adf9468eb53b42f69e86cac05dfaea3f82e7))(vite@6.3.5(jiti@1.21.7)(terser@5.40.0)(yaml@2.8.0))
       wrangler:
-        specifier: ^4.17.0
-        version: 4.17.0
+        specifier: ^4.18.0
+        version: 4.18.0
 
 packages:
 
···
     peerDependencies:
       ajv: '>=8'
 
-  '@atcute/atproto@3.0.3':
-    resolution: {integrity: sha512-pJOTvviq816o0uAG3JquVNmCPph67p30+0UU4XDoJIChPAwtXMT5SW3sjNpWYh3sfwayhSCiBRBOAgKsUHR+xg==}
+  '@atcute/atproto@3.1.0':
+    resolution: {integrity: sha512-aJbDsY7FcIh8APWKAimBtshPwqoRE056tc0UV6vw4TW4e3nYaHedoJmKhlh/k8KQWxyw64MQThNGMaC89HNoTg==}
 
-  '@atcute/bluemoji@2.0.0':
-    resolution: {integrity: sha512-tgcsW4H50oWo6uHMkUVU2IgObfX63mYp/qxWfoLkKPFWbwz68SiwedaCY/E+Cw8anWGF0urFjDemmga7B5Z0QA==}
-    peerDependencies:
-      '@atcute/bluesky': ^2.0.0
-      '@atcute/client': ^3.0.0
+  '@atcute/bluemoji@3.1.0':
+    resolution: {integrity: sha512-8EfcEDrXlStvu57WVcGSeDWfbEDKTjfI43rk+oohe2sdYU113ObTe8Pv1vW0DRfOYcQqR4+eF2SbpvXE6//24g==}
 
   '@atcute/bluesky-richtext-parser@1.0.7':
     resolution: {integrity: sha512-nOvU699OXiGMbyswao7JJnY0C9WkwE7PVC/m5WWt0UN9fsXSOor9IZWw+v9SATp+94BTJoG38XyUomUaJnoQRA==}
···
   '@atcute/bluesky-search-parser@0.1.0':
     resolution: {integrity: sha512-bTClwD9VGwaECOyWe1mf8V6t+7/77e3tiUHTE6CSrHXOJ/yM8N2xbn+dIi2ki2JLHvgvBN9wsWpFLykgfWhBaw==}
 
-  '@atcute/bluesky@2.1.1':
-    resolution: {integrity: sha512-wEZfFW58J6yC1SqHcVJOn4qbHENTTzjeCEWthRT5HvKovADLqk54HSMSAuXDMBUbintSTBr0khQNZQ3ZdgzDdQ==}
-    peerDependencies:
-      '@atcute/client': ^3.0.0
-
-  '@atcute/bluesky@3.0.4':
-    resolution: {integrity: sha512-GiadvV6HVkBKRGMuWU3EjMq+EfOEf7YJXArthu7XlQIXVYuJDwVqGldxAlPgUkOrAW3PMc/fANrFhatbQRR4cg==}
+  '@atcute/bluesky@3.1.0':
+    resolution: {integrity: sha512-i5ABWnRpw+YsMyUz9jkkrbN0m3Fz8qLy4nIMPs4IoSKgO/UjmZFvfIkabXUOUHcnHPgph2yViXA1buzTR0RNWQ==}
 
   '@atcute/cbor@2.2.4':
     resolution: {integrity: sha512-8Y/OTM8zs5VInOCjfx4f9Idiiz7ygM/FkfWv/HW3/ZUsXczn1xk7GzTBbm4P5crn4C5luwDGpO7FwClMOERrow==}
 
   '@atcute/cid@2.2.3':
     resolution: {integrity: sha512-WEzNSL1EuCVtCQDFYEBIm4dEP6PcMEwi8IYUVIWvT77eO5EjY58F63z5T4qMABxSBM0+L4kqMxypdL1Fzf6LZw==}
-
-  '@atcute/client@3.1.0':
-    resolution: {integrity: sha512-+rQPsHXSf0DUm8XoHoaH7Y2E8tIpbsW84djyPj7dqAyrFIjvGuJ1X1DvMufwbTIcmLerdy+dzl34iZcz/h3Vhg==}
 
   '@atcute/client@4.0.3':
     resolution: {integrity: sha512-RIOZWFVLca/HiPAAUDqQPOdOreCxTbL5cb+WUf5yqQOKIu5yEAP3eksinmlLmgIrlr5qVOE7brazUUzaskFCfw==}
···
       workerd:
         optional: true
 
-  '@cloudflare/workerd-darwin-64@1.20250523.0':
-    resolution: {integrity: sha512-/K7vKkPDx9idJ7hJtqYXYsKkHX9XQ6awyDyBZ4RwbaQ/o3fyS/tgHaej2rUO6zkb7CfUxiaeAB7Z6i7KltMY5Q==}
+  '@cloudflare/workerd-darwin-64@1.20250525.0':
+    resolution: {integrity: sha512-L5l+7sSJJT2+riR5rS3Q3PKNNySPjWfRIeaNGMVRi1dPO6QPi4lwuxfRUFNoeUdilZJUVPfSZvTtj9RedsKznQ==}
     engines: {node: '>=16'}
     cpu: [x64]
     os: [darwin]
 
-  '@cloudflare/workerd-darwin-arm64@1.20250523.0':
-    resolution: {integrity: sha512-tVQqStt245KzkrCT6DBXoMNHaJgh/8hQy3fsG+4gHfqw/JdKEgXigkc9hWdC6BoS5DiGK+dGVJo2MnWHFC7XlQ==}
+  '@cloudflare/workerd-darwin-arm64@1.20250525.0':
+    resolution: {integrity: sha512-Y3IbIdrF/vJWh/WBvshwcSyUh175VAiLRW7963S1dXChrZ1N5wuKGQm9xY69cIGVtitpMJWWW3jLq7J/Xxwm0Q==}
     engines: {node: '>=16'}
     cpu: [arm64]
     os: [darwin]
 
-  '@cloudflare/workerd-linux-64@1.20250523.0':
-    resolution: {integrity: sha512-PCPWBlwiKr9Es2TP93JVygXRPwx+AkygUMV2gFOPerVrdXUd13A4dJ68Qjpmh3O0xqmVIRV6PSogM3wNvwnw5Q==}
+  '@cloudflare/workerd-linux-64@1.20250525.0':
+    resolution: {integrity: sha512-KSyQPAby+c6cpENoO0ayCQlY6QIh28l/+QID7VC1SLXfiNHy+hPNsH1vVBTST6CilHVAQSsy9tCZ9O9XECB8yg==}
     engines: {node: '>=16'}
     cpu: [x64]
     os: [linux]
 
-  '@cloudflare/workerd-linux-arm64@1.20250523.0':
-    resolution: {integrity: sha512-uKa/L9W1AzT+yE0wNxFZPlMXms5xmGaaOmTAK0wuLPW6qmKj1zyBidjHqQXVZ+eK/fLy3CNeyB9EBtR0/8FH7A==}
+  '@cloudflare/workerd-linux-arm64@1.20250525.0':
+    resolution: {integrity: sha512-Nt0FUxS2kQhJUea4hMCNPaetkrAFDhPnNX/ntwcqVlGgnGt75iaAhupWJbU0GB+gIWlKeuClUUnDZqKbicoKyg==}
     engines: {node: '>=16'}
     cpu: [arm64]
     os: [linux]
 
-  '@cloudflare/workerd-windows-64@1.20250523.0':
-    resolution: {integrity: sha512-H5ggClWrskRs7pj2Fd+iJpjFMrh7DZqAfhJT3IloTW85lCEY2+y/yfXEGyDsc0UTLuTS0znldcUrVCRjSiSOkw==}
+  '@cloudflare/workerd-windows-64@1.20250525.0':
+    resolution: {integrity: sha512-mwTj+9f3uIa4NEXR1cOa82PjLa6dbrb3J+KCVJFYIaq7e63VxEzOchCXS4tublT2pmOhmFqkgBMXrxozxNkR2Q==}
     engines: {node: '>=16'}
     cpu: [x64]
     os: [win32]
···
   '@jsr/mary__exif-rm@0.2.2':
     resolution: {integrity: sha512-+ZpLaC+1CyqWhH608Sqd6/yTG0pOlokn2tCXha7s1SMQ+GLKo4Nn/PskTeeP9Pt+6gNYSu6ednoSlRvXb2ZGxg==, tarball: https://npm.jsr.io/~/11/@jsr/mary__exif-rm/0.2.2.tgz}
 
+  '@kelinci/basa-lexicons@1.0.0':
+    resolution: {integrity: sha512-QND0ktwpGySoHhqRUrLZ3YybyHnOkV6mGCLn75yJWl9PpKIMh/gmAyvXIo1ZuzSHu4v6xcSyi3A78QoH4MhTGw==}
+
   '@nodelib/fs.scandir@2.1.5':
     resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
     engines: {node: '>= 8'}
···
     resolution: {integrity: sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==}
     engines: {node: '>=8'}
 
-  browserslist@4.24.5:
-    resolution: {integrity: sha512-FDToo4Wo82hIdgc1CQ+NQD0hEhmpPjrZ3hiUgwgOG6IuTdlpr8jdjyG24P6cNP1yJpTLzS5OcGgSw0xmDU1/Tw==}
+  browserslist@4.25.0:
+    resolution: {integrity: sha512-PJ8gYKeS5e/whHBh8xrwYK+dAvEj7JXtz6uTucnMRB8OiGTsKccFekoRrjajPBHV8oOY+2tI4uxeceSimKwMFA==}
     engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
     hasBin: true
 
···
     resolution: {integrity: sha512-QOSvevhslijgYwRx6Rv7zKdMF8lbRmx+uQGx2+vDc+KI/eBnsy9kit5aj23AgGu3pa4t9AgwbnXWqS+iOY+2aA==}
     engines: {node: '>= 6'}
 
-  caniuse-lite@1.0.30001718:
-    resolution: {integrity: sha512-AflseV1ahcSunK53NfEs9gFWgOEmzr0f+kaMFA4xiLZlr9Hzt7HxcSpIFcnNCUkz6R6dWKa54rUz3HUmI3nVcw==}
+  caniuse-lite@1.0.30001720:
+    resolution: {integrity: sha512-Ec/2yV2nNPwb4DnTANEV99ZWwm3ZWfdlfkQbWSDDt+PsXEVYwlhPH8tdMaPunYTKKmz7AnHi2oNEi1GcmKCD8g==}
 
   chalk@4.1.2:
     resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==}
···
     engines: {node: '>=0.10.0'}
     hasBin: true
 
-  electron-to-chromium@1.5.159:
-    resolution: {integrity: sha512-CEvHptWAMV5p6GJ0Lq8aheyvVbfzVrv5mmidu1D3pidoVNkB3tTBsTMVtPJ+rzRK5oV229mCLz9Zj/hNvU8GBA==}
+  electron-to-chromium@1.5.161:
+    resolution: {integrity: sha512-hwtetwfKNZo/UlwHIVBlKZVdy7o8bIZxxKs0Mv/ROPiQQQmDgdm5a+KvKtBsxM8ZjFzTaCeLoodZ8jiBE3o9rA==}
 
   emoji-regex@8.0.0:
     resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==}
···
     engines: {node: '>=10.0.0'}
     hasBin: true
 
-  miniflare@4.20250523.0:
-    resolution: {integrity: sha512-g4F1AC5xi66rB2eQNo2Fx7EffaXhMdgUSRl/ivgb4LMALMpxghG98oC4twqVwDLWIFSVFjtL1YEuYrPO8044mg==}
+  miniflare@4.20250525.0:
+    resolution: {integrity: sha512-F5XRDn9WqxUaHphUT8qwy5WXC/3UwbBRJTdjjP5uwHX82vypxIlHNyHziZnplPLhQa1kbSdIY7wfuP1XJyyYZw==}
     engines: {node: '>=18.0.0'}
     hasBin: true
 
···
   postcss-value-parser@4.2.0:
     resolution: {integrity: sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==}
 
-  postcss@8.5.3:
-    resolution: {integrity: sha512-dle9A3yYxlBSrt8Fu+IpjGT8SY8hN0mlaA6GY8t0P5PjIOZemULz/E2Bnm/2dcUOena75OTNkHI76uZBNUUq3A==}
+  postcss@8.5.4:
+    resolution: {integrity: sha512-QSa9EBe+uwlGTFmHsPKokv3B/oEMQZxfqW0QqNCyhpa6mB1afzulwn8hihglqAb2pOw+BJgNlmXQ8la2VeHB7w==}
     engines: {node: ^10 || ^12 || >=14}
 
   prettier-plugin-tailwindcss@0.6.11:
···
   workbox-window@7.3.0:
     resolution: {integrity: sha512-qW8PDy16OV1UBaUNGlTVcepzrlzyzNW/ZJvFQQs2j2TzGsg6IKjcpZC1RSquqQnTOafl5pCj5bGfAHlCjOOjdA==}
 
-  workerd@1.20250523.0:
-    resolution: {integrity: sha512-OClsq9ZzZZNdkY8/JTBjf+/A6F1q/SOn3/RQWCR0kDoclxecHS6Nq80jY6NP0ubJBKnqrUggA9WOWBgwWWOGUA==}
+  workerd@1.20250525.0:
+    resolution: {integrity: sha512-SXJgLREy/Aqw2J71Oah0Pbu+SShbqbTExjVQyRBTM1r7MG7fS5NUlknhnt6sikjA/t4cO09Bi8OJqHdTkrcnYQ==}
     engines: {node: '>=16'}
     hasBin: true
 
-  wrangler@4.17.0:
-    resolution: {integrity: sha512-FIOriw2Z7aNALAtnt4hTojDuU44n8pGJl62id0ig0s45Mej/Clg07vpmz+QCLTT7huiaSSyA1wthYOwtp0+K6A==}
+  wrangler@4.18.0:
+    resolution: {integrity: sha512-/ng0KI9io97SNsBU1rheADBLLTE5Djybgsi4gXuvH1RBKJGpyj1xWvZ2fuWu8vAonit3EiZkwtERTm6kESHP3A==}
     engines: {node: '>=18.0.0'}
     hasBin: true
     peerDependencies:
-      '@cloudflare/workers-types': ^4.20250523.0
+      '@cloudflare/workers-types': ^4.20250525.0
     peerDependenciesMeta:
       '@cloudflare/workers-types':
         optional: true
···
       jsonpointer: 5.0.1
       leven: 3.1.0
 
-  '@atcute/atproto@3.0.3':
+  '@atcute/atproto@3.1.0':
     dependencies:
       '@atcute/lexicons': 1.0.4
 
-  '@atcute/bluemoji@2.0.0(@atcute/bluesky@2.1.1(@atcute/client@3.1.0))(@atcute/client@3.1.0)':
+  '@atcute/bluemoji@3.1.0':
     dependencies:
-      '@atcute/bluesky': 2.1.1(@atcute/client@3.1.0)
-      '@atcute/client': 3.1.0
+      '@atcute/atproto': 3.1.0
+      '@atcute/bluesky': 3.1.0
+      '@atcute/lexicons': 1.0.4
 
   '@atcute/bluesky-richtext-parser@1.0.7': {}
 
   '@atcute/bluesky-richtext-segmenter@2.0.3':
     dependencies:
-      '@atcute/bluesky': 3.0.4
+      '@atcute/bluesky': 3.1.0
       '@atcute/lexicons': 1.0.4
 
   '@atcute/bluesky-search-parser@0.1.0': {}
 
-  '@atcute/bluesky@2.1.1(@atcute/client@3.1.0)':
-    dependencies:
-      '@atcute/client': 3.1.0
-
-  '@atcute/bluesky@3.0.4':
+  '@atcute/bluesky@3.1.0':
     dependencies:
-      '@atcute/atproto': 3.0.3
+      '@atcute/atproto': 3.1.0
       '@atcute/lexicons': 1.0.4
 
   '@atcute/cbor@2.2.4':
···
     dependencies:
       '@atcute/multibase': 1.1.4
       '@atcute/uint8array': 1.0.3
-
-  '@atcute/client@3.1.0': {}
 
   '@atcute/client@4.0.3':
     dependencies:
···
     dependencies:
       '@babel/compat-data': 7.27.3
       '@babel/helper-validator-option': 7.27.1
-      browserslist: 4.24.5
+      browserslist: 4.25.0
       lru-cache: 5.1.1
       semver: 6.3.1
 
···
     dependencies:
       mime: 3.0.0
 
-  '@cloudflare/unenv-preset@2.3.2(unenv@2.0.0-rc.17)(workerd@1.20250523.0)':
+  '@cloudflare/unenv-preset@2.3.2(unenv@2.0.0-rc.17)(workerd@1.20250525.0)':
     dependencies:
       unenv: 2.0.0-rc.17
     optionalDependencies:
-      workerd: 1.20250523.0
+      workerd: 1.20250525.0
 
-  '@cloudflare/workerd-darwin-64@1.20250523.0':
+  '@cloudflare/workerd-darwin-64@1.20250525.0':
     optional: true
 
-  '@cloudflare/workerd-darwin-arm64@1.20250523.0':
+  '@cloudflare/workerd-darwin-arm64@1.20250525.0':
     optional: true
 
-  '@cloudflare/workerd-linux-64@1.20250523.0':
+  '@cloudflare/workerd-linux-64@1.20250525.0':
     optional: true
 
-  '@cloudflare/workerd-linux-arm64@1.20250523.0':
+  '@cloudflare/workerd-linux-arm64@1.20250525.0':
     optional: true
 
-  '@cloudflare/workerd-windows-64@1.20250523.0':
+  '@cloudflare/workerd-windows-64@1.20250525.0':
     optional: true
 
   '@cspotcode/source-map-support@0.8.1':
···
 
   '@jsr/mary__exif-rm@0.2.2': {}
 
+  '@kelinci/basa-lexicons@1.0.0':
+    dependencies:
+      '@atcute/lexicons': 1.0.4
+
   '@nodelib/fs.scandir@2.1.5':
     dependencies:
       '@nodelib/fs.stat': 2.0.5
···
 
   at-least-node@1.0.0: {}
 
-  autoprefixer@10.4.21(postcss@8.5.3):
+  autoprefixer@10.4.21(postcss@8.5.4):
     dependencies:
-      browserslist: 4.24.5
-      caniuse-lite: 1.0.30001718
+      browserslist: 4.25.0
+      caniuse-lite: 1.0.30001720
       fraction.js: 4.3.7
       normalize-range: 0.1.2
       picocolors: 1.1.1
-      postcss: 8.5.3
+      postcss: 8.5.4
       postcss-value-parser: 4.2.0
 
   babel-plugin-jsx-dom-expressions@0.39.8(@babel/core@7.27.3):
···
     dependencies:
       fill-range: 7.1.1
 
-  browserslist@4.24.5:
+  browserslist@4.25.0:
     dependencies:
-      caniuse-lite: 1.0.30001718
-      electron-to-chromium: 1.5.159
+      caniuse-lite: 1.0.30001720
+      electron-to-chromium: 1.5.161
       node-releases: 2.0.19
-      update-browserslist-db: 1.1.3(browserslist@4.24.5)
+      update-browserslist-db: 1.1.3(browserslist@4.25.0)
 
   buffer-from@1.1.2: {}
 
   camelcase-css@2.0.1: {}
 
-  caniuse-lite@1.0.30001718: {}
+  caniuse-lite@1.0.30001720: {}
 
   chalk@4.1.2:
     dependencies:
···
 
   core-js-compat@3.42.0:
     dependencies:
-      browserslist: 4.24.5
+      browserslist: 4.25.0
 
   cross-spawn@7.0.6:
     dependencies:
···
     dependencies:
       jake: 10.9.2
 
-  electron-to-chromium@1.5.159: {}
+  electron-to-chromium@1.5.161: {}
 
   emoji-regex@8.0.0: {}
 
···
 
   mime@3.0.0: {}
 
-  miniflare@4.20250523.0:
+  miniflare@4.20250525.0:
     dependencies:
       '@cspotcode/source-map-support': 0.8.1
       acorn: 8.14.0
···
       sharp: 0.33.5
       stoppable: 1.1.0
       undici: 5.29.0
-      workerd: 1.20250523.0
+      workerd: 1.20250525.0
       ws: 8.18.0
       youch: 3.3.4
       zod: 3.22.3
···
 
   pirates@4.0.7: {}
 
-  postcss-import@15.1.0(postcss@8.5.3):
+  postcss-import@15.1.0(postcss@8.5.4):
     dependencies:
-      postcss: 8.5.3
+      postcss: 8.5.4
       postcss-value-parser: 4.2.0
       read-cache: 1.0.0
       resolve: 1.22.10
 
-  postcss-js@4.0.1(postcss@8.5.3):
+  postcss-js@4.0.1(postcss@8.5.4):
     dependencies:
       camelcase-css: 2.0.1
-      postcss: 8.5.3
+      postcss: 8.5.4
 
-  postcss-load-config@4.0.2(postcss@8.5.3):
+  postcss-load-config@4.0.2(postcss@8.5.4):
     dependencies:
       lilconfig: 3.1.3
       yaml: 2.8.0
     optionalDependencies:
-      postcss: 8.5.3
+      postcss: 8.5.4
 
-  postcss-nested@6.2.0(postcss@8.5.3):
+  postcss-nested@6.2.0(postcss@8.5.4):
     dependencies:
-      postcss: 8.5.3
+      postcss: 8.5.4
       postcss-selector-parser: 6.1.2
 
   postcss-selector-parser@6.1.2:
···
 
   postcss-value-parser@4.2.0: {}
 
-  postcss@8.5.3:
+  postcss@8.5.4:
     dependencies:
       nanoid: 3.3.11
       picocolors: 1.1.1
···
       normalize-path: 3.0.0
       object-hash: 3.0.0
       picocolors: 1.1.1
-      postcss: 8.5.3
-      postcss-import: 15.1.0(postcss@8.5.3)
-      postcss-js: 4.0.1(postcss@8.5.3)
-      postcss-load-config: 4.0.2(postcss@8.5.3)
-      postcss-nested: 6.2.0(postcss@8.5.3)
+      postcss: 8.5.4
+      postcss-import: 15.1.0(postcss@8.5.4)
+      postcss-js: 4.0.1(postcss@8.5.4)
+      postcss-load-config: 4.0.2(postcss@8.5.4)
+      postcss-nested: 6.2.0(postcss@8.5.4)
       postcss-selector-parser: 6.1.2
       resolve: 1.22.10
       sucrase: 3.35.0
···
 
   upath@1.2.0: {}
 
-  update-browserslist-db@1.1.3(browserslist@4.24.5):
+  update-browserslist-db@1.1.3(browserslist@4.25.0):
     dependencies:
-      browserslist: 4.24.5
+      browserslist: 4.25.0
       escalade: 3.2.0
       picocolors: 1.1.1
 
···
       esbuild: 0.25.5
       fdir: 6.4.5(picomatch@4.0.2)
       picomatch: 4.0.2
-      postcss: 8.5.3
+      postcss: 8.5.4
       rollup: 4.41.1
       tinyglobby: 0.2.14
     optionalDependencies:
···
       '@types/trusted-types': 2.0.7
       workbox-core: 7.3.0
 
-  workerd@1.20250523.0:
+  workerd@1.20250525.0:
     optionalDependencies:
-      '@cloudflare/workerd-darwin-64': 1.20250523.0
-      '@cloudflare/workerd-darwin-arm64': 1.20250523.0
-      '@cloudflare/workerd-linux-64': 1.20250523.0
-      '@cloudflare/workerd-linux-arm64': 1.20250523.0
-      '@cloudflare/workerd-windows-64': 1.20250523.0
+      '@cloudflare/workerd-darwin-64': 1.20250525.0
+      '@cloudflare/workerd-darwin-arm64': 1.20250525.0
+      '@cloudflare/workerd-linux-64': 1.20250525.0
+      '@cloudflare/workerd-linux-arm64': 1.20250525.0
+      '@cloudflare/workerd-windows-64': 1.20250525.0
 
-  wrangler@4.17.0:
+  wrangler@4.18.0:
     dependencies:
       '@cloudflare/kv-asset-handler': 0.4.0
-      '@cloudflare/unenv-preset': 2.3.2(unenv@2.0.0-rc.17)(workerd@1.20250523.0)
+      '@cloudflare/unenv-preset': 2.3.2(unenv@2.0.0-rc.17)(workerd@1.20250525.0)
       blake3-wasm: 2.1.5
       esbuild: 0.25.4
-      miniflare: 4.20250523.0
+      miniflare: 4.20250525.0
       path-to-regexp: 6.3.0
       unenv: 2.0.0-rc.17
-      workerd: 1.20250523.0
+      workerd: 1.20250525.0
     optionalDependencies:
       fsevents: 2.3.3
     transitivePeerDependencies:

src/api/cache/post-shadow.ts

···
 import { type Accessor, batch, createRenderEffect, createSignal, onCleanup } from 'solid-js';
 
-import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs } from '@atcute/bluesky';
 import { EventEmitter } from '@mary/events';
 import type { QueryClient } from '@mary/solid-query';
 

src/api/cache/profile-shadow.ts

···
 import { type Accessor, batch, createRenderEffect, createSignal, onCleanup } from 'solid-js';
 
-import type { AppBskyActorDefs, At } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs } from '@atcute/bluesky';
+import type { Did } from '@atcute/lexicons';
 import { EventEmitter } from '@mary/events';
 import type { QueryClient } from '@mary/solid-query';
 
···
 	| AppBskyActorDefs.ProfileViewBasic
 	| AppBskyActorDefs.ProfileViewDetailed;
 
-const emitter = new EventEmitter<{ [uri: At.Did]: [] }>();
+const emitter = new EventEmitter<{ [uri: Did]: [] }>();
 const shadows = new WeakMap<AllProfileView, ProfileShadow>();
 
 export const useProfileShadow = (profile: AccessorMaybe<AllProfileView>): Accessor<ProfileShadowView> => {
···
 	};
 };
 
-export const updateProfileShadow = (queryClient: QueryClient, did: At.Did, value: Partial<ProfileShadow>) => {
+export const updateProfileShadow = (queryClient: QueryClient, did: Did, value: Partial<ProfileShadow>) => {
 	for (const profile of findProfilesInCache(queryClient, did)) {
 		shadows.set(profile, { ...shadows.get(profile), ...value });
 	}
···
 	batch(() => emitter.emit(did));
 };
 
-export function findProfilesInCache(queryClient: QueryClient, did: At.Did): Generator<AllProfileView> {
+export function findProfilesInCache(queryClient: QueryClient, did: Did): Generator<AllProfileView> {
 	return iterateQueryCache<AllProfileView>(queryClient, [
 		findAllProfilesInBookmarkFeed(did),
 		findAllProfilesInNotificationFeed(did),

src/api/models/post-thread.tsx

···
-import type {
-	AppBskyFeedDefs,
-	AppBskyFeedGetPostThread,
-	AppBskyFeedPost,
-	At,
-	Brand,
-} from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs, AppBskyFeedGetPostThread, AppBskyFeedPost } from '@atcute/bluesky';
+import type { $type, Did } from '@atcute/lexicons';
 
 import type { ThreadViewPreferences } from '~/lib/preferences/account';
 
···
 
 export const fillModerationCache = (
 	cache: ThreadModerationCache,
-	thread: AppBskyFeedGetPostThread.Output['thread'],
+	thread: AppBskyFeedGetPostThread.$output['thread'],
 	options: ModerationOptions,
 ) => {
 	if (thread.$type === 'app.bsky.feed.defs#threadViewPost') {
···
 	moderationOptions,
 	selfDid,
 }: {
-	thread: Brand.Union<AppBskyFeedDefs.ThreadViewPost>;
+	thread: $type.enforce<AppBskyFeedDefs.ThreadViewPost>;
 	preferences: ThreadViewPreferences;
 	moderationOptions: ModerationOptions;
-	selfDid?: At.Did;
+	selfDid?: Did;
 }): ThreadData => {
 	const { followsFirst, sort, treeView } = preferences;
 
···
 
 			if (last && last.type === 'post') {
 				const post = last.post;
-				const reply = (post.record as AppBskyFeedPost.Record).reply;
+				const reply = (post.record as AppBskyFeedPost.Main).reply;
 
 				if (reply) {
 					const uri = reply.parent.uri;
···
 
 			// Filter the replies to only what we want
 			const items = replies.filter(
-				(x): x is Brand.Union<AppBskyFeedDefs.ThreadViewPost | AppBskyFeedDefs.BlockedPost> => {
+				(x): x is $type.enforce<AppBskyFeedDefs.ThreadViewPost | AppBskyFeedDefs.BlockedPost> => {
 					return (
 						x.$type === 'app.bsky.feed.defs#threadViewPost' ||
 						(x.$type === 'app.bsky.feed.defs#blockedPost' && !x.author.viewer?.blockedBy)

src/api/models/timeline.ts

···
-import type { AppBskyActorDefs, AppBskyFeedDefs } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs, AppBskyFeedDefs } from '@atcute/bluesky';
 
 type Post = AppBskyFeedDefs.PostView;
 type TimelineItem = AppBskyFeedDefs.FeedViewPost;

src/api/moderation/entities/generic.ts

···
-import type { At, ComAtprotoLabelDefs } from '@atcute/client/lexicons';
+import type { ComAtprotoLabelDefs } from '@atcute/atproto';
+import type { Did } from '@atcute/lexicons';
 
 import { type ModerationCause, type ModerationOptions, decideLabelModeration } from '..';
 import { TargetContent } from '../constants';
 
 export const moderateGeneric = (
 	item: { labels?: ComAtprotoLabelDefs.Label[] },
-	userDid: At.Did,
+	userDid: Did,
 	opts: ModerationOptions,
 ) => {
 	const accu: ModerationCause[] = [];

src/api/moderation/entities/post.ts

···
-import type { AppBskyFeedDefs, AppBskyFeedPost } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs, AppBskyFeedPost } from '@atcute/bluesky';
 
 import { unwrapPostEmbedText } from '~/api/utils/post';
 
···
 
 export const moderatePost = (post: AppBskyFeedDefs.PostView, opts: ModerationOptions) => {
 	const author = post.author;
-	const record = post.record as AppBskyFeedPost.Record;
+	const record = post.record as AppBskyFeedPost.Main;
 	const text = record.text + unwrapPostEmbedText(record.embed);
 
 	const accu: ModerationCause[] = moderateProfile(author, opts);

src/api/moderation/entities/profile.ts

···
-import type { AppBskyActorDefs } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 
 import {
 	type ModerationCause,

src/api/moderation/entities/quote.ts

···
-import type { AppBskyEmbedRecord, AppBskyFeedPost } from '@atcute/client/lexicons';
+import type { AppBskyEmbedRecord, AppBskyFeedPost } from '@atcute/bluesky';
 
 import { unwrapPostEmbedText } from '~/api/utils/post';
 
···
 
 export const moderateQuote = (quote: AppBskyEmbedRecord.ViewRecord, opts: ModerationOptions) => {
 	const author = quote.author;
-	const record = quote.value as AppBskyFeedPost.Record;
+	const record = quote.value as AppBskyFeedPost.Main;
 	const text = record.text + unwrapPostEmbedText(record.embed);
 
 	const accu: ModerationCause[] = moderateProfile(author, opts);

src/api/moderation/index.ts

···
-import type { At, ComAtprotoLabelDefs } from '@atcute/client/lexicons';
+import type { ComAtprotoLabelDefs } from '@atcute/atproto';
+import type { Did } from '@atcute/lexicons';
 
 import {
 	BlurContent,
···
 
 export interface ModerationLabeler {
 	/** DID of the labeler */
-	did: At.Did;
+	did: Did;
 	/** Profile details of the labeler */
 	profile: {
 		avatar?: string;
···
 	/** Preferences for global-defined labels */
 	labels: LabelPreferenceMapping;
 	/** Preferences for labels from subscribed labelers */
-	labelers: Record<At.Did, ModerationLabelerPreferences>;
+	labelers: Record<Did, ModerationLabelerPreferences>;
 	/** Keyword filters */
 	keywords: KeywordFilter[];
 
 	/** List of users to hide reposts from */
-	hideReposts: At.Did[];
+	hideReposts: Did[];
 }
 
 export interface ModerationOptions {
 	_filtersCache?: [raw: string, match: RegExp][];
 
 	preferences: ModerationPreferences;
-	labelerDefinitions: Record<At.Did, ModerationLabeler>;
+	labelerDefinitions: Record<Did, ModerationLabeler>;
 }
 
 export const decideLabelModeration = (
 	accu: ModerationCause[],
 	target: LabelTarget,
 	labels: Label[] | undefined,
-	userDid: At.Did,
+	userDid: Did,
 	opts: ModerationOptions,
 ) => {
 	if (labels /* && labels.length > 0 */) {

src/api/moderation/labeler.ts

···
-import type { AppBskyLabelerDefs } from '@atcute/client/lexicons';
+import type { AppBskyLabelerDefs } from '@atcute/bluesky';
 import { mapDefined } from '@mary/array-fns';
 
 import type { LabelDefinitionMapping, ModerationLabeler } from '.';

src/api/mutations/post.ts

···
-import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs } from '@atcute/bluesky';
 import { useQueryClient } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
 import { useSession } from '~/lib/states/session';
 
 import { type PostShadowView, updatePostShadow } from '../cache/post-shadow';
-import { parseCanonicalResourceUri } from '../types/at-uri';
+import { assertCanonicalResourceUri } from '../types/at-uri';
 import { getCurrentDate } from '../utils/misc';
 import { createRecord, deleteRecord } from '../utils/records';
 import { createToggleMutationQueue } from '../utils/toggle-mutation';
···
 
 				return result.uri;
 			} else if (prevLikeUri) {
-				const uri = parseCanonicalResourceUri(prevLikeUri);
+				const uri = assertCanonicalResourceUri(prevLikeUri);
 
 				await deleteRecord(client, {
 					repo: currentAccount!.did,
···
 
 				return result.uri;
 			} else if (prevRepostUri) {
-				const uri = parseCanonicalResourceUri(prevRepostUri);
+				const uri = assertCanonicalResourceUri(prevRepostUri);
 
 				await deleteRecord(client, {
 					repo: currentAccount!.did,

src/api/mutations/profile.ts

···
-import type { AppBskyActorDefs } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 import { useQueryClient } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
 import { useSession } from '~/lib/states/session';
 
 import { type ProfileShadowView, updateProfileShadow } from '../cache/profile-shadow';
-import { parseCanonicalResourceUri } from '../types/at-uri';
+import { assertCanonicalResourceUri } from '../types/at-uri';
 import { getCurrentDate } from '../utils/misc';
 import { createRecord, deleteRecord } from '../utils/records';
 import { createToggleMutationQueue } from '../utils/toggle-mutation';
···
 
 				return result.uri;
 			} else if (prevFollowUri) {
-				const uri = parseCanonicalResourceUri(prevFollowUri);
+				const uri = assertCanonicalResourceUri(prevFollowUri);
 
 				await deleteRecord(client, {
 					repo: currentAccount!.did,

src/api/queries-cache/bookmark-feed.ts

···
-import type { AppBskyActorDefs, AppBskyFeedDefs, At } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs, AppBskyFeedDefs } from '@atcute/bluesky';
+import type { Did } from '@atcute/lexicons';
 import type { InfiniteData } from '@mary/solid-query';
 
 import type { CacheMatcher } from '../cache/utils';
···
 	};
 };
 
-export const findAllProfiles = (did: At.Did): CacheMatcher<AppBskyActorDefs.ProfileViewBasic> => {
+export const findAllProfiles = (did: Did): CacheMatcher<AppBskyActorDefs.ProfileViewBasic> => {
 	return {
 		filter: {
 			queryKey: ['bookmarks-feed'],

src/api/queries-cache/feed-precache.ts

···
-import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs } from '@atcute/bluesky';
 import type { QueryClient } from '@mary/solid-query';
 
 export const precacheFeed = (queryClient: QueryClient, feed: AppBskyFeedDefs.GeneratorView) => {

src/api/queries-cache/list-precache.ts

···
-import type { AppBskyGraphDefs } from '@atcute/client/lexicons';
+import type { AppBskyGraphDefs } from '@atcute/bluesky';
 import type { QueryClient } from '@mary/solid-query';
 
 export const precacheList = (

src/api/queries-cache/notification-feed.ts

···
-import type { AppBskyActorDefs, AppBskyFeedDefs, At } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs, AppBskyFeedDefs } from '@atcute/bluesky';
+import type { Did } from '@atcute/lexicons';
 import type { InfiniteData } from '@mary/solid-query';
 
 import type { CacheMatcher } from '../cache/utils';
···
 };
 
 export const findAllProfiles = (
-	did: At.Did,
+	did: Did,
 ): CacheMatcher<AppBskyActorDefs.ProfileViewBasic | AppBskyActorDefs.ProfileView> => {
 	return {
 		filter: {

src/api/queries-cache/post-quotes.ts

···
-import type { AppBskyFeedDefs, AppBskyFeedGetQuotes } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs, AppBskyFeedGetQuotes } from '@atcute/bluesky';
 import type { InfiniteData } from '@mary/solid-query';
 
 import type { CacheMatcher } from '../cache/utils';
···
 		filter: {
 			queryKey: ['post-quotes'],
 		},
-		*iterate(data: InfiniteData<AppBskyFeedGetQuotes.Output>) {
+		*iterate(data: InfiniteData<AppBskyFeedGetQuotes.$output>) {
 			for (const page of data.pages) {
 				for (const post of page.posts) {
 					if (post.uri === uri) {

src/api/queries-cache/post-thread.ts

···
-import type {
-	AppBskyActorDefs,
-	AppBskyFeedDefs,
-	AppBskyFeedGetPostThread,
-	At,
-} from '@atcute/client/lexicons';
+import type { AppBskyActorDefs, AppBskyFeedDefs, AppBskyFeedGetPostThread } from '@atcute/bluesky';
+import type { Did } from '@atcute/lexicons';
 
 import type { CacheMatcher } from '../cache/utils';
 import { embedViewRecordToPostView, getEmbeddedPost } from '../utils/post';
 
-function* traverseThread(
-	node: AppBskyFeedGetPostThread.Output['thread'],
-): Generator<AppBskyFeedDefs.ThreadViewPost> {
+type Thread = AppBskyFeedGetPostThread.$output['thread'];
+
+function* traverseThread(node: Thread): Generator<AppBskyFeedDefs.ThreadViewPost> {
 	if (node.$type === 'app.bsky.feed.defs#threadViewPost') {
 		const parent = node.parent;
 		const replies = node.replies;
···
 		filter: {
 			queryKey: ['post-thread'],
 		},
-		*iterate(data: AppBskyFeedGetPostThread.Output['thread']) {
+		*iterate(data: Thread) {
 			for (const thread of traverseThread(data)) {
 				const post = thread.post;
 
···
 	};
 };
 
-export const findAllProfiles = (did: At.Did): CacheMatcher<AppBskyActorDefs.ProfileViewBasic> => {
+export const findAllProfiles = (did: Did): CacheMatcher<AppBskyActorDefs.ProfileViewBasic> => {
 	return {
 		filter: {
 			queryKey: ['post-thread'],
 		},
-		*iterate(data: AppBskyFeedGetPostThread.Output['thread']) {
+		*iterate(data: Thread) {
 			for (const thread of traverseThread(data)) {
 				const post = thread.post;
 

src/api/queries-cache/profile-autocomplete.ts

···
-import type { AppBskyActorDefs, AppBskyActorSearchActorsTypeahead, At } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs, AppBskyActorSearchActorsTypeahead } from '@atcute/bluesky';
+import type { Did } from '@atcute/lexicons';
 
 import type { CacheMatcher } from '../cache/utils';
 
-export const findAllProfiles = (did: At.Did): CacheMatcher<AppBskyActorDefs.ProfileViewBasic> => {
+export const findAllProfiles = (did: Did): CacheMatcher<AppBskyActorDefs.ProfileViewBasic> => {
 	return {
 		filter: {
 			queryKey: ['profile-autocomplete'],
 		},
-		*iterate(data: AppBskyActorSearchActorsTypeahead.Output) {
+		*iterate(data: AppBskyActorSearchActorsTypeahead.$output) {
 			for (const profile of data.actors) {
 				if (profile.did === did) {
 					yield profile;

src/api/queries-cache/profile-list.ts

···
-import type { AppBskyActorDefs, At } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs } from '@atcute/bluesky';
+import type { Did } from '@atcute/lexicons';
 import type { InfiniteData } from '@mary/solid-query';
 
 import type { CacheMatcher } from '../cache/utils';
 import type { ProfilesListPage, ProfilesListWithSubjectPage } from '../types/profile-response';
 
-export const findAllProfiles = (did: At.Did): CacheMatcher<AppBskyActorDefs.ProfileView> => {
+export const findAllProfiles = (did: Did): CacheMatcher<AppBskyActorDefs.ProfileView> => {
 	return {
 		filter: [
 			{ queryKey: ['profile-followers'] },

src/api/queries-cache/profile-precache.ts

···
-import type { AppBskyActorDefs } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 import type { QueryClient } from '@mary/solid-query';
 
 export const precacheProfile = (

src/api/queries-cache/profile.ts

···
-import type { AppBskyActorDefs, At } from '@atcute/client/lexicons';
+import { AppBskyActorDefs } from '@atcute/bluesky';
+import type { Did } from '@atcute/lexicons';
 
 import type { CacheMatcher } from '../cache/utils';
 
-export const findAllProfiles = (did: At.Did): CacheMatcher<AppBskyActorDefs.ProfileViewDetailed> => {
+export const findAllProfiles = (did: Did): CacheMatcher<AppBskyActorDefs.ProfileViewDetailed> => {
 	return {
 		filter: {
 			queryKey: ['profile', did],

src/api/queries-cache/timeline.ts

···
-import type { AppBskyActorDefs, AppBskyFeedDefs, At } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs, AppBskyFeedDefs } from '@atcute/bluesky';
+import type { Did } from '@atcute/lexicons';
 import type { InfiniteData } from '@mary/solid-query';
 
 import type { CacheMatcher } from '../cache/utils';
···
 	};
 };
 
-export const findAllProfiles = (did: At.Did): CacheMatcher<AppBskyActorDefs.ProfileViewBasic> => {
+export const findAllProfiles = (did: Did): CacheMatcher<AppBskyActorDefs.ProfileViewBasic> => {
 	return {
 		filter: {
 			queryKey: ['timeline'],

src/api/queries/blob.ts

···
 import { type Client, ok } from '@atcute/client';
-import type { At } from '@atcute/client/lexicons';
+import type { Blob as AtpBlob } from '@atcute/lexicons';
 
-export const uploadBlob = async (client: Client, blob: Blob): Promise<At.Blob<any>> => {
+export const uploadBlob = async (client: Client, blob: Blob): Promise<AtpBlob<any>> => {
 	const data = await ok(
 		client.post('com.atproto.repo.uploadBlob', {
 			input: blob,

src/api/queries/bookmark-feed.ts

···
+import type { AppBskyFeedDefs } from '@atcute/bluesky';
 import { tokenize } from '@atcute/bluesky-search-parser';
 import { ok } from '@atcute/client';
-import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
 import { mapDefined } from '@mary/array-fns';
 import { filter, map, take, toArray } from '@mary/async-iterator-fns';
 import { createInfiniteQuery, createQuery } from '@mary/solid-query';

src/api/queries/composer.ts

···
-import type { At } from '@atcute/client/lexicons';
+import type { GenericUri } from '@atcute/lexicons';
 import { createQuery } from '@mary/solid-query';
 
 const LINK_PROXY_ENDPOINT = 'https://cardyb.bsky.app/v1/extract';
···
 }
 
 export interface LinkMeta {
-	uri: At.GenericUri;
+	uri: GenericUri;
 	title: string;
 	description: string;
 	thumb: Blob | undefined;
···
 				}
 
 				const meta: LinkMeta = {
-					uri: $uri as At.GenericUri,
+					uri: $uri as GenericUri,
 					title: data.title,
 					description: data.description,
 					thumb: thumb,

src/api/queries/feed.ts

···
 import { modifyMutable, reconcile } from 'solid-js/store';
 
+import type { AppBskyFeedDefs } from '@atcute/bluesky';
 import { ok } from '@atcute/client';
-import type { AppBskyFeedDefs, At } from '@atcute/client/lexicons';
+import { type Did } from '@atcute/lexicons';
 import { createQuery } from '@mary/solid-query';
 
 import type { SavedGeneratorFeed } from '~/lib/preferences/account';
···
 import { useSession } from '~/lib/states/session';
 import { omit } from '~/lib/utils/misc';
 
-import { makeAtUri, parseCanonicalResourceUri } from '../types/at-uri';
+import { assertCanonicalResourceUri, makeAtUri } from '../types/at-uri';
 import { isDid } from '../types/identity';
 
 import { resolveHandle } from './handle';
···
 		return {
 			queryKey: ['feed-meta', $feedUri],
 			async queryFn(ctx): Promise<AppBskyFeedDefs.GeneratorView> {
-				const uri = parseCanonicalResourceUri($feedUri);
+				const uri = assertCanonicalResourceUri($feedUri);
 
-				let did: At.Did;
+				let did: Did;
 				if (isDid(uri.repo)) {
 					did = uri.repo;
 				} else {

src/api/queries/handle.ts

···
 import { type Client, ok } from '@atcute/client';
-import type { At } from '@atcute/client/lexicons';
+import type { Handle } from '@atcute/lexicons';
 import { createQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
 
-export const useResolveHandleQuery = (handle: () => At.Handle) => {
+export const useResolveHandleQuery = (handle: () => Handle) => {
 	const { client } = useAgent();
 
 	return createQuery(() => {
···
 	});
 };
 
-export const resolveHandle = async (client: Client, handle: At.Handle, signal?: AbortSignal) => {
+export const resolveHandle = async (client: Client, handle: Handle, signal?: AbortSignal) => {
 	const data = await ok(
 		client.get('com.atproto.identity.resolveHandle', {
 			signal: signal,

src/api/queries/labeler.ts

···
+import type { AppBskyLabelerDefs } from '@atcute/bluesky';
 import { ClientResponseError, ok } from '@atcute/client';
-import type { AppBskyLabelerDefs, At } from '@atcute/client/lexicons';
+import type { Did } from '@atcute/lexicons';
 import { createQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
 
 import { interpretLabelerDefinition } from '../moderation/labeler';
 
-export const createLabelerMetaQuery = (did: () => At.Did) => {
+export const createLabelerMetaQuery = (did: () => Did) => {
 	const { client } = useAgent();
 
 	const query = createQuery(() => {

src/api/queries/list-members.ts

···
 import { ok } from '@atcute/client';
-import type { At } from '@atcute/client/lexicons';
+import type { ResourceUri } from '@atcute/lexicons';
 import { type QueryFunctionContext as QC, createInfiniteQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
 
-export const createListMembersQuery = (listUri: () => At.ResourceUri) => {
+export const createListMembersQuery = (listUri: () => ResourceUri) => {
 	const { client } = useAgent();
 
 	return createInfiniteQuery(() => {

src/api/queries/list.ts

···
 import { modifyMutable, reconcile } from 'solid-js/store';
 
+import type { AppBskyGraphDefs } from '@atcute/bluesky';
 import { ok } from '@atcute/client';
-import type { AppBskyGraphDefs, At } from '@atcute/client/lexicons';
+import { type Did } from '@atcute/lexicons';
 import { createQuery } from '@mary/solid-query';
 
 import type { SavedListFeed } from '~/lib/preferences/account';
···
 import { useSession } from '~/lib/states/session';
 import { omit } from '~/lib/utils/misc';
 
-import { makeAtUri, parseCanonicalResourceUri } from '../types/at-uri';
+import { assertCanonicalResourceUri, makeAtUri } from '../types/at-uri';
 import { isDid } from '../types/identity';
 
 import { resolveHandle } from './handle';
···
 		return {
 			queryKey: ['list-meta', $listUri],
 			async queryFn(ctx) {
-				const uri = parseCanonicalResourceUri($listUri);
+				const uri = assertCanonicalResourceUri($listUri);
 
-				let did: At.Did;
+				let did: Did;
 				if (isDid(uri.repo)) {
 					did = uri.repo;
 				} else {

src/api/queries/my-lists.ts

···
+import type { AppBskyGraphDefs } from '@atcute/bluesky';
 import { ok } from '@atcute/client';
-import type { AppBskyGraphDefs } from '@atcute/client/lexicons';
 import { createQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';

src/api/queries/notification-feed.tsx

···
 import { createSignal } from 'solid-js';
 
+import type { AppBskyFeedDefs, AppBskyNotificationListNotifications } from '@atcute/bluesky';
 import { ok } from '@atcute/client';
-import type { AppBskyFeedDefs, AppBskyNotificationListNotifications } from '@atcute/client/lexicons';
 import { chunked, mapDefined } from '@mary/array-fns';
 import { type QueryFunctionContext as QC, createInfiniteQuery, useQueryClient } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
 
-import { parseCanonicalResourceUri } from '../types/at-uri';
+import { assertCanonicalResourceUri } from '../types/at-uri';
 import { dequal } from '../utils/dequal';
 import { resetInfiniteData } from '../utils/query';
 
···
 								// skip if they're not related to posts.
 								if (
 									!subjectUri ||
-									parseCanonicalResourceUri(subjectUri).collection !== 'app.bsky.feed.post'
+									assertCanonicalResourceUri(subjectUri).collection !== 'app.bsky.feed.post'
 								) {
 									return;
 								}

src/api/queries/post-quotes.ts

···
+import type { AppBskyFeedGetQuotes } from '@atcute/bluesky';
 import { ok } from '@atcute/client';
-import type { AppBskyFeedGetQuotes, At } from '@atcute/client/lexicons';
+import type { ResourceUri } from '@atcute/lexicons';
 import { type QueryFunctionContext as QC, createInfiniteQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
 
-export const createPostQuotesQuery = (uri: () => At.ResourceUri) => {
+export const createPostQuotesQuery = (uri: () => ResourceUri) => {
 	const { client } = useAgent();
 
 	return createInfiniteQuery(() => {
···
 		return {
 			queryKey: ['post-quotes', $uri],
 			structuralSharing: false,
-			async queryFn(ctx: QC<never, string | undefined>): Promise<AppBskyFeedGetQuotes.Output> {
+			async queryFn(ctx: QC<never, string | undefined>): Promise<AppBskyFeedGetQuotes.$output> {
 				const data = await ok(
 					client.get('app.bsky.feed.getQuotes', {
 						signal: ctx.signal,

src/api/queries/post-thread.ts

···
+import type { AppBskyFeedDefs } from '@atcute/bluesky';
 import { ClientResponseError, ok } from '@atcute/client';
-import type { AppBskyFeedDefs, At, Brand } from '@atcute/client/lexicons';
+import type { $type, ResourceUri } from '@atcute/lexicons';
 import { createQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
···
 const MAX_HEIGHT = 10;
 const MAX_DEPTH = 4;
 
-type ThreadReturn = Brand.Union<AppBskyFeedDefs.ThreadViewPost | AppBskyFeedDefs.BlockedPost>;
+type ThreadReturn = $type.enforce<AppBskyFeedDefs.ThreadViewPost | AppBskyFeedDefs.BlockedPost>;
 
-export const usePostThreadQuery = (uri: () => At.ResourceUri) => {
+export const usePostThreadQuery = (uri: () => ResourceUri) => {
 	const { client } = useAgent();
 
 	return createQuery((queryClient) => {
···
 					// Break if either:
 					// - This isn't a quote embed transformed into a post view
 					// - We've went through 10 post views
-					if (!('$transform' in found) || ++step >= 10) {
+					if (!('$transform' in post) || ++step >= 10) {
 						break;
 					}
 				}

src/api/queries/post.ts

···
 import { ok } from '@atcute/client';
-import type { At } from '@atcute/client/lexicons';
+import { type Did } from '@atcute/lexicons';
 import { createQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
 
 import { findPostsInCache } from '../cache/post-shadow';
-import { makeAtUri, parseCanonicalResourceUri } from '../types/at-uri';
+import { assertCanonicalResourceUri, makeAtUri } from '../types/at-uri';
 import { isDid } from '../types/identity';
 
 import { resolveHandle } from './handle';
···
 		return {
 			queryKey: ['post', $postUri],
 			async queryFn(ctx) {
-				const uri = parseCanonicalResourceUri($postUri);
+				const uri = assertCanonicalResourceUri($postUri);
 
-				let did: At.Did;
+				let did: Did;
 				if (isDid(uri.repo)) {
 					did = uri.repo;
 				} else {

src/api/queries/profile-feeds.ts

···
 import { ok } from '@atcute/client';
-import type { At } from '@atcute/client/lexicons';
+import type { ActorIdentifier } from '@atcute/lexicons';
 import { type QueryFunctionContext as QC, createInfiniteQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
 
-export const createProfileFeedsQuery = (didOrHandle: () => At.Identifier) => {
+export const createProfileFeedsQuery = (didOrHandle: () => ActorIdentifier) => {
 	const { client } = useAgent();
 
 	return createInfiniteQuery(() => {

src/api/queries/profile-followers.ts

···
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 import { ok } from '@atcute/client';
-import type { AppBskyActorDefs, At } from '@atcute/client/lexicons';
+import type { ActorIdentifier } from '@atcute/lexicons';
 import { type InfiniteData, type QueryFunctionContext as QC, createInfiniteQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
 
 import { type ProfilesListWithSubjectPage, toProfilesListWithSubjectPage } from '../types/profile-response';
 
-export const createProfileFollowersQuery = (didOrHandle: () => At.Identifier) => {
+export const createProfileFollowersQuery = (didOrHandle: () => ActorIdentifier) => {
 	const { client } = useAgent();
 
 	return createInfiniteQuery((queryClient) => {

src/api/queries/profile-following.ts

···
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 import { ok } from '@atcute/client';
-import type { AppBskyActorDefs, At } from '@atcute/client/lexicons';
+import type { ActorIdentifier } from '@atcute/lexicons';
 import { type InfiniteData, type QueryFunctionContext as QC, createInfiniteQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
 
 import { type ProfilesListWithSubjectPage, toProfilesListWithSubjectPage } from '../types/profile-response';
 
-export const createProfileFollowingQuery = (didOrHandle: () => At.Identifier) => {
+export const createProfileFollowingQuery = (didOrHandle: () => ActorIdentifier) => {
 	const { client } = useAgent();
 
 	return createInfiniteQuery((queryClient) => {

src/api/queries/profile-known-followers.ts

···
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 import { ok } from '@atcute/client';
-import type { AppBskyActorDefs, At } from '@atcute/client/lexicons';
+import type { ActorIdentifier } from '@atcute/lexicons';
 import { type InfiniteData, type QueryFunctionContext as QC, createInfiniteQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
 
 import { type ProfilesListWithSubjectPage, toProfilesListWithSubjectPage } from '../types/profile-response';
 
-export const createProfileKnownFollowersQuery = (didOrHandle: () => At.Identifier) => {
+export const createProfileKnownFollowersQuery = (didOrHandle: () => ActorIdentifier) => {
 	const { client } = useAgent();
 
 	return createInfiniteQuery((queryClient) => {

src/api/queries/profile-lists.ts

···
 import { ok } from '@atcute/client';
-import type { At } from '@atcute/client/lexicons';
+import type { ActorIdentifier } from '@atcute/lexicons';
 import { type QueryFunctionContext as QC, createInfiniteQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
 
-export const createProfileListsQuery = (didOrHandle: () => At.Identifier) => {
+export const createProfileListsQuery = (didOrHandle: () => ActorIdentifier) => {
 	const { client } = useAgent();
 
 	const collator = new Intl.Collator('en-US');

src/api/queries/profile.ts

···
 import { modifyMutable, reconcile } from 'solid-js/store';
 
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 import { ok } from '@atcute/client';
-import type { AppBskyActorDefs, At } from '@atcute/client/lexicons';
+import type { ActorIdentifier } from '@atcute/lexicons';
 import { createQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
···
 	gcTime?: number;
 }
 
-export const createProfileQuery = (didOrHandle: () => At.Identifier, opts: ProfileQueryOptions = {}) => {
+export const createProfileQuery = (didOrHandle: () => ActorIdentifier, opts: ProfileQueryOptions = {}) => {
 	const { client } = useAgent();
 	const { currentAccount } = useSession();
 

src/api/queries/search-feeds.ts

···
+import type { AppBskyUnspeccedGetPopularFeedGenerators } from '@atcute/bluesky';
 import { ok } from '@atcute/client';
-import type { AppBskyUnspeccedGetPopularFeedGenerators } from '@atcute/client/lexicons';
 import { type QueryFunctionContext as QC, createInfiniteQuery } from '@mary/solid-query';
 
 import { useAgent } from '~/lib/states/agent';
···
 			queryKey: ['search-feeds', q],
 			async queryFn(
 				ctx: QC<never, string | undefined>,
-			): Promise<AppBskyUnspeccedGetPopularFeedGenerators.Output> {
+			): Promise<AppBskyUnspeccedGetPopularFeedGenerators.$output> {
 				const data = await ok(
 					client.get('app.bsky.unspecced.getPopularFeedGenerators', {
 						signal: ctx.signal,

src/api/queries/subject-likers.ts

···
 import { ok } from '@atcute/client';
-import type { At } from '@atcute/client/lexicons';
+import type { ResourceUri } from '@atcute/lexicons';
 import type { QueryFunctionContext as QC } from '@mary/solid-query';
 import { createInfiniteQuery } from '@mary/solid-query';
 
···
 
 import type { ProfilesListPage } from '../types/profile-response';
 
-export const createSubjectLikersQuery = (uri: () => At.ResourceUri) => {
+export const createSubjectLikersQuery = (uri: () => ResourceUri) => {
 	const { client } = useAgent();
 
 	return createInfiniteQuery(() => {

src/api/queries/subject-reposters.ts

···
 import { ok } from '@atcute/client';
-import type { At } from '@atcute/client/lexicons';
+import type { ResourceUri } from '@atcute/lexicons';
 import type { QueryFunctionContext as QC } from '@mary/solid-query';
 import { createInfiniteQuery } from '@mary/solid-query';
 
···
 
 import { type ProfilesListPage, toProfilesListPage } from '../types/profile-response';
 
-export const createSubjectRepostersQuery = (uri: () => At.ResourceUri) => {
+export const createSubjectRepostersQuery = (uri: () => ResourceUri) => {
 	const { client } = useAgent();
 
 	return createInfiniteQuery(() => {

src/api/queries/timeline.ts

···
 import { createEffect, createMemo, createRenderEffect, onCleanup, untrack } from 'solid-js';
 
+import {
+	type AppBskyFeedDefs,
+	type AppBskyFeedGetTimeline,
+	type AppBskyFeedPost,
+	unwrapRawRecordEmbed,
+	unwrapRecordEmbed,
+} from '@atcute/bluesky';
 import { type Client, ok } from '@atcute/client';
-import type { AppBskyFeedDefs, AppBskyFeedGetTimeline, AppBskyFeedPost, At } from '@atcute/client/lexicons';
+import { type Did, type ResourceUri } from '@atcute/lexicons';
 import { type FalsyValue, definite } from '@mary/array-fns';
 import { type InfiniteData, createInfiniteQuery, createQuery, useQueryClient } from '@mary/solid-query';
 
···
 	getModerationUI,
 } from '../moderation';
 import { ContextContentList, PreferenceHide, TargetContent } from '../moderation/constants';
-import { parseCanonicalResourceUri } from '../types/at-uri';
-import { unwrapRecordEmbed } from '../utils/bluesky/embed';
-import { unwrapRecordEmbedView } from '../utils/bluesky/embed-view';
+import { assertCanonicalResourceUri } from '../types/at-uri';
 import { EQUALS_DEQUAL } from '../utils/dequal';
 import { unwrapPostEmbedText } from '../utils/post';
 import { resetInfiniteData, wrapQuery } from '../utils/query';
 
-type PostRecord = AppBskyFeedPost.Record;
+type PostRecord = AppBskyFeedPost.Main;
 
 export interface FollowingTimelineParams {
 	type: 'following';
···
 
 export interface FeedTimelineParams {
 	type: 'feed';
-	uri: At.ResourceUri;
+	uri: ResourceUri;
 	showReplies: boolean;
 	showReposts: boolean;
 	showQuotes: boolean;
···
 
 export interface ListTimelineParams {
 	type: 'list';
-	uri: At.ResourceUri;
+	uri: ResourceUri;
 	showReplies: boolean;
 	showQuotes: boolean;
 }
 
 export interface ProfileTimelineParams {
 	type: 'profile';
-	actor: At.Did;
+	actor: Did;
 	tab: 'posts' | 'replies' | 'likes' | 'media';
 }
 
···
 	limit: number,
 	cursor: string | undefined,
 	signal: AbortSignal,
-): Promise<AppBskyFeedGetTimeline.Output> => {
+): Promise<AppBskyFeedGetTimeline.$output> => {
 	const type = params.type;
 
 	if (type === 'following') {
···
 const createHideQuotesFilter = (): PostFilter => {
 	return (item) => {
 		const post = item.post.record as PostRecord;
-		const record = unwrapRecordEmbed(post.embed);
+		const record = unwrapRawRecordEmbed(post.embed);
 
 		return (
-			record === undefined || parseCanonicalResourceUri(record.record.uri).collection === 'app.bsky.feed.post'
+			record === undefined ||
+			assertCanonicalResourceUri(record.record.uri).collection === 'app.bsky.feed.post'
 		);
 	};
 };
···
 const createHideQuotesFromMutedFilter = (): PostFilter => {
 	return (item) => {
 		const post = item.post;
-		const record = unwrapRecordEmbedView(post.embed);
+		const record = unwrapRecordEmbed(post.embed);
 
 		return (
 			record === undefined ||
···
 	};
 };
 
-const createHomeSliceFilter = (uid: At.Did, followsOnly: boolean): SliceFilter | undefined => {
+const createHomeSliceFilter = (uid: Did, followsOnly: boolean): SliceFilter | undefined => {
 	return (slice) => {
 		const items = slice.items;
 		const first = items[0];
···
 	};
 };
 
-const createProfileSliceFilter = (did: At.Did): SliceFilter | undefined => {
+const createProfileSliceFilter = (did: Did): SliceFilter | undefined => {
 	return (slice) => {
 		const items = slice.items;
 		const first = items[0];

src/api/types/at-uri.ts

···
-import type { At, Records } from '@atcute/client/lexicons';
+import {
+	type ActorIdentifier,
+	type Nsid,
+	type ParsedCanonicalResourceUri,
+	type RecordKey,
+	type ResourceUri,
+	parseCanonicalResourceUri,
+} from '@atcute/lexicons';
+import type { Records } from '@atcute/lexicons/ambient';
 
 import { assert } from '~/lib/utils/invariant';
 
-export const ATURI_RE =
-	/^at:\/\/(did:[a-z]+:[a-zA-Z0-9._:%\-]*[a-zA-Z0-9._\-]|(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z][a-zA-Z0-9-]{0,61}[a-zA-Z0-9])\/([a-zA-Z0-9-.]+)\/((?!\.{1,2}$)[a-zA-Z0-9_~.:-]{1,512})(?:#(\/[a-zA-Z0-9._~:@!$&%')(*+,;=\-[\]/\\]*))?$/;
-
-export interface ParsedCanonicalResourceUri {
-	repo: At.Did;
-	collection: At.Nsid;
-	rkey: At.RecordKey;
-	fragment: string | undefined;
-}
-
-export const parseCanonicalResourceUri = (str: string): ParsedCanonicalResourceUri => {
-	const match = ATURI_RE.exec(str);
-	assert(match !== null, `failed to parse canonical-at-uri for ${str}`);
+// #__NO_SIDE_EFFECTS__
+export const assertCanonicalResourceUri = (input: string): ParsedCanonicalResourceUri => {
+	const result = parseCanonicalResourceUri(input);
+	if (!result.ok) {
+		assert(false, result.error);
+	}
 
-	return {
-		repo: match[1] as At.Did,
-		collection: match[2] as At.Nsid,
-		rkey: match[3] as At.RecordKey,
-		fragment: match[4],
-	};
+	return result.value;
 };
 
 export const makeAtUri = (
-	repo: At.Identifier,
-	collection: keyof Records | (string & {}),
-	rkey: At.RecordKey,
-): At.ResourceUri => {
+	repo: ActorIdentifier,
+	collection: keyof Records | (Nsid & {}),
+	rkey: RecordKey,
+): ResourceUri => {
 	return `at://${repo}/${collection}/${rkey}`;
 };

src/api/types/profile-response.ts

···
-import type { AppBskyActorDefs } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 
 export interface ProfilesListPage {
 	cursor: string | undefined;

src/api/utils/bluesky/embed-view.ts

···
-import type { AppBskyEmbedRecordWithMedia, AppBskyFeedDefs } from '@atcute/client/lexicons';
-
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
-
-export interface EmbedsView {
-	media?: AppBskyEmbedRecordWithMedia.View['media'];
-	record?: AppBskyEmbedRecordWithMedia.View['record']['record'];
-}
-
-export type MediaEmbedView = NonNullable<EmbedsView['media']>;
-export type RecordEmbedView = NonNullable<EmbedsView['record']>;
-
-export const unwrapMediaEmbedView = (embed: AppBskyFeedDefs.PostView['embed']): EmbedsView['media'] => {
-	switch (embed?.$type) {
-		case 'app.bsky.embed.recordWithMedia#view':
-			return embed.media;
-		case 'app.bsky.embed.record#view':
-			return;
-	}
-
-	return embed;
-};
-
-export const unwrapRecordEmbedView = (embed: AppBskyFeedDefs.PostView['embed']): EmbedsView['record'] => {
-	switch (embed?.$type) {
-		case 'app.bsky.embed.recordWithMedia#view':
-			return embed.record.record;
-
-		case 'app.bsky.embed.record#view':
-			return embed.record;
-	}
-};
-
-export const unwrapEmbedView = (embed: AppBskyFeedDefs.PostView['embed']): EmbedsView => {
-	return {
-		media: unwrapMediaEmbedView(embed),
-		record: unwrapRecordEmbedView(embed),
-	};
-};
-
-export const getQuoteEmbedView = (embed: RecordEmbedView | undefined) => {
-	switch (embed?.$type) {
-		case 'app.bsky.embed.record#viewRecord': {
-			return embed;
-		}
-
-		case 'app.bsky.embed.record#viewNotFound':
-		case 'app.bsky.embed.record#viewDetached':
-		case 'app.bsky.embed.record#viewBlocked': {
-			const uri = parseCanonicalResourceUri(embed.uri);
-			if (uri.collection === 'app.bsky.feed.post') {
-				return embed;
-			}
-		}
-	}
-};

src/api/utils/bluesky/embed.ts

···
-import type { AppBskyEmbedRecordWithMedia, AppBskyFeedPost } from '@atcute/client/lexicons';
-
-export interface Embeds {
-	media?: AppBskyEmbedRecordWithMedia.Main['media'];
-	record?: AppBskyEmbedRecordWithMedia.Main['record'];
-}
-
-export type MediaEmbed = NonNullable<Embeds['media']>;
-export type RecordEmbed = NonNullable<Embeds['record']>;
-
-export const unwrapMediaEmbed = (embed: AppBskyFeedPost.Record['embed']): Embeds['media'] => {
-	switch (embed?.$type) {
-		case 'app.bsky.embed.recordWithMedia':
-			return embed.media;
-		case 'app.bsky.embed.record':
-			return;
-	}
-
-	return embed;
-};
-
-export const unwrapRecordEmbed = (embed: AppBskyFeedPost.Record['embed']): Embeds['record'] => {
-	switch (embed?.$type) {
-		case 'app.bsky.embed.recordWithMedia':
-			return embed.record;
-
-		case 'app.bsky.embed.record':
-			return embed;
-	}
-};
-
-export const unwrapEmbed = (embed: AppBskyFeedPost.Record['embed']): Embeds => {
-	return {
-		media: unwrapMediaEmbed(embed),
-		record: unwrapRecordEmbed(embed),
-	};
-};

src/api/utils/did.ts

···
 import { type Client, ok } from '@atcute/client';
-import type { At } from '@atcute/client/lexicons';
+import type { Did, Handle } from '@atcute/lexicons';
 
 import { isDid } from '../types/identity';
 
-const getDid = async (client: Client, actor: At.Handle, signal?: AbortSignal) => {
-	let did: At.Did;
+const getDid = async (client: Client, actor: Handle, signal?: AbortSignal) => {
+	let did: Did;
 	if (isDid(actor)) {
 		did = actor;
 	} else {

src/api/utils/post.ts

···
 	AppBskyEmbedRecord,
 	AppBskyFeedDefs,
 	AppBskyFeedPost,
-	Brand,
-} from '@atcute/client/lexicons';
+} from '@atcute/bluesky';
+import type { $type } from '@atcute/lexicons';
 
-type RecordEmbed = AppBskyFeedPost.Record['embed'];
+type RecordEmbed = AppBskyFeedPost.Main['embed'];
 type ViewEmbed = AppBskyFeedDefs.PostView['embed'];
 
 export const unwrapPostEmbedText = (embed: RecordEmbed | ViewEmbed): string => {
···
 type RecordMedia = AppBskyEmbedExternal.Main | AppBskyEmbedImages.Main;
 type ViewMedia = AppBskyEmbedExternal.View | AppBskyEmbedImages.View;
 
-const getMediaEmbed = (embed: RecordEmbed | ViewEmbed): Brand.Union<RecordMedia | ViewMedia> | undefined => {
+const getMediaEmbed = (
+	embed: RecordEmbed | ViewEmbed,
+): $type.enforce<RecordMedia | ViewMedia> | undefined => {
 	if (embed) {
 		const type = embed.$type;
 

src/api/utils/records.ts

···
+import type { ComAtprotoRepoGetRecord, ComAtprotoRepoListRecords } from '@atcute/atproto';
 import { type Client, ok } from '@atcute/client';
-import type {
-	At,
-	ComAtprotoRepoGetRecord,
-	ComAtprotoRepoListRecords,
-	Records,
-} from '@atcute/client/lexicons';
+import type { Cid, Did, InferInput, ResourceUri } from '@atcute/lexicons';
+import type { Records } from '@atcute/lexicons/ambient';
 
 type RecordType = keyof Records;
 
 export interface CreateRecordOptions<K extends RecordType> {
-	repo: At.Did;
+	repo: Did;
 	collection: K;
 	rkey?: string;
-	record: Records[K];
+	record: InferInput<Records[K]>;
 	swapCommit?: string;
 	validate?: boolean;
 }
···
 export const createRecord = async <K extends RecordType>(client: Client, options: CreateRecordOptions<K>) => {
 	const data = await ok(
 		client.post('com.atproto.repo.createRecord', {
-			input: options,
+			input: options as any,
 		}),
 	);
 
···
 };
 
 export interface PutRecordOptions<K extends RecordType> {
-	repo: At.Did;
+	repo: Did;
 	collection: K;
 	rkey: string;
-	record: Records[K];
+	record: InferInput<Records[K]>;
 	swapCommit?: string;
-	swapRecord?: At.Cid | null;
+	swapRecord?: Cid | null;
 	validate?: boolean;
 }
 
 export const putRecord = async <K extends RecordType>(client: Client, options: PutRecordOptions<K>) => {
 	const data = await ok(
 		client.post('com.atproto.repo.putRecord', {
-			input: options,
+			input: options as any,
 		}),
 	);
 
···
 };
 
 export interface DeleteRecordOptions<K extends RecordType> {
-	repo: At.Did;
+	repo: Did;
 	collection: K;
 	rkey: string;
 	swapCommit?: string;
···
 
 export interface GetRecordOptions<K extends RecordType> {
 	signal?: AbortSignal;
-	repo: At.Did;
+	repo: Did;
 	collection: K;
 	rkey: string;
 	cid?: string;
 }
 
-export interface GetRecordOutput<T> extends ComAtprotoRepoGetRecord.Output {
+export type GetRecordOutput<T> = ComAtprotoRepoGetRecord.$output & {
 	value: T;
-}
+};
 
 export const getRecord = async <K extends RecordType>(
 	client: Client,
 	options: GetRecordOptions<K>,
-): Promise<GetRecordOutput<Records[K]>> => {
+): Promise<GetRecordOutput<InferInput<Records[K]>>> => {
 	const data = await ok(
 		client.get('com.atproto.repo.getRecord', {
 			signal: options.signal,
···
 
 export interface ListRecordsOptions<K extends RecordType> {
 	signal?: AbortSignal;
-	repo: At.Did;
+	repo: Did;
 	collection: K;
 	cursor?: string;
 	limit?: number;
 }
 
-export interface ListRecordsOutput<T> extends ComAtprotoRepoListRecords.Output {
+export type ListRecordsOutput<T> = ComAtprotoRepoListRecords.$output & {
 	cursor?: string;
-	records: { cid: At.Cid; uri: At.ResourceUri; value: T }[];
-}
+	records: { cid: Cid; uri: ResourceUri; value: T }[];
+};
 
 export const listRecords = async <K extends RecordType>(
 	client: Client,
 	options: ListRecordsOptions<K>,
-): Promise<ListRecordsOutput<Records[K]>> => {
+): Promise<ListRecordsOutput<InferInput<Records[K]>>> => {
 	const data = await ok(
 		client.get('com.atproto.repo.listRecords', {
 			signal: options.signal,

src/api/utils/richtext-stringify.ts

···
+import type { AppBskyRichtextFacet } from '@atcute/bluesky';
 import { segmentize } from '@atcute/bluesky-richtext-segmenter';
-import type { AppBskyRichtextFacet } from '@atcute/client/lexicons';
 
 import { isLinkValid } from './strings';
 

src/atcute-env.d.ts

···
-import type { AppBskyRichtextFacet } from '@atcute/client/lexicons';
-
-declare module '@atcute/client/lexicons' {
-	namespace AppBskyRichtextFacet {
-		type FacetFeature = Brand.Union<Link | Mention | Tag | BlueMojiRichtextFacet.Main>;
-
-		interface Main {
-			features: FacetFeature[];
-		}
-	}
-}
-
-declare module '@atcute/bluesky-richtext-segmenter' {
-	export interface RichtextSegment {
-		features: AppBskyRichtextFacet.FacetFeature[] | undefined;
-	}
-}

src/basa-env.d.ts

···
-/* eslint-disable */
-// This file is automatically generated, do not edit!
-import '@atcute/client/lexicons';
-
-declare module '@atcute/client/lexicons' {
-	/** Describes the translation proxy instance */
-	namespace XBasaDescribeServer {
-		interface Params {}
-		type Input = undefined;
-		interface Output {
-			engines: Engines;
-		}
-		interface Engine {
-			[Brand.Type]?: 'x.basa.describeServer#engine';
-			/** Supported language codes */
-			languages: string[];
-		}
-		interface Engines {
-			[Brand.Type]?: 'x.basa.describeServer#engines';
-			deepl?: Engine;
-			google?: Engine;
-		}
-	}
-
-	/** Translates a given text into another language */
-	namespace XBasaTranslate {
-		interface Params {
-			/** Text needing translation */
-			text: string;
-			/** Target language */
-			to: string;
-			/**
-			 * Which translation service to use
-			 * @default "google"
-			 */
-			engine?: 'google' | 'deepl';
-			/**
-			 * Source language
-			 * @default "auto"
-			 */
-			from?: string;
-		}
-		type Input = undefined;
-		interface Output {
-			/** Translated text */
-			result: string;
-			/** Deteced language from source text */
-			sourceLanguage?: string;
-			/** Transliteration of source text */
-			sourceTransliteration?: string;
-			/** Transliteration of translated text */
-			targetTransliteration?: string;
-		}
-	}
-
-	interface Records {}
-
-	interface Queries {
-		'x.basa.describeServer': {
-			response: { json: XBasaDescribeServer.Output };
-			/** @deprecated */
-			output: XBasaDescribeServer.Output;
-		};
-		'x.basa.translate': {
-			params: XBasaTranslate.Params;
-			response: { json: XBasaTranslate.Output };
-			/** @deprecated */
-			output: XBasaTranslate.Output;
-		};
-	}
-
-	interface Procedures {}
-}

src/components/avatar.tsx

···
 import { Match, Switch } from 'solid-js';
 
-import type { AppBskyActorDefs } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 
 import { type ModerationCause, getModerationUI } from '~/api/moderation';
 import { ContextProfileMedia, type ModerationContext } from '~/api/moderation/constants';

src/components/bookmarks/add-post-to-folder-dialog.tsx

···
 import { For, createMemo } from 'solid-js';
 
-import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs } from '@atcute/bluesky';
 import { intersection } from '@mary/array-fns';
 import { useQueryClient } from '@mary/solid-query';
 

src/components/bookmarks/bookmark-feed-item.tsx

···
 import { createMemo } from 'solid-js';
 
-import type { AppBskyFeedPost } from '@atcute/client/lexicons';
+import type { AppBskyFeedPost } from '@atcute/bluesky';
 
 import { usePostShadow } from '~/api/cache/post-shadow';
 import { getModerationUI } from '~/api/moderation';
 import { ContextContentList } from '~/api/moderation/constants';
 import { moderatePost } from '~/api/moderation/entities/post';
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
+import { assertCanonicalResourceUri } from '~/api/types/at-uri';
 
 import { history } from '~/globals/navigation';
 
···
 	const { post, stale } = item;
 
 	const author = post.author;
-	const record = post.record as AppBskyFeedPost.Record;
+	const record = post.record as AppBskyFeedPost.Main;
 	const embed = post.embed;
 
 	const shadow = usePostShadow(post);
 
-	const uri = parseCanonicalResourceUri(post.uri);
+	const uri = assertCanonicalResourceUri(post.uri);
+
 	const authorHref = `/${author.did}`;
 	const href = `/${author.did}/${uri.rkey}`;
 

src/components/composer/composer-dialog.tsx

···
 } from 'solid-js';
 import { createMutable, unwrap } from 'solid-js/store';
 
-import type { AppBskyActorDefs } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 import { type CreateQueryResult, useQueryClient } from '@mary/solid-query';
 
 import { GLOBAL_LABELS, getLocalizedLabel } from '~/api/moderation';

src/components/composer/composer-input.tsx

···
 	createSignal,
 } from 'solid-js';
 
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 import { ok } from '@atcute/client';
-import type { AppBskyActorDefs } from '@atcute/client/lexicons';
 
 import { safeUrlParse } from '~/api/utils/strings';
 

src/components/composer/composer-reply-context.tsx

···
 import { Match, Switch, createMemo } from 'solid-js';
 
-import type { AppBskyFeedPost } from '@atcute/client/lexicons';
+import { type AppBskyFeedPost, unwrapMediaEmbed } from '@atcute/bluesky';
 
 import { getModerationUI } from '~/api/moderation';
 import { ContextContentMedia } from '~/api/moderation/constants';
 import { moderatePost } from '~/api/moderation/entities/post';
 import { createPostQuery } from '~/api/queries/post';
-import { unwrapMediaEmbedView } from '~/api/utils/bluesky/embed-view';
 import { formatQueryError } from '~/api/utils/error';
 
 import { inject } from '~/lib/states/singleton';
···
 			<Match when={query.data} keyed>
 				{(post) => {
 					const author = post.author;
-					const record = post.record as AppBskyFeedPost.Record;
+					const record = post.record as AppBskyFeedPost.Main;
 
 					const moderation = createMemo(() => moderatePost(post, moderationOptions()));
 					const shouldBlurImage = () => getModerationUI(moderation(), ContextContentMedia).b.length !== 0;
 
-					const media = unwrapMediaEmbedView(post.embed);
+					const media = unwrapMediaEmbed(post.embed);
 
 					return (
 						<div class="relative flex gap-3 px-4 pt-3">

src/components/composer/dialogs/composed-interaction-dialog.tsx

···
 import { For, Match, Switch, batch, createEffect, createMemo, createSignal, untrack } from 'solid-js';
 
-import type { AppBskyFeedThreadgate, Brand } from '@atcute/client/lexicons';
+import type { AppBskyFeedThreadgate } from '@atcute/bluesky';
+import type { $type } from '@atcute/lexicons';
 
 import { createMyListsQuery } from '~/api/queries/my-lists';
 import { dequal } from '~/api/utils/dequal';
···
 									<Boxed.List>
 										<For each={lists.data}>
 											{(list) => {
-												const rule: Brand.Union<AppBskyFeedThreadgate.ListRule> = {
+												const rule: $type.enforce<AppBskyFeedThreadgate.ListRule> = {
 													$type: 'app.bsky.feed.threadgate#listRule',
 													list: list.uri,
 												};

src/components/composer/embeds/link-embed.tsx

···
 import { Match, Switch, onCleanup } from 'solid-js';
 
-import type { AppBskyEmbedExternal, At } from '@atcute/client/lexicons';
+import type { AppBskyEmbedExternal } from '@atcute/bluesky';
+import type { GenericUri } from '@atcute/lexicons';
 
 import { createLinkMetaQuery } from '~/api/queries/composer';
 
···
 					{(state) => {
 						const meta = state.external;
 
-						let thumbUrl: At.GenericUri | undefined;
-						if (meta.thumb) {
+						let thumbUrl: GenericUri | undefined;
+						if (meta.thumb && '$type' in meta.thumb) {
 							const did = currentAccount!.did;
 							const cid = meta.thumb.ref.$link;
 
···
 												title: data.title,
 												description: data.description,
 												uri: data.uri,
-												thumb: thumbUrl as At.GenericUri,
+												thumb: thumbUrl as GenericUri,
 											},
 										};
 

src/components/composer/embeds/quote-embed.tsx

···
 import { Match, Switch } from 'solid-js';
 
-import type { AppBskyEmbedRecord } from '@atcute/client/lexicons';
+import type { AppBskyEmbedRecord } from '@atcute/bluesky';
 
 import { createPostQuery } from '~/api/queries/post';
 

src/components/composer/gifs/gif-search-dialog.tsx

···
 import { For, Match, Switch, createSignal } from 'solid-js';
 
-import type { At } from '@atcute/client/lexicons';
+import type { GenericUri } from '@atcute/lexicons';
 import { chunked } from '@mary/array-fns';
 
 import { type Gif, createGifSearchQuery } from '~/api/queries/composer-gif';
···
 export default GifSearchDialog;
 
 export interface GifMedia {
-	embedUrl: At.GenericUri;
+	embedUrl: GenericUri;
 	alt: string;
 	ratio: { width: number; height: number };
 
···
 	const [, id, file] = /\/([^/]+?AAAAC)\/([^/]+?)\.gif\/?$/.exec(url)!;
 
 	return {
-		embedUrl: (url + `?hh=${dimensions[1]}&ww=${dimensions[0]}`) as At.GenericUri,
+		embedUrl: (url + `?hh=${dimensions[1]}&ww=${dimensions[0]}`) as GenericUri,
 		alt: gif.content_description,
 		ratio: { width: dimensions[0], height: dimensions[1] },
 

src/components/composer/lib/api.ts

···
 import { nanoid } from 'nanoid/non-secure';
 
-import { Client, ClientResponseError, ok, simpleFetchHandler } from '@atcute/client';
+import type {
+	ComAtprotoLabelDefs,
+	ComAtprotoRepoApplyWrites,
+	ComAtprotoRepoStrongRef,
+} from '@atcute/atproto';
+import type { BlueMojiRichtextFacet } from '@atcute/bluemoji';
 import type {
 	AppBskyEmbedImages,
 	AppBskyEmbedRecord,
···
 	AppBskyGraphDefs,
 	AppBskyRichtextFacet,
 	AppBskyVideoDefs,
-	At,
-	BlueMojiRichtextFacet,
-	Brand,
-	ComAtprotoLabelDefs,
-	ComAtprotoRepoApplyWrites,
-	ComAtprotoRepoStrongRef,
-} from '@atcute/client/lexicons';
+} from '@atcute/bluesky';
+import { Client, ClientResponseError, ok, simpleFetchHandler } from '@atcute/client';
+import { type $type, type Blob as AtpBlob, type Did, type GenericUri, type Handle } from '@atcute/lexicons';
 import * as TID from '@atcute/tid';
 import type { QueryClient } from '@mary/solid-query';
 
···
 import { uploadBlob } from '~/api/queries/blob';
 import type { LinkMeta } from '~/api/queries/composer';
 import { resolveHandle } from '~/api/queries/handle';
-import { makeAtUri, parseCanonicalResourceUri } from '~/api/types/at-uri';
+import { assertCanonicalResourceUri, makeAtUri } from '~/api/types/at-uri';
 import { isDid } from '~/api/types/identity';
 import { getRecord } from '~/api/utils/records';
 import { trimRichText } from '~/api/utils/richtext';
···
 	const did = agent.did!;
 
 	const now = new Date();
-	const writes: ComAtprotoRepoApplyWrites.Input['writes'] = [];
+	const writes: ComAtprotoRepoApplyWrites.$input['writes'] = [];
 
 	let reply: AppBskyFeedPost.ReplyRef | undefined;
 	let rkey: string | undefined;
···
 			queryKey: ['post', replyUri],
 			staleTime: 30_000,
 			async queryFn(ctx) {
-				const uri = parseCanonicalResourceUri(replyUri);
+				const uri = assertCanonicalResourceUri(replyUri);
 
-				let did: At.Did;
+				let did: Did;
 				if (isDid(uri.repo)) {
 					did = uri.repo;
 				} else {
···
 			},
 		});
 
-		const root = (post.record as AppBskyFeedPost.Record).reply?.root;
+		const root = (post.record as AppBskyFeedPost.Main).reply?.root;
 		const ref: ComAtprotoRepoStrongRef.Main = {
 			uri: post.uri,
 			cid: post.cid,
···
 	}
 
 	if (state.redraftUri) {
-		const uri = parseCanonicalResourceUri(state.redraftUri);
+		const uri = assertCanonicalResourceUri(state.redraftUri);
 
 		writes.push({
 			$type: 'com.atproto.repo.applyWrites#delete',
···
 
 		// Get the self-labels
 		const labels = getEmbedLabels(post.embed);
-		let selfLabels: Brand.Union<ComAtprotoLabelDefs.SelfLabels> | undefined;
+		let selfLabels: $type.enforce<ComAtprotoLabelDefs.SelfLabels> | undefined;
 
 		if (labels?.length) {
 			selfLabels = {
···
 		}
 
 		// Now form the record
-		const record: AppBskyFeedPost.Record = {
+		const record: AppBskyFeedPost.Main = {
 			$type: 'app.bsky.feed.post',
 			createdAt: now.toISOString(),
 			text: rt.text,
···
 
 		// If this is the first post, and we have a threadgate set, create one now.
 		if (idx === 0 && !reply && state.threadgate.allow) {
-			const threadgateRecord: AppBskyFeedThreadgate.Record = {
+			const threadgateRecord: AppBskyFeedThreadgate.Main = {
 				$type: 'app.bsky.feed.threadgate',
 				createdAt: now.toISOString(),
 				post: uri,
···
 
 		// If we have a postgate set, create one for this post.
 		if (state.postgate.embeddingRules?.length) {
-			const postgateRecord: AppBskyFeedPostgate.Record = {
+			const postgateRecord: AppBskyFeedPostgate.Main = {
 				$type: 'app.bsky.feed.postgate',
 				createdAt: now.toISOString(),
 				post: uri,
···
 
 	return writes;
 
-	async function resolveEmbed(root: PostEmbed): Promise<AppBskyFeedPost.Record['embed']> {
+	async function resolveEmbed(root: PostEmbed): Promise<AppBskyFeedPost.Main['embed']> {
 		let pMedia: Promise<AppBskyEmbedRecordWithMedia.Main['media']> | undefined;
-		let pRecord: Promise<Brand.Union<AppBskyEmbedRecord.Main>> | undefined;
+		let pRecord: Promise<$type.enforce<AppBskyEmbedRecord.Main>> | undefined;
 
 		if (root.media) {
 			pMedia = resolveMediaEmbed(root.media);
···
 				}
 
 				// Check the upload status
-				let result: At.Blob<any>;
+				let result: AtpBlob<any>;
 				{
 					let pollFailures = 0;
 
···
 						const state = status.state;
 
 						if (state === 'JOB_STATE_COMPLETED') {
-							if (!status.blob) {
+							if (!status.blob || !('$type' in status.blob)) {
 								throw new PublishError(`Unexpected error when processing video`);
 							}
 
···
 				const gif = embed.gif;
 				const alt = embed.alt;
 
-				let thumbBlob: At.Blob<any> | undefined;
+				let thumbBlob: AtpBlob<any> | undefined;
 
 				{
 					log?.(`Retrieving GIF thumbnail`);
···
 
 			// compress... upload...
 			const thumb = meta.thumb;
-			let thumbBlob: At.Blob<any> | undefined;
+			let thumbBlob: AtpBlob<any> | undefined;
 
 			if (thumb !== undefined) {
 				log?.(`Uploading link thumbnail`);
···
 
 		async function resolveRecordEmbed(
 			record: PostRecordEmbed,
-		): Promise<Brand.Union<AppBskyEmbedRecord.Main>> {
+		): Promise<$type.enforce<AppBskyEmbedRecord.Main>> {
 			const type = record.type;
 
 			if (type === 'feed') {
···
 			if (type === 'link' || type === 'autolink') {
 				facets.push({
 					index: index,
-					features: [{ $type: 'app.bsky.richtext.facet#link', uri: token.url as At.GenericUri }],
+					features: [{ $type: 'app.bsky.richtext.facet#link', uri: token.url as GenericUri }],
 				});
 			} else if (type === 'mention') {
-				const handle = token.handle as At.Handle;
+				const handle = token.handle as Handle;
 
 				if (handle === 'handle.invalid') {
 					throw new InvalidHandleError(handle);
···
 
 				const raws = value.formats;
 
-				const cids: Brand.Union<BlueMojiRichtextFacet.Formats_v0> = {
+				const cids: $type.enforce<BlueMojiRichtextFacet.Formats_v0> = {
 					$type: 'blue.moji.richtext.facet#formats_v0',
 				};
 
···
 						cids.lottie = true;
 					}
 
-					if (raws.gif_128) {
+					if (raws.gif_128 && '$type' in raws.gif_128) {
 						cids.gif_128 = raws.gif_128.ref.$link;
 					}
 
-					if (raws.png_128) {
+					if (raws.png_128 && '$type' in raws.png_128) {
 						cids.png_128 = raws.png_128.ref.$link;
 					}
 
-					if (raws.webp_128) {
+					if (raws.webp_128 && '$type' in raws.webp_128) {
 						cids.webp_128 = raws.webp_128.ref.$link;
 					}
 				}
 
-				const facet: Brand.Union<BlueMojiRichtextFacet.Main> = {
+				const facet: $type.enforce<BlueMojiRichtextFacet.Main> = {
 					$type: 'blue.moji.richtext.facet',
 					did: did,
 					name: value.name,

src/components/composer/lib/link-detection.ts

···
-import type { At } from '@atcute/client/lexicons';
+import type { ActorIdentifier } from '@atcute/lexicons';
 
 import { makeAtUri } from '~/api/types/at-uri';
 import { safeUrlParse } from '~/api/utils/strings';
···
 
 		if (host === 'bsky.app') {
 			if ((match = BSKY_POST_LINK_RE.exec(path))) {
-				const didOrHandle = match[1] as At.Identifier;
+				const didOrHandle = match[1] as ActorIdentifier;
 				const rkey = match[2];
 
 				return {
···
 			}
 
 			if ((match = BSKY_FEED_LINK_RE.exec(path))) {
-				const didOrHandle = match[1] as At.Identifier;
+				const didOrHandle = match[1] as ActorIdentifier;
 				const rkey = match[2];
 
 				return {
···
 			}
 
 			if ((match = BSKY_LIST_LINK_RE.exec(path))) {
-				const didOrHandle = match[1] as At.Identifier;
+				const didOrHandle = match[1] as ActorIdentifier;
 				const rkey = match[2];
 
 				return {

src/components/composer/lib/state.tsx

···
 import { unwrap } from 'solid-js/store';
 
-import type {
-	AppBskyEmbedDefs,
-	AppBskyEmbedExternal,
-	AppBskyFeedDefs,
-	At,
-	Brand,
-} from '@atcute/client/lexicons';
+import type { AppBskyEmbedDefs, AppBskyEmbedExternal, AppBskyFeedDefs } from '@atcute/bluesky';
+import type { $type, Blob as AtpBlob } from '@atcute/lexicons';
 
 import { primarySystemLanguage } from '~/globals/locales';
 
···
 
 export interface RemoteMediaSource {
 	type: 'remote';
-	blob: At.Blob;
+	blob: AtpBlob;
 	aspectRatio?: AppBskyEmbedDefs.AspectRatio;
 }
 
···
 
 export interface RemoteLinkSource {
 	type: 'remote';
-	state: Brand.Union<AppBskyEmbedExternal.Main>;
+	state: $type.enforce<AppBskyEmbedExternal.Main>;
 }
 
 export type LinkSource = UriLinkSource | RemoteLinkSource;

src/components/embeds/embed.tsx

···
-import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+import { type AppBskyFeedDefs, type MediaEmbed, type RecordEmbed, unwrapEmbed } from '@atcute/bluesky';
 
 import { type ModerationCause, getModerationUI } from '~/api/moderation';
 import { ContextContentMedia } from '~/api/moderation/constants';
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
-import { type MediaEmbedView, type RecordEmbedView, unwrapEmbedView } from '~/api/utils/bluesky/embed-view';
+import { assertCanonicalResourceUri } from '~/api/types/at-uri';
 
 import ContentHider from '../moderation/content-hider';
 
···
 }
 
 const Embed = (props: EmbedProps) => {
-	const { media, record } = unwrapEmbedView(props.embed);
+	const { media, record } = unwrapEmbed(props.embed);
 
 	const gutterTop = props.gutterTop;
 	const large = props.large;
···
 
 interface MediaEmbedProps {
 	/** Expected to be static */
-	embed: MediaEmbedView;
+	embed: MediaEmbed;
 	moderation?: ModerationCause[];
 }
 
···
 
 interface RecordEmbedProps {
 	/** Expected to be static */
-	embed: RecordEmbedView;
+	embed: RecordEmbed;
 	/** Expected to be static */
 	large?: boolean;
 }
···
 	}
 
 	if (type === 'app.bsky.embed.record#viewNotFound' || type === 'app.bsky.embed.record#viewBlocked') {
-		const uri = parseCanonicalResourceUri(embed.uri);
+		const uri = assertCanonicalResourceUri(embed.uri);
 
 		if (type === 'app.bsky.embed.record#viewBlocked' && uri.collection === 'app.bsky.feed.post') {
 			return <QuoteBlockedEmbed embed={embed} uri={uri} />;

src/components/embeds/external-embed.tsx

···
 import { type JSX, createSignal } from 'solid-js';
 
-import type { AppBskyEmbedExternal } from '@atcute/client/lexicons';
+import type { AppBskyEmbedExternal } from '@atcute/bluesky';
 
 import { safeUrlParse } from '~/api/utils/strings';
 

src/components/embeds/feed-embed.tsx

···
 import { createMemo } from 'solid-js';
 
-import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs } from '@atcute/bluesky';
 import { useQueryClient } from '@mary/solid-query';
 
 import { moderateGeneric } from '~/api/moderation/entities/generic';
 import { precacheFeed } from '~/api/queries-cache/feed-precache';
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
+import { assertCanonicalResourceUri } from '~/api/types/at-uri';
 
 import { inject } from '~/lib/states/singleton';
 import ModerationService from '~/lib/states/singletons/moderation';
···
 
 	const moderation = createMemo(() => moderateGeneric(feed, feed.creator.did, moderationOptions()));
 
-	const href = `/${feed.creator.did}/feeds/${parseCanonicalResourceUri(feed.uri).rkey}`;
+	const href = `/${feed.creator.did}/feeds/${assertCanonicalResourceUri(feed.uri).rkey}`;
 
 	return (
 		<a

src/components/embeds/image-grid-embed.tsx

···
-import type { AppBskyEmbedImages } from '@atcute/client/lexicons';
+import type { AppBskyEmbedImages } from '@atcute/bluesky';
 
 export interface ImageGridEmbedProps {
 	/** Expected to be static */

src/components/embeds/image-standalone-embed.tsx

···
-import type { AppBskyEmbedImages } from '@atcute/client/lexicons';
+import type { AppBskyEmbedImages } from '@atcute/bluesky';
 
 import { openModal } from '~/globals/modals';
 

src/components/embeds/lib/image-utils.ts

···
-import type { AppBskyEmbedImages } from '@atcute/client/lexicons';
+import type { AppBskyEmbedImages } from '@atcute/bluesky';
 
 const clamp = (value: number, min: number, max: number): number => {
 	return Math.max(min, Math.min(max, value));

src/components/embeds/lib/snippet.tsx

···
-import type { AppBskyEmbedExternal } from '@atcute/client/lexicons';
+import type { AppBskyEmbedExternal } from '@atcute/bluesky';
 
 import { safeUrlParse } from '~/api/utils/strings';
 

src/components/embeds/list-embed.tsx

···
 import { createMemo } from 'solid-js';
 
-import type { AppBskyGraphDefs } from '@atcute/client/lexicons';
+import type { AppBskyGraphDefs } from '@atcute/bluesky';
 
 import { moderateGeneric } from '~/api/moderation/entities/generic';
 

src/components/embeds/players/video-player.tsx

···
 import { nanoid } from 'nanoid/non-secure';
 import { createEffect, createSignal, onCleanup } from 'solid-js';
 
-import type { AppBskyEmbedVideo } from '@atcute/client/lexicons';
+import type { AppBskyEmbedVideo } from '@atcute/bluesky';
 
 import { globalEvents } from '~/globals/events';
 

src/components/embeds/quote-blocked-embed.tsx

···
-import type { AppBskyEmbedRecord } from '@atcute/client/lexicons';
-
-import type { ParsedCanonicalResourceUri } from '~/api/types/at-uri';
+import type { AppBskyEmbedRecord } from '@atcute/bluesky';
+import type { ParsedCanonicalResourceUri } from '@atcute/lexicons';
 
 import BlockOutlinedIcon from '../icons-central/block-outline';
 

src/components/embeds/quote-embed.tsx

···
 import { type JSX, createMemo } from 'solid-js';
 
-import type { AppBskyEmbedRecord, AppBskyFeedPost } from '@atcute/client/lexicons';
+import { AppBskyEmbedRecord, AppBskyFeedPost, unwrapMediaEmbed } from '@atcute/bluesky';
 
 import { getModerationUI } from '~/api/moderation';
 import { ContextContentMedia } from '~/api/moderation/constants';
 import { moderateQuote } from '~/api/moderation/entities/quote';
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
-import { unwrapMediaEmbedView } from '~/api/utils/bluesky/embed-view';
+import { assertCanonicalResourceUri } from '~/api/types/at-uri';
 
 import { inject } from '~/lib/states/singleton';
 import ModerationService from '~/lib/states/singletons/moderation';
···
 const QuoteEmbed = ({ quote, interactive, large }: QuoteEmbedProps) => {
 	const moderationOptions = inject(ModerationService);
 
-	const record = quote.value as AppBskyFeedPost.Record;
+	const record = quote.value as AppBskyFeedPost.Main;
 	const author = quote.author;
 
-	const uri = parseCanonicalResourceUri(quote.uri);
+	const uri = assertCanonicalResourceUri(quote.uri);
 	const href = `/${author.did}/${uri.rkey}`;
 
 	const text = record.text.trim();
-	const media = unwrapMediaEmbedView(quote.embeds?.[0]);
+	const media = unwrapMediaEmbed(quote.embeds?.[0]);
 
 	const moderation = createMemo(() => moderateQuote(quote, moderationOptions()));
 

src/components/embeds/video-embed.tsx

···
 import { Show, Suspense, createSignal, lazy } from 'solid-js';
 
-import type { AppBskyEmbedDefs, AppBskyEmbedVideo } from '@atcute/client/lexicons';
+import { AppBskyEmbedDefs, AppBskyEmbedVideo } from '@atcute/bluesky';
 
 import { replaceVideoCdnUrl } from '~/lib/bsky/video';
 

src/components/error-view.tsx

···
 import { Match, Switch } from 'solid-js';
 
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 import { ClientResponseError } from '@atcute/client';
-import type { AppBskyActorDefs } from '@atcute/client/lexicons';
 import { TokenRefreshError } from '@atcute/oauth-browser-client';
 import { useQueryClient } from '@mary/solid-query';
 

src/components/explore/my-feeds-section.tsx

···
 import { For, createMemo } from 'solid-js';
 
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
+import { assertCanonicalResourceUri } from '~/api/types/at-uri';
 
 import type { SavedFeed } from '~/lib/preferences/account';
 import { useSession } from '~/lib/states/session';
···
 					let href: string;
 					switch (type) {
 						case 'generator': {
-							const uri = parseCanonicalResourceUri(feed.info.uri);
+							const uri = assertCanonicalResourceUri(feed.info.uri);
 							href = `/${uri.repo}/feeds/${uri.rkey}`;
 							break;
 						}
 						case 'list': {
-							const uri = parseCanonicalResourceUri(feed.info.uri);
+							const uri = assertCanonicalResourceUri(feed.info.uri);
 							href = `/${uri.repo}/lists/${uri.rkey}`;
 							break;
 						}

src/components/feeds/feed-info-prompt.tsx

···
-import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs } from '@atcute/bluesky';
 
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
+import { assertCanonicalResourceUri } from '~/api/types/at-uri';
 
 import { useModalContext } from '~/globals/modals';
 
···
 	const feed = props.feed;
 
 	const authorUrl = `/${feed.creator.did}`;
-	const feedUrl = `${authorUrl}/feeds/${parseCanonicalResourceUri(feed.uri).rkey}`;
+	const feedUrl = `${authorUrl}/feeds/${assertCanonicalResourceUri(feed.uri).rkey}`;
 
 	return (
 		<Prompt.Container maxWidth="md">

src/components/feeds/feed-item.tsx

···
 import { createMemo } from 'solid-js';
 
-import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs } from '@atcute/bluesky';
 import { useQueryClient } from '@mary/solid-query';
 
 import { moderateGeneric } from '~/api/moderation/entities/generic';
 import { precacheFeed } from '~/api/queries-cache/feed-precache';
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
+import { assertCanonicalResourceUri } from '~/api/types/at-uri';
 
 import { history } from '~/globals/navigation';
 
···
 	const moderationOptions = inject(ModerationService);
 
 	const creator = item.creator;
-	const href = `/${creator.did}/feeds/${parseCanonicalResourceUri(item.uri).rkey}`;
+	const href = `/${creator.did}/feeds/${assertCanonicalResourceUri(item.uri).rkey}`;
 
 	const moderation = createMemo(() => moderateGeneric(item, creator.did, moderationOptions()));
 

src/components/feeds/feed-overflow-menu.tsx

···
 import { createMemo } from 'solid-js';
 
-import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs } from '@atcute/bluesky';
 
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
+import { assertCanonicalResourceUri } from '~/api/types/at-uri';
 
 import { useModalContext } from '~/globals/modals';
 
···
 				icon={OpenInNewOutlinedIcon}
 				label="Open in Bluesky app"
 				onClick={() => {
-					const uri = `https://bsky.app/profile/${feed.creator.did}/feed/${parseCanonicalResourceUri(feed.uri).rkey}`;
+					const { repo, rkey } = assertCanonicalResourceUri(feed.uri);
+					const uri = `https://bsky.app/profile/${repo}/feed/${rkey}`;
 
 					close();
 					window.open(uri, '_blank');

src/components/lists/lib/utils.ts

···
-import type { AppBskyGraphDefs } from '@atcute/client/lexicons';
+import type { AppBskyGraphDefs } from '@atcute/bluesky';
 
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
+import { assertCanonicalResourceUri } from '~/api/types/at-uri';
 
 export const getListPurposeLabel = (purpose: AppBskyGraphDefs.ListPurpose) => {
 	switch (purpose) {
···
 
 export const getListUrl = (list: AppBskyGraphDefs.ListView) => {
 	const did = list.creator.did;
-	const { rkey } = parseCanonicalResourceUri(list.uri);
+	const { rkey } = assertCanonicalResourceUri(list.uri);
 
 	switch (list.purpose) {
 		case 'app.bsky.graph.defs#curatelist':

src/components/lists/list-item.tsx

···
 import { createMemo } from 'solid-js';
 
-import type { AppBskyGraphDefs } from '@atcute/client/lexicons';
+import type { AppBskyGraphDefs } from '@atcute/bluesky';
 import { useQueryClient } from '@mary/solid-query';
 
 import { moderateGeneric } from '~/api/moderation/entities/generic';

src/components/main/sign-in-dialog.tsx

···
 import { Match, Switch, createSignal, onMount } from 'solid-js';
 
-import type { At } from '@atcute/client/lexicons';
+import type { Did } from '@atcute/lexicons';
 import {
 	type AuthorizationServerMetadata,
 	type IdentityMetadata,
···
 }
 
 export interface SignInDialogProps {
-	relogin?: { did: At.Did; handle?: string };
+	relogin?: { did: Did; handle?: string };
 }
 
 const SignInDialog = (props: SignInDialogProps) => {

src/components/moderation/block-account-prompt.tsx

···
 import { Match, Switch } from 'solid-js';
 
-import type { AppBskyActorDefs, At } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs } from '@atcute/bluesky';
+import { type Did } from '@atcute/lexicons';
 import { QueryClient, createMutation } from '@mary/solid-query';
 
 import { type ProfileShadowView, updateProfileShadow, useProfileShadow } from '~/api/cache/profile-shadow';
 import { createListMetaQuery } from '~/api/queries/list';
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
+import { assertCanonicalResourceUri } from '~/api/types/at-uri';
 import { getCurrentDate } from '~/api/utils/misc';
 import { createRecord, deleteRecord } from '~/api/utils/records';
 
···
 
 	const mutation = createMutation((queryClient) => ({
 		async mutationFn() {
-			const { repo, rkey } = parseCanonicalResourceUri(props.shadow.blockUri!);
+			const uri = assertCanonicalResourceUri(props.shadow.blockUri!);
 
 			return await deleteRecord(client, {
-				repo: repo as At.Did,
+				repo: uri.repo,
 				collection: 'app.bsky.graph.block',
-				rkey: rkey,
+				rkey: uri.rkey,
 			});
 		},
 		onSuccess() {
···
 	);
 };
 
-const resetThreadQueries = (queryClient: QueryClient, did: At.Did) => {
+const resetThreadQueries = (queryClient: QueryClient, did: Did) => {
 	const substring = `at://${did}/`;
 
 	queryClient.resetQueries({

src/components/moderation/labels-on-me.tsx

···
 import { Show } from 'solid-js';
 
-import type { ComAtprotoLabelDefs } from '@atcute/client/lexicons';
+import type { ComAtprotoLabelDefs } from '@atcute/atproto';
 
 import { useSession } from '~/lib/states/session';
 

src/components/moderation/mute-account-prompt.tsx

···
 import { Match, Switch, onMount } from 'solid-js';
 
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 import { ok } from '@atcute/client';
-import type { AppBskyActorDefs } from '@atcute/client/lexicons';
 import { createMutation } from '@mary/solid-query';
 
 import { updateProfileShadow, useProfileShadow } from '~/api/cache/profile-shadow';

src/components/notifications/notification-item.tsx

···
 import { type Component, type ComponentProps, type JSX, createMemo } from 'solid-js';
 
-import type {
-	AppBskyEmbedImages,
-	AppBskyFeedDefs,
-	AppBskyFeedPost,
-	AppBskyNotificationListNotifications,
-} from '@atcute/client/lexicons';
+import {
+	type AppBskyEmbedImages,
+	type AppBskyFeedDefs,
+	type AppBskyFeedPost,
+	type AppBskyNotificationListNotifications,
+	type MediaEmbed,
+	unwrapMediaEmbed,
+} from '@atcute/bluesky';
 import { useQueryClient } from '@mary/solid-query';
 
 import { getModerationUI } from '~/api/moderation';
···
 	NotificationSlice,
 	RepostNotificationSlice,
 } from '~/api/queries/notification-feed';
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
-import { type MediaEmbedView, unwrapMediaEmbedView } from '~/api/utils/bluesky/embed-view';
+import { assertCanonicalResourceUri } from '~/api/types/at-uri';
 
 import { history } from '~/globals/navigation';
 
···
 				}
 			} else {
 				const post = item.view;
-				const uri = parseCanonicalResourceUri(post.uri);
-				href = `/${uri.repo}/${uri.rkey}`;
+				const { repo, rkey } = assertCanonicalResourceUri(post.uri);
+
+				href = `/${repo}/${rkey}`;
 			}
 
 			if (isElementAltClicked(ev)) {
···
 
 	if (type === 'like' || type === 'repost') {
 		const post = data.view;
-		const record = post.record as AppBskyFeedPost.Record;
+		const record = post.record as AppBskyFeedPost.Main;
 
-		const media = unwrapMediaEmbedView(post.embed);
+		const media = unwrapMediaEmbed(post.embed);
 		const gif = maybeUnwrapGifEmbed(media);
 
 		return (
···
 	);
 };
 
-const maybeUnwrapGifEmbed = (embed: MediaEmbedView | undefined): BlueskyGifSnippet | undefined => {
+const maybeUnwrapGifEmbed = (embed: MediaEmbed | undefined): BlueskyGifSnippet | undefined => {
 	if (embed?.$type === 'app.bsky.embed.external#view') {
 		const snippet = detectSnippet(embed.external);
 		if (snippet.type !== SnippetType.BLUESKY_GIF) {

src/components/profiles/edit-profile-dialog.tsx

···
 import { Show, createMemo, createSignal } from 'solid-js';
 
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 import { ClientResponseError } from '@atcute/client';
-import type { AppBskyActorDefs, At } from '@atcute/client/lexicons';
+import type { Blob as AtpBlob } from '@atcute/lexicons';
 import { createMutation } from '@mary/solid-query';
 
 import { uploadBlob } from '~/api/queries/blob';
···
 			const $avatar = avatar();
 			const $banner = banner();
 
-			let avatarPromise: Promise<At.Blob<any>> | undefined;
-			let bannerPromise: Promise<At.Blob<any>> | undefined;
+			let avatarPromise: Promise<AtpBlob<any>> | undefined;
+			let bannerPromise: Promise<AtpBlob<any>> | undefined;
 
 			if ($avatar instanceof Blob) {
 				avatarPromise = compressProfileImage($avatar, 1000, 1000).then((res) => uploadBlob(client, res.blob));

src/components/profiles/handle-overflow-menu.tsx

···
-import type { AppBskyActorDefs } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 
 import { useModalContext } from '~/globals/modals';
 

src/components/profiles/profile-follow-button.tsx

···
 import { type JSX, createMemo } from 'solid-js';
 
-import type { AppBskyActorDefs } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 
 import { useProfileShadow } from '~/api/cache/profile-shadow';
 import { createProfileFollowMutation } from '~/api/mutations/profile';

src/components/profiles/profile-item-pressable.tsx

···
 import { type JSX, createMemo } from 'solid-js';
 
-import type { AppBskyActorDefs } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 
 import { moderateProfile } from '~/api/moderation/entities/profile';
 

src/components/profiles/profile-item.tsx

···
 import { type JSX, createMemo } from 'solid-js';
 
-import type { AppBskyActorDefs } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 import { useQueryClient } from '@mary/solid-query';
 
 import { moderateProfile } from '~/api/moderation/entities/profile';

src/components/profiles/profile-overflow-menu.tsx

···
 import { createMemo } from 'solid-js';
 
-import type { AppBskyActorDefs } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 
 import { useProfileShadow } from '~/api/cache/profile-shadow';
 

src/components/profiles/profile-view-header.tsx

···
 import { type Component, type ComponentProps, type JSX, Match, Show, Switch, createMemo } from 'solid-js';
 
-import type { AppBskyActorDefs } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 
 import { useProfileShadow } from '~/api/cache/profile-shadow';
 import { getModerationUI } from '~/api/moderation';
 import { ContextProfileMedia, ContextProfileView } from '~/api/moderation/constants';
 import { moderateProfile } from '~/api/moderation/entities/profile';
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
+import { assertCanonicalResourceUri } from '~/api/types/at-uri';
 
 import { openModal } from '~/globals/modals';
 
···
 						<Match when={viewer()?.mutedByList}>
 							{(list) => {
 								const href = () => {
-									const uri = parseCanonicalResourceUri(list().uri);
-									return `/${uri.repo}/lists/${uri.rkey}`;
+									const { repo, rkey } = assertCanonicalResourceUri(list().uri);
+									return `/${repo}/lists/${rkey}`;
 								};
 
 								return (

src/components/rich-text.tsx

···
 import type { JSX } from 'solid-js';
 
+import type { BlueMojiRichtextFacet } from '@atcute/bluemoji';
+import type { AppBskyRichtextFacet } from '@atcute/bluesky';
 import { segmentize } from '@atcute/bluesky-richtext-segmenter';
-import type { AppBskyRichtextFacet } from '@atcute/client/lexicons';
 
 import { isLinkValid } from '~/api/utils/strings';
 
···
 
 							break;
 						} else if (type === 'blue.moji.richtext.facet') {
-							const formats = feature.formats;
+							const feat = feature as BlueMojiRichtextFacet.Main;
+							const formats = feat.formats;
 							if (formats.$type !== 'blue.moji.richtext.facet#formats_v0' || !formats.png_128) {
 								continue;
 							}
 
 							node = (
 								<img
-									src={/* @once */ getCdnUrl(feature.did, formats.png_128)}
-									title={/* @once */ feature.name}
+									src={/* @once */ getCdnUrl(feat.did, formats.png_128)}
+									title={/* @once */ feat.name}
 									class={`mx-px inline-block align-top text-[0]` + (!large ? ` h-5 w-5` : ` h-6 w-6`)}
 								/>
 							);

src/components/threads/highlighted-post.tsx

···
 import { Show, createMemo } from 'solid-js';
 
-import type { AppBskyFeedDefs, AppBskyFeedPost } from '@atcute/client/lexicons';
+import { AppBskyFeedDefs, AppBskyFeedPost } from '@atcute/bluesky';
 
 import { usePostShadow } from '~/api/cache/post-shadow';
 import { getModerationUI } from '~/api/moderation';
 import { ContextContentView } from '~/api/moderation/constants';
 import { moderatePost } from '~/api/moderation/entities/post';
 import { createPostLikeMutation, createPostRepostMutation } from '~/api/mutations/post';
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
+import { assertCanonicalResourceUri } from '~/api/types/at-uri';
 
 import { primarySystemLanguage } from '~/globals/locales';
 import { openModal } from '~/globals/modals';
···
 	const moderationOptions = inject(ModerationService);
 
 	const author = () => post().author;
-	const record = () => post().record as AppBskyFeedPost.Record;
+	const record = () => post().record as AppBskyFeedPost.Main;
 	const embed = () => post().embed;
 
 	const shadow = usePostShadow(post);
 
-	const uri = parseCanonicalResourceUri(post().uri);
+	const { rkey } = assertCanonicalResourceUri(post().uri);
 	const authorDid = author().did;
 
 	const isOurPost = currentAccount && authorDid === currentAccount.did;
 
 	const authorHref = `/${authorDid}`;
-	const href = `/${authorDid}/${uri.rkey}`;
+	const href = `/${authorDid}/${rkey}`;
 
 	const moderation = createMemo(() => moderatePost(post(), moderationOptions()));
 	const ui = createMemo(() => getModerationUI(moderation(), ContextContentView));
···
 					}
 
 					if (props.translate) {
-						return <PostTranslation text={(post().record as AppBskyFeedPost.Record).text} />;
+						return <PostTranslation text={(post().record as AppBskyFeedPost.Main).text} />;
 					}
 
 					if (needTranslation(post(), currentAccount.preferences.translation)) {
···
 		return false;
 	}
 
-	const record = post.record as AppBskyFeedPost.Record;
+	const record = post.record as AppBskyFeedPost.Main;
 	const langs = record.langs;
 
 	if (!langs || langs.length < 1 || !record.text) {

src/components/threads/overflow-thread-item.tsx

···
 import type { OverflowAncestorItem, OverflowDescendantItem } from '~/api/models/post-thread';
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
+import { assertCanonicalResourceUri } from '~/api/types/at-uri';
 
 import MoreHorizOutlinedIcon from '../icons-central/more-horiz-outline';
 
···
 	return (
 		<a
 			href={(() => {
-				const uri = parseCanonicalResourceUri(props.item.uri);
+				const uri = assertCanonicalResourceUri(props.item.uri);
 				return `/${uri.repo}/${uri.rkey}`;
 			})()}
 			class={

src/components/threads/post-thread-item.tsx

···
 import { type JSX, Show, createMemo } from 'solid-js';
 
-import type { AppBskyFeedPost } from '@atcute/client/lexicons';
+import type { AppBskyFeedPost } from '@atcute/bluesky';
 import { useQueryClient } from '@mary/solid-query';
 
 import { usePostShadow } from '~/api/cache/post-shadow';
···
 import { ContextContentList } from '~/api/moderation/constants';
 import { moderatePost } from '~/api/moderation/entities/post';
 import { precacheProfile } from '~/api/queries-cache/profile-precache';
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
+import { assertCanonicalResourceUri } from '~/api/types/at-uri';
 
 import { history } from '~/globals/navigation';
 
···
 	const post = () => item().post;
 
 	const author = () => post().author;
-	const record = post().record as AppBskyFeedPost.Record;
+	const record = post().record as AppBskyFeedPost.Main;
 	const embed = post().embed;
 
 	const shadow = usePostShadow(post);
 
-	const uri = parseCanonicalResourceUri(post().uri);
 	const authorHref = `/${author().did}`;
-	const href = `/${author().did}/${uri.rkey}`;
+	const href = `/${author().did}/${assertCanonicalResourceUri(post().uri).rkey}`;
 
 	const isOurPost = currentAccount && currentAccount.did === author().did;
 

src/components/timeline/delete-post-prompt.tsx

···
+import { AppBskyFeedDefs, AppBskyFeedPost } from '@atcute/bluesky';
 import { ClientResponseError, ok } from '@atcute/client';
-import type { AppBskyFeedDefs, AppBskyFeedPost } from '@atcute/client/lexicons';
 import { useQueryClient } from '@mary/solid-query';
 
 import { updatePostShadow } from '~/api/cache/post-shadow';
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
+import { assertCanonicalResourceUri } from '~/api/types/at-uri';
 
 import { useAgent } from '~/lib/states/agent';
 import { useSession } from '~/lib/states/session';
···
 	const queryClient = useQueryClient();
 
 	const onDelete = async () => {
-		const uri = parseCanonicalResourceUri(post.uri);
+		const { rkey } = assertCanonicalResourceUri(post.uri);
 
 		const write = await client.post('com.atproto.repo.applyWrites', {
 			input: {
···
 					{
 						$type: 'com.atproto.repo.applyWrites#delete',
 						collection: 'app.bsky.feed.post',
-						rkey: uri.rkey,
+						rkey: rkey,
 					},
 				],
 			},
···
 				input: {
 					repo: currentAccount!.did,
 					collection: 'app.bsky.feed.post',
-					rkey: uri.rkey,
+					rkey: rkey,
 					validate: false,
 					record: {
 						$type: 'app.bsky.feed.post',
 						text: '',
 						createdAt: '1970-01-01T00:00:00.000Z',
-					} satisfies AppBskyFeedPost.Record,
+					} satisfies AppBskyFeedPost.Main,
 				},
 			}),
 		);
···
 				input: {
 					repo: currentAccount!.did,
 					collection: 'app.bsky.feed.post',
-					rkey: uri.rkey,
+					rkey: rkey,
 				},
 			}),
 		);

src/components/timeline/pin-post-prompt.tsx

···
 import { Match, Show, Switch, batch } from 'solid-js';
 
+import type { AppBskyFeedDefs } from '@atcute/bluesky';
 import { ClientResponseError } from '@atcute/client';
-import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
 import { createMutation } from '@mary/solid-query';
 
 import { updatePostShadow, usePostShadow } from '~/api/cache/post-shadow';

src/components/timeline/post-actions.tsx

···
-import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs } from '@atcute/bluesky';
 
 import { type PostShadowView } from '~/api/cache/post-shadow';
 import { createPostLikeMutation, createPostRepostMutation } from '~/api/mutations/post';

src/components/timeline/post-feed-item.tsx

···
 import { createMemo } from 'solid-js';
 
-import type { AppBskyFeedPost, At } from '@atcute/client/lexicons';
+import type { AppBskyFeedPost } from '@atcute/bluesky';
+import { type Did } from '@atcute/lexicons';
 import { useQueryClient } from '@mary/solid-query';
 
 import { usePostShadow } from '~/api/cache/post-shadow';
···
 import { ContextContentList } from '~/api/moderation/constants';
 import { moderatePost } from '~/api/moderation/entities/post';
 import { precacheProfile } from '~/api/queries-cache/profile-precache';
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
+import { assertCanonicalResourceUri } from '~/api/types/at-uri';
 
 import { history } from '~/globals/navigation';
 
···
 	/** Expected to be static */
 	item: UiTimelineItem;
 	highlighted?: boolean;
-	timelineDid?: At.Did;
+	timelineDid?: Did;
 }
 
 const PostFeedItem = ({ item, highlighted, timelineDid }: PostFeedItemProps) => {
···
 	const author = post.author;
 	const authorDid = author.did;
 
-	const record = post.record as AppBskyFeedPost.Record;
+	const record = post.record as AppBskyFeedPost.Main;
 	const embed = post.embed;
 
 	const shadow = usePostShadow(post);
 
-	const uri = parseCanonicalResourceUri(post.uri);
+	const { rkey } = assertCanonicalResourceUri(post.uri);
+
 	const authorHref = `/${authorDid}`;
-	const href = `/${authorDid}/${uri.rkey}`;
+	const href = `/${authorDid}/${rkey}`;
 
 	const isOurPost = currentAccount && authorDid === currentAccount.did;
 

src/components/timeline/post-meta.tsx

···
-import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs } from '@atcute/bluesky';
 import { useQueryClient } from '@mary/solid-query';
 
 import { precacheProfile } from '~/api/queries-cache/profile-precache';

src/components/timeline/post-overflow-menu.tsx

···
 import { createMemo } from 'solid-js';
 
-import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs } from '@atcute/bluesky';
 import { useQueryClient } from '@mary/solid-query';
 
 import { usePostShadow } from '~/api/cache/post-shadow';

src/components/timeline/post-reply-context.tsx

···
-import type { AppBskyFeedPost } from '@atcute/client/lexicons';
+import type { AppBskyFeedPost } from '@atcute/bluesky';
 
 import type { UiTimelineItem } from '~/api/models/timeline';
 import { createProfileQuery } from '~/api/queries/profile';
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
+import { assertCanonicalResourceUri } from '~/api/types/at-uri';
 
 import { useSession } from '~/lib/states/session';
 
···
 			);
 		}
 
-		const raw = (post.record as AppBskyFeedPost.Record).reply?.parent;
+		const raw = (post.record as AppBskyFeedPost.Main).reply?.parent;
 		if (raw) {
-			const did = parseCanonicalResourceUri(raw.uri).repo;
+			const { repo: did } = assertCanonicalResourceUri(raw.uri);
+
 			if (did === currentAccount?.did) {
 				return <div class="mb-0.5 flex text-de text-contrast-muted">Replying to you</div>;
 			}

src/components/timeline/post-share-menu.tsx

···
-import type { AppBskyFeedDefs, AppBskyFeedPost } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs, AppBskyFeedPost } from '@atcute/bluesky';
 
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
+import { assertCanonicalResourceUri } from '~/api/types/at-uri';
 import { serializeRichText } from '~/api/utils/richtext-stringify';
 
 import { useModalContext } from '~/globals/modals';
···
 	const post = props.post;
 
 	const did = post.author.did;
-	const { rkey } = parseCanonicalResourceUri(post.uri);
+	const { rkey } = assertCanonicalResourceUri(post.uri);
 
 	return (
 		<Menu.Container anchor={props.anchor} placement="bottom-end">
···
 				icon={ClipboardOutlinedIcon}
 				label="Copy post text"
 				onClick={() => {
-					const record = post.record as AppBskyFeedPost.Record;
+					const record = post.record as AppBskyFeedPost.Main;
 					const serialized = serializeRichText(record.text, record.facets);
 
 					navigator.clipboard.writeText(serialized).then(close);

src/components/timeline/revise-post-prompt.tsx

···
-import type { AppBskyFeedDefs, AppBskyFeedPost, AppBskyFeedThreadgate } from '@atcute/client/lexicons';
+import {
+	type AppBskyFeedDefs,
+	type AppBskyFeedPost,
+	type AppBskyFeedThreadgate,
+	type RawMediaEmbed,
+	type RawRecordEmbed,
+	unwrapRawEmbed,
+} from '@atcute/bluesky';
 
-import { parseCanonicalResourceUri } from '~/api/types/at-uri';
-import { type MediaEmbed, type RecordEmbed, unwrapEmbed } from '~/api/utils/bluesky/embed';
+import { assertCanonicalResourceUri } from '~/api/types/at-uri';
 import { serializeRichText } from '~/api/utils/richtext-stringify';
 
 import { openModal, useModalContext } from '~/globals/modals';
···
 import {
 	type ComposerState,
 	type PostEmbed,
+	type PostImage,
 	type PostLinkEmbed,
 	type PostMediaEmbed,
 	type PostRecordEmbed,
···
 	const { close } = useModalContext();
 
 	(async () => {
-		const record = post.record as AppBskyFeedPost.Record;
-		const threadgate = post.threadgate?.record as AppBskyFeedThreadgate.Record | undefined;
+		const record = post.record as AppBskyFeedPost.Main;
+		const threadgate = post.threadgate?.record as AppBskyFeedThreadgate.Main | undefined;
 		const embeddingDisabled = post.viewer?.embeddingDisabled;
 
-		const embeds = unwrapEmbed(record.embed);
+		const embeds = unwrapRawEmbed(record.embed);
 		const draftEmbeds: PostEmbed = {
 			link: embeds.media ? toLinkEmbed(post, embeds.media) : undefined,
 			media: embeds.media ? toMediaEmbed(post, embeds.media) : undefined,
···
 
 export default RevisePostPrompt;
 
-const toMediaEmbed = (post: AppBskyFeedDefs.PostView, embed: MediaEmbed): PostMediaEmbed | undefined => {
+const toMediaEmbed = (post: AppBskyFeedDefs.PostView, embed: RawMediaEmbed): PostMediaEmbed | undefined => {
 	const authorDid = post.author.did;
 
 	switch (embed.$type) {
 		case 'app.bsky.embed.images': {
 			return {
 				type: 'image',
-				images: embed.images.map((item) => ({
-					source: {
-						type: 'remote',
-						blob: item.image,
-						aspectRatio: item.aspectRatio,
-					},
-					alt: item.alt,
-				})),
+				images: embed.images.map((item): PostImage => {
+					assert('$type' in item.image);
+
+					return {
+						source: {
+							type: 'remote',
+							blob: item.image,
+							aspectRatio: item.aspectRatio,
+						},
+						alt: item.alt,
+					};
+				}),
 				labels: post.labels?.filter((label) => label.src === authorDid).map((label) => label.val) ?? [],
 			};
 		}
 		case 'app.bsky.embed.video': {
+			assert('$type' in embed.video);
+
 			return {
 				type: 'video',
 				source: {
···
 	}
 };
 
-const toLinkEmbed = (post: AppBskyFeedDefs.PostView, embed: MediaEmbed): PostLinkEmbed | undefined => {
+const toLinkEmbed = (post: AppBskyFeedDefs.PostView, embed: RawMediaEmbed): PostLinkEmbed | undefined => {
 	const authorDid = post.author.did;
 
 	switch (embed.$type) {
···
 	}
 };
 
-const toRecordEmbed = (embed: RecordEmbed): PostRecordEmbed | undefined => {
+const toRecordEmbed = (embed: RawRecordEmbed): PostRecordEmbed | undefined => {
 	const ref = embed.record;
 
-	const uri = ref.uri;
-	const { collection } = parseCanonicalResourceUri(uri);
+	const refUri = ref.uri;
+	const uri = assertCanonicalResourceUri(refUri);
 
-	switch (collection) {
+	switch (uri.collection) {
 		case 'app.bsky.feed.post': {
-			return { type: 'quote', uri, origin: false };
+			return { type: 'quote', uri: refUri, origin: false };
 		}
 		case 'app.bsky.graph.list': {
-			return { type: 'list', uri };
+			return { type: 'list', uri: refUri };
 		}
 		case 'app.bsky.feed.generator': {
-			return { type: 'feed', uri };
+			return { type: 'feed', uri: refUri };
 		}
 	}
 
-	assert(false, `unknown "${collection}" record type`);
+	assert(false, `unknown "${uri.collection}" record type`);
 };

src/components/timeline/timeline-list.tsx

···
-import type { At } from '@atcute/client/lexicons';
+import type { Did } from '@atcute/lexicons';
 
 import { type TimelineParams, useTimelineQuery } from '~/api/queries/timeline';
 
···
 
 export interface TimelineListProps {
 	params: TimelineParams;
-	timelineDid?: At.Did;
+	timelineDid?: Did;
 }
 
 const TimelineList = (props: TimelineListProps) => {

src/lib/aglais-bookmarks/db.ts

···
 import type { DBSchema } from 'idb';
 
-import type { AppBskyFeedDefs } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs } from '@atcute/bluesky';
 
 export interface BookmarkDBSchema extends DBSchema {
 	tags: {

src/lib/aglais-bookmarks/search.ts

···
+import type { AppBskyFeedDefs, AppBskyFeedPost } from '@atcute/bluesky';
 import type { Token } from '@atcute/bluesky-search-parser';
-import type { AppBskyFeedDefs, AppBskyFeedPost } from '@atcute/client/lexicons';
 import { mapDefined } from '@mary/array-fns';
 
 import { DID_RE, HANDLE_RE } from '~/api/types/identity';
···
 		});
 
 		const re = new RegExp('\\b' + values.join('|') + '\\b', 'i');
-		predicates.push((post) => re.test((post.record as AppBskyFeedPost.Record).text));
+		predicates.push((post) => re.test((post.record as AppBskyFeedPost.Main).text));
 	}
 
 	return (post: AppBskyFeedDefs.PostView) => predicates.every((fn) => fn(post));

src/lib/atproto/labeler.ts

···
 import { type FetchHandler, type FetchHandlerObject, buildFetchHandler } from '@atcute/client';
-import type { At } from '@atcute/client/lexicons';
-import { mergeHeaders } from '@atcute/client/utils/http';
+import type { Did } from '@atcute/lexicons';
 
 export interface Labeler {
-	did: At.Did;
+	did: Did;
 	redact: boolean;
 }
 
···
 		});
 	};
 };
+
+const mergeHeaders = (
+	init: HeadersInit | undefined,
+	defaults: Record<string, string | null>,
+): HeadersInit | undefined => {
+	let headers: Headers | undefined;
+
+	for (const name in defaults) {
+		const value = defaults[name];
+
+		if (value !== null) {
+			headers ??= new Headers(init);
+
+			if (!headers.has(name)) {
+				headers.set(name, value);
+			}
+		}
+	}
+
+	return headers ?? init;
+};

src/lib/bsky/image.ts

···
-import type { AppBskyEmbedDefs } from '@atcute/client/lexicons';
+import type { AppBskyEmbedDefs } from '@atcute/bluesky';
 import { remove as removeExif } from '@mary/exif-rm';
 
 const MAX_SIZE = 1_000_000; // 1 MB

src/lib/preferences/account.ts

···
-import type { AppBskyFeedDefs, AppBskyGraphDefs, At } from '@atcute/client/lexicons';
+import type { AppBskyFeedDefs, AppBskyGraphDefs } from '@atcute/bluesky';
+import type { Did, ResourceUri } from '@atcute/lexicons';
 
 import type { ModerationLabeler, ModerationPreferences } from '~/api/moderation';
 
···
 
 export interface ModerationLabelerPreferences {
 	updated: number;
-	definitions: Record<At.Did, ModerationLabeler>;
+	definitions: Record<Did, ModerationLabeler>;
 }
 
 export type SavedFeed = SavedGeneratorFeed | SavedListFeed | SavedSearchFeed;
···
 
 export interface PersistedThreadgate {
 	allow?: Array<
-		{ type: 'following' } | { type: 'follower' } | { type: 'mention' } | { type: 'list'; uri: At.ResourceUri }
+		{ type: 'following' } | { type: 'follower' } | { type: 'mention' } | { type: 'list'; uri: ResourceUri }
 	>;
 }
 

src/lib/preferences/sessions.ts

···
-import type { AppBskyActorDefs, At } from '@atcute/client/lexicons';
+import type { AppBskyActorDefs } from '@atcute/bluesky';
+import type { Did } from '@atcute/lexicons';
 
 export interface SessionPreferenceSchema {
 	$version: 1;
-	active: At.Did | undefined;
+	active: Did | undefined;
 	accounts: AccountData[];
 }
 
 export interface AccountData {
 	/** Account DID */
-	readonly did: At.Did;
+	readonly did: Did;
 	profile: AppBskyActorDefs.ProfileViewDetailed;
 }

src/lib/preferences/snippets/composer.ts

···
-import type { AppBskyFeedPostgate, AppBskyFeedThreadgate } from '@atcute/client/lexicons';
+import type { AppBskyFeedPostgate, AppBskyFeedThreadgate } from '@atcute/bluesky';
 
 import type { PersistedPostgate, PersistedThreadgate } from '../account';
 
-export type ThreadgateState = Pick<AppBskyFeedThreadgate.Record, 'allow' | 'hiddenReplies'>;
-export type PostgateState = Pick<AppBskyFeedPostgate.Record, 'detachedEmbeddingUris' | 'embeddingRules'>;
+export type ThreadgateState = Pick<AppBskyFeedThreadgate.Main, 'allow' | 'hiddenReplies'>;
+export type PostgateState = Pick<AppBskyFeedPostgate.Main, 'detachedEmbeddingUris' | 'embeddingRules'>;
 
 export const toPersistedThreadgate = (gate: ThreadgateState): PersistedThreadgate => {
 	return {

src/lib/states/agent.tsx

···
 import { type JSX, type ParentProps, createContext, createMemo, useContext } from 'solid-js';
 
 import { Client, simpleFetchHandler } from '@atcute/client';
-import type { At } from '@atcute/client/lexicons';
+import type { Did } from '@atcute/lexicons';
 import type { OAuthUserAgent } from '@atcute/oauth-browser-client';
 import { QueryClient, QueryClientProvider } from '@mary/solid-query';
 
···
 import { useSession } from './session';
 
 export interface AgentContext {
-	did: At.Did | null;
+	did: Did | null;
 	client: Client;
 	handler: OAuthUserAgent | null;
 	persister: ReturnType<typeof createQueryPersister>;

src/lib/states/session.tsx

···
 } from 'solid-js';
 
 import { Client, ClientResponseError, type FetchHandler, type FetchHandlerObject } from '@atcute/client';
-import type { At } from '@atcute/client/lexicons';
+import type { Did, GenericUri } from '@atcute/lexicons';
 import { OAuthUserAgent, deleteStoredSession, getSession } from '@atcute/oauth-browser-client';
 import { mapDefined } from '@mary/array-fns';
 
···
 import { assert } from '../utils/invariant';
 
 export interface CurrentAccountState {
-	readonly did: At.Did;
+	readonly did: Did;
 	readonly data: AccountData;
 	readonly preferences: PerAccountPreferenceSchema;
 
···
 	readonly currentAccount: CurrentAccountState | undefined;
 
 	getAccounts(): AccountData[];
-	resumeSession(did: At.Did): Promise<void>;
-	removeAccount(did: At.Did): Promise<void>;
+	resumeSession(did: Did): Promise<void>;
+	removeAccount(did: Did): Promise<void>;
 
 	logout(): Promise<void>;
 }
···
 	};
 
 	const createAccountState = (
-		did: At.Did,
+		did: Did,
 		session: OAuthUserAgent | undefined,
 		client: Client,
 	): CurrentAccountState => {
···
 
 			const labelers = createMemo((): Labeler[] => {
 				return Object.entries(preferences.moderation.labelers).map(([did, info]): Labeler => {
-					return { did: did as At.Did, redact: info.redact };
+					return { did: did as Did, redact: info.redact };
 				});
 			});
 
···
 		getAccounts(): AccountData[] {
 			return sessions.accounts;
 		},
-		async resumeSession(did: At.Did): Promise<void> {
+		async resumeSession(did: Did): Promise<void> {
 			const account = sessions.accounts.find((acc) => acc.did === did);
 			if (!account) {
 				return;
···
 			});
 		},
 
-		async removeAccount(did: At.Did): Promise<void> {
+		async removeAccount(did: Did): Promise<void> {
 			const $state = untrack(state);
 			const isLoggedIn = $state !== undefined && $state.did === did;
 
···
 	return session;
 };
 
-const createAccountPreferences = (did: At.Did) => {
+const createAccountPreferences = (did: Did) => {
 	const key = `account-${did}`;
 	return createReactiveLocalStorage<PerAccountPreferenceSchema>(key, (version, prev) => {
 		if (version === 0) {
···
 							},
 							displayName: 'Popular With Friends',
 							description: '',
-							avatar: '' as At.GenericUri,
+							avatar: '' as GenericUri,
 							indexedAt: '0000-00-00T00:00:00.000Z',
 						},
 					},

src/lib/states/singletons/moderation.ts

···
 import { unwrap } from 'solid-js/store';
 
 import { ok } from '@atcute/client';
-import type { At } from '@atcute/client/lexicons';
+import type { Did } from '@atcute/lexicons';
 import { mapDefined } from '@mary/array-fns';
 import { createBatchedFetch } from '@mary/batch-fetch';
 import { type QueryFunctionContext as QC, createQueries } from '@mary/solid-query';
···
 		return currentAccount.preferences.moderation;
 	});
 
-	const fetchLabeler = createBatchedFetch<At.Did, ModerationLabeler>({
+	const fetchLabeler = createBatchedFetch<Did, ModerationLabeler>({
 		limit: 20,
 		timeout: 1,
 		idFromResource: (labeler) => labeler.did,
···
 	const labelerDefs = createQueries(() => {
 		return {
 			queries: Object.keys(modPreferences().labelers).map((_did) => {
-				const did = _did as At.Did;
+				const did = _did as Did;
 
 				return {
 					queryKey: ['labeler-definition', did],
···
 				const defs = mapDefined(results, (result) => result.data);
 				const fields = Object.fromEntries(defs.map((def) => [def.did, def]));
 
-				return fields as Record<At.Did, ModerationLabeler>;
+				return fields as Record<Did, ModerationLabeler>;
 			},
 		};
 	});

src/main.tsx

···
 import { type JSX, createSignal, onMount } from 'solid-js';
 import { render } from 'solid-js/web';
 
-import type { At } from '@atcute/client/lexicons';
+import type { Did } from '@atcute/lexicons';
 import { configureOAuth } from '@atcute/oauth-browser-client';
 
 import * as navigation from '~/globals/navigation';
···
 	const session = useSession();
 
 	onMount(() => {
-		const resumeAccount = async (did: At.Did | undefined) => {
+		const resumeAccount = async (did: Did | undefined) => {
 			try {
 				if (did) {
 					await session.resumeSession(did);

src/shell.tsx

···
 	lazy,
 } from 'solid-js';
 
-import type { AppBskyNotificationGetUnreadCount } from '@atcute/client/lexicons';
+import type { AppBskyNotificationGetUnreadCount } from '@atcute/bluesky';
 import type { DefinedCreateQueryResult } from '@mary/solid-query';
 
 import { createNotificationCountQuery } from '~/api/queries/notification-count';
···
 	unread,
 }: {
 	route: Accessor<MatchedRouteState>;
-	unread: DefinedCreateQueryResult<AppBskyNotificationGetUnreadCount.Output>;
+	unread: DefinedCreateQueryResult<AppBskyNotificationGetUnreadCount.$output>;
 }) => {
 	const active = () => route().def.meta?.name;
 

src/views/bluemoji-emotes.tsx

···
 import { type JSX, createEffect, createSignal } from 'solid-js';
 
+import type { Blob as AtpBlob } from '@atcute/lexicons';
 import { remove as removeExif } from '@mary/exif-rm';
 import { createInfiniteQuery } from '@mary/solid-query';
 
···
 					return (
 						<div class="flex items-center gap-4 px-4 py-4">
 							<img
-								src={/* @once */ getCdnUrl(currentAccount!.did, blob!.ref.$link)}
+								src={/* @once */ getCdnUrl(currentAccount!.did, (blob! as AtpBlob).ref.$link)}
 								class="h-8 w-8 object-cover"
 							/>
 

src/views/post-likes.tsx

···
-import type { At } from '@atcute/client/lexicons';
+import type { Did, RecordKey } from '@atcute/lexicons';
 
 import { createSubjectLikersQuery } from '~/api/queries/subject-likers';
 import { makeAtUri } from '~/api/types/at-uri';
···
 
 const PostLikesPage = () => {
 	const { did, rkey } = useParams<{
-		did: At.Did;
-		rkey: At.RecordKey;
+		did: Did;
+		rkey: RecordKey;
 	}>();
 
 	const uri = makeAtUri(did, 'app.bsky.feed.post', rkey);

src/views/post-quotes.tsx

···
-import type { At } from '@atcute/client/lexicons';
+import type { Did, RecordKey } from '@atcute/lexicons';
 
 import { createPostQuotesQuery } from '~/api/queries/post-quotes';
 import { makeAtUri } from '~/api/types/at-uri';
···
 
 const PostQuotesPage = () => {
 	const { did, rkey } = useParams<{
-		did: At.Did;
-		rkey: At.RecordKey;
+		did: Did;
+		rkey: RecordKey;
 	}>();
 
 	const uri = makeAtUri(did, 'app.bsky.feed.post', rkey);

src/views/post-reposts.tsx

···
-import type { At } from '@atcute/client/lexicons';
+import type { Did, RecordKey } from '@atcute/lexicons';
 
 import { createSubjectRepostersQuery } from '~/api/queries/subject-reposters';
 import { makeAtUri } from '~/api/types/at-uri';
···
 
 const PostLikesPage = () => {
 	const { did, rkey } = useParams<{
-		did: At.Did;
-		rkey: At.RecordKey;
+		did: Did;
+		rkey: RecordKey;
 	}>();
 
 	const uri = makeAtUri(did, 'app.bsky.feed.post', rkey);

src/views/post-thread.tsx

···
 import { For, Match, Switch, createEffect, createMemo, createSignal } from 'solid-js';
 
+import type { AppBskyFeedDefs, AppBskyFeedPost } from '@atcute/bluesky';
 import { ClientResponseError } from '@atcute/client';
-import type { AppBskyFeedDefs, AppBskyFeedPost, At, Brand } from '@atcute/client/lexicons';
+import type { $type, ActorIdentifier, Did, RecordKey } from '@atcute/lexicons';
 import { useQueryClient } from '@mary/solid-query';
 
 import {
···
 
 const PostThreadPage = () => {
 	const { didOrHandle, rkey } = useParams<{
-		didOrHandle: At.Identifier;
-		rkey: At.RecordKey;
+		didOrHandle: ActorIdentifier;
+		rkey: RecordKey;
 	}>();
 
 	const queryClient = useQueryClient();
···
 		if (data && data.$type === 'app.bsky.feed.defs#threadViewPost') {
 			const post = data.post;
 			const author = post.author;
-			const record = post.record as AppBskyFeedPost.Record;
+			const record = post.record as AppBskyFeedPost.Main;
 
 			const authorTitle = `@${truncateMiddle(author.handle, 29).toLowerCase()}`;
 			const postContent = record.text?.trim();
···
 										const data = accessor();
 										const type = data.$type;
 
-										let did: At.Did | undefined;
+										let did: Did | undefined;
 
 										if (type === 'app.bsky.feed.defs#threadViewPost') {
 											did = data.post.author.did;
···
 export default PostThreadPage;
 
 const ThreadView = (props: {
-	data: Brand.Union<AppBskyFeedDefs.ThreadViewPost>;
+	data: $type.enforce<AppBskyFeedDefs.ThreadViewPost>;
 	isPlaceholderData: boolean;
 	onReplyPublish?: () => void;
 	onMainPostDelete?: () => void;
···
 			}
 		}
 
-		return (post.record as AppBskyFeedPost.Record).reply !== undefined;
+		return (post.record as AppBskyFeedPost.Main).reply !== undefined;
 	};
 
 	return (

src/views/profile-curation-list.tsx

···
 import { Match, Switch } from 'solid-js';
 
-import type { At } from '@atcute/client/lexicons';
+import type { Did, RecordKey } from '@atcute/lexicons';
 
 import { createListMetaQuery } from '~/api/queries/list';
 import { makeAtUri } from '~/api/types/at-uri';
···
 
 const CurationListPage = () => {
 	const { did, rkey } = useParams<{
-		did: At.Did;
-		rkey: At.RecordKey;
+		did: Did;
+		rkey: RecordKey;
 	}>();
 
 	const uri = makeAtUri(did, 'app.bsky.graph.list', rkey);

src/views/profile-feed.tsx

···
 import { Match, Show, Switch } from 'solid-js';
 
-import type { At } from '@atcute/client/lexicons';
+import type { ActorIdentifier, RecordKey } from '@atcute/lexicons';
 import { useQueryClient } from '@mary/solid-query';
 
 import { createFeedMetaQuery } from '~/api/queries/feed';
···
 
 const FeedPage = () => {
 	const { didOrHandle, rkey } = useParams<{
-		didOrHandle: At.Identifier;
-		rkey: At.RecordKey;
+		didOrHandle: ActorIdentifier;
+		rkey: RecordKey;
 	}>();
 
 	const queryClient = useQueryClient();

src/views/profile-feeds.tsx

···
-import type { At } from '@atcute/client/lexicons';
+import type { Did } from '@atcute/lexicons';
 
 import { createProfileQuery } from '~/api/queries/profile';
 import { createProfileFeedsQuery } from '~/api/queries/profile-feeds';
···
 import VirtualItem from '~/components/virtual-item';
 
 const ProfileFeedsPage = () => {
-	const { did } = useParams<{
-		did: At.Did;
-	}>();
+	const { did } = useParams<{ did: Did }>();
 
 	const feeds = createProfileFeedsQuery(() => did);
 	const profile = createProfileQuery(() => did);

src/views/profile-followers.tsx

···
 import { createMemo } from 'solid-js';
 
-import type { At } from '@atcute/client/lexicons';
+import type { Did } from '@atcute/lexicons';
 
 import { createProfileFollowersQuery } from '~/api/queries/profile-followers';
 
···
 import VirtualItem from '~/components/virtual-item';
 
 const ProfileFollowersPage = () => {
-	const { did } = useParams<{
-		did: At.Did;
-	}>();
+	const { did } = useParams<{ did: Did }>();
 
 	const followers = createProfileFollowersQuery(() => did);
 	const subject = createMemo(() => followers.data?.pages[0].subject);

src/views/profile-following.tsx

···
 import { createMemo } from 'solid-js';
 
-import type { At } from '@atcute/client/lexicons';
+import type { Did } from '@atcute/lexicons';
 
 import { createProfileFollowingQuery } from '~/api/queries/profile-following';
 
···
 import VirtualItem from '~/components/virtual-item';
 
 const ProfileFollowingPage = () => {
-	const { did } = useParams<{
-		did: At.Did;
-	}>();
+	const { did } = useParams<{ did: Did }>();
 
 	const following = createProfileFollowingQuery(() => did);
 	const subject = createMemo(() => following.data?.pages[0].subject);

src/views/profile-known-followers.tsx

···
 import { createMemo } from 'solid-js';
 
-import type { At } from '@atcute/client/lexicons';
+import type { Did } from '@atcute/lexicons';
 
 import { createProfileKnownFollowersQuery } from '~/api/queries/profile-known-followers';
 
···
 import VirtualItem from '~/components/virtual-item';
 
 const ProfileKnownFollowersPage = () => {
-	const { did } = useParams<{
-		did: At.Did;
-	}>();
+	const { did } = useParams<{ did: Did }>();
 
 	const followers = createProfileKnownFollowersQuery(() => did);
 	const subject = createMemo(() => followers.data?.pages[0].subject);

src/views/profile-labels.tsx

···
 import { Match, Show, Switch, createMemo } from 'solid-js';
 
-import type { At } from '@atcute/client/lexicons';
+import type { Did } from '@atcute/lexicons';
 import { mapDefined } from '@mary/array-fns';
 
 import {
···
 import LabelerOverflowMenu from '~/components/settings/moderation/labeling/labeler-overflow-menu';
 
 const ProfileLabelsPage = () => {
-	const { did } = useParams();
+	const { did } = useParams<{ did: Did }>();
 	const { currentAccount } = useSession();
 
-	const query = createLabelerMetaQuery(() => did as At.Did);
+	const query = createLabelerMetaQuery(() => did);
 
 	const config = createMemo(() => {
 		if (!currentAccount) {
···
 		}
 
 		const preferences = currentAccount.preferences;
-		return preferences.moderation.labelers[did as At.Did];
+		return preferences.moderation.labelers[did];
 	});
 
 	useTitle(() => {
···
 														const preferences = currentAccount!.preferences;
 														const labelers = preferences.moderation.labelers;
 
-														labelers[did as At.Did] = {
+														labelers[did] = {
 															labels: {},
 															privileged: false,
 															redact: false,
···
 																const preferences = currentAccount!.preferences;
 																const labelers = preferences.moderation.labelers;
 
-																delete labelers[did as At.Did];
+																delete labelers[did];
 															}}
 														/>
 													));

src/views/profile-list.tsx

···
 import { Match, Switch } from 'solid-js';
 
-import type { At } from '@atcute/client/lexicons';
+import type { ActorIdentifier, RecordKey } from '@atcute/lexicons';
 import { useQueryClient } from '@mary/solid-query';
 
 import { createListMetaQuery } from '~/api/queries/list';
···
 
 const ListStubPage = () => {
 	const { didOrHandle, rkey } = useParams<{
-		didOrHandle: At.Identifier;
-		rkey: At.RecordKey;
+		didOrHandle: ActorIdentifier;
+		rkey: RecordKey;
 	}>();
 
 	const queryClient = useQueryClient();

src/views/profile-lists.tsx

···
-import type { At } from '@atcute/client/lexicons';
+import type { Did } from '@atcute/lexicons';
 
 import { createProfileQuery } from '~/api/queries/profile';
 import { createProfileListsQuery } from '~/api/queries/profile-lists';
···
 import PagedList from '~/components/paged-list';
 
 const ProfileListsPage = () => {
-	const { did } = useParams<{
-		did: At.Did;
-	}>();
+	const { did } = useParams<{ did: Did }>();
 
 	const lists = createProfileListsQuery(() => did);
 	const profile = createProfileQuery(() => did);

src/views/profile-moderation-list.tsx

···
 import { Match, Show, Switch, createMemo } from 'solid-js';
 
-import type { AppBskyGraphDefs, At } from '@atcute/client/lexicons';
+import type { AppBskyGraphDefs } from '@atcute/bluesky';
+import type { Did, RecordKey, ResourceUri } from '@atcute/lexicons';
 import { useQueryClient } from '@mary/solid-query';
 
 import { ContextContentMedia } from '~/api/moderation/constants';
···
 
 const ProfileModerationListPage = () => {
 	const { did, rkey } = useParams<{
-		did: At.Did;
-		rkey: At.RecordKey;
+		did: Did;
+		rkey: RecordKey;
 	}>();
 
 	const uri = makeAtUri(did, 'app.bsky.graph.list', rkey);
···
 	);
 };
 
-const MembersList = ({ uri }: { uri: At.ResourceUri }) => {
+const MembersList = ({ uri }: { uri: ResourceUri }) => {
 	const members = createListMembersQuery(() => uri);
 
 	return (

src/views/profile-search.tsx

···
 import { createSignal } from 'solid-js';
 
-import type { At } from '@atcute/client/lexicons';
+import type { ActorIdentifier } from '@atcute/lexicons';
 
 import { createProfileQuery } from '~/api/queries/profile';
 import { isDid } from '~/api/types/identity';
···
 
 const ProfileSearchPage = () => {
 	const { didOrHandle } = useParams<{
-		didOrHandle: At.Identifier;
+		didOrHandle: ActorIdentifier;
 	}>();
 
 	const [query, setQuery] = createSignal('');

src/views/profile.tsx

···
 import { Match, Show, Switch, createMemo } from 'solid-js';
 
+import type { AppBskyActorDefs } from '@atcute/bluesky';
 import { ClientResponseError } from '@atcute/client';
-import type { AppBskyActorDefs, At } from '@atcute/client/lexicons';
+import type { ActorIdentifier } from '@atcute/lexicons';
 import { useQueryClient } from '@mary/solid-query';
 
 import { useProfileShadow } from '~/api/cache/profile-shadow';
···
 
 const ProfilePage = () => {
 	const { didOrHandle } = useParams<{
-		didOrHandle: At.Identifier;
+		didOrHandle: ActorIdentifier;
 	}>();
 
 	const queryClient = useQueryClient();

src/views/settings-app-passwords.tsx

···
 import { For, Match, Show, Switch } from 'solid-js';
 
+import type { ComAtprotoServerListAppPasswords } from '@atcute/atproto';
 import { ok } from '@atcute/client';
-import type { ComAtprotoServerListAppPasswords } from '@atcute/client/lexicons';
 import { createMutation, createQuery } from '@mary/solid-query';
 
 import { openModal } from '~/globals/modals';

tsconfig.json

···
 	"compilerOptions": {
 		"target": "ESNext",
 		"lib": ["DOM", "DOM.Iterable", "ESNext"],
-		"types": ["dom-close-watcher", "dom-webcodecs"],
+		"types": [
+			"dom-close-watcher",
+			"dom-webcodecs",
+			"@atcute/atproto",
+			"@atcute/bluemoji",
+			"@atcute/bluesky",
+			"@kelinci/basa-lexicons",
+		],
 		"skipLibCheck": true,
 
 		"module": "ESNext",