switch to @atcute/lex-cli

lex.config.js

···
+import { defineLexiconConfig } from "@atcute/lex-cli";
+
+export default defineLexiconConfig({
+	files: ["lexicons/**/*.json"],
+	outdir: "src/lexicons/",
+});

lexicons/com/atproto/repo/createRecord.json

···
-{
-	"lexicon": 1,
-	"id": "com.atproto.repo.createRecord",
-	"defs": {
-		"main": {
-			"type": "procedure",
-			"description": "Create a single new repository record. Requires auth, implemented by PDS.",
-			"input": {
-				"encoding": "application/json",
-				"schema": {
-					"type": "object",
-					"required": ["repo", "collection", "record"],
-					"properties": {
-						"repo": {
-							"type": "string",
-							"format": "at-identifier",
-							"description": "The handle or DID of the repo (aka, current account)."
-						},
-						"collection": {
-							"type": "string",
-							"format": "nsid",
-							"description": "The NSID of the record collection."
-						},
-						"rkey": {
-							"type": "string",
-							"format": "record-key",
-							"description": "The Record Key.",
-							"maxLength": 512
-						},
-						"validate": {
-							"type": "boolean",
-							"description": "Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons."
-						},
-						"record": {
-							"type": "unknown",
-							"description": "The record itself. Must contain a $type field."
-						},
-						"swapCommit": {
-							"type": "string",
-							"format": "cid",
-							"description": "Compare and swap with the previous commit by CID."
-						}
-					}
-				}
-			},
-			"output": {
-				"encoding": "application/json",
-				"schema": {
-					"type": "object",
-					"required": ["uri", "cid"],
-					"properties": {
-						"uri": { "type": "string", "format": "at-uri" },
-						"cid": { "type": "string", "format": "cid" },
-						"commit": {
-							"type": "ref",
-							"ref": "com.atproto.repo.defs#commitMeta"
-						},
-						"validationStatus": {
-							"type": "string",
-							"knownValues": ["valid", "unknown"]
-						}
-					}
-				}
-			},
-			"errors": [
-				{
-					"name": "InvalidSwap",
-					"description": "Indicates that 'swapCommit' didn't match current repo commit."
-				}
-			]
-		}
-	}
-}

lexicons/com/atproto/repo/defs.json

···
-{
-	"lexicon": 1,
-	"id": "com.atproto.repo.defs",
-	"defs": {
-		"commitMeta": {
-			"type": "object",
-			"required": ["cid", "rev"],
-			"properties": {
-				"cid": { "type": "string", "format": "cid" },
-				"rev": { "type": "string", "format": "tid" }
-			}
-		}
-	}
-}

lexicons/com/atproto/repo/deleteRecord.json

···
-{
-	"lexicon": 1,
-	"id": "com.atproto.repo.deleteRecord",
-	"defs": {
-		"main": {
-			"type": "procedure",
-			"description": "Delete a repository record, or ensure it doesn't exist. Requires auth, implemented by PDS.",
-			"input": {
-				"encoding": "application/json",
-				"schema": {
-					"type": "object",
-					"required": ["repo", "collection", "rkey"],
-					"properties": {
-						"repo": {
-							"type": "string",
-							"format": "at-identifier",
-							"description": "The handle or DID of the repo (aka, current account)."
-						},
-						"collection": {
-							"type": "string",
-							"format": "nsid",
-							"description": "The NSID of the record collection."
-						},
-						"rkey": {
-							"type": "string",
-							"format": "record-key",
-							"description": "The Record Key."
-						},
-						"swapRecord": {
-							"type": "string",
-							"format": "cid",
-							"description": "Compare and swap with the previous record by CID."
-						},
-						"swapCommit": {
-							"type": "string",
-							"format": "cid",
-							"description": "Compare and swap with the previous commit by CID."
-						}
-					}
-				}
-			},
-			"output": {
-				"encoding": "application/json",
-				"schema": {
-					"type": "object",
-					"properties": {
-						"commit": {
-							"type": "ref",
-							"ref": "com.atproto.repo.defs#commitMeta"
-						}
-					}
-				}
-			},
-			"errors": [{ "name": "InvalidSwap" }]
-		}
-	}
-}

lexicons/com/atproto/repo/getRecord.json

···
-{
-	"lexicon": 1,
-	"id": "com.atproto.repo.getRecord",
-	"defs": {
-		"main": {
-			"type": "query",
-			"description": "Get a single record from a repository. Does not require auth.",
-			"parameters": {
-				"type": "params",
-				"required": ["repo", "collection", "rkey"],
-				"properties": {
-					"repo": {
-						"type": "string",
-						"format": "at-identifier",
-						"description": "The handle or DID of the repo."
-					},
-					"collection": {
-						"type": "string",
-						"format": "nsid",
-						"description": "The NSID of the record collection."
-					},
-					"rkey": {
-						"type": "string",
-						"description": "The Record Key.",
-						"format": "record-key"
-					},
-					"cid": {
-						"type": "string",
-						"format": "cid",
-						"description": "The CID of the version of the record. If not specified, then return the most recent version."
-					}
-				}
-			},
-			"output": {
-				"encoding": "application/json",
-				"schema": {
-					"type": "object",
-					"required": ["uri", "value"],
-					"properties": {
-						"uri": { "type": "string", "format": "at-uri" },
-						"cid": { "type": "string", "format": "cid" },
-						"value": { "type": "unknown" }
-					}
-				}
-			},
-			"errors": [{ "name": "RecordNotFound" }]
-		}
-	}
-}

lexicons/com/atproto/repo/listRecords.json

···
-{
-	"lexicon": 1,
-	"id": "com.atproto.repo.listRecords",
-	"defs": {
-		"main": {
-			"type": "query",
-			"description": "List a range of records in a repository, matching a specific collection. Does not require auth.",
-			"parameters": {
-				"type": "params",
-				"required": ["repo", "collection"],
-				"properties": {
-					"repo": {
-						"type": "string",
-						"format": "at-identifier",
-						"description": "The handle or DID of the repo."
-					},
-					"collection": {
-						"type": "string",
-						"format": "nsid",
-						"description": "The NSID of the record type."
-					},
-					"limit": {
-						"type": "integer",
-						"minimum": 1,
-						"maximum": 100,
-						"default": 50,
-						"description": "The number of records to return."
-					},
-					"cursor": { "type": "string" },
-					"rkeyStart": {
-						"type": "string",
-						"description": "DEPRECATED: The lowest sort-ordered rkey to start from (exclusive)"
-					},
-					"rkeyEnd": {
-						"type": "string",
-						"description": "DEPRECATED: The highest sort-ordered rkey to stop at (exclusive)"
-					},
-					"reverse": {
-						"type": "boolean",
-						"description": "Flag to reverse the order of the returned records."
-					}
-				}
-			},
-			"output": {
-				"encoding": "application/json",
-				"schema": {
-					"type": "object",
-					"required": ["records"],
-					"properties": {
-						"cursor": { "type": "string" },
-						"records": {
-							"type": "array",
-							"items": { "type": "ref", "ref": "#record" }
-						}
-					}
-				}
-			}
-		},
-		"record": {
-			"type": "object",
-			"required": ["uri", "cid", "value"],
-			"properties": {
-				"uri": { "type": "string", "format": "at-uri" },
-				"cid": { "type": "string", "format": "cid" },
-				"value": { "type": "unknown" }
-			}
-		}
-	}
-}

lexicons/com/atproto/repo/putRecord.json

···
-{
-	"lexicon": 1,
-	"id": "com.atproto.repo.putRecord",
-	"defs": {
-		"main": {
-			"type": "procedure",
-			"description": "Write a repository record, creating or updating it as needed. Requires auth, implemented by PDS.",
-			"input": {
-				"encoding": "application/json",
-				"schema": {
-					"type": "object",
-					"required": ["repo", "collection", "rkey", "record"],
-					"nullable": ["swapRecord"],
-					"properties": {
-						"repo": {
-							"type": "string",
-							"format": "at-identifier",
-							"description": "The handle or DID of the repo (aka, current account)."
-						},
-						"collection": {
-							"type": "string",
-							"format": "nsid",
-							"description": "The NSID of the record collection."
-						},
-						"rkey": {
-							"type": "string",
-							"format": "record-key",
-							"description": "The Record Key.",
-							"maxLength": 512
-						},
-						"validate": {
-							"type": "boolean",
-							"description": "Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons."
-						},
-						"record": {
-							"type": "unknown",
-							"description": "The record to write."
-						},
-						"swapRecord": {
-							"type": "string",
-							"format": "cid",
-							"description": "Compare and swap with the previous record by CID. WARNING: nullable and optional field; may cause problems with golang implementation"
-						},
-						"swapCommit": {
-							"type": "string",
-							"format": "cid",
-							"description": "Compare and swap with the previous commit by CID."
-						}
-					}
-				}
-			},
-			"output": {
-				"encoding": "application/json",
-				"schema": {
-					"type": "object",
-					"required": ["uri", "cid"],
-					"properties": {
-						"uri": { "type": "string", "format": "at-uri" },
-						"cid": { "type": "string", "format": "cid" },
-						"commit": {
-							"type": "ref",
-							"ref": "com.atproto.repo.defs#commitMeta"
-						},
-						"validationStatus": {
-							"type": "string",
-							"knownValues": ["valid", "unknown"]
-						}
-					}
-				}
-			},
-			"errors": [{ "name": "InvalidSwap" }]
-		}
-	}
-}

package.json

···
 	"scripts": {
 		"lint": "biome lint",
 		"format": "biome format --write ./src",
+		"lex": "lex-cli generate -c ./lex.config.js",
 		"test": "vitest --run",
-		"lex-gen": "lex gen-api ./src/leaflet/lexicons ./lexicons/pub/leaflet/* ./lexicons/pub/leaflet/*/* ./lexicons/com/atproto/*/* --yes",
 		"typecheck": "tsc",
 		"build": "rm -rf dist && tsup"
 	},
···
 		}
 	},
 	"devDependencies": {
-		"@atproto/lex-cli": "^0.9.1",
+		"@atcute/lex-cli": "^2.1.1",
 		"@biomejs/biome": "2.1.3",
 		"@types/sanitize-html": "^2.16.0",
 		"astro": "^5.12.8",
···
 		"vitest": "^3.2.4"
 	},
 	"dependencies": {
+		"@atcute/lexicons": "^1.1.0",
 		"@atproto/api": "^0.16.1",
 		"@atproto/did": "^0.1.5",
-		"@atproto/lexicon": "^0.4.12",
-		"@atproto/syntax": "^0.4.0",
-		"@atproto/xrpc": "^0.7.1",
-		"multiformats": "^13.4.0",
 		"sanitize-html": "^2.17.0"
 	}
 }

pnpm-lock.yaml

···
 
   .:
     dependencies:
+      '@atcute/lexicons':
+        specifier: ^1.1.0
+        version: 1.1.0
       '@atproto/api':
         specifier: ^0.16.1
         version: 0.16.1
       '@atproto/did':
         specifier: ^0.1.5
         version: 0.1.5
-      '@atproto/lexicon':
-        specifier: ^0.4.12
-        version: 0.4.12
-      '@atproto/syntax':
-        specifier: ^0.4.0
-        version: 0.4.0
-      '@atproto/xrpc':
-        specifier: ^0.7.1
-        version: 0.7.1
-      multiformats:
-        specifier: ^13.4.0
-        version: 13.4.0
       sanitize-html:
         specifier: ^2.17.0
         version: 2.17.0
     devDependencies:
-      '@atproto/lex-cli':
-        specifier: ^0.9.1
-        version: 0.9.1
+      '@atcute/lex-cli':
+        specifier: ^2.1.1
+        version: 2.1.1
       '@biomejs/biome':
         specifier: 2.1.3
         version: 2.1.3
···
     resolution: {integrity: sha512-UFBgfeldP06qu6khs/yY+q1cDAaArM2/7AEIqQ9Cuvf7B1hNLq0xDrZkct+QoIGyjq56y8IaE2I3CTvG99mlhQ==}
     engines: {node: 18.20.8 || ^20.3.0 || >=22.0.0}
 
+  '@atcute/lex-cli@2.1.1':
+    resolution: {integrity: sha512-QaR0sOP8Z24opGHKsSfleDbP/ahUb6HECkVaOqSwG7ORZzbLK1w0265o1BRjCVr2dT6FxlsMUa2Ge85JMA9bxg==}
+    hasBin: true
+
+  '@atcute/lexicon-doc@1.0.3':
+    resolution: {integrity: sha512-U7rinsTOwXGGcrF6/s7GzTXargcQpDr4BTrj5ci/XTK+POEK5jpcI+Ag1fF932pBX3k97em6y4TWwTSO8M/McQ==}
+
+  '@atcute/lexicons@1.1.0':
+    resolution: {integrity: sha512-LFqwnria78xLYb62Ri/+WwQpUTgZp2DuyolNGIIOV1dpiKhFFFh//nscHMA6IExFLQRqWDs3tTjy7zv0h3sf1Q==}
+
   '@atproto/api@0.16.1':
     resolution: {integrity: sha512-w48BlTmzKym7nZETWxgiuUX/wwRXU3xsLLKORWo/xtGnwlvpchUFnHKI3k4ttYJ2/JQE59+/4C16BaLzDyiU2w==}
 
···
 
   '@atproto/did@0.1.5':
     resolution: {integrity: sha512-8+1D08QdGE5TF0bB0vV8HLVrVZJeLNITpRTUVEoABNMRaUS7CoYSVb0+JNQDeJIVmqMjOL8dOjvCUDkp3gEaGQ==}
-
-  '@atproto/lex-cli@0.9.1':
-    resolution: {integrity: sha512-ftcUZd8rElHeUJq6pTcQkURnTEe7woCF4I1NK3j5GpT/itacEZtcppabjy5o2aUsbktZsALj3ch3xm7ZZ+Zp0w==}
-    engines: {node: '>=18.7.0'}
-    hasBin: true
 
   '@atproto/lexicon@0.4.12':
     resolution: {integrity: sha512-fcEvEQ1GpQYF5igZ4IZjPWEoWVpsEF22L9RexxLS3ptfySXLflEyH384e7HITzO/73McDeaJx3lqHIuqn9ulnw==}
···
     resolution: {integrity: sha512-ruv7Ae4J5dUYULmeXw1gmb7rYRz57OWCPM57pHojnLq/3Z1CK2lNSLTCVjxVk1F/TZHwOZZrOWi0ur95BbLxNQ==}
     engines: {node: '>=6.9.0'}
 
+  '@badrap/valita@0.4.6':
+    resolution: {integrity: sha512-4kdqcjyxo/8RQ8ayjms47HCWZIF5981oE5nIenbfThKDxWXtEHKipAOWlflpPJzZx9y/JWYQkp18Awr7VuepFg==}
+    engines: {node: '>= 18'}
+
   '@biomejs/biome@2.1.3':
     resolution: {integrity: sha512-KE/tegvJIxTkl7gJbGWSgun7G6X/n2M6C35COT6ctYrAy7SiPyNvi6JtoQERVK/VRbttZfgGq96j2bFmhmnH4w==}
     engines: {node: '>=14.21.3'}
···
     engines: {node: '>=18'}
     cpu: [x64]
     os: [win32]
+
+  '@externdefs/collider@0.3.0':
+    resolution: {integrity: sha512-x5CpeZ4c8n+1wMFthUMWSQKqCGcQo52/Qbda5ES+JFRRg/D8Ep6/JOvUUq5HExFuv/wW+6UYG2U/mXzw0IAd8Q==}
+    peerDependencies:
+      '@badrap/valita': ^0.4.4
 
   '@img/sharp-darwin-arm64@0.33.5':
     resolution: {integrity: sha512-UT4p+iz/2H4twwAoLCqfA9UH5pI6DggwKEGuaPy7nCVQ8ZsiY5PIcrRvD1DzuY3qYL07NtIQcWnBSY/heikIFQ==}
···
 
   '@swc/helpers@0.5.17':
     resolution: {integrity: sha512-5IKx/Y13RsYd+sauPb2x+U/xZikHjolzfuDgTAl/Tdf3Q8rslRvC19NKDLgAJQ6wsqADk10ntlv08nPFw/gO/A==}
-
-  '@ts-morph/common@0.25.0':
-    resolution: {integrity: sha512-kMnZz+vGGHi4GoHnLmMhGNjm44kGtKUXGnOvrKmMwAuvNjM/PgKVGfUnL7IDvK7Jb2QQ82jq3Zmp04Gy+r3Dkg==}
 
   '@types/chai@5.2.2':
     resolution: {integrity: sha512-8kB30R7Hwqf40JPiKhVzodJs2Qc1ZJ5zuT3uzw5Hq/dhNCl3G3l83jfpdI1e20BP348+fV7VIL/+FxaXkqBmWg==}
···
     resolution: {integrity: sha512-5nFxhUrX0PqtyogoYOA8IPswy5sZFTOsBFl/9bNsmDLgsxYTzSZQJDPppDnZPTQbzSEm0hqGjWPzRemQCYbD6A==}
     engines: {node: '>=18'}
 
-  chalk@4.1.2:
-    resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==}
-    engines: {node: '>=10'}
-
   chalk@5.5.0:
     resolution: {integrity: sha512-1tm8DTaJhPBG3bIkVeZt1iZM9GfSX2lzOeDVZH9R9ffRHpmHvxZ/QhgQH/aDTkswQVt+YHdXAdS/In/30OjCbg==}
     engines: {node: ^12.17.0 || ^14.13 || >=16.0.0}
···
     resolution: {integrity: sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==}
     engines: {node: '>=6'}
 
-  code-block-writer@13.0.3:
-    resolution: {integrity: sha512-Oofo0pq3IKnsFtuHqSF7TqBfr71aeyZDVJ0HpmqB7FBM2qEigL0iPONSCZSO9pE9dZTAxANe5XHG9Uy0YMv8cg==}
-
   color-convert@2.0.1:
     resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
     engines: {node: '>=7.0.0'}
···
     resolution: {integrity: sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==}
     engines: {node: '>= 6'}
 
-  commander@9.5.0:
-    resolution: {integrity: sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==}
-    engines: {node: ^12.20.0 || >=14}
-
   common-ancestor-path@1.0.1:
     resolution: {integrity: sha512-L3sHRo1pXXEqX8VU28kfgUY+YGsk09hPqZiZmLacNib6XNTCM8ubYeT7ryXQw8asB1sKgcU5lkB7ONug08aB8w==}
 
···
     resolution: {integrity: sha512-/veY75JbMK4j1yjvuUxuVsiS/hr/4iHs9FTT6cgTexxdE0Ly/glccBAkloH/DofkjRbZU3bnoj38mOmhkZ0lHw==}
     engines: {node: '>=12'}
 
+  esm-env@1.2.2:
+    resolution: {integrity: sha512-Epxrv+Nr/CaL4ZcFGPJIYLWFom+YeV1DqMLHJoEd9SYRxNbaFruBwfEX/kkHUJf55j2+TUbmDcmuilbP1TmXHA==}
+
   estree-walker@2.0.2:
     resolution: {integrity: sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==}
 
···
 
   h3@1.15.4:
     resolution: {integrity: sha512-z5cFQWDffyOe4vQ9xIqNfCZdV4p//vy6fBnr8Q1AWnVZ0teurKMG66rLj++TKwKPUP3u7iMUvrvKaEUiQw2QWQ==}
-
-  has-flag@4.0.0:
-    resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==}
-    engines: {node: '>=8'}
 
   hast-util-from-html@2.0.3:
     resolution: {integrity: sha512-CUSRHXyKjzHov8yKsQjGOElXy/3EKpyX56ELnkHH34vDVw1N1XSQ1ZcAvTyAPtGqLTuKP/uxM+aLkSPqF/EtMw==}
···
   ms@2.1.3:
     resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
 
-  multiformats@13.4.0:
-    resolution: {integrity: sha512-Mkb/QcclrJxKC+vrcIFl297h52QcKh2Az/9A5vbWytbQt4225UWWWmIuSsKksdww9NkIeYcA7DkfftyLuC/JSg==}
-
   multiformats@9.9.0:
     resolution: {integrity: sha512-HoMUjhH9T8DDBNT+6xzkrd9ga/XiBI4xLr58LJACwK6G3HTOPeMz4nB4KJs33L2BelrIJa7P0VuNaVF3hMYfjg==}
 
···
 
   parse5@7.3.0:
     resolution: {integrity: sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==}
-
-  path-browserify@1.0.1:
-    resolution: {integrity: sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==}
 
   path-key@3.1.1:
     resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==}
···
     engines: {node: '>=16 || 14 >=14.17'}
     hasBin: true
 
-  supports-color@7.2.0:
-    resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}
-    engines: {node: '>=8'}
-
   thenify-all@1.6.0:
     resolution: {integrity: sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==}
     engines: {node: '>=0.8'}
···
 
   ts-interface-checker@0.1.13:
     resolution: {integrity: sha512-Y/arvbn+rrz3JCKl9C4kVNfTfSm2/mEp5FSz5EsZSANGPSlQrpRI5M4PKF+mJnE52jOO90PnPSc3Ur3bTQw0gA==}
-
-  ts-morph@24.0.0:
-    resolution: {integrity: sha512-2OAOg/Ob5yx9Et7ZX4CvTCc0UFoZHwLEJ+dpDPSUi5TgwwlTlX47w+iFRrEwzUZwYACjq83cgjS/Da50Ga37uw==}
 
   tsconfck@3.1.6:
     resolution: {integrity: sha512-ks6Vjr/jEw0P1gmOVwutM3B7fWxoWBL2KRDb1JfqGVawBmO5UsvmWOQFGHBPl5yxYz4eERr19E6L7NMv+Fej4w==}
···
     resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==}
     engines: {node: '>=12'}
 
-  yesno@0.4.0:
-    resolution: {integrity: sha512-tdBxmHvbXPBKYIg81bMCB7bVeDmHkRzk5rVJyYYXurwKkHq/MCd8rz4HSJUP7hW0H2NlXiq8IFiWvYKEHhlotA==}
-
   yocto-queue@1.2.1:
     resolution: {integrity: sha512-AyeEbWOu/TAXdxlV9wmGcR0+yh2j3vYPGOECcIj2S7MkrLyC7ne+oye2BKTItt0ii2PHk4cDy+95+LshzbXnGg==}
     engines: {node: '>=12.20'}
···
     transitivePeerDependencies:
       - supports-color
 
+  '@atcute/lex-cli@2.1.1':
+    dependencies:
+      '@atcute/lexicon-doc': 1.0.3
+      '@badrap/valita': 0.4.6
+      '@externdefs/collider': 0.3.0(@badrap/valita@0.4.6)
+      picocolors: 1.1.1
+      prettier: 3.6.2
+
+  '@atcute/lexicon-doc@1.0.3':
+    dependencies:
+      '@badrap/valita': 0.4.6
+
+  '@atcute/lexicons@1.1.0':
+    dependencies:
+      esm-env: 1.2.2
+
   '@atproto/api@0.16.1':
     dependencies:
       '@atproto/common-web': 0.4.2
···
     dependencies:
       zod: 3.25.76
 
-  '@atproto/lex-cli@0.9.1':
-    dependencies:
-      '@atproto/lexicon': 0.4.12
-      '@atproto/syntax': 0.4.0
-      chalk: 4.1.2
-      commander: 9.5.0
-      prettier: 3.6.2
-      ts-morph: 24.0.0
-      yesno: 0.4.0
-      zod: 3.25.76
-
   '@atproto/lexicon@0.4.12':
     dependencies:
       '@atproto/common-web': 0.4.2
···
     dependencies:
       '@babel/helper-string-parser': 7.27.1
       '@babel/helper-validator-identifier': 7.27.1
+
+  '@badrap/valita@0.4.6': {}
 
   '@biomejs/biome@2.1.3':
     optionalDependencies:
···
   '@esbuild/win32-x64@0.25.8':
     optional: true
 
+  '@externdefs/collider@0.3.0(@badrap/valita@0.4.6)':
+    dependencies:
+      '@badrap/valita': 0.4.6
+
   '@img/sharp-darwin-arm64@0.33.5':
     optionalDependencies:
       '@img/sharp-libvips-darwin-arm64': 1.0.4
···
   '@swc/helpers@0.5.17':
     dependencies:
       tslib: 2.8.1
-
-  '@ts-morph/common@0.25.0':
-    dependencies:
-      minimatch: 9.0.5
-      path-browserify: 1.0.1
-      tinyglobby: 0.2.14
 
   '@types/chai@5.2.2':
     dependencies:
···
       loupe: 3.2.0
       pathval: 2.0.1
 
-  chalk@4.1.2:
-    dependencies:
-      ansi-styles: 4.3.0
-      supports-color: 7.2.0
-
   chalk@5.5.0: {}
 
   character-entities-html4@2.1.0: {}
···
 
   clsx@2.1.1: {}
 
-  code-block-writer@13.0.3: {}
-
   color-convert@2.0.1:
     dependencies:
       color-name: 1.1.4
···
   comma-separated-tokens@2.0.3: {}
 
   commander@4.1.1: {}
-
-  commander@9.5.0: {}
 
   common-ancestor-path@1.0.1: {}
 
···
 
   escape-string-regexp@5.0.0: {}
 
+  esm-env@1.2.2: {}
+
   estree-walker@2.0.2: {}
 
   estree-walker@3.0.3:
···
       radix3: 1.1.2
       ufo: 1.6.1
       uncrypto: 0.1.3
-
-  has-flag@4.0.0: {}
 
   hast-util-from-html@2.0.3:
     dependencies:
···
 
   ms@2.1.3: {}
 
-  multiformats@13.4.0: {}
-
   multiformats@9.9.0: {}
 
   mz@2.7.0:
···
   parse5@7.3.0:
     dependencies:
       entities: 6.0.1
-
-  path-browserify@1.0.1: {}
 
   path-key@3.1.1: {}
 
···
       pirates: 4.0.7
       ts-interface-checker: 0.1.13
 
-  supports-color@7.2.0:
-    dependencies:
-      has-flag: 4.0.0
-
   thenify-all@1.6.0:
     dependencies:
       thenify: 3.3.1
···
   trough@2.2.0: {}
 
   ts-interface-checker@0.1.13: {}
-
-  ts-morph@24.0.0:
-    dependencies:
-      '@ts-morph/common': 0.25.0
-      code-block-writer: 13.0.3
 
   tsconfck@3.1.6(typescript@5.9.2):
     optionalDependencies:
···
   xxhash-wasm@1.1.0: {}
 
   yargs-parser@21.1.1: {}
-
-  yesno@0.4.0: {}
 
   yocto-queue@1.2.1: {}
 

src/leaflet/lexicons/index.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import {
-  XrpcClient,
-  type FetchHandler,
-  type FetchHandlerOptions,
-} from '@atproto/xrpc'
-import { schemas } from './lexicons.js'
-import { CID } from 'multiformats/cid'
-import { type OmitKey, type Un$Typed } from './util.js'
-import * as PubLeafletDocument from './types/pub/leaflet/document.js'
-import * as PubLeafletBlocksCode from './types/pub/leaflet/blocks/code.js'
-import * as PubLeafletBlocksHeader from './types/pub/leaflet/blocks/header.js'
-import * as PubLeafletBlocksImage from './types/pub/leaflet/blocks/image.js'
-import * as PubLeafletBlocksMath from './types/pub/leaflet/blocks/math.js'
-import * as PubLeafletBlocksText from './types/pub/leaflet/blocks/text.js'
-import * as PubLeafletBlocksUnorderedList from './types/pub/leaflet/blocks/unorderedList.js'
-import * as PubLeafletBlocksWebsite from './types/pub/leaflet/blocks/website.js'
-import * as PubLeafletPagesLinearDocument from './types/pub/leaflet/pages/linearDocument.js'
-import * as PubLeafletRichtextFacet from './types/pub/leaflet/richtext/facet.js'
-import * as ComAtprotoRepoCreateRecord from './types/com/atproto/repo/createRecord.js'
-import * as ComAtprotoRepoDefs from './types/com/atproto/repo/defs.js'
-import * as ComAtprotoRepoDeleteRecord from './types/com/atproto/repo/deleteRecord.js'
-import * as ComAtprotoRepoGetRecord from './types/com/atproto/repo/getRecord.js'
-import * as ComAtprotoRepoListRecords from './types/com/atproto/repo/listRecords.js'
-import * as ComAtprotoRepoPutRecord from './types/com/atproto/repo/putRecord.js'
-import * as ComAtprotoRepoStrongRef from './types/com/atproto/repo/strongRef.js'
-
-export * as PubLeafletDocument from './types/pub/leaflet/document.js'
-export * as PubLeafletBlocksCode from './types/pub/leaflet/blocks/code.js'
-export * as PubLeafletBlocksHeader from './types/pub/leaflet/blocks/header.js'
-export * as PubLeafletBlocksImage from './types/pub/leaflet/blocks/image.js'
-export * as PubLeafletBlocksMath from './types/pub/leaflet/blocks/math.js'
-export * as PubLeafletBlocksText from './types/pub/leaflet/blocks/text.js'
-export * as PubLeafletBlocksUnorderedList from './types/pub/leaflet/blocks/unorderedList.js'
-export * as PubLeafletBlocksWebsite from './types/pub/leaflet/blocks/website.js'
-export * as PubLeafletPagesLinearDocument from './types/pub/leaflet/pages/linearDocument.js'
-export * as PubLeafletRichtextFacet from './types/pub/leaflet/richtext/facet.js'
-export * as ComAtprotoRepoCreateRecord from './types/com/atproto/repo/createRecord.js'
-export * as ComAtprotoRepoDefs from './types/com/atproto/repo/defs.js'
-export * as ComAtprotoRepoDeleteRecord from './types/com/atproto/repo/deleteRecord.js'
-export * as ComAtprotoRepoGetRecord from './types/com/atproto/repo/getRecord.js'
-export * as ComAtprotoRepoListRecords from './types/com/atproto/repo/listRecords.js'
-export * as ComAtprotoRepoPutRecord from './types/com/atproto/repo/putRecord.js'
-export * as ComAtprotoRepoStrongRef from './types/com/atproto/repo/strongRef.js'
-
-export const PUB_LEAFLET_PAGES = {
-  LinearDocumentTextAlignLeft: 'pub.leaflet.pages.linearDocument#textAlignLeft',
-  LinearDocumentTextAlignCenter:
-    'pub.leaflet.pages.linearDocument#textAlignCenter',
-  LinearDocumentTextAlignRight:
-    'pub.leaflet.pages.linearDocument#textAlignRight',
-}
-
-export class AtpBaseClient extends XrpcClient {
-  pub: PubNS
-  com: ComNS
-
-  constructor(options: FetchHandler | FetchHandlerOptions) {
-    super(options, schemas)
-    this.pub = new PubNS(this)
-    this.com = new ComNS(this)
-  }
-
-  /** @deprecated use `this` instead */
-  get xrpc(): XrpcClient {
-    return this
-  }
-}
-
-export class PubNS {
-  _client: XrpcClient
-  leaflet: PubLeafletNS
-
-  constructor(client: XrpcClient) {
-    this._client = client
-    this.leaflet = new PubLeafletNS(client)
-  }
-}
-
-export class PubLeafletNS {
-  _client: XrpcClient
-  document: PubLeafletDocumentRecord
-  blocks: PubLeafletBlocksNS
-  pages: PubLeafletPagesNS
-  richtext: PubLeafletRichtextNS
-
-  constructor(client: XrpcClient) {
-    this._client = client
-    this.blocks = new PubLeafletBlocksNS(client)
-    this.pages = new PubLeafletPagesNS(client)
-    this.richtext = new PubLeafletRichtextNS(client)
-    this.document = new PubLeafletDocumentRecord(client)
-  }
-}
-
-export class PubLeafletBlocksNS {
-  _client: XrpcClient
-
-  constructor(client: XrpcClient) {
-    this._client = client
-  }
-}
-
-export class PubLeafletPagesNS {
-  _client: XrpcClient
-
-  constructor(client: XrpcClient) {
-    this._client = client
-  }
-}
-
-export class PubLeafletRichtextNS {
-  _client: XrpcClient
-
-  constructor(client: XrpcClient) {
-    this._client = client
-  }
-}
-
-export class PubLeafletDocumentRecord {
-  _client: XrpcClient
-
-  constructor(client: XrpcClient) {
-    this._client = client
-  }
-
-  async list(
-    params: OmitKey<ComAtprotoRepoListRecords.QueryParams, 'collection'>,
-  ): Promise<{
-    cursor?: string
-    records: { uri: string; value: PubLeafletDocument.Record }[]
-  }> {
-    const res = await this._client.call('com.atproto.repo.listRecords', {
-      collection: 'pub.leaflet.document',
-      ...params,
-    })
-    return res.data
-  }
-
-  async get(
-    params: OmitKey<ComAtprotoRepoGetRecord.QueryParams, 'collection'>,
-  ): Promise<{ uri: string; cid: string; value: PubLeafletDocument.Record }> {
-    const res = await this._client.call('com.atproto.repo.getRecord', {
-      collection: 'pub.leaflet.document',
-      ...params,
-    })
-    return res.data
-  }
-
-  async create(
-    params: OmitKey<
-      ComAtprotoRepoCreateRecord.InputSchema,
-      'collection' | 'record'
-    >,
-    record: Un$Typed<PubLeafletDocument.Record>,
-    headers?: Record<string, string>,
-  ): Promise<{ uri: string; cid: string }> {
-    const collection = 'pub.leaflet.document'
-    const res = await this._client.call(
-      'com.atproto.repo.createRecord',
-      undefined,
-      { collection, ...params, record: { ...record, $type: collection } },
-      { encoding: 'application/json', headers },
-    )
-    return res.data
-  }
-
-  async put(
-    params: OmitKey<
-      ComAtprotoRepoPutRecord.InputSchema,
-      'collection' | 'record'
-    >,
-    record: Un$Typed<PubLeafletDocument.Record>,
-    headers?: Record<string, string>,
-  ): Promise<{ uri: string; cid: string }> {
-    const collection = 'pub.leaflet.document'
-    const res = await this._client.call(
-      'com.atproto.repo.putRecord',
-      undefined,
-      { collection, ...params, record: { ...record, $type: collection } },
-      { encoding: 'application/json', headers },
-    )
-    return res.data
-  }
-
-  async delete(
-    params: OmitKey<ComAtprotoRepoDeleteRecord.InputSchema, 'collection'>,
-    headers?: Record<string, string>,
-  ): Promise<void> {
-    await this._client.call(
-      'com.atproto.repo.deleteRecord',
-      undefined,
-      { collection: 'pub.leaflet.document', ...params },
-      { headers },
-    )
-  }
-}
-
-export class ComNS {
-  _client: XrpcClient
-  atproto: ComAtprotoNS
-
-  constructor(client: XrpcClient) {
-    this._client = client
-    this.atproto = new ComAtprotoNS(client)
-  }
-}
-
-export class ComAtprotoNS {
-  _client: XrpcClient
-  repo: ComAtprotoRepoNS
-
-  constructor(client: XrpcClient) {
-    this._client = client
-    this.repo = new ComAtprotoRepoNS(client)
-  }
-}
-
-export class ComAtprotoRepoNS {
-  _client: XrpcClient
-
-  constructor(client: XrpcClient) {
-    this._client = client
-  }
-
-  createRecord(
-    data?: ComAtprotoRepoCreateRecord.InputSchema,
-    opts?: ComAtprotoRepoCreateRecord.CallOptions,
-  ): Promise<ComAtprotoRepoCreateRecord.Response> {
-    return this._client
-      .call('com.atproto.repo.createRecord', opts?.qp, data, opts)
-      .catch((e) => {
-        throw ComAtprotoRepoCreateRecord.toKnownErr(e)
-      })
-  }
-
-  deleteRecord(
-    data?: ComAtprotoRepoDeleteRecord.InputSchema,
-    opts?: ComAtprotoRepoDeleteRecord.CallOptions,
-  ): Promise<ComAtprotoRepoDeleteRecord.Response> {
-    return this._client
-      .call('com.atproto.repo.deleteRecord', opts?.qp, data, opts)
-      .catch((e) => {
-        throw ComAtprotoRepoDeleteRecord.toKnownErr(e)
-      })
-  }
-
-  getRecord(
-    params?: ComAtprotoRepoGetRecord.QueryParams,
-    opts?: ComAtprotoRepoGetRecord.CallOptions,
-  ): Promise<ComAtprotoRepoGetRecord.Response> {
-    return this._client
-      .call('com.atproto.repo.getRecord', params, undefined, opts)
-      .catch((e) => {
-        throw ComAtprotoRepoGetRecord.toKnownErr(e)
-      })
-  }
-
-  listRecords(
-    params?: ComAtprotoRepoListRecords.QueryParams,
-    opts?: ComAtprotoRepoListRecords.CallOptions,
-  ): Promise<ComAtprotoRepoListRecords.Response> {
-    return this._client.call(
-      'com.atproto.repo.listRecords',
-      params,
-      undefined,
-      opts,
-    )
-  }
-
-  putRecord(
-    data?: ComAtprotoRepoPutRecord.InputSchema,
-    opts?: ComAtprotoRepoPutRecord.CallOptions,
-  ): Promise<ComAtprotoRepoPutRecord.Response> {
-    return this._client
-      .call('com.atproto.repo.putRecord', opts?.qp, data, opts)
-      .catch((e) => {
-        throw ComAtprotoRepoPutRecord.toKnownErr(e)
-      })
-  }
-}

src/leaflet/lexicons/lexicons.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import {
-  type LexiconDoc,
-  Lexicons,
-  ValidationError,
-  type ValidationResult,
-} from '@atproto/lexicon'
-import { type $Typed, is$typed, maybe$typed } from './util.js'
-
-export const schemaDict = {
-  PubLeafletDocument: {
-    lexicon: 1,
-    id: 'pub.leaflet.document',
-    revision: 1,
-    description: 'A lexicon for long form rich media documents',
-    defs: {
-      main: {
-        type: 'record',
-        key: 'tid',
-        description: 'Record containing a document',
-        record: {
-          type: 'object',
-          required: ['pages', 'author', 'title', 'publication'],
-          properties: {
-            title: {
-              type: 'string',
-              maxLength: 1280,
-              maxGraphemes: 128,
-            },
-            postRef: {
-              type: 'ref',
-              ref: 'lex:com.atproto.repo.strongRef',
-            },
-            description: {
-              type: 'string',
-              maxLength: 3000,
-              maxGraphemes: 300,
-            },
-            publishedAt: {
-              type: 'string',
-              format: 'datetime',
-            },
-            publication: {
-              type: 'string',
-              format: 'at-uri',
-            },
-            author: {
-              type: 'string',
-              format: 'at-identifier',
-            },
-            pages: {
-              type: 'array',
-              items: {
-                type: 'union',
-                refs: ['lex:pub.leaflet.pages.linearDocument'],
-              },
-            },
-          },
-        },
-      },
-    },
-  },
-  PubLeafletBlocksCode: {
-    lexicon: 1,
-    id: 'pub.leaflet.blocks.code',
-    defs: {
-      main: {
-        type: 'object',
-        required: ['plaintext'],
-        properties: {
-          plaintext: {
-            type: 'string',
-          },
-          language: {
-            type: 'string',
-          },
-          syntaxHighlightingTheme: {
-            type: 'string',
-          },
-        },
-      },
-    },
-  },
-  PubLeafletBlocksHeader: {
-    lexicon: 1,
-    id: 'pub.leaflet.blocks.header',
-    defs: {
-      main: {
-        type: 'object',
-        required: ['plaintext'],
-        properties: {
-          level: {
-            type: 'integer',
-            minimum: 1,
-            maximum: 6,
-          },
-          plaintext: {
-            type: 'string',
-          },
-          facets: {
-            type: 'array',
-            items: {
-              type: 'ref',
-              ref: 'lex:pub.leaflet.richtext.facet',
-            },
-          },
-        },
-      },
-    },
-  },
-  PubLeafletBlocksImage: {
-    lexicon: 1,
-    id: 'pub.leaflet.blocks.image',
-    defs: {
-      main: {
-        type: 'object',
-        required: ['image', 'aspectRatio'],
-        properties: {
-          image: {
-            type: 'blob',
-            accept: ['image/*'],
-            maxSize: 1000000,
-          },
-          alt: {
-            type: 'string',
-            description:
-              'Alt text description of the image, for accessibility.',
-          },
-          aspectRatio: {
-            type: 'ref',
-            ref: 'lex:pub.leaflet.blocks.image#aspectRatio',
-          },
-        },
-      },
-      aspectRatio: {
-        type: 'object',
-        required: ['width', 'height'],
-        properties: {
-          width: {
-            type: 'integer',
-          },
-          height: {
-            type: 'integer',
-          },
-        },
-      },
-    },
-  },
-  PubLeafletBlocksMath: {
-    lexicon: 1,
-    id: 'pub.leaflet.blocks.math',
-    defs: {
-      main: {
-        type: 'object',
-        required: ['tex'],
-        properties: {
-          tex: {
-            type: 'string',
-          },
-        },
-      },
-    },
-  },
-  PubLeafletBlocksText: {
-    lexicon: 1,
-    id: 'pub.leaflet.blocks.text',
-    defs: {
-      main: {
-        type: 'object',
-        required: ['plaintext'],
-        properties: {
-          plaintext: {
-            type: 'string',
-          },
-          facets: {
-            type: 'array',
-            items: {
-              type: 'ref',
-              ref: 'lex:pub.leaflet.richtext.facet',
-            },
-          },
-        },
-      },
-    },
-  },
-  PubLeafletBlocksUnorderedList: {
-    lexicon: 1,
-    id: 'pub.leaflet.blocks.unorderedList',
-    defs: {
-      main: {
-        type: 'object',
-        required: ['children'],
-        properties: {
-          children: {
-            type: 'array',
-            items: {
-              type: 'ref',
-              ref: 'lex:pub.leaflet.blocks.unorderedList#listItem',
-            },
-          },
-        },
-      },
-      listItem: {
-        type: 'object',
-        required: ['content'],
-        properties: {
-          content: {
-            type: 'union',
-            refs: [
-              'lex:pub.leaflet.blocks.text',
-              'lex:pub.leaflet.blocks.header',
-              'lex:pub.leaflet.blocks.image',
-            ],
-          },
-          children: {
-            type: 'array',
-            items: {
-              type: 'ref',
-              ref: 'lex:pub.leaflet.blocks.unorderedList#listItem',
-            },
-          },
-        },
-      },
-    },
-  },
-  PubLeafletBlocksWebsite: {
-    lexicon: 1,
-    id: 'pub.leaflet.blocks.website',
-    defs: {
-      main: {
-        type: 'object',
-        required: ['src'],
-        properties: {
-          previewImage: {
-            type: 'blob',
-            accept: ['image/*'],
-            maxSize: 1000000,
-          },
-          title: {
-            type: 'string',
-          },
-          description: {
-            type: 'string',
-          },
-          src: {
-            type: 'string',
-            format: 'uri',
-          },
-        },
-      },
-    },
-  },
-  PubLeafletPagesLinearDocument: {
-    lexicon: 1,
-    id: 'pub.leaflet.pages.linearDocument',
-    defs: {
-      main: {
-        type: 'object',
-        properties: {
-          blocks: {
-            type: 'array',
-            items: {
-              type: 'ref',
-              ref: 'lex:pub.leaflet.pages.linearDocument#block',
-            },
-          },
-        },
-      },
-      block: {
-        type: 'object',
-        required: ['block'],
-        properties: {
-          block: {
-            type: 'union',
-            refs: [
-              'lex:pub.leaflet.blocks.text',
-              'lex:pub.leaflet.blocks.header',
-              'lex:pub.leaflet.blocks.image',
-              'lex:pub.leaflet.blocks.unorderedList',
-              'lex:pub.leaflet.blocks.website',
-              'lex:pub.leaflet.blocks.math',
-              'lex:pub.leaflet.blocks.code',
-            ],
-          },
-          alignment: {
-            type: 'string',
-            knownValues: [
-              'lex:pub.leaflet.pages.linearDocument#textAlignLeft',
-              'lex:pub.leaflet.pages.linearDocument#textAlignCenter',
-              'lex:pub.leaflet.pages.linearDocument#textAlignRight',
-            ],
-          },
-        },
-      },
-      textAlignLeft: {
-        type: 'token',
-      },
-      textAlignCenter: {
-        type: 'token',
-      },
-      textAlignRight: {
-        type: 'token',
-      },
-    },
-  },
-  PubLeafletRichtextFacet: {
-    lexicon: 1,
-    id: 'pub.leaflet.richtext.facet',
-    defs: {
-      main: {
-        type: 'object',
-        description: 'Annotation of a sub-string within rich text.',
-        required: ['index', 'features'],
-        properties: {
-          index: {
-            type: 'ref',
-            ref: 'lex:pub.leaflet.richtext.facet#byteSlice',
-          },
-          features: {
-            type: 'array',
-            items: {
-              type: 'union',
-              refs: [
-                'lex:pub.leaflet.richtext.facet#link',
-                'lex:pub.leaflet.richtext.facet#code',
-                'lex:pub.leaflet.richtext.facet#highlight',
-                'lex:pub.leaflet.richtext.facet#underline',
-                'lex:pub.leaflet.richtext.facet#strikethrough',
-                'lex:pub.leaflet.richtext.facet#id',
-                'lex:pub.leaflet.richtext.facet#bold',
-                'lex:pub.leaflet.richtext.facet#italic',
-              ],
-            },
-          },
-        },
-      },
-      byteSlice: {
-        type: 'object',
-        description:
-          'Specifies the sub-string range a facet feature applies to. Start index is inclusive, end index is exclusive. Indices are zero-indexed, counting bytes of the UTF-8 encoded text. NOTE: some languages, like Javascript, use UTF-16 or Unicode codepoints for string slice indexing; in these languages, convert to byte arrays before working with facets.',
-        required: ['byteStart', 'byteEnd'],
-        properties: {
-          byteStart: {
-            type: 'integer',
-            minimum: 0,
-          },
-          byteEnd: {
-            type: 'integer',
-            minimum: 0,
-          },
-        },
-      },
-      link: {
-        type: 'object',
-        description:
-          'Facet feature for a URL. The text URL may have been simplified or truncated, but the facet reference should be a complete URL.',
-        required: ['uri'],
-        properties: {
-          uri: {
-            type: 'string',
-            format: 'uri',
-          },
-        },
-      },
-      code: {
-        type: 'object',
-        description: 'Facet feature for inline code.',
-        required: [],
-        properties: {},
-      },
-      highlight: {
-        type: 'object',
-        description: 'Facet feature for highlighted text.',
-        required: [],
-        properties: {},
-      },
-      underline: {
-        type: 'object',
-        description: 'Facet feature for underline markup',
-        required: [],
-        properties: {},
-      },
-      strikethrough: {
-        type: 'object',
-        description: 'Facet feature for strikethrough markup',
-        required: [],
-        properties: {},
-      },
-      id: {
-        type: 'object',
-        description:
-          'Facet feature for an identifier. Used for linking to a segment',
-        required: [],
-        properties: {
-          id: {
-            type: 'string',
-          },
-        },
-      },
-      bold: {
-        type: 'object',
-        description: 'Facet feature for bold text',
-        required: [],
-        properties: {},
-      },
-      italic: {
-        type: 'object',
-        description: 'Facet feature for italic text',
-        required: [],
-        properties: {},
-      },
-    },
-  },
-  ComAtprotoRepoCreateRecord: {
-    lexicon: 1,
-    id: 'com.atproto.repo.createRecord',
-    defs: {
-      main: {
-        type: 'procedure',
-        description:
-          'Create a single new repository record. Requires auth, implemented by PDS.',
-        input: {
-          encoding: 'application/json',
-          schema: {
-            type: 'object',
-            required: ['repo', 'collection', 'record'],
-            properties: {
-              repo: {
-                type: 'string',
-                format: 'at-identifier',
-                description:
-                  'The handle or DID of the repo (aka, current account).',
-              },
-              collection: {
-                type: 'string',
-                format: 'nsid',
-                description: 'The NSID of the record collection.',
-              },
-              rkey: {
-                type: 'string',
-                format: 'record-key',
-                description: 'The Record Key.',
-                maxLength: 512,
-              },
-              validate: {
-                type: 'boolean',
-                description:
-                  "Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons.",
-              },
-              record: {
-                type: 'unknown',
-                description: 'The record itself. Must contain a $type field.',
-              },
-              swapCommit: {
-                type: 'string',
-                format: 'cid',
-                description:
-                  'Compare and swap with the previous commit by CID.',
-              },
-            },
-          },
-        },
-        output: {
-          encoding: 'application/json',
-          schema: {
-            type: 'object',
-            required: ['uri', 'cid'],
-            properties: {
-              uri: {
-                type: 'string',
-                format: 'at-uri',
-              },
-              cid: {
-                type: 'string',
-                format: 'cid',
-              },
-              commit: {
-                type: 'ref',
-                ref: 'lex:com.atproto.repo.defs#commitMeta',
-              },
-              validationStatus: {
-                type: 'string',
-                knownValues: ['valid', 'unknown'],
-              },
-            },
-          },
-        },
-        errors: [
-          {
-            name: 'InvalidSwap',
-            description:
-              "Indicates that 'swapCommit' didn't match current repo commit.",
-          },
-        ],
-      },
-    },
-  },
-  ComAtprotoRepoDefs: {
-    lexicon: 1,
-    id: 'com.atproto.repo.defs',
-    defs: {
-      commitMeta: {
-        type: 'object',
-        required: ['cid', 'rev'],
-        properties: {
-          cid: {
-            type: 'string',
-            format: 'cid',
-          },
-          rev: {
-            type: 'string',
-            format: 'tid',
-          },
-        },
-      },
-    },
-  },
-  ComAtprotoRepoDeleteRecord: {
-    lexicon: 1,
-    id: 'com.atproto.repo.deleteRecord',
-    defs: {
-      main: {
-        type: 'procedure',
-        description:
-          "Delete a repository record, or ensure it doesn't exist. Requires auth, implemented by PDS.",
-        input: {
-          encoding: 'application/json',
-          schema: {
-            type: 'object',
-            required: ['repo', 'collection', 'rkey'],
-            properties: {
-              repo: {
-                type: 'string',
-                format: 'at-identifier',
-                description:
-                  'The handle or DID of the repo (aka, current account).',
-              },
-              collection: {
-                type: 'string',
-                format: 'nsid',
-                description: 'The NSID of the record collection.',
-              },
-              rkey: {
-                type: 'string',
-                format: 'record-key',
-                description: 'The Record Key.',
-              },
-              swapRecord: {
-                type: 'string',
-                format: 'cid',
-                description:
-                  'Compare and swap with the previous record by CID.',
-              },
-              swapCommit: {
-                type: 'string',
-                format: 'cid',
-                description:
-                  'Compare and swap with the previous commit by CID.',
-              },
-            },
-          },
-        },
-        output: {
-          encoding: 'application/json',
-          schema: {
-            type: 'object',
-            properties: {
-              commit: {
-                type: 'ref',
-                ref: 'lex:com.atproto.repo.defs#commitMeta',
-              },
-            },
-          },
-        },
-        errors: [
-          {
-            name: 'InvalidSwap',
-          },
-        ],
-      },
-    },
-  },
-  ComAtprotoRepoGetRecord: {
-    lexicon: 1,
-    id: 'com.atproto.repo.getRecord',
-    defs: {
-      main: {
-        type: 'query',
-        description:
-          'Get a single record from a repository. Does not require auth.',
-        parameters: {
-          type: 'params',
-          required: ['repo', 'collection', 'rkey'],
-          properties: {
-            repo: {
-              type: 'string',
-              format: 'at-identifier',
-              description: 'The handle or DID of the repo.',
-            },
-            collection: {
-              type: 'string',
-              format: 'nsid',
-              description: 'The NSID of the record collection.',
-            },
-            rkey: {
-              type: 'string',
-              description: 'The Record Key.',
-              format: 'record-key',
-            },
-            cid: {
-              type: 'string',
-              format: 'cid',
-              description:
-                'The CID of the version of the record. If not specified, then return the most recent version.',
-            },
-          },
-        },
-        output: {
-          encoding: 'application/json',
-          schema: {
-            type: 'object',
-            required: ['uri', 'value'],
-            properties: {
-              uri: {
-                type: 'string',
-                format: 'at-uri',
-              },
-              cid: {
-                type: 'string',
-                format: 'cid',
-              },
-              value: {
-                type: 'unknown',
-              },
-            },
-          },
-        },
-        errors: [
-          {
-            name: 'RecordNotFound',
-          },
-        ],
-      },
-    },
-  },
-  ComAtprotoRepoListRecords: {
-    lexicon: 1,
-    id: 'com.atproto.repo.listRecords',
-    defs: {
-      main: {
-        type: 'query',
-        description:
-          'List a range of records in a repository, matching a specific collection. Does not require auth.',
-        parameters: {
-          type: 'params',
-          required: ['repo', 'collection'],
-          properties: {
-            repo: {
-              type: 'string',
-              format: 'at-identifier',
-              description: 'The handle or DID of the repo.',
-            },
-            collection: {
-              type: 'string',
-              format: 'nsid',
-              description: 'The NSID of the record type.',
-            },
-            limit: {
-              type: 'integer',
-              minimum: 1,
-              maximum: 100,
-              default: 50,
-              description: 'The number of records to return.',
-            },
-            cursor: {
-              type: 'string',
-            },
-            rkeyStart: {
-              type: 'string',
-              description:
-                'DEPRECATED: The lowest sort-ordered rkey to start from (exclusive)',
-            },
-            rkeyEnd: {
-              type: 'string',
-              description:
-                'DEPRECATED: The highest sort-ordered rkey to stop at (exclusive)',
-            },
-            reverse: {
-              type: 'boolean',
-              description: 'Flag to reverse the order of the returned records.',
-            },
-          },
-        },
-        output: {
-          encoding: 'application/json',
-          schema: {
-            type: 'object',
-            required: ['records'],
-            properties: {
-              cursor: {
-                type: 'string',
-              },
-              records: {
-                type: 'array',
-                items: {
-                  type: 'ref',
-                  ref: 'lex:com.atproto.repo.listRecords#record',
-                },
-              },
-            },
-          },
-        },
-      },
-      record: {
-        type: 'object',
-        required: ['uri', 'cid', 'value'],
-        properties: {
-          uri: {
-            type: 'string',
-            format: 'at-uri',
-          },
-          cid: {
-            type: 'string',
-            format: 'cid',
-          },
-          value: {
-            type: 'unknown',
-          },
-        },
-      },
-    },
-  },
-  ComAtprotoRepoPutRecord: {
-    lexicon: 1,
-    id: 'com.atproto.repo.putRecord',
-    defs: {
-      main: {
-        type: 'procedure',
-        description:
-          'Write a repository record, creating or updating it as needed. Requires auth, implemented by PDS.',
-        input: {
-          encoding: 'application/json',
-          schema: {
-            type: 'object',
-            required: ['repo', 'collection', 'rkey', 'record'],
-            nullable: ['swapRecord'],
-            properties: {
-              repo: {
-                type: 'string',
-                format: 'at-identifier',
-                description:
-                  'The handle or DID of the repo (aka, current account).',
-              },
-              collection: {
-                type: 'string',
-                format: 'nsid',
-                description: 'The NSID of the record collection.',
-              },
-              rkey: {
-                type: 'string',
-                format: 'record-key',
-                description: 'The Record Key.',
-                maxLength: 512,
-              },
-              validate: {
-                type: 'boolean',
-                description:
-                  "Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons.",
-              },
-              record: {
-                type: 'unknown',
-                description: 'The record to write.',
-              },
-              swapRecord: {
-                type: 'string',
-                format: 'cid',
-                description:
-                  'Compare and swap with the previous record by CID. WARNING: nullable and optional field; may cause problems with golang implementation',
-              },
-              swapCommit: {
-                type: 'string',
-                format: 'cid',
-                description:
-                  'Compare and swap with the previous commit by CID.',
-              },
-            },
-          },
-        },
-        output: {
-          encoding: 'application/json',
-          schema: {
-            type: 'object',
-            required: ['uri', 'cid'],
-            properties: {
-              uri: {
-                type: 'string',
-                format: 'at-uri',
-              },
-              cid: {
-                type: 'string',
-                format: 'cid',
-              },
-              commit: {
-                type: 'ref',
-                ref: 'lex:com.atproto.repo.defs#commitMeta',
-              },
-              validationStatus: {
-                type: 'string',
-                knownValues: ['valid', 'unknown'],
-              },
-            },
-          },
-        },
-        errors: [
-          {
-            name: 'InvalidSwap',
-          },
-        ],
-      },
-    },
-  },
-  ComAtprotoRepoStrongRef: {
-    lexicon: 1,
-    id: 'com.atproto.repo.strongRef',
-    description: 'A URI with a content-hash fingerprint.',
-    defs: {
-      main: {
-        type: 'object',
-        required: ['uri', 'cid'],
-        properties: {
-          uri: {
-            type: 'string',
-            format: 'at-uri',
-          },
-          cid: {
-            type: 'string',
-            format: 'cid',
-          },
-        },
-      },
-    },
-  },
-} as const satisfies Record<string, LexiconDoc>
-export const schemas = Object.values(schemaDict) satisfies LexiconDoc[]
-export const lexicons: Lexicons = new Lexicons(schemas)
-
-export function validate<T extends { $type: string }>(
-  v: unknown,
-  id: string,
-  hash: string,
-  requiredType: true,
-): ValidationResult<T>
-export function validate<T extends { $type?: string }>(
-  v: unknown,
-  id: string,
-  hash: string,
-  requiredType?: false,
-): ValidationResult<T>
-export function validate(
-  v: unknown,
-  id: string,
-  hash: string,
-  requiredType?: boolean,
-): ValidationResult {
-  return (requiredType ? is$typed : maybe$typed)(v, id, hash)
-    ? lexicons.validate(`${id}#${hash}`, v)
-    : {
-        success: false,
-        error: new ValidationError(
-          `Must be an object with "${hash === 'main' ? id : `${id}#${hash}`}" $type property`,
-        ),
-      }
-}
-
-export const ids = {
-  PubLeafletDocument: 'pub.leaflet.document',
-  PubLeafletBlocksCode: 'pub.leaflet.blocks.code',
-  PubLeafletBlocksHeader: 'pub.leaflet.blocks.header',
-  PubLeafletBlocksImage: 'pub.leaflet.blocks.image',
-  PubLeafletBlocksMath: 'pub.leaflet.blocks.math',
-  PubLeafletBlocksText: 'pub.leaflet.blocks.text',
-  PubLeafletBlocksUnorderedList: 'pub.leaflet.blocks.unorderedList',
-  PubLeafletBlocksWebsite: 'pub.leaflet.blocks.website',
-  PubLeafletPagesLinearDocument: 'pub.leaflet.pages.linearDocument',
-  PubLeafletRichtextFacet: 'pub.leaflet.richtext.facet',
-  ComAtprotoRepoCreateRecord: 'com.atproto.repo.createRecord',
-  ComAtprotoRepoDefs: 'com.atproto.repo.defs',
-  ComAtprotoRepoDeleteRecord: 'com.atproto.repo.deleteRecord',
-  ComAtprotoRepoGetRecord: 'com.atproto.repo.getRecord',
-  ComAtprotoRepoListRecords: 'com.atproto.repo.listRecords',
-  ComAtprotoRepoPutRecord: 'com.atproto.repo.putRecord',
-  ComAtprotoRepoStrongRef: 'com.atproto.repo.strongRef',
-} as const

src/leaflet/lexicons/types/com/atproto/repo/createRecord.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { HeadersMap, XRPCError } from '@atproto/xrpc'
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-import type * as ComAtprotoRepoDefs from './defs.js'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'com.atproto.repo.createRecord'
-
-export type QueryParams = {}
-
-export interface InputSchema {
-  /** The handle or DID of the repo (aka, current account). */
-  repo: string
-  /** The NSID of the record collection. */
-  collection: string
-  /** The Record Key. */
-  rkey?: string
-  /** Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons. */
-  validate?: boolean
-  /** The record itself. Must contain a $type field. */
-  record: { [_ in string]: unknown }
-  /** Compare and swap with the previous commit by CID. */
-  swapCommit?: string
-}
-
-export interface OutputSchema {
-  uri: string
-  cid: string
-  commit?: ComAtprotoRepoDefs.CommitMeta
-  validationStatus?: 'valid' | 'unknown' | (string & {})
-}
-
-export interface CallOptions {
-  signal?: AbortSignal
-  headers?: HeadersMap
-  qp?: QueryParams
-  encoding?: 'application/json'
-}
-
-export interface Response {
-  success: boolean
-  headers: HeadersMap
-  data: OutputSchema
-}
-
-export class InvalidSwapError extends XRPCError {
-  constructor(src: XRPCError) {
-    super(src.status, src.error, src.message, src.headers, { cause: src })
-  }
-}
-
-export function toKnownErr(e: any) {
-  if (e instanceof XRPCError) {
-    if (e.error === 'InvalidSwap') return new InvalidSwapError(e)
-  }
-
-  return e
-}

src/leaflet/lexicons/types/com/atproto/repo/defs.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'com.atproto.repo.defs'
-
-export interface CommitMeta {
-  $type?: 'com.atproto.repo.defs#commitMeta'
-  cid: string
-  rev: string
-}
-
-const hashCommitMeta = 'commitMeta'
-
-export function isCommitMeta<V>(v: V) {
-  return is$typed(v, id, hashCommitMeta)
-}
-
-export function validateCommitMeta<V>(v: V) {
-  return validate<CommitMeta & V>(v, id, hashCommitMeta)
-}

src/leaflet/lexicons/types/com/atproto/repo/deleteRecord.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { HeadersMap, XRPCError } from '@atproto/xrpc'
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-import type * as ComAtprotoRepoDefs from './defs.js'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'com.atproto.repo.deleteRecord'
-
-export type QueryParams = {}
-
-export interface InputSchema {
-  /** The handle or DID of the repo (aka, current account). */
-  repo: string
-  /** The NSID of the record collection. */
-  collection: string
-  /** The Record Key. */
-  rkey: string
-  /** Compare and swap with the previous record by CID. */
-  swapRecord?: string
-  /** Compare and swap with the previous commit by CID. */
-  swapCommit?: string
-}
-
-export interface OutputSchema {
-  commit?: ComAtprotoRepoDefs.CommitMeta
-}
-
-export interface CallOptions {
-  signal?: AbortSignal
-  headers?: HeadersMap
-  qp?: QueryParams
-  encoding?: 'application/json'
-}
-
-export interface Response {
-  success: boolean
-  headers: HeadersMap
-  data: OutputSchema
-}
-
-export class InvalidSwapError extends XRPCError {
-  constructor(src: XRPCError) {
-    super(src.status, src.error, src.message, src.headers, { cause: src })
-  }
-}
-
-export function toKnownErr(e: any) {
-  if (e instanceof XRPCError) {
-    if (e.error === 'InvalidSwap') return new InvalidSwapError(e)
-  }
-
-  return e
-}

src/leaflet/lexicons/types/com/atproto/repo/getRecord.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { HeadersMap, XRPCError } from '@atproto/xrpc'
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'com.atproto.repo.getRecord'
-
-export type QueryParams = {
-  /** The handle or DID of the repo. */
-  repo: string
-  /** The NSID of the record collection. */
-  collection: string
-  /** The Record Key. */
-  rkey: string
-  /** The CID of the version of the record. If not specified, then return the most recent version. */
-  cid?: string
-}
-export type InputSchema = undefined
-
-export interface OutputSchema {
-  uri: string
-  cid?: string
-  value: { [_ in string]: unknown }
-}
-
-export interface CallOptions {
-  signal?: AbortSignal
-  headers?: HeadersMap
-}
-
-export interface Response {
-  success: boolean
-  headers: HeadersMap
-  data: OutputSchema
-}
-
-export class RecordNotFoundError extends XRPCError {
-  constructor(src: XRPCError) {
-    super(src.status, src.error, src.message, src.headers, { cause: src })
-  }
-}
-
-export function toKnownErr(e: any) {
-  if (e instanceof XRPCError) {
-    if (e.error === 'RecordNotFound') return new RecordNotFoundError(e)
-  }
-
-  return e
-}

src/leaflet/lexicons/types/com/atproto/repo/listRecords.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { HeadersMap, XRPCError } from '@atproto/xrpc'
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'com.atproto.repo.listRecords'
-
-export type QueryParams = {
-  /** The handle or DID of the repo. */
-  repo: string
-  /** The NSID of the record type. */
-  collection: string
-  /** The number of records to return. */
-  limit?: number
-  cursor?: string
-  /** DEPRECATED: The lowest sort-ordered rkey to start from (exclusive) */
-  rkeyStart?: string
-  /** DEPRECATED: The highest sort-ordered rkey to stop at (exclusive) */
-  rkeyEnd?: string
-  /** Flag to reverse the order of the returned records. */
-  reverse?: boolean
-}
-export type InputSchema = undefined
-
-export interface OutputSchema {
-  cursor?: string
-  records: Record[]
-}
-
-export interface CallOptions {
-  signal?: AbortSignal
-  headers?: HeadersMap
-}
-
-export interface Response {
-  success: boolean
-  headers: HeadersMap
-  data: OutputSchema
-}
-
-export function toKnownErr(e: any) {
-  return e
-}
-
-export interface Record {
-  $type?: 'com.atproto.repo.listRecords#record'
-  uri: string
-  cid: string
-  value: { [_ in string]: unknown }
-}
-
-const hashRecord = 'record'
-
-export function isRecord<V>(v: V) {
-  return is$typed(v, id, hashRecord)
-}
-
-export function validateRecord<V>(v: V) {
-  return validate<Record & V>(v, id, hashRecord)
-}

src/leaflet/lexicons/types/com/atproto/repo/putRecord.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { HeadersMap, XRPCError } from '@atproto/xrpc'
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-import type * as ComAtprotoRepoDefs from './defs.js'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'com.atproto.repo.putRecord'
-
-export type QueryParams = {}
-
-export interface InputSchema {
-  /** The handle or DID of the repo (aka, current account). */
-  repo: string
-  /** The NSID of the record collection. */
-  collection: string
-  /** The Record Key. */
-  rkey: string
-  /** Can be set to 'false' to skip Lexicon schema validation of record data, 'true' to require it, or leave unset to validate only for known Lexicons. */
-  validate?: boolean
-  /** The record to write. */
-  record: { [_ in string]: unknown }
-  /** Compare and swap with the previous record by CID. WARNING: nullable and optional field; may cause problems with golang implementation */
-  swapRecord?: string | null
-  /** Compare and swap with the previous commit by CID. */
-  swapCommit?: string
-}
-
-export interface OutputSchema {
-  uri: string
-  cid: string
-  commit?: ComAtprotoRepoDefs.CommitMeta
-  validationStatus?: 'valid' | 'unknown' | (string & {})
-}
-
-export interface CallOptions {
-  signal?: AbortSignal
-  headers?: HeadersMap
-  qp?: QueryParams
-  encoding?: 'application/json'
-}
-
-export interface Response {
-  success: boolean
-  headers: HeadersMap
-  data: OutputSchema
-}
-
-export class InvalidSwapError extends XRPCError {
-  constructor(src: XRPCError) {
-    super(src.status, src.error, src.message, src.headers, { cause: src })
-  }
-}
-
-export function toKnownErr(e: any) {
-  if (e instanceof XRPCError) {
-    if (e.error === 'InvalidSwap') return new InvalidSwapError(e)
-  }
-
-  return e
-}

src/leaflet/lexicons/types/com/atproto/repo/strongRef.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'com.atproto.repo.strongRef'
-
-export interface Main {
-  $type?: 'com.atproto.repo.strongRef'
-  uri: string
-  cid: string
-}
-
-const hashMain = 'main'
-
-export function isMain<V>(v: V) {
-  return is$typed(v, id, hashMain)
-}
-
-export function validateMain<V>(v: V) {
-  return validate<Main & V>(v, id, hashMain)
-}

src/leaflet/lexicons/types/pub/leaflet/blocks/code.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'pub.leaflet.blocks.code'
-
-export interface Main {
-  $type?: 'pub.leaflet.blocks.code'
-  plaintext: string
-  language?: string
-  syntaxHighlightingTheme?: string
-}
-
-const hashMain = 'main'
-
-export function isMain<V>(v: V) {
-  return is$typed(v, id, hashMain)
-}
-
-export function validateMain<V>(v: V) {
-  return validate<Main & V>(v, id, hashMain)
-}

src/leaflet/lexicons/types/pub/leaflet/blocks/header.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-import type * as PubLeafletRichtextFacet from '../richtext/facet.js'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'pub.leaflet.blocks.header'
-
-export interface Main {
-  $type?: 'pub.leaflet.blocks.header'
-  level?: number
-  plaintext: string
-  facets?: PubLeafletRichtextFacet.Main[]
-}
-
-const hashMain = 'main'
-
-export function isMain<V>(v: V) {
-  return is$typed(v, id, hashMain)
-}
-
-export function validateMain<V>(v: V) {
-  return validate<Main & V>(v, id, hashMain)
-}

src/leaflet/lexicons/types/pub/leaflet/blocks/image.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'pub.leaflet.blocks.image'
-
-export interface Main {
-  $type?: 'pub.leaflet.blocks.image'
-  image: BlobRef
-  /** Alt text description of the image, for accessibility. */
-  alt?: string
-  aspectRatio: AspectRatio
-}
-
-const hashMain = 'main'
-
-export function isMain<V>(v: V) {
-  return is$typed(v, id, hashMain)
-}
-
-export function validateMain<V>(v: V) {
-  return validate<Main & V>(v, id, hashMain)
-}
-
-export interface AspectRatio {
-  $type?: 'pub.leaflet.blocks.image#aspectRatio'
-  width: number
-  height: number
-}
-
-const hashAspectRatio = 'aspectRatio'
-
-export function isAspectRatio<V>(v: V) {
-  return is$typed(v, id, hashAspectRatio)
-}
-
-export function validateAspectRatio<V>(v: V) {
-  return validate<AspectRatio & V>(v, id, hashAspectRatio)
-}

src/leaflet/lexicons/types/pub/leaflet/blocks/math.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'pub.leaflet.blocks.math'
-
-export interface Main {
-  $type?: 'pub.leaflet.blocks.math'
-  tex: string
-}
-
-const hashMain = 'main'
-
-export function isMain<V>(v: V) {
-  return is$typed(v, id, hashMain)
-}
-
-export function validateMain<V>(v: V) {
-  return validate<Main & V>(v, id, hashMain)
-}

src/leaflet/lexicons/types/pub/leaflet/blocks/text.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-import type * as PubLeafletRichtextFacet from '../richtext/facet.js'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'pub.leaflet.blocks.text'
-
-export interface Main {
-  $type?: 'pub.leaflet.blocks.text'
-  plaintext: string
-  facets?: PubLeafletRichtextFacet.Main[]
-}
-
-const hashMain = 'main'
-
-export function isMain<V>(v: V) {
-  return is$typed(v, id, hashMain)
-}
-
-export function validateMain<V>(v: V) {
-  return validate<Main & V>(v, id, hashMain)
-}

src/leaflet/lexicons/types/pub/leaflet/blocks/unorderedList.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-import type * as PubLeafletBlocksText from './text.js'
-import type * as PubLeafletBlocksHeader from './header.js'
-import type * as PubLeafletBlocksImage from './image.js'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'pub.leaflet.blocks.unorderedList'
-
-export interface Main {
-  $type?: 'pub.leaflet.blocks.unorderedList'
-  children: ListItem[]
-}
-
-const hashMain = 'main'
-
-export function isMain<V>(v: V) {
-  return is$typed(v, id, hashMain)
-}
-
-export function validateMain<V>(v: V) {
-  return validate<Main & V>(v, id, hashMain)
-}
-
-export interface ListItem {
-  $type?: 'pub.leaflet.blocks.unorderedList#listItem'
-  content:
-    | $Typed<PubLeafletBlocksText.Main>
-    | $Typed<PubLeafletBlocksHeader.Main>
-    | $Typed<PubLeafletBlocksImage.Main>
-    | { $type: string }
-  children?: ListItem[]
-}
-
-const hashListItem = 'listItem'
-
-export function isListItem<V>(v: V) {
-  return is$typed(v, id, hashListItem)
-}
-
-export function validateListItem<V>(v: V) {
-  return validate<ListItem & V>(v, id, hashListItem)
-}

src/leaflet/lexicons/types/pub/leaflet/blocks/website.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'pub.leaflet.blocks.website'
-
-export interface Main {
-  $type?: 'pub.leaflet.blocks.website'
-  previewImage?: BlobRef
-  title?: string
-  description?: string
-  src: string
-}
-
-const hashMain = 'main'
-
-export function isMain<V>(v: V) {
-  return is$typed(v, id, hashMain)
-}
-
-export function validateMain<V>(v: V) {
-  return validate<Main & V>(v, id, hashMain)
-}

src/leaflet/lexicons/types/pub/leaflet/document.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../lexicons'
-import { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util'
-import type * as ComAtprotoRepoStrongRef from '../../com/atproto/repo/strongRef.js'
-import type * as PubLeafletPagesLinearDocument from './pages/linearDocument.js'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'pub.leaflet.document'
-
-export interface Record {
-  $type: 'pub.leaflet.document'
-  title: string
-  postRef?: ComAtprotoRepoStrongRef.Main
-  description?: string
-  publishedAt?: string
-  publication: string
-  author: string
-  pages: ($Typed<PubLeafletPagesLinearDocument.Main> | { $type: string })[]
-  [k: string]: unknown
-}
-
-const hashRecord = 'main'
-
-export function isRecord<V>(v: V) {
-  return is$typed(v, id, hashRecord)
-}
-
-export function validateRecord<V>(v: V) {
-  return validate<Record & V>(v, id, hashRecord, true)
-}

src/leaflet/lexicons/types/pub/leaflet/pages/linearDocument.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-import type * as PubLeafletBlocksText from '../blocks/text.js'
-import type * as PubLeafletBlocksHeader from '../blocks/header.js'
-import type * as PubLeafletBlocksImage from '../blocks/image.js'
-import type * as PubLeafletBlocksUnorderedList from '../blocks/unorderedList.js'
-import type * as PubLeafletBlocksWebsite from '../blocks/website.js'
-import type * as PubLeafletBlocksMath from '../blocks/math.js'
-import type * as PubLeafletBlocksCode from '../blocks/code.js'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'pub.leaflet.pages.linearDocument'
-
-export interface Main {
-  $type?: 'pub.leaflet.pages.linearDocument'
-  blocks?: Block[]
-}
-
-const hashMain = 'main'
-
-export function isMain<V>(v: V) {
-  return is$typed(v, id, hashMain)
-}
-
-export function validateMain<V>(v: V) {
-  return validate<Main & V>(v, id, hashMain)
-}
-
-export interface Block {
-  $type?: 'pub.leaflet.pages.linearDocument#block'
-  block:
-    | $Typed<PubLeafletBlocksText.Main>
-    | $Typed<PubLeafletBlocksHeader.Main>
-    | $Typed<PubLeafletBlocksImage.Main>
-    | $Typed<PubLeafletBlocksUnorderedList.Main>
-    | $Typed<PubLeafletBlocksWebsite.Main>
-    | $Typed<PubLeafletBlocksMath.Main>
-    | $Typed<PubLeafletBlocksCode.Main>
-    | { $type: string }
-  alignment?:
-    | 'lex:pub.leaflet.pages.linearDocument#textAlignLeft'
-    | 'lex:pub.leaflet.pages.linearDocument#textAlignCenter'
-    | 'lex:pub.leaflet.pages.linearDocument#textAlignRight'
-    | (string & {})
-}
-
-const hashBlock = 'block'
-
-export function isBlock<V>(v: V) {
-  return is$typed(v, id, hashBlock)
-}
-
-export function validateBlock<V>(v: V) {
-  return validate<Block & V>(v, id, hashBlock)
-}
-
-export const TEXTALIGNLEFT = `${id}#textAlignLeft`
-export const TEXTALIGNCENTER = `${id}#textAlignCenter`
-export const TEXTALIGNRIGHT = `${id}#textAlignRight`

src/leaflet/lexicons/types/pub/leaflet/richtext/facet.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-import { type ValidationResult, BlobRef } from '@atproto/lexicon'
-import { CID } from 'multiformats/cid'
-import { validate as _validate } from '../../../../lexicons'
-import {
-  type $Typed,
-  is$typed as _is$typed,
-  type OmitKey,
-} from '../../../../util'
-
-const is$typed = _is$typed,
-  validate = _validate
-const id = 'pub.leaflet.richtext.facet'
-
-/** Annotation of a sub-string within rich text. */
-export interface Main {
-  $type?: 'pub.leaflet.richtext.facet'
-  index: ByteSlice
-  features: (
-    | $Typed<Link>
-    | $Typed<Code>
-    | $Typed<Highlight>
-    | $Typed<Underline>
-    | $Typed<Strikethrough>
-    | $Typed<Id>
-    | $Typed<Bold>
-    | $Typed<Italic>
-    | { $type: string }
-  )[]
-}
-
-const hashMain = 'main'
-
-export function isMain<V>(v: V) {
-  return is$typed(v, id, hashMain)
-}
-
-export function validateMain<V>(v: V) {
-  return validate<Main & V>(v, id, hashMain)
-}
-
-/** Specifies the sub-string range a facet feature applies to. Start index is inclusive, end index is exclusive. Indices are zero-indexed, counting bytes of the UTF-8 encoded text. NOTE: some languages, like Javascript, use UTF-16 or Unicode codepoints for string slice indexing; in these languages, convert to byte arrays before working with facets. */
-export interface ByteSlice {
-  $type?: 'pub.leaflet.richtext.facet#byteSlice'
-  byteStart: number
-  byteEnd: number
-}
-
-const hashByteSlice = 'byteSlice'
-
-export function isByteSlice<V>(v: V) {
-  return is$typed(v, id, hashByteSlice)
-}
-
-export function validateByteSlice<V>(v: V) {
-  return validate<ByteSlice & V>(v, id, hashByteSlice)
-}
-
-/** Facet feature for a URL. The text URL may have been simplified or truncated, but the facet reference should be a complete URL. */
-export interface Link {
-  $type?: 'pub.leaflet.richtext.facet#link'
-  uri: string
-}
-
-const hashLink = 'link'
-
-export function isLink<V>(v: V) {
-  return is$typed(v, id, hashLink)
-}
-
-export function validateLink<V>(v: V) {
-  return validate<Link & V>(v, id, hashLink)
-}
-
-/** Facet feature for inline code. */
-export interface Code {
-  $type?: 'pub.leaflet.richtext.facet#code'
-}
-
-const hashCode = 'code'
-
-export function isCode<V>(v: V) {
-  return is$typed(v, id, hashCode)
-}
-
-export function validateCode<V>(v: V) {
-  return validate<Code & V>(v, id, hashCode)
-}
-
-/** Facet feature for highlighted text. */
-export interface Highlight {
-  $type?: 'pub.leaflet.richtext.facet#highlight'
-}
-
-const hashHighlight = 'highlight'
-
-export function isHighlight<V>(v: V) {
-  return is$typed(v, id, hashHighlight)
-}
-
-export function validateHighlight<V>(v: V) {
-  return validate<Highlight & V>(v, id, hashHighlight)
-}
-
-/** Facet feature for underline markup */
-export interface Underline {
-  $type?: 'pub.leaflet.richtext.facet#underline'
-}
-
-const hashUnderline = 'underline'
-
-export function isUnderline<V>(v: V) {
-  return is$typed(v, id, hashUnderline)
-}
-
-export function validateUnderline<V>(v: V) {
-  return validate<Underline & V>(v, id, hashUnderline)
-}
-
-/** Facet feature for strikethrough markup */
-export interface Strikethrough {
-  $type?: 'pub.leaflet.richtext.facet#strikethrough'
-}
-
-const hashStrikethrough = 'strikethrough'
-
-export function isStrikethrough<V>(v: V) {
-  return is$typed(v, id, hashStrikethrough)
-}
-
-export function validateStrikethrough<V>(v: V) {
-  return validate<Strikethrough & V>(v, id, hashStrikethrough)
-}
-
-/** Facet feature for an identifier. Used for linking to a segment */
-export interface Id {
-  $type?: 'pub.leaflet.richtext.facet#id'
-  id?: string
-}
-
-const hashId = 'id'
-
-export function isId<V>(v: V) {
-  return is$typed(v, id, hashId)
-}
-
-export function validateId<V>(v: V) {
-  return validate<Id & V>(v, id, hashId)
-}
-
-/** Facet feature for bold text */
-export interface Bold {
-  $type?: 'pub.leaflet.richtext.facet#bold'
-}
-
-const hashBold = 'bold'
-
-export function isBold<V>(v: V) {
-  return is$typed(v, id, hashBold)
-}
-
-export function validateBold<V>(v: V) {
-  return validate<Bold & V>(v, id, hashBold)
-}
-
-/** Facet feature for italic text */
-export interface Italic {
-  $type?: 'pub.leaflet.richtext.facet#italic'
-}
-
-const hashItalic = 'italic'
-
-export function isItalic<V>(v: V) {
-  return is$typed(v, id, hashItalic)
-}
-
-export function validateItalic<V>(v: V) {
-  return validate<Italic & V>(v, id, hashItalic)
-}

src/leaflet/lexicons/util.ts

···
-/**
- * GENERATED CODE - DO NOT MODIFY
- */
-
-import { type ValidationResult } from '@atproto/lexicon'
-
-export type OmitKey<T, K extends keyof T> = {
-  [K2 in keyof T as K2 extends K ? never : K2]: T[K2]
-}
-
-export type $Typed<V, T extends string = string> = V & { $type: T }
-export type Un$Typed<V extends { $type?: string }> = OmitKey<V, '$type'>
-
-export type $Type<Id extends string, Hash extends string> = Hash extends 'main'
-  ? Id
-  : `${Id}#${Hash}`
-
-function isObject<V>(v: V): v is V & object {
-  return v != null && typeof v === 'object'
-}
-
-function is$type<Id extends string, Hash extends string>(
-  $type: unknown,
-  id: Id,
-  hash: Hash,
-): $type is $Type<Id, Hash> {
-  return hash === 'main'
-    ? $type === id
-    : // $type === `${id}#${hash}`
-      typeof $type === 'string' &&
-        $type.length === id.length + 1 + hash.length &&
-        $type.charCodeAt(id.length) === 35 /* '#' */ &&
-        $type.startsWith(id) &&
-        $type.endsWith(hash)
-}
-
-export type $TypedObject<
-  V,
-  Id extends string,
-  Hash extends string,
-> = V extends {
-  $type: $Type<Id, Hash>
-}
-  ? V
-  : V extends { $type?: string }
-    ? V extends { $type?: infer T extends $Type<Id, Hash> }
-      ? V & { $type: T }
-      : never
-    : V & { $type: $Type<Id, Hash> }
-
-export function is$typed<V, Id extends string, Hash extends string>(
-  v: V,
-  id: Id,
-  hash: Hash,
-): v is $TypedObject<V, Id, Hash> {
-  return isObject(v) && '$type' in v && is$type(v.$type, id, hash)
-}
-
-export function maybe$typed<V, Id extends string, Hash extends string>(
-  v: V,
-  id: Id,
-  hash: Hash,
-): v is V & object & { $type?: $Type<Id, Hash> } {
-  return (
-    isObject(v) &&
-    ('$type' in v ? v.$type === undefined || is$type(v.$type, id, hash) : true)
-  )
-}
-
-export type Validator<R = unknown> = (v: unknown) => ValidationResult<R>
-export type ValidatorParam<V extends Validator> =
-  V extends Validator<infer R> ? R : never
-
-/**
- * Utility function that allows to convert a "validate*" utility function into a
- * type predicate.
- */
-export function asPredicate<V extends Validator>(validate: V) {
-  return function <T>(v: T): v is T & ValidatorParam<V> {
-    return validate(v).success
-  }
-}

src/lexicons/index.ts

···
+export * as ComAtprotoRepoStrongRef from "./types/com/atproto/repo/strongRef.js";
+export * as PubLeafletBlocksCode from "./types/pub/leaflet/blocks/code.js";
+export * as PubLeafletBlocksHeader from "./types/pub/leaflet/blocks/header.js";
+export * as PubLeafletBlocksImage from "./types/pub/leaflet/blocks/image.js";
+export * as PubLeafletBlocksMath from "./types/pub/leaflet/blocks/math.js";
+export * as PubLeafletBlocksText from "./types/pub/leaflet/blocks/text.js";
+export * as PubLeafletBlocksUnorderedList from "./types/pub/leaflet/blocks/unorderedList.js";
+export * as PubLeafletBlocksWebsite from "./types/pub/leaflet/blocks/website.js";
+export * as PubLeafletDocument from "./types/pub/leaflet/document.js";
+export * as PubLeafletPagesLinearDocument from "./types/pub/leaflet/pages/linearDocument.js";
+export * as PubLeafletRichtextFacet from "./types/pub/leaflet/richtext/facet.js";

src/lexicons/types/com/atproto/repo/strongRef.ts

···
+import type {} from "@atcute/lexicons";
+import * as v from "@atcute/lexicons/validations";
+
+const _mainSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("com.atproto.repo.strongRef"),
+  ),
+  cid: /*#__PURE__*/ v.cidString(),
+  uri: /*#__PURE__*/ v.resourceUriString(),
+});
+
+type main$schematype = typeof _mainSchema;
+
+export interface mainSchema extends main$schematype {}
+
+export const mainSchema = _mainSchema as mainSchema;
+
+export interface Main extends v.InferInput<typeof mainSchema> {}

src/lexicons/types/pub/leaflet/blocks/code.ts

···
+import type {} from "@atcute/lexicons";
+import * as v from "@atcute/lexicons/validations";
+
+const _mainSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.blocks.code"),
+  ),
+  language: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
+  plaintext: /*#__PURE__*/ v.string(),
+  syntaxHighlightingTheme: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
+});
+
+type main$schematype = typeof _mainSchema;
+
+export interface mainSchema extends main$schematype {}
+
+export const mainSchema = _mainSchema as mainSchema;
+
+export interface Main extends v.InferInput<typeof mainSchema> {}

src/lexicons/types/pub/leaflet/blocks/header.ts

···
+import type {} from "@atcute/lexicons";
+import * as v from "@atcute/lexicons/validations";
+import * as PubLeafletRichtextFacet from "../richtext/facet.js";
+
+const _mainSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.blocks.header"),
+  ),
+  get facets() {
+    return /*#__PURE__*/ v.optional(
+      /*#__PURE__*/ v.array(PubLeafletRichtextFacet.mainSchema),
+    );
+  },
+  level: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.integer(), [
+      /*#__PURE__*/ v.integerRange(1, 6),
+    ]),
+  ),
+  plaintext: /*#__PURE__*/ v.string(),
+});
+
+type main$schematype = typeof _mainSchema;
+
+export interface mainSchema extends main$schematype {}
+
+export const mainSchema = _mainSchema as mainSchema;
+
+export interface Main extends v.InferInput<typeof mainSchema> {}

src/lexicons/types/pub/leaflet/blocks/image.ts

···
+import type {} from "@atcute/lexicons";
+import * as v from "@atcute/lexicons/validations";
+
+const _aspectRatioSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.blocks.image#aspectRatio"),
+  ),
+  height: /*#__PURE__*/ v.integer(),
+  width: /*#__PURE__*/ v.integer(),
+});
+const _mainSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.blocks.image"),
+  ),
+  alt: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
+  get aspectRatio() {
+    return aspectRatioSchema;
+  },
+  image: /*#__PURE__*/ v.blob(),
+});
+
+type aspectRatio$schematype = typeof _aspectRatioSchema;
+type main$schematype = typeof _mainSchema;
+
+export interface aspectRatioSchema extends aspectRatio$schematype {}
+export interface mainSchema extends main$schematype {}
+
+export const aspectRatioSchema = _aspectRatioSchema as aspectRatioSchema;
+export const mainSchema = _mainSchema as mainSchema;
+
+export interface AspectRatio extends v.InferInput<typeof aspectRatioSchema> {}
+export interface Main extends v.InferInput<typeof mainSchema> {}

src/lexicons/types/pub/leaflet/blocks/math.ts

···
+import type {} from "@atcute/lexicons";
+import * as v from "@atcute/lexicons/validations";
+
+const _mainSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.blocks.math"),
+  ),
+  tex: /*#__PURE__*/ v.string(),
+});
+
+type main$schematype = typeof _mainSchema;
+
+export interface mainSchema extends main$schematype {}
+
+export const mainSchema = _mainSchema as mainSchema;
+
+export interface Main extends v.InferInput<typeof mainSchema> {}

src/lexicons/types/pub/leaflet/blocks/text.ts

···
+import type {} from "@atcute/lexicons";
+import * as v from "@atcute/lexicons/validations";
+import * as PubLeafletRichtextFacet from "../richtext/facet.js";
+
+const _mainSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.blocks.text"),
+  ),
+  get facets() {
+    return /*#__PURE__*/ v.optional(
+      /*#__PURE__*/ v.array(PubLeafletRichtextFacet.mainSchema),
+    );
+  },
+  plaintext: /*#__PURE__*/ v.string(),
+});
+
+type main$schematype = typeof _mainSchema;
+
+export interface mainSchema extends main$schematype {}
+
+export const mainSchema = _mainSchema as mainSchema;
+
+export interface Main extends v.InferInput<typeof mainSchema> {}

src/lexicons/types/pub/leaflet/blocks/unorderedList.ts

···
+import type {} from "@atcute/lexicons";
+import * as v from "@atcute/lexicons/validations";
+import * as PubLeafletBlocksHeader from "./header.js";
+import * as PubLeafletBlocksImage from "./image.js";
+import * as PubLeafletBlocksText from "./text.js";
+
+const _listItemSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.blocks.unorderedList#listItem"),
+  ),
+  get children() {
+    return /*#__PURE__*/ v.optional(/*#__PURE__*/ v.array(listItemSchema));
+  },
+  get content() {
+    return /*#__PURE__*/ v.variant([
+      PubLeafletBlocksHeader.mainSchema,
+      PubLeafletBlocksImage.mainSchema,
+      PubLeafletBlocksText.mainSchema,
+    ]);
+  },
+});
+const _mainSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.blocks.unorderedList"),
+  ),
+  get children() {
+    return /*#__PURE__*/ v.array(listItemSchema);
+  },
+});
+
+type listItem$schematype = typeof _listItemSchema;
+type main$schematype = typeof _mainSchema;
+
+export interface listItemSchema extends listItem$schematype {}
+export interface mainSchema extends main$schematype {}
+
+export const listItemSchema = _listItemSchema as listItemSchema;
+export const mainSchema = _mainSchema as mainSchema;
+
+export interface ListItem extends v.InferInput<typeof listItemSchema> {}
+export interface Main extends v.InferInput<typeof mainSchema> {}

src/lexicons/types/pub/leaflet/blocks/website.ts

···
+import type {} from "@atcute/lexicons";
+import * as v from "@atcute/lexicons/validations";
+
+const _mainSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.blocks.website"),
+  ),
+  description: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
+  previewImage: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.blob()),
+  src: /*#__PURE__*/ v.genericUriString(),
+  title: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
+});
+
+type main$schematype = typeof _mainSchema;
+
+export interface mainSchema extends main$schematype {}
+
+export const mainSchema = _mainSchema as mainSchema;
+
+export interface Main extends v.InferInput<typeof mainSchema> {}

src/lexicons/types/pub/leaflet/document.ts

···
+import type {} from "@atcute/lexicons";
+import * as v from "@atcute/lexicons/validations";
+import type {} from "@atcute/lexicons/ambient";
+import * as ComAtprotoRepoStrongRef from "../../com/atproto/repo/strongRef.js";
+import * as PubLeafletPagesLinearDocument from "./pages/linearDocument.js";
+
+const _mainSchema = /*#__PURE__*/ v.record(
+  /*#__PURE__*/ v.tidString(),
+  /*#__PURE__*/ v.object({
+    $type: /*#__PURE__*/ v.literal("pub.leaflet.document"),
+    author: /*#__PURE__*/ v.actorIdentifierString(),
+    description: /*#__PURE__*/ v.optional(
+      /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [
+        /*#__PURE__*/ v.stringLength(0, 3000),
+        /*#__PURE__*/ v.stringGraphemes(0, 300),
+      ]),
+    ),
+    get pages() {
+      return /*#__PURE__*/ v.array(
+        /*#__PURE__*/ v.variant([PubLeafletPagesLinearDocument.mainSchema]),
+      );
+    },
+    get postRef() {
+      return /*#__PURE__*/ v.optional(ComAtprotoRepoStrongRef.mainSchema);
+    },
+    publication: /*#__PURE__*/ v.resourceUriString(),
+    publishedAt: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.datetimeString()),
+    title: /*#__PURE__*/ v.constrain(/*#__PURE__*/ v.string(), [
+      /*#__PURE__*/ v.stringLength(0, 1280),
+      /*#__PURE__*/ v.stringGraphemes(0, 128),
+    ]),
+  }),
+);
+
+type main$schematype = typeof _mainSchema;
+
+export interface mainSchema extends main$schematype {}
+
+export const mainSchema = _mainSchema as mainSchema;
+
+export interface Main extends v.InferInput<typeof mainSchema> {}
+
+declare module "@atcute/lexicons/ambient" {
+  interface Records {
+    "pub.leaflet.document": mainSchema;
+  }
+}

src/lexicons/types/pub/leaflet/pages/linearDocument.ts

···
+import type {} from "@atcute/lexicons";
+import * as v from "@atcute/lexicons/validations";
+import * as PubLeafletBlocksCode from "../blocks/code.js";
+import * as PubLeafletBlocksHeader from "../blocks/header.js";
+import * as PubLeafletBlocksImage from "../blocks/image.js";
+import * as PubLeafletBlocksMath from "../blocks/math.js";
+import * as PubLeafletBlocksText from "../blocks/text.js";
+import * as PubLeafletBlocksUnorderedList from "../blocks/unorderedList.js";
+import * as PubLeafletBlocksWebsite from "../blocks/website.js";
+
+const _blockSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.pages.linearDocument#block"),
+  ),
+  alignment: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.string<
+      "#textAlignCenter" | "#textAlignLeft" | "#textAlignRight" | (string & {})
+    >(),
+  ),
+  get block() {
+    return /*#__PURE__*/ v.variant([
+      PubLeafletBlocksCode.mainSchema,
+      PubLeafletBlocksHeader.mainSchema,
+      PubLeafletBlocksImage.mainSchema,
+      PubLeafletBlocksMath.mainSchema,
+      PubLeafletBlocksText.mainSchema,
+      PubLeafletBlocksUnorderedList.mainSchema,
+      PubLeafletBlocksWebsite.mainSchema,
+    ]);
+  },
+});
+const _mainSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.pages.linearDocument"),
+  ),
+  get blocks() {
+    return /*#__PURE__*/ v.optional(/*#__PURE__*/ v.array(blockSchema));
+  },
+});
+const _textAlignCenterSchema = /*#__PURE__*/ v.literal(
+  "pub.leaflet.pages.linearDocument#textAlignCenter",
+);
+const _textAlignLeftSchema = /*#__PURE__*/ v.literal(
+  "pub.leaflet.pages.linearDocument#textAlignLeft",
+);
+const _textAlignRightSchema = /*#__PURE__*/ v.literal(
+  "pub.leaflet.pages.linearDocument#textAlignRight",
+);
+
+type block$schematype = typeof _blockSchema;
+type main$schematype = typeof _mainSchema;
+type textAlignCenter$schematype = typeof _textAlignCenterSchema;
+type textAlignLeft$schematype = typeof _textAlignLeftSchema;
+type textAlignRight$schematype = typeof _textAlignRightSchema;
+
+export interface blockSchema extends block$schematype {}
+export interface mainSchema extends main$schematype {}
+export interface textAlignCenterSchema extends textAlignCenter$schematype {}
+export interface textAlignLeftSchema extends textAlignLeft$schematype {}
+export interface textAlignRightSchema extends textAlignRight$schematype {}
+
+export const blockSchema = _blockSchema as blockSchema;
+export const mainSchema = _mainSchema as mainSchema;
+export const textAlignCenterSchema =
+  _textAlignCenterSchema as textAlignCenterSchema;
+export const textAlignLeftSchema = _textAlignLeftSchema as textAlignLeftSchema;
+export const textAlignRightSchema =
+  _textAlignRightSchema as textAlignRightSchema;
+
+export interface Block extends v.InferInput<typeof blockSchema> {}
+export interface Main extends v.InferInput<typeof mainSchema> {}
+export type TextAlignCenter = v.InferInput<typeof textAlignCenterSchema>;
+export type TextAlignLeft = v.InferInput<typeof textAlignLeftSchema>;
+export type TextAlignRight = v.InferInput<typeof textAlignRightSchema>;

src/lexicons/types/pub/leaflet/richtext/facet.ts

···
+import type {} from "@atcute/lexicons";
+import * as v from "@atcute/lexicons/validations";
+
+const _boldSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.richtext.facet#bold"),
+  ),
+});
+const _byteSliceSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.richtext.facet#byteSlice"),
+  ),
+  byteEnd: /*#__PURE__*/ v.integer(),
+  byteStart: /*#__PURE__*/ v.integer(),
+});
+const _codeSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.richtext.facet#code"),
+  ),
+});
+const _highlightSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.richtext.facet#highlight"),
+  ),
+});
+const _idSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.richtext.facet#id"),
+  ),
+  id: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
+});
+const _italicSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.richtext.facet#italic"),
+  ),
+});
+const _linkSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.richtext.facet#link"),
+  ),
+  uri: /*#__PURE__*/ v.genericUriString(),
+});
+const _mainSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.richtext.facet"),
+  ),
+  get features() {
+    return /*#__PURE__*/ v.array(
+      /*#__PURE__*/ v.variant([
+        boldSchema,
+        codeSchema,
+        highlightSchema,
+        idSchema,
+        italicSchema,
+        linkSchema,
+        strikethroughSchema,
+        underlineSchema,
+      ]),
+    );
+  },
+  get index() {
+    return byteSliceSchema;
+  },
+});
+const _strikethroughSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.richtext.facet#strikethrough"),
+  ),
+});
+const _underlineSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("pub.leaflet.richtext.facet#underline"),
+  ),
+});
+
+type bold$schematype = typeof _boldSchema;
+type byteSlice$schematype = typeof _byteSliceSchema;
+type code$schematype = typeof _codeSchema;
+type highlight$schematype = typeof _highlightSchema;
+type id$schematype = typeof _idSchema;
+type italic$schematype = typeof _italicSchema;
+type link$schematype = typeof _linkSchema;
+type main$schematype = typeof _mainSchema;
+type strikethrough$schematype = typeof _strikethroughSchema;
+type underline$schematype = typeof _underlineSchema;
+
+export interface boldSchema extends bold$schematype {}
+export interface byteSliceSchema extends byteSlice$schematype {}
+export interface codeSchema extends code$schematype {}
+export interface highlightSchema extends highlight$schematype {}
+export interface idSchema extends id$schematype {}
+export interface italicSchema extends italic$schematype {}
+export interface linkSchema extends link$schematype {}
+export interface mainSchema extends main$schematype {}
+export interface strikethroughSchema extends strikethrough$schematype {}
+export interface underlineSchema extends underline$schematype {}
+
+export const boldSchema = _boldSchema as boldSchema;
+export const byteSliceSchema = _byteSliceSchema as byteSliceSchema;
+export const codeSchema = _codeSchema as codeSchema;
+export const highlightSchema = _highlightSchema as highlightSchema;
+export const idSchema = _idSchema as idSchema;
+export const italicSchema = _italicSchema as italicSchema;
+export const linkSchema = _linkSchema as linkSchema;
+export const mainSchema = _mainSchema as mainSchema;
+export const strikethroughSchema = _strikethroughSchema as strikethroughSchema;
+export const underlineSchema = _underlineSchema as underlineSchema;
+
+export interface Bold extends v.InferInput<typeof boldSchema> {}
+export interface ByteSlice extends v.InferInput<typeof byteSliceSchema> {}
+export interface Code extends v.InferInput<typeof codeSchema> {}
+export interface Highlight extends v.InferInput<typeof highlightSchema> {}
+export interface Id extends v.InferInput<typeof idSchema> {}
+export interface Italic extends v.InferInput<typeof italicSchema> {}
+export interface Link extends v.InferInput<typeof linkSchema> {}
+export interface Main extends v.InferInput<typeof mainSchema> {}
+export interface Strikethrough
+  extends v.InferInput<typeof strikethroughSchema> {}
+export interface Underline extends v.InferInput<typeof underlineSchema> {}

src/types.ts

···
 import type { Agent } from "@atproto/api";
-import type { PubLeafletRichtextFacet } from "./leaflet/lexicons/index.js";
+import type { PubLeafletRichtextFacet } from "./lexicons/index.js";
 
 export interface LeafletLoaderOptions {
 	/**

src/utils.ts

···
+import { is } from "@atcute/lexicons";
 import { AtUri, UnicodeString } from "@atproto/api";
 import sanitizeHTML from "sanitize-html";
+import { LiveLoaderError } from "./leaflet-live-loader.js";
 import {
 	PubLeafletBlocksHeader,
 	PubLeafletBlocksText,
 	type PubLeafletDocument,
 	PubLeafletPagesLinearDocument,
-	PubLeafletRichtextFacet,
-} from "./leaflet/lexicons/index.js";
-import { LiveLoaderError } from "./leaflet-live-loader.js";
+} from "./lexicons/index.js";
 import type {
 	Facet,
 	GetLeafletDocumentsParams,
···
 	id: string;
 	uri: string;
 	cid: string;
-	value: PubLeafletDocument.Record;
+	value: PubLeafletDocument.Main;
 }) {
 	let html = "";
 	const firstPage = record.value.pages[0];
 	let blocks: PubLeafletPagesLinearDocument.Block[] = [];
-	if (PubLeafletPagesLinearDocument.isMain(firstPage)) {
+	if (is(PubLeafletPagesLinearDocument.mainSchema, firstPage)) {
 		blocks = firstPage.blocks || [];
 	}
 
 	for (const block of blocks) {
-		if (PubLeafletBlocksText.isMain(block.block)) {
+		if (is(PubLeafletBlocksText.mainSchema, block.block)) {
 			const rt = new RichText({
 				text: block.block.plaintext,
 				facets: block.block.facets || [],
 			});
 			const children = [];
 			for (const segment of rt.segments()) {
-				const link = segment.facet?.find(PubLeafletRichtextFacet.isLink);
-				const isBold = segment.facet?.find(PubLeafletRichtextFacet.isBold);
-				const isCode = segment.facet?.find(PubLeafletRichtextFacet.isCode);
+				const link = segment.facet?.find(
+					(segment) => segment.$type === "pub.leaflet.richtext.facet#link",
+				);
+				const isBold = segment.facet?.find(
+					(segment) => segment.$type === "pub.leaflet.richtext.facet#bold",
+				);
+				const isCode = segment.facet?.find(
+					(segment) => segment.$type === "pub.leaflet.richtext.facet#code",
+				);
 				const isStrikethrough = segment.facet?.find(
-					PubLeafletRichtextFacet.isStrikethrough,
+					(segment) =>
+						segment.$type === "pub.leaflet.richtext.facet#strikethrough",
 				);
 				const isUnderline = segment.facet?.find(
-					PubLeafletRichtextFacet.isUnderline,
+					(segment) => segment.$type === "pub.leaflet.richtext.facet#underline",
+				);
+				const isItalic = segment.facet?.find(
+					(segment) => segment.$type === "pub.leaflet.richtext.facet#italic",
 				);
-				const isItalic = segment.facet?.find(PubLeafletRichtextFacet.isItalic);
 				if (isCode) {
 					children.push(` <code>
           ${segment.text}
···
 			html += `<p>${children.join("\n")}</p>`;
 		}
 
-		if (PubLeafletBlocksHeader.isMain(block.block)) {
+		if (is(PubLeafletBlocksHeader.mainSchema, block.block)) {
 			if (block.block.level === 1) {
 				html += `<h2>${block.block.plaintext}</h2>`;
 			}
 		}
-		if (PubLeafletBlocksHeader.isMain(block.block)) {
+		if (is(PubLeafletBlocksHeader.mainSchema, block.block)) {
 			if (block.block.level === 2) {
 				html += `<h3>${block.block.plaintext}</h3>`;
 			}
 		}
-		if (PubLeafletBlocksHeader.isMain(block.block)) {
+		if (is(PubLeafletBlocksHeader.mainSchema, block.block)) {
 			if (block.block.level === 3) {
 				html += `<h4>${block.block.plaintext}</h4>`;
 			}
 		}
-		if (PubLeafletBlocksHeader.isMain(block.block)) {
+		if (is(PubLeafletBlocksHeader.mainSchema, block.block)) {
 			if (!block.block.level) {
 				html += `<h6>${block.block.plaintext}</h6>`;
 			}

tsconfig.json

···
 		"strict": true,
 		"noUncheckedIndexedAccess": true,
 		"noImplicitOverride": true,
-		"module": "esnext",
+		"module": "nodenext",
 		"baseUrl": "./src",
 		"outDir": "dist",
-		"moduleResolution": "bundler",
+		"moduleResolution": "nodenext",
 		"rootDir": "src",
 		"sourceMap": true,
 		"noEmit": true,