workspaces refactor

.gitignore

···
-/lib
-/node_modules
+lib
+node_modules
 /.attest

aislop/plan-emit.md

···
 
 1. ✅ **Phase 1**: Basic CLI structure + Track B (inferred generation) - COMPLETE
 2. ✅ **Phase 2**: File organization + output directory structure - COMPLETE
-3. **Phase 3**: Track A (standard generation, delegate to lex-cli)
-4. **Phase 4**: Configuration file support
-5. **Phase 5**: Documentation + examples
+3. ✅ **Phase 3**: Convert to pnpm workspaces monorepo - COMPLETE
+4. **Phase 4**: Track A (standard generation, delegate to lex-cli)
+5. **Phase 5**: Configuration file support
+6. **Phase 6**: Documentation + examples
 
 ## Phase 1 & 2 Implementation Notes
 
···
 - Successfully generated types from sample lexicons
 - Runtime validation works (tested with node)
 - Schema imports work correctly with JSON modules
+
+## Phase 3: Monorepo Strategy
+
+### Why Monorepo?
+
+The CLI tool should be a separate package from the core inference library for several reasons:
+
+1. **Separation of concerns**: Core inference types vs. code generation tooling
+2. **Dependency isolation**: CLI needs `sade`, `tinyglobby`, etc. - consumers of the core library don't
+3. **Bundle size**: Users importing just types don't want CLI bloat
+4. **Independent versioning**: CLI can evolve separately from type inference
+5. **Better organization**: Clear boundaries between runtime and build-time code
+
+### Proposed Structure
+
+```
+prototypey/
+├── package.json                     # Root workspace config
+├── pnpm-workspace.yaml             # Workspace definition
+├── packages/
+│   ├── prototypey/                 # Core inference library
+│   │   ├── package.json           # Main package (prototypey)
+│   │   ├── src/
+│   │   │   ├── index.ts
+│   │   │   ├── infer.ts
+│   │   │   ├── lib.ts
+│   │   │   └── type-utils.ts
+│   │   ├── lib/                   # Built output
+│   │   └── tests/
+│   │
+│   └── cli/                        # CLI package
+│       ├── package.json           # Separate package (@prototypey/cli)
+│       ├── src/
+│       │   ├── index.ts
+│       │   ├── commands/
+│       │   │   └── gen-inferred.ts
+│       │   └── templates/
+│       │       └── inferred.ts
+│       └── lib/                   # Built CLI output
+│
+├── samples/                        # Shared samples
+├── generated/                      # Generated output (gitignored)
+└── lexicons/                       # Input lexicons (gitignored)
+```
+
+### Package Configurations
+
+**Root `pnpm-workspace.yaml`:**
+```yaml
+packages:
+  - 'packages/*'
+```
+
+**Root `package.json`:**
+```json
+{
+  "name": "prototypey-monorepo",
+  "private": true,
+  "scripts": {
+    "build": "pnpm -r build",
+    "test": "pnpm -r test",
+    "lint": "pnpm -r lint",
+    "format": "prettier . --write"
+  }
+}
+```
+
+**`packages/prototypey/package.json`:**
+```json
+{
+  "name": "prototypey",
+  "version": "0.0.0",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./infer": "./lib/infer.js"
+  },
+  "dependencies": {},
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run"
+  }
+}
+```
+
+**`packages/cli/package.json`:**
+```json
+{
+  "name": "@prototypey/cli",
+  "version": "0.0.0",
+  "bin": {
+    "prototypey": "./lib/index.js"
+  },
+  "dependencies": {
+    "prototypey": "workspace:*",
+    "sade": "^1.8.1",
+    "tinyglobby": "^0.2.15"
+  },
+  "scripts": {
+    "build": "tsdown --entry src/index.ts --format esm --dts false"
+  }
+}
+```
+
+### Migration Steps
+
+1. Create `pnpm-workspace.yaml` at root
+2. Create `packages/prototypey/` and move core files
+3. Create `packages/cli/` and move CLI files
+4. Update import paths in CLI to use `prototypey` package
+5. Update root `package.json` to be private workspace root
+6. Update build scripts to use `pnpm -r` (recursive)
+7. Test both packages build independently
+8. Update documentation
+
+### Benefits
+
+- **Cleaner dependency tree**: Core has zero dependencies
+- **Better DX**: Users can `npm install prototypey` for types only
+- **CLI as optional tool**: `npm install -D @prototypey/cli` when needed
+- **Easier testing**: Each package can have its own test suite
+- **Future expansion**: Easy to add more packages (e.g., `@prototypey/validator`)
 
 ## ATProto Lexicon Background Research
 

package.json

···
 {
-	"name": "prototypey",
+	"name": "prototypey-monorepo",
 	"version": "0.0.0",
-	"description": "A very lovely package. Hooray!",
+	"private": true,
+	"description": "Type-safe lexicon inference for ATProto schemas",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/tylersayshi/prototypey.git"
···
 		"name": "tylersayshi",
 		"email": "[e-mail]"
 	},
-	"type": "module",
-	"main": "lib/index.js",
-	"bin": {
-		"prototypey": "./lib/cli/index.js"
-	},
-	"files": [
-		"LICENSE.md",
-		"README.md",
-		"lib/",
-		"package.json"
-	],
 	"scripts": {
-		"build": "tsdown",
-		"build:cli": "tsdown --entry src/cli/index.ts --format esm --dts false --outDir lib/cli",
-		"codegen:samples": "node lib/cli/index.js gen-inferred ./generated/inferred './samples/*.json'",
+		"build": "pnpm -r build",
+		"codegen:samples": "node packages/cli/lib/index.js gen-inferred ./generated/inferred './samples/*.json'",
 		"format": "prettier . --list-different",
 		"format:fix": "prettier . --write",
-		"lint": "eslint . --max-warnings 0",
-		"test": "vitest run",
-		"test:bench": "node tests/infer.bench.ts",
-		"test:update-snapshots": "vitest run -u",
-		"tsc": "tsc"
+		"lint": "pnpm -r lint",
+		"test": "pnpm -r test",
+		"tsc": "pnpm -r tsc"
 	},
 	"devDependencies": {
-		"@ark/attest": "^0.49.0",
 		"@eslint/js": "9.29.0",
-		"@types/node": "24.0.4",
 		"eslint": "9.29.0",
 		"prettier": "3.6.1",
-		"tsdown": "0.12.7",
-		"typescript": "5.8.3",
-		"typescript-eslint": "8.35.0",
-		"vitest": "^3.2.4"
+		"typescript-eslint": "8.35.0"
 	},
 	"packageManager": "pnpm@10.4.0",
 	"engines": {
 		"node": ">=20.19.0"
-	},
-	"dependencies": {
-		"sade": "^1.8.1",
-		"tinyglobby": "^0.2.15"
 	}
 }

packages/cli/package.json

···
+{
+	"name": "@prototypey/cli",
+	"version": "0.0.0",
+	"description": "CLI tool for generating types from ATProto lexicon schemas",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/tylersayshi/prototypey.git",
+		"directory": "packages/cli"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "tylersayshi",
+		"email": "[e-mail]"
+	},
+	"type": "module",
+	"bin": {
+		"prototypey": "./lib/index.js"
+	},
+	"files": [
+		"lib/",
+		"README.md"
+	],
+	"scripts": {
+		"build": "tsdown --entry src/index.ts --format esm --dts false"
+	},
+	"dependencies": {
+		"prototypey": "workspace:*",
+		"sade": "^1.8.1",
+		"tinyglobby": "^0.2.15"
+	},
+	"devDependencies": {
+		"@types/node": "24.0.4",
+		"tsdown": "0.12.7",
+		"typescript": "5.8.3"
+	},
+	"engines": {
+		"node": ">=20.19.0"
+	}
+}

packages/cli/src/commands/gen-inferred.ts

···
+import { glob } from "tinyglobby";
+import { readFile, mkdir, writeFile } from "node:fs/promises";
+import { join, dirname, relative, parse } from "node:path";
+import { generateInferredCode } from "../templates/inferred.ts";
+
+interface LexiconSchema {
+	lexicon: number;
+	id: string;
+	defs: Record<string, unknown>;
+}
+
+export async function genInferred(
+	outdir: string,
+	schemas: string | string[],
+): Promise<void> {
+	try {
+		const schemaPatterns = Array.isArray(schemas) ? schemas : [schemas];
+
+		// Find all schema files matching the patterns
+		const schemaFiles = await glob(schemaPatterns, {
+			absolute: true,
+			onlyFiles: true,
+		});
+
+		if (schemaFiles.length === 0) {
+			console.log("No schema files found matching patterns:", schemaPatterns);
+			return;
+		}
+
+		console.log(`Found ${schemaFiles.length} schema file(s)`);
+
+		// Process each schema file
+		for (const schemaPath of schemaFiles) {
+			await processSchema(schemaPath, outdir);
+		}
+
+		console.log(`\nGenerated inferred types in ${outdir}`);
+	} catch (error) {
+		console.error("Error generating inferred types:", error);
+		process.exit(1);
+	}
+}
+
+async function processSchema(
+	schemaPath: string,
+	outdir: string,
+): Promise<void> {
+	const content = await readFile(schemaPath, "utf-8");
+	const schema: LexiconSchema = JSON.parse(content);
+
+	if (!schema.id || !schema.defs) {
+		console.warn(`Skipping ${schemaPath}: Missing id or defs`);
+		return;
+	}
+
+	// Convert NSID to file path: app.bsky.feed.post -> app/bsky/feed/post.ts
+	const nsidParts = schema.id.split(".");
+	const relativePath = join(...nsidParts) + ".ts";
+	const outputPath = join(outdir, relativePath);
+
+	// Create directory structure
+	await mkdir(dirname(outputPath), { recursive: true });
+
+	// Generate the TypeScript code
+	const code = generateInferredCode(schema, schemaPath, outdir);
+
+	// Write the file
+	await writeFile(outputPath, code, "utf-8");
+
+	console.log(`  ✓ ${schema.id} -> ${relativePath}`);
+}

packages/cli/src/index.ts

···
+#!/usr/bin/env node
+import sade from "sade";
+import { genInferred } from "./commands/gen-inferred.ts";
+
+const prog = sade("prototypey");
+
+prog
+	.version("0.0.0")
+	.describe("Type-safe lexicon inference and code generation");
+
+prog
+	.command("gen-inferred <outdir> <schemas...>")
+	.describe("Generate type-inferred code from lexicon schemas")
+	.example("gen-inferred ./generated/inferred ./lexicons/**/*.json")
+	.action(genInferred);
+
+prog.parse(process.argv);

packages/cli/src/templates/inferred.ts

···
+import { relative, dirname } from "node:path";
+
+interface LexiconSchema {
+	lexicon: number;
+	id: string;
+	defs: Record<string, unknown>;
+}
+
+export function generateInferredCode(
+	schema: LexiconSchema,
+	schemaPath: string,
+	outdir: string,
+): string {
+	const { id } = schema;
+
+	// Calculate relative import path from output file to schema file
+	// We need to go from generated/{nsid}.ts to the original schema
+	const nsidParts = id.split(".");
+	const outputDir = dirname([outdir, ...nsidParts].join("/"));
+	const relativeSchemaPath = relative(outputDir, schemaPath);
+
+	// Generate a clean type name from the NSID
+	const typeName = generateTypeName(id);
+
+	return `// Generated by prototypey - DO NOT EDIT
+// Source: ${id}
+import type { Infer } from "prototypey";
+import schema from "${relativeSchemaPath}" with { type: "json" };
+
+/**
+ * Type-inferred from lexicon schema: ${id}
+ */
+export type ${typeName} = Infer<typeof schema>;
+
+/**
+ * The lexicon schema object
+ */
+export const ${typeName}Schema = schema;
+
+/**
+ * Type guard to check if a value is a ${typeName}
+ */
+export function is${typeName}(v: unknown): v is ${typeName} {
+	return (
+		typeof v === "object" &&
+		v !== null &&
+		"$type" in v &&
+		v.$type === "${id}"
+	);
+}
+`;
+}
+
+function generateTypeName(nsid: string): string {
+	// Convert app.bsky.feed.post -> Post
+	// Convert com.atproto.repo.createRecord -> CreateRecord
+	const parts = nsid.split(".");
+	const lastPart = parts[parts.length - 1];
+
+	// Convert kebab-case or camelCase to PascalCase
+	return lastPart
+		.split(/[-_]/)
+		.map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+		.join("");
+}

packages/cli/tsconfig.json

···
+{
+	"compilerOptions": {
+		"declaration": true,
+		"declarationMap": true,
+		"esModuleInterop": true,
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+		"noEmit": true,
+		"resolveJsonModule": true,
+		"noErrorTruncation": true,
+		"skipLibCheck": true,
+		"strict": true,
+		"target": "ES2022",
+		"allowImportingTsExtensions": true
+	},
+	"include": ["src", "tests"]
+}

packages/cli/tsdown.config.ts

···
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+	dts: true,
+	entry: ["src/index.ts"],
+	outDir: "lib",
+	unbundle: true,
+});

packages/prototypey/.attest/assertions/typescript.json

···
+{
+    "tests/infer.test.ts": [
+        {
+            "location": {
+                "start": {
+                    "line": 19,
+                    "char": 2
+                },
+                "end": {
+                    "line": 19,
+                    "char": 30
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"com.example.post\"; tags?: string[] | undefined; likes?: number | undefined; createdAt: string; text: string; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 36,
+                    "char": 2
+                },
+                "end": {
+                    "line": 36,
+                    "char": 22
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test\"; optional?: string | undefined; required: string; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 50,
+                    "char": 2
+                },
+                "end": {
+                    "line": 50,
+                    "char": 22
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test\"; nullable: string | null; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 66,
+                    "char": 2
+                },
+                "end": {
+                    "line": 66,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.string\"; simpleString?: string | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 80,
+                    "char": 2
+                },
+                "end": {
+                    "line": 80,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.integer\"; count?: number | undefined; age?: number | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 95,
+                    "char": 2
+                },
+                "end": {
+                    "line": 95,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.boolean\"; isActive?: boolean | undefined; hasAccess: boolean; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 109,
+                    "char": 2
+                },
+                "end": {
+                    "line": 109,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.null\"; nullValue?: null | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 122,
+                    "char": 2
+                },
+                "end": {
+                    "line": 122,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.unknown\"; metadata?: unknown; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 134,
+                    "char": 2
+                },
+                "end": {
+                    "line": 134,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.bytes\"; data?: Uint8Array<ArrayBufferLike> | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 147,
+                    "char": 2
+                },
+                "end": {
+                    "line": 147,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.blob\"; image?: Blob | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 163,
+                    "char": 2
+                },
+                "end": {
+                    "line": 163,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.token\"; symbol?: string | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 180,
+                    "char": 2
+                },
+                "end": {
+                    "line": 180,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.array.string\"; tags?: string[] | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 193,
+                    "char": 2
+                },
+                "end": {
+                    "line": 193,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.array.integer\"; scores?: number[] | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 206,
+                    "char": 2
+                },
+                "end": {
+                    "line": 206,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.array.boolean\"; flags?: boolean[] | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 219,
+                    "char": 2
+                },
+                "end": {
+                    "line": 219,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.array.unknown\"; items?: unknown[] | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 239,
+                    "char": 2
+                },
+                "end": {
+                    "line": 239,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.mixed\"; age?: number | undefined; email?: string | undefined; id: string; name: string; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 257,
+                    "char": 2
+                },
+                "end": {
+                    "line": 257,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.allOptional\"; field1?: string | undefined; field2?: number | undefined; field3?: boolean | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 274,
+                    "char": 2
+                },
+                "end": {
+                    "line": 274,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.allRequired\"; field1: string; field2: number; field3: boolean; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 293,
+                    "char": 2
+                },
+                "end": {
+                    "line": 293,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.nullableOptional\"; description?: string | null | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 308,
+                    "char": 2
+                },
+                "end": {
+                    "line": 308,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.multipleNullable\"; field1?: string | null | undefined; field2?: number | null | undefined; field3?: boolean | null | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 323,
+                    "char": 2
+                },
+                "end": {
+                    "line": 323,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.nullableRequired\"; value: string | null; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 339,
+                    "char": 2
+                },
+                "end": {
+                    "line": 339,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.mixedNullable\"; optional?: string | undefined; required: string; optionalNullable?: string | null | undefined; requiredNullable: string | null; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 359,
+                    "char": 2
+                },
+                "end": {
+                    "line": 359,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.ref\"; post?: { [x: string]: unknown; $type: \"com.example.post\"; } | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 374,
+                    "char": 2
+                },
+                "end": {
+                    "line": 374,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.refRequired\"; author?: { [x: string]: unknown; $type: \"com.example.user\"; } | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 389,
+                    "char": 2
+                },
+                "end": {
+                    "line": 389,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.refNullable\"; parent?: { [x: string]: unknown; $type: \"com.example.node\"; } | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 408,
+                    "char": 2
+                },
+                "end": {
+                    "line": 408,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.union\"; content?: { [x: string]: unknown; $type: \"com.example.text\"; } | { [x: string]: unknown; $type: \"com.example.image\"; } | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 426,
+                    "char": 2
+                },
+                "end": {
+                    "line": 426,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.unionRequired\"; media: { [x: string]: unknown; $type: \"com.example.video\"; } | { [x: string]: unknown; $type: \"com.example.audio\"; }; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 446,
+                    "char": 2
+                },
+                "end": {
+                    "line": 446,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.unionMultiple\"; attachment?: { [x: string]: unknown; $type: \"com.example.image\"; } | { [x: string]: unknown; $type: \"com.example.video\"; } | { [x: string]: unknown; $type: \"com.example.audio\"; } | { [x: string]: unknown; $type: \"com.example.document\"; } | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 472,
+                    "char": 2
+                },
+                "end": {
+                    "line": 472,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.params\"; limit?: number | undefined; offset?: number | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 487,
+                    "char": 2
+                },
+                "end": {
+                    "line": 487,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.paramsRequired\"; limit?: number | undefined; query: string; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 510,
+                    "char": 2
+                },
+                "end": {
+                    "line": 510,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.record\"; published?: boolean | undefined; content: string; title: string; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 532,
+                    "char": 2
+                },
+                "end": {
+                    "line": 532,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.nested\"; user?: { name: string; email: string; } | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 551,
+                    "char": 2
+                },
+                "end": {
+                    "line": 551,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.deepNested\"; data?: { user?: { profile?: { name: string; } | undefined; } | undefined; } | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 579,
+                    "char": 2
+                },
+                "end": {
+                    "line": 579,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.arrayOfObjects\"; users?: { id: string; name: string; }[] | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 594,
+                    "char": 2
+                },
+                "end": {
+                    "line": 594,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.nestedArrays\"; matrix?: number[][] | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 607,
+                    "char": 2
+                },
+                "end": {
+                    "line": 607,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.arrayOfRefs\"; followers?: { [x: string]: unknown; $type: \"com.example.user\"; }[] | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 638,
+                    "char": 2
+                },
+                "end": {
+                    "line": 638,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test.complex\"; tags?: string[] | undefined; content?: { [x: string]: unknown; $type: \"com.example.text\"; } | { [x: string]: unknown; $type: \"com.example.image\"; } | undefined; author?: { avatar?: string | undefined; did: string; handle: string; } | undefined; metadata?: { likes?: number | undefined; views?: number | undefined; shares?: number | undefined; } | undefined; id: string; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 683,
+                    "char": 2
+                },
+                "end": {
+                    "line": 683,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "never",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 701,
+                    "char": 2
+                },
+                "end": {
+                    "line": 701,
+                    "char": 25
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"com.example.blog\"; title: string; body: string; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 724,
+                    "char": 2
+                },
+                "end": {
+                    "line": 724,
+                    "char": 18
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test\"; author?: { name: string; email: string; $type: \"#user\"; } | undefined; content: string; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 743,
+                    "char": 2
+                },
+                "end": {
+                    "line": 743,
+                    "char": 18
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test\"; users?: { name: string; $type: \"#user\"; }[] | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 758,
+                    "char": 2
+                },
+                "end": {
+                    "line": 758,
+                    "char": 18
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test\"; embed?: { content: string; $type: \"#text\"; } | { url: string; $type: \"#image\"; } | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 781,
+                    "char": 2
+                },
+                "end": {
+                    "line": 781,
+                    "char": 18
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test\"; author?: { profile?: { bio: string; $type: \"#profile\"; } | undefined; name: string; $type: \"#user\"; } | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 807,
+                    "char": 2
+                },
+                "end": {
+                    "line": 807,
+                    "char": 18
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test\"; parent?: { parent?: \"[Circular reference detected: #main]\" | undefined; value: string; $type: \"#main\"; } | undefined; value: string; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 837,
+                    "char": 2
+                },
+                "end": {
+                    "line": 837,
+                    "char": 18
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test\"; users?: { posts?: { author?: \"[Circular reference detected: #user]\" | undefined; title: string; $type: \"#post\"; }[] | undefined; name: string; $type: \"#user\"; }[] | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        },
+        {
+            "location": {
+                "start": {
+                    "line": 864,
+                    "char": 2
+                },
+                "end": {
+                    "line": 864,
+                    "char": 18
+                }
+            },
+            "args": [
+                {
+                    "type": "{ $type: \"test\"; author?: \"[Reference not found: #user]\" | undefined; }",
+                    "relationships": {
+                        "args": [
+                            "equality"
+                        ],
+                        "typeArgs": []
+                    }
+                }
+            ],
+            "typeArgs": [],
+            "errors": [],
+            "completions": {}
+        }
+    ]
+}

packages/prototypey/package.json

···
+{
+	"name": "prototypey",
+	"version": "0.0.0",
+	"description": "Type-safe lexicon inference for ATProto schemas",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/tylersayshi/prototypey.git",
+		"directory": "packages/prototypey"
+	},
+	"license": "MIT",
+	"author": {
+		"name": "tylersayshi",
+		"email": "[e-mail]"
+	},
+	"type": "module",
+	"main": "lib/index.js",
+	"exports": {
+		".": "./lib/index.js",
+		"./infer": "./lib/infer.js"
+	},
+	"files": [
+		"lib/",
+		"README.md"
+	],
+	"scripts": {
+		"build": "tsdown",
+		"test": "vitest run",
+		"test:bench": "node tests/infer.bench.ts",
+		"test:update-snapshots": "vitest run -u",
+		"tsc": "tsc"
+	},
+	"devDependencies": {
+		"@ark/attest": "^0.49.0",
+		"@types/node": "24.0.4",
+		"tsdown": "0.12.7",
+		"typescript": "5.8.3",
+		"vitest": "^3.2.4"
+	},
+	"engines": {
+		"node": ">=20.19.0"
+	}
+}

packages/prototypey/setup-vitest.ts

···
+import { setup } from "@ark/attest";
+
+// config options can be passed here
+export default () =>
+	setup({
+		// Set to true during development to skip type checking (faster)
+		skipTypes: false,
+
+		// Fail if benchmarks deviate by more than 20%
+		benchPercentThreshold: 20,
+	});

packages/prototypey/src/index.ts

···
+export * from "./lib.ts";
+export * from "./infer.ts";

packages/prototypey/src/infer.ts

···
+import { Prettify } from "./type-utils.ts";
+
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+type InferType<T> = T extends { type: "record" }
+	? InferRecord<T>
+	: T extends { type: "object" }
+		? InferObject<T>
+		: T extends { type: "array" }
+			? InferArray<T>
+			: T extends { type: "params" }
+				? InferParams<T>
+				: T extends { type: "union" }
+					? InferUnion<T>
+					: T extends { type: "token" }
+						? InferToken<T>
+						: T extends { type: "ref" }
+							? InferRef<T>
+							: T extends { type: "unknown" }
+								? unknown
+								: T extends { type: "null" }
+									? null
+									: T extends { type: "boolean" }
+										? boolean
+										: T extends { type: "integer" }
+											? number
+											: T extends { type: "string" }
+												? string
+												: T extends { type: "bytes" }
+													? Uint8Array
+													: T extends { type: "cid-link" }
+														? string
+														: T extends { type: "blob" }
+															? Blob
+															: never;
+
+type InferToken<T> = T extends { enum: readonly (infer U)[] } ? U : string;
+
+export type GetRequired<T> = T extends { required: readonly (infer R)[] }
+	? R
+	: never;
+export type GetNullable<T> = T extends { nullable: readonly (infer N)[] }
+	? N
+	: never;
+
+type InferObject<
+	T,
+	Nullable extends string = GetNullable<T> & string,
+	Required extends string = GetRequired<T> & string,
+	NullableAndRequired extends string = Required & Nullable & string,
+	Normal extends string = "properties" extends keyof T
+		? Exclude<keyof T["properties"], Required | Nullable> & string
+		: never,
+> = Prettify<
+	T extends { properties: infer P }
+		? {
+				-readonly [K in Normal]?: InferType<P[K & keyof P]>;
+			} & {
+				-readonly [K in Exclude<Required, NullableAndRequired>]-?: InferType<
+					P[K & keyof P]
+				>;
+			} & {
+				-readonly [K in Exclude<Nullable, NullableAndRequired>]?: InferType<
+					P[K & keyof P]
+				> | null;
+			} & {
+				-readonly [K in NullableAndRequired]: InferType<P[K & keyof P]> | null;
+			}
+		: {}
+>;
+
+type InferArray<T> = T extends { items: infer Items }
+	? InferType<Items>[]
+	: never[];
+
+type InferUnion<T> = T extends { refs: readonly (infer R)[] }
+	? R extends string
+		? { $type: R; [key: string]: unknown }
+		: never
+	: never;
+
+type InferRef<T> = T extends { ref: infer R }
+	? R extends string
+		? { $type: R; [key: string]: unknown }
+		: unknown
+	: unknown;
+
+type InferParams<T> = InferObject<T>;
+
+type InferRecord<T> = T extends { record: infer R }
+	? R extends { type: "object" }
+		? InferObject<R>
+		: R extends { type: "union" }
+			? InferUnion<R>
+			: unknown
+	: unknown;
+
+/**
+ * Recursively replaces stub references in a type with their actual definitions.
+ * Detects circular references and missing references, returning string literal error messages.
+ */
+type ReplaceRefsInType<T, Defs, Visited = never> =
+	// Check if this is a ref stub type (has $type starting with #)
+	T extends { $type: `#${infer DefName}` }
+		? DefName extends keyof Defs
+			? // Check for circular reference
+				DefName extends Visited
+				? `[Circular reference detected: #${DefName}]`
+				: // Recursively resolve the ref and preserve the $type marker
+					Prettify<
+						ReplaceRefsInType<Defs[DefName], Defs, Visited | DefName> & {
+							$type: T["$type"];
+						}
+					>
+			: // Reference not found in definitions
+				`[Reference not found: #${DefName}]`
+		: // Handle arrays (but not Uint8Array or other typed arrays)
+			T extends Uint8Array | Blob
+			? T
+			: T extends readonly (infer Item)[]
+				? ReplaceRefsInType<Item, Defs, Visited>[]
+				: // Handle plain objects (exclude built-in types and functions)
+					T extends object
+					? T extends (...args: unknown[]) => unknown
+						? T
+						: { [K in keyof T]: ReplaceRefsInType<T[K], Defs, Visited> }
+					: // Primitives pass through unchanged
+						T;
+
+/**
+ * Infers the TypeScript type for a lexicon namespace, returning only the 'main' definition
+ * with all local refs (#user, #post, etc.) resolved to their actual types.
+ */
+export type Infer<T extends { id: string; defs: Record<string, unknown> }> =
+	Prettify<
+		"main" extends keyof T["defs"]
+			? { $type: T["id"] } & ReplaceRefsInType<
+					InferType<T["defs"]["main"]>,
+					{ [K in keyof T["defs"]]: InferType<T["defs"][K]> }
+				>
+			: never
+	>;

packages/prototypey/src/lib.ts

···
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+import type { Infer } from "./infer.ts";
+import type { UnionToTuple } from "./type-utils.ts";
+
+/** @see https://atproto.com/specs/lexicon#overview-of-types */
+type LexiconType =
+	// Concrete types
+	| "null"
+	| "boolean"
+	| "integer"
+	| "string"
+	| "bytes"
+	| "cid-link"
+	| "blob"
+	// Container types
+	| "array"
+	| "object"
+	| "params"
+	// Meta types
+	| "token"
+	| "ref"
+	| "union"
+	| "unknown"
+	// Primary types
+	| "record"
+	| "query"
+	| "procedure"
+	| "subscription";
+
+/**
+ * Common options available for lexicon items.
+ * @see https://atproto.com/specs/lexicon#string-formats
+ */
+interface LexiconItemCommonOptions {
+	/** Indicates this field must be provided */
+	required?: boolean;
+	/** Indicates this field can be explicitly set to null */
+	nullable?: boolean;
+}
+
+/**
+ * Base interface for all lexicon items.
+ * @see https://atproto.com/specs/lexicon#overview-of-types
+ */
+interface LexiconItem extends LexiconItemCommonOptions {
+	type: LexiconType;
+}
+
+/**
+ * Definition in a lexicon namespace.
+ * @see https://atproto.com/specs/lexicon#lexicon-document
+ */
+interface Def {
+	type: LexiconType;
+}
+
+/**
+ * Lexicon namespace document structure.
+ * @see https://atproto.com/specs/lexicon#lexicon-document
+ */
+interface LexiconNamespace {
+	/** Namespaced identifier (NSID) for this lexicon */
+	id: string;
+	/** Named definitions within this namespace */
+	defs: Record<string, Def>;
+}
+
+/**
+ * String type options.
+ * @see https://atproto.com/specs/lexicon#string
+ */
+interface StringOptions extends LexiconItemCommonOptions {
+	/**
+	 * Semantic string format constraint.
+	 * @see https://atproto.com/specs/lexicon#string-formats
+	 */
+	format?:
+		| "at-identifier" // Handle or DID
+		| "at-uri" // AT Protocol URI
+		| "cid" // Content Identifier
+		| "datetime" // Timestamp (UTC, ISO 8601)
+		| "did" // Decentralized Identifier
+		| "handle" // User handle identifier
+		| "nsid" // Namespaced Identifier
+		| "tid" // Timestamp Identifier
+		| "record-key" // Repository record key
+		| "uri" // Generic URI
+		| "language"; // IETF BCP 47 language tag
+	/** Maximum string length in bytes */
+	maxLength?: number;
+	/** Minimum string length in bytes */
+	minLength?: number;
+	/** Maximum string length in Unicode graphemes */
+	maxGraphemes?: number;
+	/** Minimum string length in Unicode graphemes */
+	minGraphemes?: number;
+	/** Hints at expected values, not enforced */
+	knownValues?: string[];
+	/** Restricts to an exact set of string values */
+	enum?: string[];
+	/** Default value if not provided */
+	default?: string;
+	/** Fixed, unchangeable value */
+	const?: string;
+}
+
+/**
+ * Boolean type options.
+ * @see https://atproto.com/specs/lexicon#boolean
+ */
+interface BooleanOptions extends LexiconItemCommonOptions {
+	/** Default value if not provided */
+	default?: boolean;
+	/** Fixed, unchangeable value */
+	const?: boolean;
+}
+
+/**
+ * Integer type options.
+ * @see https://atproto.com/specs/lexicon#integer
+ */
+interface IntegerOptions extends LexiconItemCommonOptions {
+	/** Minimum allowed value (inclusive) */
+	minimum?: number;
+	/** Maximum allowed value (inclusive) */
+	maximum?: number;
+	/** Restricts to an exact set of integer values */
+	enum?: number[];
+	/** Default value if not provided */
+	default?: number;
+	/** Fixed, unchangeable value */
+	const?: number;
+}
+
+/**
+ * Bytes type options for arbitrary byte arrays.
+ * @see https://atproto.com/specs/lexicon#bytes
+ */
+interface BytesOptions extends LexiconItemCommonOptions {
+	/** Minimum byte array length */
+	minLength?: number;
+	/** Maximum byte array length */
+	maxLength?: number;
+}
+
+/**
+ * Blob type options for binary data with MIME types.
+ * @see https://atproto.com/specs/lexicon#blob
+ */
+interface BlobOptions extends LexiconItemCommonOptions {
+	/** Allowed MIME types (e.g., ["image/png", "image/jpeg"]) */
+	accept?: string[];
+	/** Maximum blob size in bytes */
+	maxSize?: number;
+}
+
+/**
+ * Array type options.
+ * @see https://atproto.com/specs/lexicon#array
+ */
+interface ArrayOptions extends LexiconItemCommonOptions {
+	/** Minimum array length */
+	minLength?: number;
+	/** Maximum array length */
+	maxLength?: number;
+}
+
+/**
+ * Record type options for repository records.
+ * @see https://atproto.com/specs/lexicon#record
+ */
+interface RecordOptions {
+	/** Record key strategy: "self" for self-describing or "tid" for timestamp IDs */
+	key: "self" | "tid";
+	/** Object schema defining the record structure */
+	record: { type: "object" };
+	/** Human-readable description */
+	description?: string;
+}
+
+/**
+ * Union type options for multiple possible types.
+ * @see https://atproto.com/specs/lexicon#union
+ */
+interface UnionOptions extends LexiconItemCommonOptions {
+	/** If true, only listed refs are allowed; if false, additional types may be added */
+	closed?: boolean;
+}
+
+/**
+ * Map of property names to their lexicon item definitions.
+ * @see https://atproto.com/specs/lexicon#object
+ */
+type ObjectProperties = Record<
+	string,
+	{
+		type: LexiconType;
+	}
+>;
+
+type RequiredKeys<T> = {
+	[K in keyof T]: T[K] extends { required: true } ? K : never;
+}[keyof T];
+
+type NullableKeys<T> = {
+	[K in keyof T]: T[K] extends { nullable: true } ? K : never;
+}[keyof T];
+
+/**
+ * Resulting object schema with required and nullable fields extracted.
+ * @see https://atproto.com/specs/lexicon#object
+ */
+type ObjectResult<T extends ObjectProperties> = {
+	type: "object";
+	/** Property definitions */
+	properties: {
+		[K in keyof T]: T[K] extends { type: "object" }
+			? T[K]
+			: Omit<T[K], "required" | "nullable">;
+	};
+} & ([RequiredKeys<T>] extends [never]
+	? {}
+	: { required: UnionToTuple<RequiredKeys<T>> }) &
+	([NullableKeys<T>] extends [never]
+		? {}
+		: { nullable: UnionToTuple<NullableKeys<T>> });
+
+/**
+ * Map of parameter names to their lexicon item definitions.
+ * @see https://atproto.com/specs/lexicon#params
+ */
+type ParamsProperties = Record<string, LexiconItem>;
+
+/**
+ * Resulting params schema with required fields extracted.
+ * @see https://atproto.com/specs/lexicon#params
+ */
+type ParamsResult<T extends ParamsProperties> = {
+	type: "params";
+	/** Parameter definitions */
+	properties: {
+		[K in keyof T]: Omit<T[K], "required" | "nullable">;
+	};
+} & ([RequiredKeys<T>] extends [never]
+	? {}
+	: { required: UnionToTuple<RequiredKeys<T>> });
+
+/**
+ * HTTP request or response body schema.
+ * @see https://atproto.com/specs/lexicon#http-endpoints
+ */
+interface BodySchema {
+	/** MIME type encoding (typically "application/json") */
+	encoding: "application/json" | (string & {});
+	/** Human-readable description */
+	description?: string;
+	/** Object schema defining the body structure */
+	schema?: ObjectResult<ObjectProperties>;
+}
+
+/**
+ * Error definition for HTTP endpoints.
+ * @see https://atproto.com/specs/lexicon#http-endpoints
+ */
+interface ErrorDef {
+	/** Error name/code */
+	name: string;
+	/** Human-readable error description */
+	description?: string;
+}
+
+/**
+ * Query endpoint options (HTTP GET).
+ * @see https://atproto.com/specs/lexicon#query
+ */
+interface QueryOptions {
+	/** Human-readable description */
+	description?: string;
+	/** Query string parameters */
+	parameters?: ParamsResult<ParamsProperties>;
+	/** Response body schema */
+	output?: BodySchema;
+	/** Possible error responses */
+	errors?: ErrorDef[];
+}
+
+/**
+ * Procedure endpoint options (HTTP POST).
+ * @see https://atproto.com/specs/lexicon#procedure
+ */
+interface ProcedureOptions {
+	/** Human-readable description */
+	description?: string;
+	/** Query string parameters */
+	parameters?: ParamsResult<ParamsProperties>;
+	/** Request body schema */
+	input?: BodySchema;
+	/** Response body schema */
+	output?: BodySchema;
+	/** Possible error responses */
+	errors?: ErrorDef[];
+}
+
+/**
+ * WebSocket message schema for subscriptions.
+ * @see https://atproto.com/specs/lexicon#subscription
+ */
+interface MessageSchema {
+	/** Human-readable description */
+	description?: string;
+	/** Union of possible message types */
+	schema: { type: "union"; refs: readonly string[] };
+}
+
+/**
+ * Subscription endpoint options (WebSocket).
+ * @see https://atproto.com/specs/lexicon#subscription
+ */
+interface SubscriptionOptions {
+	/** Human-readable description */
+	description?: string;
+	/** Query string parameters */
+	parameters?: ParamsResult<ParamsProperties>;
+	/** Message schema for events */
+	message?: MessageSchema;
+	/** Possible error responses */
+	errors?: ErrorDef[];
+}
+
+class Namespace<T extends LexiconNamespace> {
+	public json: T;
+	public infer: Infer<T> = null as unknown as Infer<T>;
+
+	constructor(json: T) {
+		this.json = json;
+	}
+}
+
+/**
+ * Main API for creating lexicon schemas.
+ * @see https://atproto.com/specs/lexicon
+ */
+export const lx = {
+	/**
+	 * Creates a null type.
+	 * @see https://atproto.com/specs/lexicon#null
+	 */
+	null(
+		options?: LexiconItemCommonOptions,
+	): { type: "null" } & LexiconItemCommonOptions {
+		return {
+			type: "null",
+			...options,
+		};
+	},
+	/**
+	 * Creates a boolean type with optional constraints.
+	 * @see https://atproto.com/specs/lexicon#boolean
+	 */
+	boolean<T extends BooleanOptions>(options?: T): T & { type: "boolean" } {
+		return {
+			type: "boolean",
+			...options,
+		} as T & { type: "boolean" };
+	},
+	/**
+	 * Creates an integer type with optional min/max and enum constraints.
+	 * @see https://atproto.com/specs/lexicon#integer
+	 */
+	integer<T extends IntegerOptions>(options?: T): T & { type: "integer" } {
+		return {
+			type: "integer",
+			...options,
+		} as T & { type: "integer" };
+	},
+	/**
+	 * Creates a string type with optional format, length, and value constraints.
+	 * @see https://atproto.com/specs/lexicon#string
+	 */
+	string<T extends StringOptions>(options?: T): T & { type: "string" } {
+		return {
+			type: "string",
+			...options,
+		} as T & { type: "string" };
+	},
+	/**
+	 * Creates an unknown type for flexible, unvalidated objects.
+	 * @see https://atproto.com/specs/lexicon#unknown
+	 */
+	unknown(
+		options?: LexiconItemCommonOptions,
+	): { type: "unknown" } & LexiconItemCommonOptions {
+		return {
+			type: "unknown",
+			...options,
+		};
+	},
+	/**
+	 * Creates a bytes type for arbitrary byte arrays.
+	 * @see https://atproto.com/specs/lexicon#bytes
+	 */
+	bytes<T extends BytesOptions>(options?: T): T & { type: "bytes" } {
+		return {
+			type: "bytes",
+			...options,
+		} as T & { type: "bytes" };
+	},
+	/**
+	 * Creates a CID link reference to content-addressed data.
+	 * @see https://atproto.com/specs/lexicon#cid-link
+	 */
+	cidLink<Link extends string>(link: Link): { type: "cid-link"; $link: Link } {
+		return {
+			type: "cid-link",
+			$link: link,
+		};
+	},
+	/**
+	 * Creates a blob type for binary data with MIME type constraints.
+	 * @see https://atproto.com/specs/lexicon#blob
+	 */
+	blob<T extends BlobOptions>(options?: T): T & { type: "blob" } {
+		return {
+			type: "blob",
+			...options,
+		} as T & { type: "blob" };
+	},
+	/**
+	 * Creates an array type with item schema and length constraints.
+	 * @see https://atproto.com/specs/lexicon#array
+	 */
+	array<Items extends { type: LexiconType }, Options extends ArrayOptions>(
+		items: Items,
+		options?: Options,
+	): Options & { type: "array"; items: Items } {
+		return {
+			type: "array",
+			items,
+			...options,
+		} as Options & { type: "array"; items: Items };
+	},
+	/**
+	 * Creates a token type for symbolic values in unions.
+	 * @see https://atproto.com/specs/lexicon#token
+	 */
+	token<Description extends string>(
+		description: Description,
+	): { type: "token"; description: Description } {
+		return { type: "token", description };
+	},
+	/**
+	 * Creates a reference to another schema definition.
+	 * @see https://atproto.com/specs/lexicon#ref
+	 */
+	ref<Ref extends string>(
+		ref: Ref,
+		options?: LexiconItemCommonOptions,
+	): LexiconItemCommonOptions & { type: "ref"; ref: Ref } {
+		return {
+			type: "ref",
+			ref,
+			...options,
+		} as LexiconItemCommonOptions & { type: "ref"; ref: Ref };
+	},
+	/**
+	 * Creates a union type for multiple possible type variants.
+	 * @see https://atproto.com/specs/lexicon#union
+	 */
+	union<const Refs extends readonly string[], Options extends UnionOptions>(
+		refs: Refs,
+		options?: Options,
+	): Options & { type: "union"; refs: Refs } {
+		return {
+			type: "union",
+			refs,
+			...options,
+		} as Options & { type: "union"; refs: Refs };
+	},
+	/**
+	 * Creates a record type for repository records.
+	 * @see https://atproto.com/specs/lexicon#record
+	 */
+	record<T extends RecordOptions>(options: T): T & { type: "record" } {
+		return {
+			type: "record",
+			...options,
+		};
+	},
+	/**
+	 * Creates an object type with defined properties.
+	 * @see https://atproto.com/specs/lexicon#object
+	 */
+	object<T extends ObjectProperties>(options: T): ObjectResult<T> {
+		const required = Object.keys(options).filter(
+			(key) => "required" in options[key] && options[key].required,
+		);
+		const nullable = Object.keys(options).filter(
+			(key) => "nullable" in options[key] && options[key].nullable,
+		);
+		const result: Record<string, unknown> = {
+			type: "object",
+			properties: options,
+		};
+		if (required.length > 0) {
+			result.required = required;
+		}
+		if (nullable.length > 0) {
+			result.nullable = nullable;
+		}
+		return result as ObjectResult<T>;
+	},
+	/**
+	 * Creates a params type for query string parameters.
+	 * @see https://atproto.com/specs/lexicon#params
+	 */
+	params<Properties extends ParamsProperties>(
+		properties: Properties,
+	): ParamsResult<Properties> {
+		const required = Object.keys(properties).filter(
+			(key) => properties[key].required,
+		);
+		const result: Record<string, unknown> = {
+			type: "params",
+			properties,
+		};
+		if (required.length > 0) {
+			result.required = required;
+		}
+		return result as ParamsResult<Properties>;
+	},
+	/**
+	 * Creates a query endpoint definition (HTTP GET).
+	 * @see https://atproto.com/specs/lexicon#query
+	 */
+	query<T extends QueryOptions>(options?: T): T & { type: "query" } {
+		return {
+			type: "query",
+			...options,
+		} as T & { type: "query" };
+	},
+	/**
+	 * Creates a procedure endpoint definition (HTTP POST).
+	 * @see https://atproto.com/specs/lexicon#procedure
+	 */
+	procedure<T extends ProcedureOptions>(
+		options?: T,
+	): T & { type: "procedure" } {
+		return {
+			type: "procedure",
+			...options,
+		} as T & { type: "procedure" };
+	},
+	/**
+	 * Creates a subscription endpoint definition (WebSocket).
+	 * @see https://atproto.com/specs/lexicon#subscription
+	 */
+	subscription<T extends SubscriptionOptions>(
+		options?: T,
+	): T & { type: "subscription" } {
+		return {
+			type: "subscription",
+			...options,
+		} as T & { type: "subscription" };
+	},
+	/**
+	 * Creates a lexicon namespace document.
+	 * @see https://atproto.com/specs/lexicon#lexicon-document
+	 */
+	namespace<ID extends string, D extends LexiconNamespace["defs"]>(
+		id: ID,
+		defs: D,
+	): Namespace<{ lexicon: 1; id: ID; defs: D }> {
+		return new Namespace({
+			lexicon: 1,
+			id,
+			defs,
+		});
+	},
+};

packages/prototypey/src/type-utils.ts

···
+/**
+ * Converts a string union type to a tuple type
+ * @example
+ * type Colors = "red" | "green" | "blue";
+ * type ColorTuple = UnionToTuple<Colors>; // ["red", "green", "blue"]
+ */
+export type UnionToTuple<T> = (
+	(T extends unknown ? (x: () => T) => void : never) extends (
+		x: infer I,
+	) => void
+		? I
+		: never
+) extends () => infer R
+	? [...UnionToTuple<Exclude<T, R>>, R]
+	: [];
+
+export type Prettify<T> = {
+	[K in keyof T]: T[K];
+} & {};

packages/prototypey/tests/base-case.test.ts

···
+import { expect, test } from "vitest";
+import { lx } from "../src/lib.ts";
+
+test("app.bsky.actor.profile", () => {
+	const profileNamespace = lx.namespace("app.bsky.actor.profile", {
+		main: lx.record({
+			key: "self",
+			record: lx.object({
+				displayName: lx.string({ maxLength: 64, maxGraphemes: 64 }),
+				description: lx.string({ maxLength: 256, maxGraphemes: 256 }),
+			}),
+		}),
+	});
+
+	expect(profileNamespace.json).toEqual({
+		lexicon: 1,
+		id: "app.bsky.actor.profile",
+		defs: {
+			main: {
+				type: "record",
+				key: "self",
+				record: {
+					type: "object",
+					properties: {
+						displayName: {
+							type: "string",
+							maxLength: 64,
+							maxGraphemes: 64,
+						},
+						description: {
+							type: "string",
+							maxLength: 256,
+							maxGraphemes: 256,
+						},
+					},
+				},
+			},
+		},
+	});
+});

packages/prototypey/tests/bsky-actor.test.ts

···
+import { expect, test } from "vitest";
+import { lx } from "../src/lib.ts";
+
+test("app.bsky.actor.defs - profileViewBasic", () => {
+	const profileViewBasic = lx.object({
+		did: lx.string({ required: true, format: "did" }),
+		handle: lx.string({ required: true, format: "handle" }),
+		displayName: lx.string({ maxGraphemes: 64, maxLength: 640 }),
+		pronouns: lx.string(),
+		avatar: lx.string({ format: "uri" }),
+		associated: lx.ref("#profileAssociated"),
+		viewer: lx.ref("#viewerState"),
+		labels: lx.array(lx.ref("com.atproto.label.defs#label")),
+		createdAt: lx.string({ format: "datetime" }),
+		verification: lx.ref("#verificationState"),
+		status: lx.ref("#statusView"),
+	});
+
+	expect(profileViewBasic).toEqual({
+		type: "object",
+		properties: {
+			did: { type: "string", required: true, format: "did" },
+			handle: { type: "string", required: true, format: "handle" },
+			displayName: { type: "string", maxGraphemes: 64, maxLength: 640 },
+			pronouns: { type: "string" },
+			avatar: { type: "string", format: "uri" },
+			associated: { type: "ref", ref: "#profileAssociated" },
+			viewer: { type: "ref", ref: "#viewerState" },
+			labels: {
+				type: "array",
+				items: { type: "ref", ref: "com.atproto.label.defs#label" },
+			},
+			createdAt: { type: "string", format: "datetime" },
+			verification: { type: "ref", ref: "#verificationState" },
+			status: { type: "ref", ref: "#statusView" },
+		},
+		required: ["did", "handle"],
+	});
+});
+
+test("app.bsky.actor.defs - profileView", () => {
+	const profileView = lx.object({
+		did: lx.string({ required: true, format: "did" }),
+		handle: lx.string({ required: true, format: "handle" }),
+		displayName: lx.string({ maxGraphemes: 64, maxLength: 640 }),
+		pronouns: lx.string(),
+		description: lx.string({ maxGraphemes: 256, maxLength: 2560 }),
+		avatar: lx.string({ format: "uri" }),
+		associated: lx.ref("#profileAssociated"),
+		indexedAt: lx.string({ format: "datetime" }),
+		createdAt: lx.string({ format: "datetime" }),
+		viewer: lx.ref("#viewerState"),
+		labels: lx.array(lx.ref("com.atproto.label.defs#label")),
+		verification: lx.ref("#verificationState"),
+		status: lx.ref("#statusView"),
+	});
+
+	expect(profileView).toEqual({
+		type: "object",
+		properties: {
+			did: { type: "string", required: true, format: "did" },
+			handle: { type: "string", required: true, format: "handle" },
+			displayName: { type: "string", maxGraphemes: 64, maxLength: 640 },
+			pronouns: { type: "string" },
+			description: { type: "string", maxGraphemes: 256, maxLength: 2560 },
+			avatar: { type: "string", format: "uri" },
+			associated: { type: "ref", ref: "#profileAssociated" },
+			indexedAt: { type: "string", format: "datetime" },
+			createdAt: { type: "string", format: "datetime" },
+			viewer: { type: "ref", ref: "#viewerState" },
+			labels: {
+				type: "array",
+				items: { type: "ref", ref: "com.atproto.label.defs#label" },
+			},
+			verification: { type: "ref", ref: "#verificationState" },
+			status: { type: "ref", ref: "#statusView" },
+		},
+		required: ["did", "handle"],
+	});
+});
+
+test("app.bsky.actor.defs - profileViewDetailed", () => {
+	const profileViewDetailed = lx.object({
+		did: lx.string({ required: true, format: "did" }),
+		handle: lx.string({ required: true, format: "handle" }),
+		displayName: lx.string({ maxGraphemes: 64, maxLength: 640 }),
+		description: lx.string({ maxGraphemes: 256, maxLength: 2560 }),
+		pronouns: lx.string(),
+		website: lx.string({ format: "uri" }),
+		avatar: lx.string({ format: "uri" }),
+		banner: lx.string({ format: "uri" }),
+		followersCount: lx.integer(),
+		followsCount: lx.integer(),
+		postsCount: lx.integer(),
+		associated: lx.ref("#profileAssociated"),
+		joinedViaStarterPack: lx.ref("app.bsky.graph.defs#starterPackViewBasic"),
+		indexedAt: lx.string({ format: "datetime" }),
+		createdAt: lx.string({ format: "datetime" }),
+		viewer: lx.ref("#viewerState"),
+		labels: lx.array(lx.ref("com.atproto.label.defs#label")),
+		pinnedPost: lx.ref("com.atproto.repo.strongRef"),
+		verification: lx.ref("#verificationState"),
+		status: lx.ref("#statusView"),
+	});
+
+	expect(profileViewDetailed).toEqual({
+		type: "object",
+		properties: {
+			did: { type: "string", required: true, format: "did" },
+			handle: { type: "string", required: true, format: "handle" },
+			displayName: { type: "string", maxGraphemes: 64, maxLength: 640 },
+			description: { type: "string", maxGraphemes: 256, maxLength: 2560 },
+			pronouns: { type: "string" },
+			website: { type: "string", format: "uri" },
+			avatar: { type: "string", format: "uri" },
+			banner: { type: "string", format: "uri" },
+			followersCount: { type: "integer" },
+			followsCount: { type: "integer" },
+			postsCount: { type: "integer" },
+			associated: { type: "ref", ref: "#profileAssociated" },
+			joinedViaStarterPack: {
+				type: "ref",
+				ref: "app.bsky.graph.defs#starterPackViewBasic",
+			},
+			indexedAt: { type: "string", format: "datetime" },
+			createdAt: { type: "string", format: "datetime" },
+			viewer: { type: "ref", ref: "#viewerState" },
+			labels: {
+				type: "array",
+				items: { type: "ref", ref: "com.atproto.label.defs#label" },
+			},
+			pinnedPost: { type: "ref", ref: "com.atproto.repo.strongRef" },
+			verification: { type: "ref", ref: "#verificationState" },
+			status: { type: "ref", ref: "#statusView" },
+		},
+		required: ["did", "handle"],
+	});
+});
+
+test("app.bsky.actor.defs - profileAssociated", () => {
+	const profileAssociated = lx.object({
+		lists: lx.integer(),
+		feedgens: lx.integer(),
+		starterPacks: lx.integer(),
+		labeler: lx.boolean(),
+		chat: lx.ref("#profileAssociatedChat"),
+		activitySubscription: lx.ref("#profileAssociatedActivitySubscription"),
+	});
+
+	expect(profileAssociated).toEqual({
+		type: "object",
+		properties: {
+			lists: { type: "integer" },
+			feedgens: { type: "integer" },
+			starterPacks: { type: "integer" },
+			labeler: { type: "boolean" },
+			chat: { type: "ref", ref: "#profileAssociatedChat" },
+			activitySubscription: {
+				type: "ref",
+				ref: "#profileAssociatedActivitySubscription",
+			},
+		},
+	});
+});
+
+test("app.bsky.actor.defs - profileAssociatedChat", () => {
+	const profileAssociatedChat = lx.object({
+		allowIncoming: lx.string({
+			required: true,
+			knownValues: ["all", "none", "following"],
+		}),
+	});
+
+	expect(profileAssociatedChat).toEqual({
+		type: "object",
+		properties: {
+			allowIncoming: {
+				type: "string",
+				required: true,
+				knownValues: ["all", "none", "following"],
+			},
+		},
+		required: ["allowIncoming"],
+	});
+});
+
+test("app.bsky.actor.defs - profileAssociatedActivitySubscription", () => {
+	const profileAssociatedActivitySubscription = lx.object({
+		allowSubscriptions: lx.string({
+			required: true,
+			knownValues: ["followers", "mutuals", "none"],
+		}),
+	});
+
+	expect(profileAssociatedActivitySubscription).toEqual({
+		type: "object",
+		properties: {
+			allowSubscriptions: {
+				type: "string",
+				required: true,
+				knownValues: ["followers", "mutuals", "none"],
+			},
+		},
+		required: ["allowSubscriptions"],
+	});
+});
+
+test("app.bsky.actor.defs - viewerState", () => {
+	const viewerState = lx.object({
+		muted: lx.boolean(),
+		mutedByList: lx.ref("app.bsky.graph.defs#listViewBasic"),
+		blockedBy: lx.boolean(),
+		blocking: lx.string({ format: "at-uri" }),
+		blockingByList: lx.ref("app.bsky.graph.defs#listViewBasic"),
+		following: lx.string({ format: "at-uri" }),
+		followedBy: lx.string({ format: "at-uri" }),
+		knownFollowers: lx.ref("#knownFollowers"),
+		activitySubscription: lx.ref(
+			"app.bsky.notification.defs#activitySubscription",
+		),
+	});
+
+	expect(viewerState).toEqual({
+		type: "object",
+		properties: {
+			muted: { type: "boolean" },
+			mutedByList: { type: "ref", ref: "app.bsky.graph.defs#listViewBasic" },
+			blockedBy: { type: "boolean" },
+			blocking: { type: "string", format: "at-uri" },
+			blockingByList: { type: "ref", ref: "app.bsky.graph.defs#listViewBasic" },
+			following: { type: "string", format: "at-uri" },
+			followedBy: { type: "string", format: "at-uri" },
+			knownFollowers: { type: "ref", ref: "#knownFollowers" },
+			activitySubscription: {
+				type: "ref",
+				ref: "app.bsky.notification.defs#activitySubscription",
+			},
+		},
+	});
+});
+
+test("app.bsky.actor.defs - knownFollowers", () => {
+	const knownFollowers = lx.object({
+		count: lx.integer({ required: true }),
+		followers: lx.array(lx.ref("#profileViewBasic"), {
+			required: true,
+			minLength: 0,
+			maxLength: 5,
+		}),
+	});
+
+	expect(knownFollowers).toEqual({
+		type: "object",
+		properties: {
+			count: { type: "integer", required: true },
+			followers: {
+				type: "array",
+				items: { type: "ref", ref: "#profileViewBasic" },
+				required: true,
+				minLength: 0,
+				maxLength: 5,
+			},
+		},
+		required: ["count", "followers"],
+	});
+});
+
+test("app.bsky.actor.defs - verificationState", () => {
+	const verificationState = lx.object({
+		verifications: lx.array(lx.ref("#verificationView"), { required: true }),
+		verifiedStatus: lx.string({
+			required: true,
+			knownValues: ["valid", "invalid", "none"],
+		}),
+		trustedVerifierStatus: lx.string({
+			required: true,
+			knownValues: ["valid", "invalid", "none"],
+		}),
+	});
+
+	expect(verificationState).toEqual({
+		type: "object",
+		properties: {
+			verifications: {
+				type: "array",
+				items: { type: "ref", ref: "#verificationView" },
+				required: true,
+			},
+			verifiedStatus: {
+				type: "string",
+				required: true,
+				knownValues: ["valid", "invalid", "none"],
+			},
+			trustedVerifierStatus: {
+				type: "string",
+				required: true,
+				knownValues: ["valid", "invalid", "none"],
+			},
+		},
+		required: ["verifications", "verifiedStatus", "trustedVerifierStatus"],
+	});
+});
+
+test("app.bsky.actor.defs - verificationView", () => {
+	const verificationView = lx.object({
+		issuer: lx.string({ required: true, format: "did" }),
+		uri: lx.string({ required: true, format: "at-uri" }),
+		isValid: lx.boolean({ required: true }),
+		createdAt: lx.string({ required: true, format: "datetime" }),
+	});
+
+	expect(verificationView).toEqual({
+		type: "object",
+		properties: {
+			issuer: { type: "string", required: true, format: "did" },
+			uri: { type: "string", required: true, format: "at-uri" },
+			isValid: { type: "boolean", required: true },
+			createdAt: { type: "string", required: true, format: "datetime" },
+		},
+		required: ["issuer", "uri", "isValid", "createdAt"],
+	});
+});
+
+test("app.bsky.actor.defs - preferences", () => {
+	const preferences = lx.array(
+		lx.union([
+			"#adultContentPref",
+			"#contentLabelPref",
+			"#savedFeedsPref",
+			"#savedFeedsPrefV2",
+			"#personalDetailsPref",
+			"#feedViewPref",
+			"#threadViewPref",
+			"#interestsPref",
+			"#mutedWordsPref",
+			"#hiddenPostsPref",
+			"#bskyAppStatePref",
+			"#labelersPref",
+			"#postInteractionSettingsPref",
+			"#verificationPrefs",
+		]),
+	);
+
+	expect(preferences).toEqual({
+		type: "array",
+		items: {
+			type: "union",
+			refs: [
+				"#adultContentPref",
+				"#contentLabelPref",
+				"#savedFeedsPref",
+				"#savedFeedsPrefV2",
+				"#personalDetailsPref",
+				"#feedViewPref",
+				"#threadViewPref",
+				"#interestsPref",
+				"#mutedWordsPref",
+				"#hiddenPostsPref",
+				"#bskyAppStatePref",
+				"#labelersPref",
+				"#postInteractionSettingsPref",
+				"#verificationPrefs",
+			],
+		},
+	});
+});
+
+test("app.bsky.actor.defs - adultContentPref", () => {
+	const adultContentPref = lx.object({
+		enabled: lx.boolean({ required: true, default: false }),
+	});
+
+	expect(adultContentPref).toEqual({
+		type: "object",
+		properties: {
+			enabled: { type: "boolean", required: true, default: false },
+		},
+		required: ["enabled"],
+	});
+});
+
+test("app.bsky.actor.defs - contentLabelPref", () => {
+	const contentLabelPref = lx.object({
+		labelerDid: lx.string({ format: "did" }),
+		label: lx.string({ required: true }),
+		visibility: lx.string({
+			required: true,
+			knownValues: ["ignore", "show", "warn", "hide"],
+		}),
+	});
+
+	expect(contentLabelPref).toEqual({
+		type: "object",
+		properties: {
+			labelerDid: { type: "string", format: "did" },
+			label: { type: "string", required: true },
+			visibility: {
+				type: "string",
+				required: true,
+				knownValues: ["ignore", "show", "warn", "hide"],
+			},
+		},
+		required: ["label", "visibility"],
+	});
+});
+
+test("app.bsky.actor.defs - savedFeed", () => {
+	const savedFeed = lx.object({
+		id: lx.string({ required: true }),
+		type: lx.string({
+			required: true,
+			knownValues: ["feed", "list", "timeline"],
+		}),
+		value: lx.string({ required: true }),
+		pinned: lx.boolean({ required: true }),
+	});
+
+	expect(savedFeed).toEqual({
+		type: "object",
+		properties: {
+			id: { type: "string", required: true },
+			type: {
+				type: "string",
+				required: true,
+				knownValues: ["feed", "list", "timeline"],
+			},
+			value: { type: "string", required: true },
+			pinned: { type: "boolean", required: true },
+		},
+		required: ["id", "type", "value", "pinned"],
+	});
+});
+
+test("app.bsky.actor.defs - savedFeedsPrefV2", () => {
+	const savedFeedsPrefV2 = lx.object({
+		items: lx.array(lx.ref("app.bsky.actor.defs#savedFeed"), {
+			required: true,
+		}),
+	});
+
+	expect(savedFeedsPrefV2).toEqual({
+		type: "object",
+		properties: {
+			items: {
+				type: "array",
+				items: { type: "ref", ref: "app.bsky.actor.defs#savedFeed" },
+				required: true,
+			},
+		},
+		required: ["items"],
+	});
+});
+
+test("app.bsky.actor.defs - savedFeedsPref", () => {
+	const savedFeedsPref = lx.object({
+		pinned: lx.array(lx.string({ format: "at-uri" }), { required: true }),
+		saved: lx.array(lx.string({ format: "at-uri" }), { required: true }),
+		timelineIndex: lx.integer(),
+	});
+
+	expect(savedFeedsPref).toEqual({
+		type: "object",
+		properties: {
+			pinned: {
+				type: "array",
+				items: { type: "string", format: "at-uri" },
+				required: true,
+			},
+			saved: {
+				type: "array",
+				items: { type: "string", format: "at-uri" },
+				required: true,
+			},
+			timelineIndex: { type: "integer" },
+		},
+		required: ["pinned", "saved"],
+	});
+});
+
+test("app.bsky.actor.defs - personalDetailsPref", () => {
+	const personalDetailsPref = lx.object({
+		birthDate: lx.string({ format: "datetime" }),
+	});
+
+	expect(personalDetailsPref).toEqual({
+		type: "object",
+		properties: {
+			birthDate: { type: "string", format: "datetime" },
+		},
+	});
+});
+
+test("app.bsky.actor.defs - feedViewPref", () => {
+	const feedViewPref = lx.object({
+		feed: lx.string({ required: true }),
+		hideReplies: lx.boolean(),
+		hideRepliesByUnfollowed: lx.boolean({ default: true }),
+		hideRepliesByLikeCount: lx.integer(),
+		hideReposts: lx.boolean(),
+		hideQuotePosts: lx.boolean(),
+	});
+
+	expect(feedViewPref).toEqual({
+		type: "object",
+		properties: {
+			feed: { type: "string", required: true },
+			hideReplies: { type: "boolean" },
+			hideRepliesByUnfollowed: { type: "boolean", default: true },
+			hideRepliesByLikeCount: { type: "integer" },
+			hideReposts: { type: "boolean" },
+			hideQuotePosts: { type: "boolean" },
+		},
+		required: ["feed"],
+	});
+});
+
+test("app.bsky.actor.defs - threadViewPref", () => {
+	const threadViewPref = lx.object({
+		sort: lx.string({
+			knownValues: ["oldest", "newest", "most-likes", "random", "hotness"],
+		}),
+		prioritizeFollowedUsers: lx.boolean(),
+	});
+
+	expect(threadViewPref).toEqual({
+		type: "object",
+		properties: {
+			sort: {
+				type: "string",
+				knownValues: ["oldest", "newest", "most-likes", "random", "hotness"],
+			},
+			prioritizeFollowedUsers: { type: "boolean" },
+		},
+	});
+});
+
+test("app.bsky.actor.defs - interestsPref", () => {
+	const interestsPref = lx.object({
+		tags: lx.array(lx.string({ maxLength: 640, maxGraphemes: 64 }), {
+			required: true,
+			maxLength: 100,
+		}),
+	});
+
+	expect(interestsPref).toEqual({
+		type: "object",
+		properties: {
+			tags: {
+				type: "array",
+				items: { type: "string", maxLength: 640, maxGraphemes: 64 },
+				required: true,
+				maxLength: 100,
+			},
+		},
+		required: ["tags"],
+	});
+});
+
+test("app.bsky.actor.defs - mutedWordTarget", () => {
+	const mutedWordTarget = lx.string({
+		knownValues: ["content", "tag"],
+		maxLength: 640,
+		maxGraphemes: 64,
+	});
+
+	expect(mutedWordTarget).toEqual({
+		type: "string",
+		knownValues: ["content", "tag"],
+		maxLength: 640,
+		maxGraphemes: 64,
+	});
+});
+
+test("app.bsky.actor.defs - mutedWord", () => {
+	const mutedWord = lx.object({
+		id: lx.string(),
+		value: lx.string({ required: true, maxLength: 10000, maxGraphemes: 1000 }),
+		targets: lx.array(lx.ref("app.bsky.actor.defs#mutedWordTarget"), {
+			required: true,
+		}),
+		actorTarget: lx.string({
+			knownValues: ["all", "exclude-following"],
+			default: "all",
+		}),
+		expiresAt: lx.string({ format: "datetime" }),
+	});
+
+	expect(mutedWord).toEqual({
+		type: "object",
+		properties: {
+			id: { type: "string" },
+			value: {
+				type: "string",
+				required: true,
+				maxLength: 10000,
+				maxGraphemes: 1000,
+			},
+			targets: {
+				type: "array",
+				items: { type: "ref", ref: "app.bsky.actor.defs#mutedWordTarget" },
+				required: true,
+			},
+			actorTarget: {
+				type: "string",
+				knownValues: ["all", "exclude-following"],
+				default: "all",
+			},
+			expiresAt: { type: "string", format: "datetime" },
+		},
+		required: ["value", "targets"],
+	});
+});
+
+test("app.bsky.actor.defs - mutedWordsPref", () => {
+	const mutedWordsPref = lx.object({
+		items: lx.array(lx.ref("app.bsky.actor.defs#mutedWord"), {
+			required: true,
+		}),
+	});
+
+	expect(mutedWordsPref).toEqual({
+		type: "object",
+		properties: {
+			items: {
+				type: "array",
+				items: { type: "ref", ref: "app.bsky.actor.defs#mutedWord" },
+				required: true,
+			},
+		},
+		required: ["items"],
+	});
+});
+
+test("app.bsky.actor.defs - hiddenPostsPref", () => {
+	const hiddenPostsPref = lx.object({
+		items: lx.array(lx.string({ format: "at-uri" }), { required: true }),
+	});
+
+	expect(hiddenPostsPref).toEqual({
+		type: "object",
+		properties: {
+			items: {
+				type: "array",
+				items: { type: "string", format: "at-uri" },
+				required: true,
+			},
+		},
+		required: ["items"],
+	});
+});
+
+test("app.bsky.actor.defs - labelersPref", () => {
+	const labelersPref = lx.object({
+		labelers: lx.array(lx.ref("#labelerPrefItem"), { required: true }),
+	});
+
+	expect(labelersPref).toEqual({
+		type: "object",
+		properties: {
+			labelers: {
+				type: "array",
+				items: { type: "ref", ref: "#labelerPrefItem" },
+				required: true,
+			},
+		},
+		required: ["labelers"],
+	});
+});
+
+test("app.bsky.actor.defs - labelerPrefItem", () => {
+	const labelerPrefItem = lx.object({
+		did: lx.string({ required: true, format: "did" }),
+	});
+
+	expect(labelerPrefItem).toEqual({
+		type: "object",
+		properties: {
+			did: { type: "string", required: true, format: "did" },
+		},
+		required: ["did"],
+	});
+});
+
+test("app.bsky.actor.defs - bskyAppStatePref", () => {
+	const bskyAppStatePref = lx.object({
+		activeProgressGuide: lx.ref("#bskyAppProgressGuide"),
+		queuedNudges: lx.array(lx.string({ maxLength: 100 }), { maxLength: 1000 }),
+		nuxs: lx.array(lx.ref("app.bsky.actor.defs#nux"), { maxLength: 100 }),
+	});
+
+	expect(bskyAppStatePref).toEqual({
+		type: "object",
+		properties: {
+			activeProgressGuide: { type: "ref", ref: "#bskyAppProgressGuide" },
+			queuedNudges: {
+				type: "array",
+				items: { type: "string", maxLength: 100 },
+				maxLength: 1000,
+			},
+			nuxs: {
+				type: "array",
+				items: { type: "ref", ref: "app.bsky.actor.defs#nux" },
+				maxLength: 100,
+			},
+		},
+	});
+});
+
+test("app.bsky.actor.defs - bskyAppProgressGuide", () => {
+	const bskyAppProgressGuide = lx.object({
+		guide: lx.string({ required: true, maxLength: 100 }),
+	});
+
+	expect(bskyAppProgressGuide).toEqual({
+		type: "object",
+		properties: {
+			guide: { type: "string", required: true, maxLength: 100 },
+		},
+		required: ["guide"],
+	});
+});
+
+test("app.bsky.actor.defs - nux", () => {
+	const nux = lx.object({
+		id: lx.string({ required: true, maxLength: 100 }),
+		completed: lx.boolean({ required: true, default: false }),
+		data: lx.string({ maxLength: 3000, maxGraphemes: 300 }),
+		expiresAt: lx.string({ format: "datetime" }),
+	});
+
+	expect(nux).toEqual({
+		type: "object",
+		properties: {
+			id: { type: "string", required: true, maxLength: 100 },
+			completed: { type: "boolean", required: true, default: false },
+			data: { type: "string", maxLength: 3000, maxGraphemes: 300 },
+			expiresAt: { type: "string", format: "datetime" },
+		},
+		required: ["id", "completed"],
+	});
+});
+
+test("app.bsky.actor.defs - verificationPrefs", () => {
+	const verificationPrefs = lx.object({
+		hideBadges: lx.boolean({ default: false }),
+	});
+
+	expect(verificationPrefs).toEqual({
+		type: "object",
+		properties: {
+			hideBadges: { type: "boolean", default: false },
+		},
+	});
+});
+
+test("app.bsky.actor.defs - postInteractionSettingsPref", () => {
+	const postInteractionSettingsPref = lx.object({
+		threadgateAllowRules: lx.array(
+			lx.union([
+				"app.bsky.feed.threadgate#mentionRule",
+				"app.bsky.feed.threadgate#followerRule",
+				"app.bsky.feed.threadgate#followingRule",
+				"app.bsky.feed.threadgate#listRule",
+			]),
+			{ maxLength: 5 },
+		),
+		postgateEmbeddingRules: lx.array(
+			lx.union(["app.bsky.feed.postgate#disableRule"]),
+			{ maxLength: 5 },
+		),
+	});
+
+	expect(postInteractionSettingsPref).toEqual({
+		type: "object",
+		properties: {
+			threadgateAllowRules: {
+				type: "array",
+				items: {
+					type: "union",
+					refs: [
+						"app.bsky.feed.threadgate#mentionRule",
+						"app.bsky.feed.threadgate#followerRule",
+						"app.bsky.feed.threadgate#followingRule",
+						"app.bsky.feed.threadgate#listRule",
+					],
+				},
+				maxLength: 5,
+			},
+			postgateEmbeddingRules: {
+				type: "array",
+				items: {
+					type: "union",
+					refs: ["app.bsky.feed.postgate#disableRule"],
+				},
+				maxLength: 5,
+			},
+		},
+	});
+});
+
+test("app.bsky.actor.defs - statusView", () => {
+	const statusView = lx.object({
+		status: lx.string({
+			required: true,
+			knownValues: ["app.bsky.actor.status#live"],
+		}),
+		record: lx.unknown({ required: true }),
+		embed: lx.union(["app.bsky.embed.external#view"]),
+		expiresAt: lx.string({ format: "datetime" }),
+		isActive: lx.boolean(),
+	});
+
+	expect(statusView).toEqual({
+		type: "object",
+		properties: {
+			status: {
+				type: "string",
+				required: true,
+				knownValues: ["app.bsky.actor.status#live"],
+			},
+			record: { type: "unknown", required: true },
+			embed: {
+				type: "union",
+				refs: ["app.bsky.embed.external#view"],
+			},
+			expiresAt: { type: "string", format: "datetime" },
+			isActive: { type: "boolean" },
+		},
+		required: ["status", "record"],
+	});
+});
+
+test("app.bsky.actor.defs - full namespace", () => {
+	const actorDefs = lx.namespace("app.bsky.actor.defs", {
+		profileViewBasic: lx.object({
+			did: lx.string({ required: true, format: "did" }),
+			handle: lx.string({ required: true, format: "handle" }),
+			displayName: lx.string({ maxGraphemes: 64, maxLength: 640 }),
+			pronouns: lx.string(),
+			avatar: lx.string({ format: "uri" }),
+			associated: lx.ref("#profileAssociated"),
+			viewer: lx.ref("#viewerState"),
+			labels: lx.array(lx.ref("com.atproto.label.defs#label")),
+			createdAt: lx.string({ format: "datetime" }),
+			verification: lx.ref("#verificationState"),
+			status: lx.ref("#statusView"),
+		}),
+		viewerState: lx.object({
+			muted: lx.boolean(),
+			mutedByList: lx.ref("app.bsky.graph.defs#listViewBasic"),
+			blockedBy: lx.boolean(),
+			blocking: lx.string({ format: "at-uri" }),
+			blockingByList: lx.ref("app.bsky.graph.defs#listViewBasic"),
+			following: lx.string({ format: "at-uri" }),
+			followedBy: lx.string({ format: "at-uri" }),
+			knownFollowers: lx.ref("#knownFollowers"),
+			activitySubscription: lx.ref(
+				"app.bsky.notification.defs#activitySubscription",
+			),
+		}),
+	});
+
+	expect(actorDefs.json.lexicon).toEqual(1);
+	expect(actorDefs.json.id).toEqual("app.bsky.actor.defs");
+	expect(actorDefs.json.defs.profileViewBasic.type).toEqual("object");
+	expect(actorDefs.json.defs.viewerState.type).toEqual("object");
+});

packages/prototypey/tests/bsky-feed.test.ts

···
+import { expect, test } from "vitest";
+import { lx } from "../src/lib.ts";
+
+test("app.bsky.feed.defs - postView", () => {
+	const postView = lx.object({
+		uri: lx.string({ required: true, format: "at-uri" }),
+		cid: lx.string({ required: true, format: "cid" }),
+		author: lx.ref("app.bsky.actor.defs#profileViewBasic", { required: true }),
+		record: lx.unknown({ required: true }),
+		embed: lx.union([
+			"app.bsky.embed.images#view",
+			"app.bsky.embed.video#view",
+			"app.bsky.embed.external#view",
+			"app.bsky.embed.record#view",
+			"app.bsky.embed.recordWithMedia#view",
+		]),
+		bookmarkCount: lx.integer(),
+		replyCount: lx.integer(),
+		repostCount: lx.integer(),
+		likeCount: lx.integer(),
+		quoteCount: lx.integer(),
+		indexedAt: lx.string({ required: true, format: "datetime" }),
+		viewer: lx.ref("#viewerState"),
+		labels: lx.array(lx.ref("com.atproto.label.defs#label")),
+		threadgate: lx.ref("#threadgateView"),
+	});
+
+	expect(postView).toEqual({
+		type: "object",
+		properties: {
+			uri: { type: "string", required: true, format: "at-uri" },
+			cid: { type: "string", required: true, format: "cid" },
+			author: {
+				type: "ref",
+				ref: "app.bsky.actor.defs#profileViewBasic",
+				required: true,
+			},
+			record: { type: "unknown", required: true },
+			embed: {
+				type: "union",
+				refs: [
+					"app.bsky.embed.images#view",
+					"app.bsky.embed.video#view",
+					"app.bsky.embed.external#view",
+					"app.bsky.embed.record#view",
+					"app.bsky.embed.recordWithMedia#view",
+				],
+			},
+			bookmarkCount: { type: "integer" },
+			replyCount: { type: "integer" },
+			repostCount: { type: "integer" },
+			likeCount: { type: "integer" },
+			quoteCount: { type: "integer" },
+			indexedAt: { type: "string", required: true, format: "datetime" },
+			viewer: { type: "ref", ref: "#viewerState" },
+			labels: {
+				type: "array",
+				items: { type: "ref", ref: "com.atproto.label.defs#label" },
+			},
+			threadgate: { type: "ref", ref: "#threadgateView" },
+		},
+		required: ["uri", "cid", "author", "record", "indexedAt"],
+	});
+});
+
+test("app.bsky.feed.defs - viewerState", () => {
+	const viewerState = lx.object({
+		repost: lx.string({ format: "at-uri" }),
+		like: lx.string({ format: "at-uri" }),
+		bookmarked: lx.boolean(),
+		threadMuted: lx.boolean(),
+		replyDisabled: lx.boolean(),
+		embeddingDisabled: lx.boolean(),
+		pinned: lx.boolean(),
+	});
+
+	expect(viewerState).toEqual({
+		type: "object",
+		properties: {
+			repost: { type: "string", format: "at-uri" },
+			like: { type: "string", format: "at-uri" },
+			bookmarked: { type: "boolean" },
+			threadMuted: { type: "boolean" },
+			replyDisabled: { type: "boolean" },
+			embeddingDisabled: { type: "boolean" },
+			pinned: { type: "boolean" },
+		},
+	});
+});
+
+test("app.bsky.feed.defs - threadContext", () => {
+	const threadContext = lx.object({
+		rootAuthorLike: lx.string({ format: "at-uri" }),
+	});
+
+	expect(threadContext).toEqual({
+		type: "object",
+		properties: {
+			rootAuthorLike: { type: "string", format: "at-uri" },
+		},
+	});
+});
+
+test("app.bsky.feed.defs - feedViewPost", () => {
+	const feedViewPost = lx.object({
+		post: lx.ref("#postView", { required: true }),
+		reply: lx.ref("#replyRef"),
+		reason: lx.union(["#reasonRepost", "#reasonPin"]),
+		feedContext: lx.string({ maxLength: 2000 }),
+		reqId: lx.string({ maxLength: 100 }),
+	});
+
+	expect(feedViewPost).toEqual({
+		type: "object",
+		properties: {
+			post: { type: "ref", ref: "#postView", required: true },
+			reply: { type: "ref", ref: "#replyRef" },
+			reason: {
+				type: "union",
+				refs: ["#reasonRepost", "#reasonPin"],
+			},
+			feedContext: { type: "string", maxLength: 2000 },
+			reqId: { type: "string", maxLength: 100 },
+		},
+		required: ["post"],
+	});
+});
+
+test("app.bsky.feed.defs - replyRef", () => {
+	const replyRef = lx.object({
+		root: lx.union(["#postView", "#notFoundPost", "#blockedPost"], {
+			required: true,
+		}),
+		parent: lx.union(["#postView", "#notFoundPost", "#blockedPost"], {
+			required: true,
+		}),
+		grandparentAuthor: lx.ref("app.bsky.actor.defs#profileViewBasic"),
+	});
+
+	expect(replyRef).toEqual({
+		type: "object",
+		properties: {
+			root: {
+				type: "union",
+				refs: ["#postView", "#notFoundPost", "#blockedPost"],
+				required: true,
+			},
+			parent: {
+				type: "union",
+				refs: ["#postView", "#notFoundPost", "#blockedPost"],
+				required: true,
+			},
+			grandparentAuthor: {
+				type: "ref",
+				ref: "app.bsky.actor.defs#profileViewBasic",
+			},
+		},
+		required: ["root", "parent"],
+	});
+});
+
+test("app.bsky.feed.defs - reasonRepost", () => {
+	const reasonRepost = lx.object({
+		by: lx.ref("app.bsky.actor.defs#profileViewBasic", { required: true }),
+		uri: lx.string({ format: "at-uri" }),
+		cid: lx.string({ format: "cid" }),
+		indexedAt: lx.string({ required: true, format: "datetime" }),
+	});
+
+	expect(reasonRepost).toEqual({
+		type: "object",
+		properties: {
+			by: {
+				type: "ref",
+				ref: "app.bsky.actor.defs#profileViewBasic",
+				required: true,
+			},
+			uri: { type: "string", format: "at-uri" },
+			cid: { type: "string", format: "cid" },
+			indexedAt: { type: "string", required: true, format: "datetime" },
+		},
+		required: ["by", "indexedAt"],
+	});
+});
+
+test("app.bsky.feed.defs - reasonPin", () => {
+	const reasonPin = lx.object({});
+
+	expect(reasonPin).toEqual({
+		type: "object",
+		properties: {},
+	});
+});
+
+test("app.bsky.feed.defs - threadViewPost", () => {
+	const threadViewPost = lx.object({
+		post: lx.ref("#postView", { required: true }),
+		parent: lx.union(["#threadViewPost", "#notFoundPost", "#blockedPost"]),
+		replies: lx.array(
+			lx.union(["#threadViewPost", "#notFoundPost", "#blockedPost"]),
+		),
+		threadContext: lx.ref("#threadContext"),
+	});
+
+	expect(threadViewPost).toEqual({
+		type: "object",
+		properties: {
+			post: { type: "ref", ref: "#postView", required: true },
+			parent: {
+				type: "union",
+				refs: ["#threadViewPost", "#notFoundPost", "#blockedPost"],
+			},
+			replies: {
+				type: "array",
+				items: {
+					type: "union",
+					refs: ["#threadViewPost", "#notFoundPost", "#blockedPost"],
+				},
+			},
+			threadContext: { type: "ref", ref: "#threadContext" },
+		},
+		required: ["post"],
+	});
+});
+
+test("app.bsky.feed.defs - notFoundPost", () => {
+	const notFoundPost = lx.object({
+		uri: lx.string({ required: true, format: "at-uri" }),
+		notFound: lx.boolean({ required: true, const: true }),
+	});
+
+	expect(notFoundPost).toEqual({
+		type: "object",
+		properties: {
+			uri: { type: "string", required: true, format: "at-uri" },
+			notFound: { type: "boolean", required: true, const: true },
+		},
+		required: ["uri", "notFound"],
+	});
+});
+
+test("app.bsky.feed.defs - blockedPost", () => {
+	const blockedPost = lx.object({
+		uri: lx.string({ required: true, format: "at-uri" }),
+		blocked: lx.boolean({ required: true, const: true }),
+		author: lx.ref("#blockedAuthor", { required: true }),
+	});
+
+	expect(blockedPost).toEqual({
+		type: "object",
+		properties: {
+			uri: { type: "string", required: true, format: "at-uri" },
+			blocked: { type: "boolean", required: true, const: true },
+			author: { type: "ref", ref: "#blockedAuthor", required: true },
+		},
+		required: ["uri", "blocked", "author"],
+	});
+});
+
+test("app.bsky.feed.defs - blockedAuthor", () => {
+	const blockedAuthor = lx.object({
+		did: lx.string({ required: true, format: "did" }),
+		viewer: lx.ref("app.bsky.actor.defs#viewerState"),
+	});
+
+	expect(blockedAuthor).toEqual({
+		type: "object",
+		properties: {
+			did: { type: "string", required: true, format: "did" },
+			viewer: { type: "ref", ref: "app.bsky.actor.defs#viewerState" },
+		},
+		required: ["did"],
+	});
+});
+
+test("app.bsky.feed.defs - generatorView", () => {
+	const generatorView = lx.object({
+		uri: lx.string({ required: true, format: "at-uri" }),
+		cid: lx.string({ required: true, format: "cid" }),
+		did: lx.string({ required: true, format: "did" }),
+		creator: lx.ref("app.bsky.actor.defs#profileView", { required: true }),
+		displayName: lx.string({ required: true }),
+		description: lx.string({ maxGraphemes: 300, maxLength: 3000 }),
+		descriptionFacets: lx.array(lx.ref("app.bsky.richtext.facet")),
+		avatar: lx.string({ format: "uri" }),
+		likeCount: lx.integer({ minimum: 0 }),
+		acceptsInteractions: lx.boolean(),
+		labels: lx.array(lx.ref("com.atproto.label.defs#label")),
+		viewer: lx.ref("#generatorViewerState"),
+		contentMode: lx.string({
+			knownValues: [
+				"app.bsky.feed.defs#contentModeUnspecified",
+				"app.bsky.feed.defs#contentModeVideo",
+			],
+		}),
+		indexedAt: lx.string({ required: true, format: "datetime" }),
+	});
+
+	expect(generatorView).toEqual({
+		type: "object",
+		properties: {
+			uri: { type: "string", required: true, format: "at-uri" },
+			cid: { type: "string", required: true, format: "cid" },
+			did: { type: "string", required: true, format: "did" },
+			creator: {
+				type: "ref",
+				ref: "app.bsky.actor.defs#profileView",
+				required: true,
+			},
+			displayName: { type: "string", required: true },
+			description: { type: "string", maxGraphemes: 300, maxLength: 3000 },
+			descriptionFacets: {
+				type: "array",
+				items: { type: "ref", ref: "app.bsky.richtext.facet" },
+			},
+			avatar: { type: "string", format: "uri" },
+			likeCount: { type: "integer", minimum: 0 },
+			acceptsInteractions: { type: "boolean" },
+			labels: {
+				type: "array",
+				items: { type: "ref", ref: "com.atproto.label.defs#label" },
+			},
+			viewer: { type: "ref", ref: "#generatorViewerState" },
+			contentMode: {
+				type: "string",
+				knownValues: [
+					"app.bsky.feed.defs#contentModeUnspecified",
+					"app.bsky.feed.defs#contentModeVideo",
+				],
+			},
+			indexedAt: { type: "string", required: true, format: "datetime" },
+		},
+		required: ["uri", "cid", "did", "creator", "displayName", "indexedAt"],
+	});
+});
+
+test("app.bsky.feed.defs - generatorViewerState", () => {
+	const generatorViewerState = lx.object({
+		like: lx.string({ format: "at-uri" }),
+	});
+
+	expect(generatorViewerState).toEqual({
+		type: "object",
+		properties: {
+			like: { type: "string", format: "at-uri" },
+		},
+	});
+});
+
+test("app.bsky.feed.defs - skeletonFeedPost", () => {
+	const skeletonFeedPost = lx.object({
+		post: lx.string({ required: true, format: "at-uri" }),
+		reason: lx.union(["#skeletonReasonRepost", "#skeletonReasonPin"]),
+		feedContext: lx.string({ maxLength: 2000 }),
+	});
+
+	expect(skeletonFeedPost).toEqual({
+		type: "object",
+		properties: {
+			post: { type: "string", required: true, format: "at-uri" },
+			reason: {
+				type: "union",
+				refs: ["#skeletonReasonRepost", "#skeletonReasonPin"],
+			},
+			feedContext: { type: "string", maxLength: 2000 },
+		},
+		required: ["post"],
+	});
+});
+
+test("app.bsky.feed.defs - skeletonReasonRepost", () => {
+	const skeletonReasonRepost = lx.object({
+		repost: lx.string({ required: true, format: "at-uri" }),
+	});
+
+	expect(skeletonReasonRepost).toEqual({
+		type: "object",
+		properties: {
+			repost: { type: "string", required: true, format: "at-uri" },
+		},
+		required: ["repost"],
+	});
+});
+
+test("app.bsky.feed.defs - skeletonReasonPin", () => {
+	const skeletonReasonPin = lx.object({});
+
+	expect(skeletonReasonPin).toEqual({
+		type: "object",
+		properties: {},
+	});
+});
+
+test("app.bsky.feed.defs - threadgateView", () => {
+	const threadgateView = lx.object({
+		uri: lx.string({ format: "at-uri" }),
+		cid: lx.string({ format: "cid" }),
+		record: lx.unknown(),
+		lists: lx.array(lx.ref("app.bsky.graph.defs#listViewBasic")),
+	});
+
+	expect(threadgateView).toEqual({
+		type: "object",
+		properties: {
+			uri: { type: "string", format: "at-uri" },
+			cid: { type: "string", format: "cid" },
+			record: { type: "unknown" },
+			lists: {
+				type: "array",
+				items: { type: "ref", ref: "app.bsky.graph.defs#listViewBasic" },
+			},
+		},
+	});
+});
+
+test("app.bsky.feed.defs - interaction", () => {
+	const interaction = lx.object({
+		item: lx.string({ format: "at-uri" }),
+		event: lx.string({
+			knownValues: [
+				"app.bsky.feed.defs#requestLess",
+				"app.bsky.feed.defs#requestMore",
+				"app.bsky.feed.defs#clickthroughItem",
+				"app.bsky.feed.defs#clickthroughAuthor",
+				"app.bsky.feed.defs#clickthroughReposter",
+				"app.bsky.feed.defs#clickthroughEmbed",
+				"app.bsky.feed.defs#interactionSeen",
+				"app.bsky.feed.defs#interactionLike",
+				"app.bsky.feed.defs#interactionRepost",
+				"app.bsky.feed.defs#interactionReply",
+				"app.bsky.feed.defs#interactionQuote",
+				"app.bsky.feed.defs#interactionShare",
+			],
+		}),
+		feedContext: lx.string({ maxLength: 2000 }),
+		reqId: lx.string({ maxLength: 100 }),
+	});
+
+	expect(interaction).toEqual({
+		type: "object",
+		properties: {
+			item: { type: "string", format: "at-uri" },
+			event: {
+				type: "string",
+				knownValues: [
+					"app.bsky.feed.defs#requestLess",
+					"app.bsky.feed.defs#requestMore",
+					"app.bsky.feed.defs#clickthroughItem",
+					"app.bsky.feed.defs#clickthroughAuthor",
+					"app.bsky.feed.defs#clickthroughReposter",
+					"app.bsky.feed.defs#clickthroughEmbed",
+					"app.bsky.feed.defs#interactionSeen",
+					"app.bsky.feed.defs#interactionLike",
+					"app.bsky.feed.defs#interactionRepost",
+					"app.bsky.feed.defs#interactionReply",
+					"app.bsky.feed.defs#interactionQuote",
+					"app.bsky.feed.defs#interactionShare",
+				],
+			},
+			feedContext: { type: "string", maxLength: 2000 },
+			reqId: { type: "string", maxLength: 100 },
+		},
+	});
+});
+
+test("app.bsky.feed.defs - requestLess token", () => {
+	const requestLess = lx.token(
+		"Request that less content like the given feed item be shown in the feed",
+	);
+
+	expect(requestLess).toEqual({
+		type: "token",
+		description:
+			"Request that less content like the given feed item be shown in the feed",
+	});
+});
+
+test("app.bsky.feed.defs - requestMore token", () => {
+	const requestMore = lx.token(
+		"Request that more content like the given feed item be shown in the feed",
+	);
+
+	expect(requestMore).toEqual({
+		type: "token",
+		description:
+			"Request that more content like the given feed item be shown in the feed",
+	});
+});
+
+test("app.bsky.feed.defs - clickthroughItem token", () => {
+	const clickthroughItem = lx.token("User clicked through to the feed item");
+
+	expect(clickthroughItem).toEqual({
+		type: "token",
+		description: "User clicked through to the feed item",
+	});
+});
+
+test("app.bsky.feed.defs - clickthroughAuthor token", () => {
+	const clickthroughAuthor = lx.token(
+		"User clicked through to the author of the feed item",
+	);
+
+	expect(clickthroughAuthor).toEqual({
+		type: "token",
+		description: "User clicked through to the author of the feed item",
+	});
+});
+
+test("app.bsky.feed.defs - clickthroughReposter token", () => {
+	const clickthroughReposter = lx.token(
+		"User clicked through to the reposter of the feed item",
+	);
+
+	expect(clickthroughReposter).toEqual({
+		type: "token",
+		description: "User clicked through to the reposter of the feed item",
+	});
+});
+
+test("app.bsky.feed.defs - clickthroughEmbed token", () => {
+	const clickthroughEmbed = lx.token(
+		"User clicked through to the embedded content of the feed item",
+	);
+
+	expect(clickthroughEmbed).toEqual({
+		type: "token",
+		description:
+			"User clicked through to the embedded content of the feed item",
+	});
+});
+
+test("app.bsky.feed.defs - contentModeUnspecified token", () => {
+	const contentModeUnspecified = lx.token(
+		"Declares the feed generator returns any types of posts.",
+	);
+
+	expect(contentModeUnspecified).toEqual({
+		type: "token",
+		description: "Declares the feed generator returns any types of posts.",
+	});
+});
+
+test("app.bsky.feed.defs - contentModeVideo token", () => {
+	const contentModeVideo = lx.token(
+		"Declares the feed generator returns posts containing app.bsky.embed.video embeds.",
+	);
+
+	expect(contentModeVideo).toEqual({
+		type: "token",
+		description:
+			"Declares the feed generator returns posts containing app.bsky.embed.video embeds.",
+	});
+});
+
+test("app.bsky.feed.defs - interactionSeen token", () => {
+	const interactionSeen = lx.token("Feed item was seen by user");
+
+	expect(interactionSeen).toEqual({
+		type: "token",
+		description: "Feed item was seen by user",
+	});
+});
+
+test("app.bsky.feed.defs - interactionLike token", () => {
+	const interactionLike = lx.token("User liked the feed item");
+
+	expect(interactionLike).toEqual({
+		type: "token",
+		description: "User liked the feed item",
+	});
+});
+
+test("app.bsky.feed.defs - interactionRepost token", () => {
+	const interactionRepost = lx.token("User reposted the feed item");
+
+	expect(interactionRepost).toEqual({
+		type: "token",
+		description: "User reposted the feed item",
+	});
+});
+
+test("app.bsky.feed.defs - interactionReply token", () => {
+	const interactionReply = lx.token("User replied to the feed item");
+
+	expect(interactionReply).toEqual({
+		type: "token",
+		description: "User replied to the feed item",
+	});
+});
+
+test("app.bsky.feed.defs - interactionQuote token", () => {
+	const interactionQuote = lx.token("User quoted the feed item");
+
+	expect(interactionQuote).toEqual({
+		type: "token",
+		description: "User quoted the feed item",
+	});
+});
+
+test("app.bsky.feed.defs - interactionShare token", () => {
+	const interactionShare = lx.token("User shared the feed item");
+
+	expect(interactionShare).toEqual({
+		type: "token",
+		description: "User shared the feed item",
+	});
+});
+
+test("app.bsky.feed.defs - full namespace", () => {
+	const feedDefs = lx.namespace("app.bsky.feed.defs", {
+		postView: lx.object({
+			uri: lx.string({ required: true, format: "at-uri" }),
+			cid: lx.string({ required: true, format: "cid" }),
+			author: lx.ref("app.bsky.actor.defs#profileViewBasic", {
+				required: true,
+			}),
+			record: lx.unknown({ required: true }),
+			embed: lx.union([
+				"app.bsky.embed.images#view",
+				"app.bsky.embed.video#view",
+				"app.bsky.embed.external#view",
+				"app.bsky.embed.record#view",
+				"app.bsky.embed.recordWithMedia#view",
+			]),
+			bookmarkCount: lx.integer(),
+			replyCount: lx.integer(),
+			repostCount: lx.integer(),
+			likeCount: lx.integer(),
+			quoteCount: lx.integer(),
+			indexedAt: lx.string({ required: true, format: "datetime" }),
+			viewer: lx.ref("#viewerState"),
+			labels: lx.array(lx.ref("com.atproto.label.defs#label")),
+			threadgate: lx.ref("#threadgateView"),
+		}),
+		viewerState: lx.object({
+			repost: lx.string({ format: "at-uri" }),
+			like: lx.string({ format: "at-uri" }),
+			bookmarked: lx.boolean(),
+			threadMuted: lx.boolean(),
+			replyDisabled: lx.boolean(),
+			embeddingDisabled: lx.boolean(),
+			pinned: lx.boolean(),
+		}),
+		requestLess: lx.token(
+			"Request that less content like the given feed item be shown in the feed",
+		),
+		requestMore: lx.token(
+			"Request that more content like the given feed item be shown in the feed",
+		),
+		clickthroughItem: lx.token("User clicked through to the feed item"),
+		clickthroughAuthor: lx.token(
+			"User clicked through to the author of the feed item",
+		),
+		clickthroughReposter: lx.token(
+			"User clicked through to the reposter of the feed item",
+		),
+		clickthroughEmbed: lx.token(
+			"User clicked through to the embedded content of the feed item",
+		),
+		contentModeUnspecified: lx.token(
+			"Declares the feed generator returns any types of posts.",
+		),
+		contentModeVideo: lx.token(
+			"Declares the feed generator returns posts containing app.bsky.embed.video embeds.",
+		),
+		interactionSeen: lx.token("Feed item was seen by user"),
+		interactionLike: lx.token("User liked the feed item"),
+		interactionRepost: lx.token("User reposted the feed item"),
+		interactionReply: lx.token("User replied to the feed item"),
+		interactionQuote: lx.token("User quoted the feed item"),
+		interactionShare: lx.token("User shared the feed item"),
+	});
+
+	expect(feedDefs.json.lexicon).toEqual(1);
+	expect(feedDefs.json.id).toEqual("app.bsky.feed.defs");
+	expect(feedDefs.json.defs.postView.type).toEqual("object");
+	expect(feedDefs.json.defs.viewerState.type).toEqual("object");
+	expect(feedDefs.json.defs.requestLess.type).toEqual("token");
+	expect(feedDefs.json.defs.contentModeVideo.type).toEqual("token");
+});

packages/prototypey/tests/infer.bench.ts

···
+import { bench } from "@ark/attest";
+import { lx } from "../src/lib.ts";
+
+bench("infer with simple object", () => {
+	const schema = lx.namespace("test.simple", {
+		main: lx.object({
+			id: lx.string({ required: true }),
+			name: lx.string({ required: true }),
+		}),
+	});
+	return schema.infer;
+}).types([899, "instantiations"]);
+
+bench("infer with complex nested structure", () => {
+	const schema = lx.namespace("test.complex", {
+		user: lx.object({
+			handle: lx.string({ required: true }),
+			displayName: lx.string(),
+		}),
+		reply: lx.object({
+			text: lx.string({ required: true }),
+			author: lx.ref("#user", { required: true }),
+		}),
+		main: lx.record({
+			key: "tid",
+			record: lx.object({
+				author: lx.ref("#user", { required: true }),
+				replies: lx.array(lx.ref("#reply")),
+				content: lx.string({ required: true }),
+				createdAt: lx.string({ required: true, format: "datetime" }),
+			}),
+		}),
+	});
+	return schema.infer;
+}).types([1040, "instantiations"]);
+
+bench("infer with circular reference", () => {
+	const ns = lx.namespace("test", {
+		user: lx.object({
+			name: lx.string({ required: true }),
+			posts: lx.array(lx.ref("#post")),
+		}),
+		post: lx.object({
+			title: lx.string({ required: true }),
+			author: lx.ref("#user", { required: true }),
+		}),
+		main: lx.object({
+			users: lx.array(lx.ref("#user")),
+		}),
+	});
+	return ns.infer;
+}).types([692, "instantiations"]);
+
+bench("infer with app.bsky.feed.defs namespace", () => {
+	const schema = lx.namespace("app.bsky.feed.defs", {
+		viewerState: lx.object({
+			repost: lx.string({ format: "at-uri" }),
+			like: lx.string({ format: "at-uri" }),
+			bookmarked: lx.boolean(),
+			threadMuted: lx.boolean(),
+			replyDisabled: lx.boolean(),
+			embeddingDisabled: lx.boolean(),
+			pinned: lx.boolean(),
+		}),
+		main: lx.object({
+			uri: lx.string({ required: true, format: "at-uri" }),
+			cid: lx.string({ required: true, format: "cid" }),
+			author: lx.ref("app.bsky.actor.defs#profileViewBasic", {
+				required: true,
+			}),
+			record: lx.unknown({ required: true }),
+			embed: lx.union([
+				"app.bsky.embed.images#view",
+				"app.bsky.embed.video#view",
+				"app.bsky.embed.external#view",
+				"app.bsky.embed.record#view",
+				"app.bsky.embed.recordWithMedia#view",
+			]),
+			bookmarkCount: lx.integer(),
+			replyCount: lx.integer(),
+			repostCount: lx.integer(),
+			likeCount: lx.integer(),
+			quoteCount: lx.integer(),
+			indexedAt: lx.string({ required: true, format: "datetime" }),
+			viewer: lx.ref("#viewerState"),
+			labels: lx.array(lx.ref("com.atproto.label.defs#label")),
+			threadgate: lx.ref("#threadgateView"),
+		}),
+		requestLess: lx.token(
+			"Request that less content like the given feed item be shown in the feed",
+		),
+		requestMore: lx.token(
+			"Request that more content like the given feed item be shown in the feed",
+		),
+		clickthroughItem: lx.token("User clicked through to the feed item"),
+		clickthroughAuthor: lx.token(
+			"User clicked through to the author of the feed item",
+		),
+		clickthroughReposter: lx.token(
+			"User clicked through to the reposter of the feed item",
+		),
+		clickthroughEmbed: lx.token(
+			"User clicked through to the embedded content of the feed item",
+		),
+		contentModeUnspecified: lx.token(
+			"Declares the feed generator returns any types of posts.",
+		),
+		contentModeVideo: lx.token(
+			"Declares the feed generator returns posts containing app.bsky.embed.video embeds.",
+		),
+		interactionSeen: lx.token("Feed item was seen by user"),
+		interactionLike: lx.token("User liked the feed item"),
+		interactionRepost: lx.token("User reposted the feed item"),
+		interactionReply: lx.token("User replied to the feed item"),
+		interactionQuote: lx.token("User quoted the feed item"),
+		interactionShare: lx.token("User shared the feed item"),
+	});
+	return schema.infer;
+}).types([1285, "instantiations"]);

packages/prototypey/tests/infer.test.ts

···
+import { test } from "vitest";
+import { attest } from "@ark/attest";
+import { lx } from "../src/lib.ts";
+
+test("InferNS produces expected type shape", () => {
+	const exampleLexicon = lx.namespace("com.example.post", {
+		main: lx.record({
+			key: "tid",
+			record: lx.object({
+				text: lx.string({ required: true }),
+				createdAt: lx.string({ required: true, format: "datetime" }),
+				likes: lx.integer(),
+				tags: lx.array(lx.string(), { maxLength: 5 }),
+			}),
+		}),
+	});
+
+	// Type snapshot - this captures how types appear on hover
+	attest(exampleLexicon.infer).type.toString.snap(`{
+  $type: "com.example.post"
+  tags?: string[] | undefined
+  likes?: number | undefined
+  createdAt: string
+  text: string
+}`);
+});
+
+test("InferObject handles required fields", () => {
+	const schema = lx.namespace("test", {
+		main: lx.object({
+			required: lx.string({ required: true }),
+			optional: lx.string(),
+		}),
+	});
+
+	attest(schema.infer).type.toString.snap(`{
+  $type: "test"
+  optional?: string | undefined
+  required: string
+}`);
+});
+
+test("InferObject handles nullable fields", () => {
+	const schema = lx.namespace("test", {
+		main: lx.object({
+			nullable: lx.string({ nullable: true, required: true }),
+		}),
+	});
+
+	attest(schema.infer).type.toString.snap(
+		'{ $type: "test"; nullable: string | null }',
+	);
+});
+
+// ============================================================================
+// PRIMITIVE TYPES TESTS
+// ============================================================================
+
+test("InferType handles string primitive", () => {
+	const namespace = lx.namespace("test.string", {
+		main: lx.object({
+			simpleString: lx.string(),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.string"
+  simpleString?: string | undefined
+}`);
+});
+
+test("InferType handles integer primitive", () => {
+	const namespace = lx.namespace("test.integer", {
+		main: lx.object({
+			count: lx.integer(),
+			age: lx.integer({ minimum: 0, maximum: 120 }),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.integer"
+  count?: number | undefined
+  age?: number | undefined
+}`);
+});
+
+test("InferType handles boolean primitive", () => {
+	const namespace = lx.namespace("test.boolean", {
+		main: lx.object({
+			isActive: lx.boolean(),
+			hasAccess: lx.boolean({ required: true }),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.boolean"
+  isActive?: boolean | undefined
+  hasAccess: boolean
+}`);
+});
+
+test("InferType handles null primitive", () => {
+	const namespace = lx.namespace("test.null", {
+		main: lx.object({
+			nullValue: lx.null(),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.null"
+  nullValue?: null | undefined
+}`);
+});
+
+test("InferType handles unknown primitive", () => {
+	const namespace = lx.namespace("test.unknown", {
+		main: lx.object({
+			metadata: lx.unknown(),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(
+		'{ $type: "test.unknown"; metadata?: unknown }',
+	);
+});
+
+test("InferType handles bytes primitive", () => {
+	const namespace = lx.namespace("test.bytes", {
+		main: lx.object({
+			data: lx.bytes(),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.bytes"
+  data?: Uint8Array<ArrayBufferLike> | undefined
+}`);
+});
+
+test("InferType handles blob primitive", () => {
+	const namespace = lx.namespace("test.blob", {
+		main: lx.object({
+			image: lx.blob({ accept: ["image/png", "image/jpeg"] }),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(
+		'{ $type: "test.blob"; image?: Blob | undefined }',
+	);
+});
+
+// ============================================================================
+// TOKEN TYPE TESTS
+// ============================================================================
+
+test("InferToken handles basic token without enum", () => {
+	const namespace = lx.namespace("test.token", {
+		main: lx.object({
+			symbol: lx.token("A symbolic value"),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.token"
+  symbol?: string | undefined
+}`);
+});
+
+// ============================================================================
+// ARRAY TYPE TESTS
+// ============================================================================
+
+test("InferArray handles string arrays", () => {
+	const namespace = lx.namespace("test.array.string", {
+		main: lx.object({
+			tags: lx.array(lx.string()),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.array.string"
+  tags?: string[] | undefined
+}`);
+});
+
+test("InferArray handles integer arrays", () => {
+	const namespace = lx.namespace("test.array.integer", {
+		main: lx.object({
+			scores: lx.array(lx.integer(), { minLength: 1, maxLength: 10 }),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.array.integer"
+  scores?: number[] | undefined
+}`);
+});
+
+test("InferArray handles boolean arrays", () => {
+	const namespace = lx.namespace("test.array.boolean", {
+		main: lx.object({
+			flags: lx.array(lx.boolean()),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.array.boolean"
+  flags?: boolean[] | undefined
+}`);
+});
+
+test("InferArray handles unknown arrays", () => {
+	const namespace = lx.namespace("test.array.unknown", {
+		main: lx.object({
+			items: lx.array(lx.unknown()),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.array.unknown"
+  items?: unknown[] | undefined
+}`);
+});
+
+// ============================================================================
+// OBJECT PROPERTY COMBINATIONS
+// ============================================================================
+
+test("InferObject handles mixed optional and required fields", () => {
+	const namespace = lx.namespace("test.mixed", {
+		main: lx.object({
+			id: lx.string({ required: true }),
+			name: lx.string({ required: true }),
+			email: lx.string(),
+			age: lx.integer(),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.mixed"
+  age?: number | undefined
+  email?: string | undefined
+  id: string
+  name: string
+}`);
+});
+
+test("InferObject handles all optional fields", () => {
+	const namespace = lx.namespace("test.allOptional", {
+		main: lx.object({
+			field1: lx.string(),
+			field2: lx.integer(),
+			field3: lx.boolean(),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.allOptional"
+  field1?: string | undefined
+  field2?: number | undefined
+  field3?: boolean | undefined
+}`);
+});
+
+test("InferObject handles all required fields", () => {
+	const namespace = lx.namespace("test.allRequired", {
+		main: lx.object({
+			field1: lx.string({ required: true }),
+			field2: lx.integer({ required: true }),
+			field3: lx.boolean({ required: true }),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.allRequired"
+  field1: string
+  field2: number
+  field3: boolean
+}`);
+});
+
+// ============================================================================
+// NULLABLE FIELDS TESTS
+// ============================================================================
+
+test("InferObject handles nullable optional field", () => {
+	const namespace = lx.namespace("test.nullableOptional", {
+		main: lx.object({
+			description: lx.string({ nullable: true }),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.nullableOptional"
+  description?: string | null | undefined
+}`);
+});
+
+test("InferObject handles multiple nullable fields", () => {
+	const namespace = lx.namespace("test.multipleNullable", {
+		main: lx.object({
+			field1: lx.string({ nullable: true }),
+			field2: lx.integer({ nullable: true }),
+			field3: lx.boolean({ nullable: true }),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.multipleNullable"
+  field1?: string | null | undefined
+  field2?: number | null | undefined
+  field3?: boolean | null | undefined
+}`);
+});
+
+test("InferObject handles nullable and required field", () => {
+	const namespace = lx.namespace("test.nullableRequired", {
+		main: lx.object({
+			value: lx.string({ nullable: true, required: true }),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.nullableRequired"
+  value: string | null
+}`);
+});
+
+test("InferObject handles mixed nullable, required, and optional", () => {
+	const namespace = lx.namespace("test.mixedNullable", {
+		main: lx.object({
+			requiredNullable: lx.string({ required: true, nullable: true }),
+			optionalNullable: lx.string({ nullable: true }),
+			required: lx.string({ required: true }),
+			optional: lx.string(),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.mixedNullable"
+  optional?: string | undefined
+  required: string
+  optionalNullable?: string | null | undefined
+  requiredNullable: string | null
+}`);
+});
+
+// ============================================================================
+// REF TYPE TESTS
+// ============================================================================
+
+test("InferRef handles basic reference", () => {
+	const namespace = lx.namespace("test.ref", {
+		main: lx.object({
+			post: lx.ref("com.example.post"),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.ref"
+  post?:
+    | { [x: string]: unknown; $type: "com.example.post" }
+    | undefined
+}`);
+});
+
+test("InferRef handles required reference", () => {
+	const namespace = lx.namespace("test.refRequired", {
+		main: lx.object({
+			author: lx.ref("com.example.user", { required: true }),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.refRequired"
+  author?:
+    | { [x: string]: unknown; $type: "com.example.user" }
+    | undefined
+}`);
+});
+
+test("InferRef handles nullable reference", () => {
+	const namespace = lx.namespace("test.refNullable", {
+		main: lx.object({
+			parent: lx.ref("com.example.node", { nullable: true }),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.refNullable"
+  parent?:
+    | { [x: string]: unknown; $type: "com.example.node" }
+    | undefined
+}`);
+});
+
+// ============================================================================
+// UNION TYPE TESTS
+// ============================================================================
+
+test("InferUnion handles basic union", () => {
+	const namespace = lx.namespace("test.union", {
+		main: lx.object({
+			content: lx.union(["com.example.text", "com.example.image"]),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.union"
+  content?:
+    | { [x: string]: unknown; $type: "com.example.text" }
+    | { [x: string]: unknown; $type: "com.example.image" }
+    | undefined
+}`);
+});
+
+test("InferUnion handles required union", () => {
+	const namespace = lx.namespace("test.unionRequired", {
+		main: lx.object({
+			media: lx.union(["com.example.video", "com.example.audio"], {
+				required: true,
+			}),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.unionRequired"
+  media:
+    | { [x: string]: unknown; $type: "com.example.video" }
+    | { [x: string]: unknown; $type: "com.example.audio" }
+}`);
+});
+
+test("InferUnion handles union with many types", () => {
+	const namespace = lx.namespace("test.unionMultiple", {
+		main: lx.object({
+			attachment: lx.union([
+				"com.example.image",
+				"com.example.video",
+				"com.example.audio",
+				"com.example.document",
+			]),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.unionMultiple"
+  attachment?:
+    | { [x: string]: unknown; $type: "com.example.image" }
+    | { [x: string]: unknown; $type: "com.example.video" }
+    | { [x: string]: unknown; $type: "com.example.audio" }
+    | {
+        [x: string]: unknown
+        $type: "com.example.document"
+      }
+    | undefined
+}`);
+});
+
+// ============================================================================
+// PARAMS TYPE TESTS
+// ============================================================================
+
+test("InferParams handles basic params", () => {
+	const namespace = lx.namespace("test.params", {
+		main: lx.params({
+			limit: lx.integer(),
+			offset: lx.integer(),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.params"
+  limit?: number | undefined
+  offset?: number | undefined
+}`);
+});
+
+test("InferParams handles required params", () => {
+	const namespace = lx.namespace("test.paramsRequired", {
+		main: lx.params({
+			query: lx.string({ required: true }),
+			limit: lx.integer(),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.paramsRequired"
+  limit?: number | undefined
+  query: string
+}`);
+});
+
+// ============================================================================
+// RECORD TYPE TESTS
+// ============================================================================
+
+test("InferRecord handles record with object schema", () => {
+	const namespace = lx.namespace("test.record", {
+		main: lx.record({
+			key: "tid",
+			record: lx.object({
+				title: lx.string({ required: true }),
+				content: lx.string({ required: true }),
+				published: lx.boolean(),
+			}),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.record"
+  published?: boolean | undefined
+  content: string
+  title: string
+}`);
+});
+
+// ============================================================================
+// NESTED OBJECTS TESTS
+// ============================================================================
+
+test("InferObject handles nested objects", () => {
+	const namespace = lx.namespace("test.nested", {
+		main: lx.object({
+			user: lx.object({
+				name: lx.string({ required: true }),
+				email: lx.string({ required: true }),
+			}),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.nested"
+  user?: { name: string; email: string } | undefined
+}`);
+});
+
+test("InferObject handles deeply nested objects", () => {
+	const namespace = lx.namespace("test.deepNested", {
+		main: lx.object({
+			data: lx.object({
+				user: lx.object({
+					profile: lx.object({
+						name: lx.string({ required: true }),
+					}),
+				}),
+			}),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.deepNested"
+  data?:
+    | {
+        user?:
+          | { profile?: { name: string } | undefined }
+          | undefined
+      }
+    | undefined
+}`);
+});
+
+// ============================================================================
+// NESTED ARRAYS TESTS
+// ============================================================================
+
+test("InferArray handles arrays of objects", () => {
+	const namespace = lx.namespace("test.arrayOfObjects", {
+		main: lx.object({
+			users: lx.array(
+				lx.object({
+					id: lx.string({ required: true }),
+					name: lx.string({ required: true }),
+				}),
+			),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.arrayOfObjects"
+  users?: { id: string; name: string }[] | undefined
+}`);
+});
+
+test("InferArray handles arrays of arrays", () => {
+	const schema = lx.object({
+		matrix: lx.array(lx.array(lx.integer())),
+	});
+
+	const namespace = lx.namespace("test.nestedArrays", {
+		main: schema,
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.nestedArrays"
+  matrix?: number[][] | undefined
+}`);
+});
+
+test("InferArray handles arrays of refs", () => {
+	const namespace = lx.namespace("test.arrayOfRefs", {
+		main: lx.object({
+			followers: lx.array(lx.ref("com.example.user")),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.arrayOfRefs"
+  followers?:
+    | { [x: string]: unknown; $type: "com.example.user" }[]
+    | undefined
+}`);
+});
+
+// ============================================================================
+// COMPLEX NESTED STRUCTURES
+// ============================================================================
+
+test("InferObject handles complex nested structure", () => {
+	const namespace = lx.namespace("test.complex", {
+		main: lx.object({
+			id: lx.string({ required: true }),
+			author: lx.object({
+				did: lx.string({ required: true, format: "did" }),
+				handle: lx.string({ required: true, format: "handle" }),
+				avatar: lx.string(),
+			}),
+			content: lx.union(["com.example.text", "com.example.image"]),
+			tags: lx.array(lx.string(), { maxLength: 10 }),
+			metadata: lx.object({
+				views: lx.integer(),
+				likes: lx.integer(),
+				shares: lx.integer(),
+			}),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "test.complex"
+  tags?: string[] | undefined
+  content?:
+    | { [x: string]: unknown; $type: "com.example.text" }
+    | { [x: string]: unknown; $type: "com.example.image" }
+    | undefined
+  author?:
+    | {
+        avatar?: string | undefined
+        did: string
+        handle: string
+      }
+    | undefined
+  metadata?:
+    | {
+        likes?: number | undefined
+        views?: number | undefined
+        shares?: number | undefined
+      }
+    | undefined
+  id: string
+}`);
+});
+
+// ============================================================================
+// MULTIPLE DEFS IN NAMESPACE
+// ============================================================================
+
+test("InferNS handles multiple defs in namespace", () => {
+	const namespace = lx.namespace("com.example.app", {
+		user: lx.object({
+			name: lx.string({ required: true }),
+			email: lx.string({ required: true }),
+		}),
+		post: lx.object({
+			title: lx.string({ required: true }),
+			content: lx.string({ required: true }),
+		}),
+		comment: lx.object({
+			text: lx.string({ required: true }),
+			author: lx.ref("com.example.user"),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap("never");
+});
+
+test("InferNS handles namespace with record and object defs", () => {
+	const namespace = lx.namespace("com.example.blog", {
+		main: lx.record({
+			key: "tid",
+			record: lx.object({
+				title: lx.string({ required: true }),
+				body: lx.string({ required: true }),
+			}),
+		}),
+		metadata: lx.object({
+			category: lx.string(),
+			tags: lx.array(lx.string()),
+		}),
+	});
+
+	attest(namespace.infer).type.toString.snap(`{
+  $type: "com.example.blog"
+  title: string
+  body: string
+}`);
+});
+
+// ============================================================================
+// LOCAL REF RESOLUTION TESTS
+// ============================================================================
+
+test("Local ref resolution: resolves refs to actual types", () => {
+	const ns = lx.namespace("test", {
+		user: lx.object({
+			name: lx.string({ required: true }),
+			email: lx.string({ required: true }),
+		}),
+		main: lx.object({
+			author: lx.ref("#user", { required: true }),
+			content: lx.string({ required: true }),
+		}),
+	});
+
+	attest(ns.infer).type.toString.snap(`{
+  $type: "test"
+  author?:
+    | { name: string; email: string; $type: "#user" }
+    | undefined
+  content: string
+}`);
+});
+
+test("Local ref resolution: refs in arrays", () => {
+	const ns = lx.namespace("test", {
+		user: lx.object({
+			name: lx.string({ required: true }),
+		}),
+		main: lx.object({
+			users: lx.array(lx.ref("#user")),
+		}),
+	});
+
+	attest(ns.infer).type.toString.snap(`{
+  $type: "test"
+  users?: { name: string; $type: "#user" }[] | undefined
+}`);
+});
+
+test("Local ref resolution: refs in unions", () => {
+	const ns = lx.namespace("test", {
+		text: lx.object({ content: lx.string({ required: true }) }),
+		image: lx.object({ url: lx.string({ required: true }) }),
+		main: lx.object({
+			embed: lx.union(["#text", "#image"]),
+		}),
+	});
+
+	attest(ns.infer).type.toString.snap(`{
+  $type: "test"
+  embed?:
+    | { content: string; $type: "#text" }
+    | { url: string; $type: "#image" }
+    | undefined
+}`);
+});
+
+test("Local ref resolution: nested refs", () => {
+	const ns = lx.namespace("test", {
+		profile: lx.object({
+			bio: lx.string({ required: true }),
+		}),
+		user: lx.object({
+			name: lx.string({ required: true }),
+			profile: lx.ref("#profile", { required: true }),
+		}),
+		main: lx.object({
+			author: lx.ref("#user", { required: true }),
+		}),
+	});
+
+	attest(ns.infer).type.toString.snap(`{
+  $type: "test"
+  author?:
+    | {
+        profile?:
+          | { bio: string; $type: "#profile" }
+          | undefined
+        name: string
+        $type: "#user"
+      }
+    | undefined
+}`);
+});
+
+// ============================================================================
+// EDGE CASE TESTS
+// ============================================================================
+
+test("Edge case: circular reference detection", () => {
+	const ns = lx.namespace("test", {
+		main: lx.object({
+			value: lx.string({ required: true }),
+			parent: lx.ref("#main"),
+		}),
+	});
+
+	attest(ns.infer).type.toString.snap(`{
+  $type: "test"
+  parent?:
+    | {
+        parent?:
+          | "[Circular reference detected: #main]"
+          | undefined
+        value: string
+        $type: "#main"
+      }
+    | undefined
+  value: string
+}`);
+});
+
+test("Edge case: circular reference between multiple types", () => {
+	const ns = lx.namespace("test", {
+		user: lx.object({
+			name: lx.string({ required: true }),
+			posts: lx.array(lx.ref("#post")),
+		}),
+		post: lx.object({
+			title: lx.string({ required: true }),
+			author: lx.ref("#user", { required: true }),
+		}),
+		main: lx.object({
+			users: lx.array(lx.ref("#user")),
+		}),
+	});
+
+	attest(ns.infer).type.toString.snap(`{
+  $type: "test"
+  users?:
+    | {
+        posts?:
+          | {
+              author?:
+                | "[Circular reference detected: #user]"
+                | undefined
+              title: string
+              $type: "#post"
+            }[]
+          | undefined
+        name: string
+        $type: "#user"
+      }[]
+    | undefined
+}`);
+});
+
+test("Edge case: missing reference detection", () => {
+	const ns = lx.namespace("test", {
+		main: lx.object({
+			author: lx.ref("#user", { required: true }),
+		}),
+	});
+
+	attest(ns.infer).type.toString.snap(`{
+  $type: "test"
+  author?: "[Reference not found: #user]" | undefined
+}`);
+});

packages/prototypey/tests/primitives.test.ts

···
+import { expect, test } from "vitest";
+import { lx } from "../src/lib.ts";
+
+test("lx.null()", () => {
+	const result = lx.null();
+	expect(result).toEqual({ type: "null" });
+});
+
+test("lx.boolean()", () => {
+	const result = lx.boolean();
+	expect(result).toEqual({ type: "boolean" });
+});
+
+test("lx.boolean() with default", () => {
+	const result = lx.boolean({ default: true });
+	expect(result).toEqual({ type: "boolean", default: true });
+});
+
+test("lx.boolean() with const", () => {
+	const result = lx.boolean({ const: false });
+	expect(result).toEqual({ type: "boolean", const: false });
+});
+
+test("lx.integer()", () => {
+	const result = lx.integer();
+	expect(result).toEqual({ type: "integer" });
+});
+
+test("lx.integer() with minimum", () => {
+	const result = lx.integer({ minimum: 0 });
+	expect(result).toEqual({ type: "integer", minimum: 0 });
+});
+
+test("lx.integer() with maximum", () => {
+	const result = lx.integer({ maximum: 100 });
+	expect(result).toEqual({ type: "integer", maximum: 100 });
+});
+
+test("lx.integer() with minimum and maximum", () => {
+	const result = lx.integer({ minimum: 0, maximum: 100 });
+	expect(result).toEqual({ type: "integer", minimum: 0, maximum: 100 });
+});
+
+test("lx.integer() with enum", () => {
+	const result = lx.integer({ enum: [1, 2, 3, 5, 8, 13] });
+	expect(result).toEqual({ type: "integer", enum: [1, 2, 3, 5, 8, 13] });
+});
+
+test("lx.integer() with default", () => {
+	const result = lx.integer({ default: 42 });
+	expect(result).toEqual({ type: "integer", default: 42 });
+});
+
+test("lx.integer() with const", () => {
+	const result = lx.integer({ const: 7 });
+	expect(result).toEqual({ type: "integer", const: 7 });
+});
+
+test("lx.string()", () => {
+	const result = lx.string();
+	expect(result).toEqual({ type: "string" });
+});
+
+test("lx.string() with maxLength", () => {
+	const result = lx.string({ maxLength: 64 });
+	expect(result).toEqual({ type: "string", maxLength: 64 });
+});
+
+test("lx.string() with enum", () => {
+	const result = lx.string({ enum: ["light", "dark", "auto"] });
+	expect(result).toEqual({ type: "string", enum: ["light", "dark", "auto"] });
+});
+
+test("lx.unknown()", () => {
+	const result = lx.unknown();
+	expect(result).toEqual({ type: "unknown" });
+});
+
+test("lx.bytes()", () => {
+	const result = lx.bytes();
+	expect(result).toEqual({ type: "bytes" });
+});
+
+test("lx.bytes() with minLength", () => {
+	const result = lx.bytes({ minLength: 1 });
+	expect(result).toEqual({ type: "bytes", minLength: 1 });
+});
+
+test("lx.bytes() with maxLength", () => {
+	const result = lx.bytes({ maxLength: 1024 });
+	expect(result).toEqual({ type: "bytes", maxLength: 1024 });
+});
+
+test("lx.bytes() with minLength and maxLength", () => {
+	const result = lx.bytes({ minLength: 1, maxLength: 1024 });
+	expect(result).toEqual({ type: "bytes", minLength: 1, maxLength: 1024 });
+});
+
+test("lx.cidLink()", () => {
+	const result = lx.cidLink(
+		"bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a",
+	);
+	expect(result).toEqual({
+		type: "cid-link",
+		$link: "bafyreidfayvfuwqa7qlnopdjiqrxzs6blmoeu4rujcjtnci5beludirz2a",
+	});
+});
+
+test("lx.blob()", () => {
+	const result = lx.blob();
+	expect(result).toEqual({ type: "blob" });
+});
+
+test("lx.blob() with accept", () => {
+	const result = lx.blob({ accept: ["image/png", "image/jpeg"] });
+	expect(result).toEqual({
+		type: "blob",
+		accept: ["image/png", "image/jpeg"],
+	});
+});
+
+test("lx.blob() with maxSize", () => {
+	const result = lx.blob({ maxSize: 1000000 });
+	expect(result).toEqual({ type: "blob", maxSize: 1000000 });
+});
+
+test("lx.blob() with accept and maxSize", () => {
+	const result = lx.blob({
+		accept: ["image/png", "image/jpeg"],
+		maxSize: 5000000,
+	});
+	expect(result).toEqual({
+		type: "blob",
+		accept: ["image/png", "image/jpeg"],
+		maxSize: 5000000,
+	});
+});
+
+test("lx.array() with string items", () => {
+	const result = lx.array(lx.string());
+	expect(result).toEqual({ type: "array", items: { type: "string" } });
+});
+
+test("lx.array() with integer items", () => {
+	const result = lx.array(lx.integer());
+	expect(result).toEqual({ type: "array", items: { type: "integer" } });
+});
+
+test("lx.array() with minLength", () => {
+	const result = lx.array(lx.string(), { minLength: 1 });
+	expect(result).toEqual({
+		type: "array",
+		items: { type: "string" },
+		minLength: 1,
+	});
+});
+
+test("lx.array() with maxLength", () => {
+	const result = lx.array(lx.string(), { maxLength: 10 });
+	expect(result).toEqual({
+		type: "array",
+		items: { type: "string" },
+		maxLength: 10,
+	});
+});
+
+test("lx.array() with minLength and maxLength", () => {
+	const result = lx.array(lx.string(), { minLength: 1, maxLength: 10 });
+	expect(result).toEqual({
+		type: "array",
+		items: { type: "string" },
+		minLength: 1,
+		maxLength: 10,
+	});
+});
+
+test("lx.array() with required", () => {
+	const result = lx.array(lx.string(), { required: true });
+	expect(result).toEqual({
+		type: "array",
+		items: { type: "string" },
+		required: true,
+	});
+});
+
+test("lx.token() with interaction event", () => {
+	const result = lx.token(
+		"Request that less content like the given feed item be shown in the feed",
+	);
+	expect(result).toEqual({
+		type: "token",
+		description:
+			"Request that less content like the given feed item be shown in the feed",
+	});
+});
+
+test("lx.token() with content mode", () => {
+	const result = lx.token(
+		"Declares the feed generator returns posts containing app.bsky.embed.video embeds",
+	);
+	expect(result).toEqual({
+		type: "token",
+		description:
+			"Declares the feed generator returns posts containing app.bsky.embed.video embeds",
+	});
+});
+
+test("lx.ref() with local definition", () => {
+	const result = lx.ref("#profileAssociated");
+	expect(result).toEqual({
+		type: "ref",
+		ref: "#profileAssociated",
+	});
+});
+
+test("lx.ref() with external schema", () => {
+	const result = lx.ref("com.atproto.label.defs#label");
+	expect(result).toEqual({
+		type: "ref",
+		ref: "com.atproto.label.defs#label",
+	});
+});
+
+test("lx.ref() with required option", () => {
+	const result = lx.ref("#profileView", { required: true });
+	expect(result).toEqual({
+		type: "ref",
+		ref: "#profileView",
+		required: true,
+	});
+});
+
+test("lx.ref() with nullable option", () => {
+	const result = lx.ref("#profileView", { nullable: true });
+	expect(result).toEqual({
+		type: "ref",
+		ref: "#profileView",
+		nullable: true,
+	});
+});
+
+test("lx.ref() with both required and nullable", () => {
+	const result = lx.ref("app.bsky.actor.defs#profileView", {
+		required: true,
+		nullable: true,
+	});
+	expect(result).toEqual({
+		type: "ref",
+		ref: "app.bsky.actor.defs#profileView",
+		required: true,
+		nullable: true,
+	});
+});
+
+test("lx.union() with local refs", () => {
+	const result = lx.union(["#reasonRepost", "#reasonPin"]);
+	expect(result).toEqual({
+		type: "union",
+		refs: ["#reasonRepost", "#reasonPin"],
+	});
+});
+
+test("lx.union() with external refs", () => {
+	const result = lx.union([
+		"app.bsky.embed.images#view",
+		"app.bsky.embed.video#view",
+		"app.bsky.embed.external#view",
+		"app.bsky.embed.record#view",
+		"app.bsky.embed.recordWithMedia#view",
+	]);
+	expect(result).toEqual({
+		type: "union",
+		refs: [
+			"app.bsky.embed.images#view",
+			"app.bsky.embed.video#view",
+			"app.bsky.embed.external#view",
+			"app.bsky.embed.record#view",
+			"app.bsky.embed.recordWithMedia#view",
+		],
+	});
+});
+
+test("lx.union() with closed option", () => {
+	const result = lx.union(["#postView", "#notFoundPost", "#blockedPost"], {
+		closed: true,
+	});
+	expect(result).toEqual({
+		type: "union",
+		refs: ["#postView", "#notFoundPost", "#blockedPost"],
+		closed: true,
+	});
+});
+
+test("lx.union() with closed: false (open union)", () => {
+	const result = lx.union(["#threadViewPost", "#notFoundPost"], {
+		closed: false,
+	});
+	expect(result).toEqual({
+		type: "union",
+		refs: ["#threadViewPost", "#notFoundPost"],
+		closed: false,
+	});
+});
+
+test("lx.params() with basic properties", () => {
+	const result = lx.params({
+		q: lx.string(),
+		limit: lx.integer(),
+	});
+	expect(result).toEqual({
+		type: "params",
+		properties: {
+			q: { type: "string" },
+			limit: { type: "integer" },
+		},
+	});
+});
+
+test("lx.params() with required properties", () => {
+	const result = lx.params({
+		q: lx.string({ required: true }),
+		limit: lx.integer(),
+	});
+	expect(result).toEqual({
+		type: "params",
+		properties: {
+			q: { type: "string", required: true },
+			limit: { type: "integer" },
+		},
+		required: ["q"],
+	});
+});
+
+test("lx.params() with property options", () => {
+	const result = lx.params({
+		q: lx.string(),
+		limit: lx.integer({ minimum: 1, maximum: 100, default: 25 }),
+		cursor: lx.string(),
+	});
+	expect(result).toEqual({
+		type: "params",
+		properties: {
+			q: { type: "string" },
+			limit: { type: "integer", minimum: 1, maximum: 100, default: 25 },
+			cursor: { type: "string" },
+		},
+	});
+});
+
+test("lx.params() with array properties", () => {
+	const result = lx.params({
+		tags: lx.array(lx.string()),
+		ids: lx.array(lx.integer()),
+	});
+	expect(result).toEqual({
+		type: "params",
+		properties: {
+			tags: { type: "array", items: { type: "string" } },
+			ids: { type: "array", items: { type: "integer" } },
+		},
+	});
+});
+
+test("lx.params() real-world example from searchActors", () => {
+	const result = lx.params({
+		q: lx.string({ required: true }),
+		limit: lx.integer({ minimum: 1, maximum: 100, default: 25 }),
+		cursor: lx.string(),
+	});
+	expect(result).toEqual({
+		type: "params",
+		properties: {
+			q: { type: "string", required: true },
+			limit: { type: "integer", minimum: 1, maximum: 100, default: 25 },
+			cursor: { type: "string" },
+		},
+		required: ["q"],
+	});
+});
+
+test("lx.query() basic", () => {
+	const result = lx.query();
+	expect(result).toEqual({ type: "query" });
+});
+
+test("lx.query() with description", () => {
+	const result = lx.query({ description: "Search for actors" });
+	expect(result).toEqual({ type: "query", description: "Search for actors" });
+});
+
+test("lx.query() with parameters", () => {
+	const result = lx.query({
+		parameters: lx.params({
+			q: lx.string({ required: true }),
+			limit: lx.integer({ minimum: 1, maximum: 100, default: 25 }),
+		}),
+	});
+	expect(result).toEqual({
+		type: "query",
+		parameters: {
+			type: "params",
+			properties: {
+				q: { type: "string", required: true },
+				limit: { type: "integer", minimum: 1, maximum: 100, default: 25 },
+			},
+			required: ["q"],
+		},
+	});
+});
+
+test("lx.query() with output", () => {
+	const result = lx.query({
+		output: {
+			encoding: "application/json",
+			schema: lx.object({
+				posts: lx.array(lx.ref("app.bsky.feed.defs#postView"), {
+					required: true,
+				}),
+				cursor: lx.string(),
+			}),
+		},
+	});
+	expect(result).toEqual({
+		type: "query",
+		output: {
+			encoding: "application/json",
+			schema: {
+				type: "object",
+				properties: {
+					posts: {
+						type: "array",
+						items: { type: "ref", ref: "app.bsky.feed.defs#postView" },
+						required: true,
+					},
+					cursor: { type: "string" },
+				},
+				required: ["posts"],
+			},
+		},
+	});
+});
+
+test("lx.query() with errors", () => {
+	const result = lx.query({
+		errors: [{ name: "BadQueryString" }],
+	});
+	expect(result).toEqual({
+		type: "query",
+		errors: [{ name: "BadQueryString" }],
+	});
+});
+
+test("lx.query() real-world example: searchPosts", () => {
+	const result = lx.query({
+		description: "Find posts matching search criteria",
+		parameters: lx.params({
+			q: lx.string({ required: true }),
+			sort: lx.string({ enum: ["top", "latest"], default: "latest" }),
+			limit: lx.integer({ minimum: 1, maximum: 100, default: 25 }),
+			cursor: lx.string(),
+		}),
+		output: {
+			encoding: "application/json",
+			schema: lx.object({
+				cursor: lx.string(),
+				hitsTotal: lx.integer(),
+				posts: lx.array(lx.ref("app.bsky.feed.defs#postView"), {
+					required: true,
+				}),
+			}),
+		},
+		errors: [{ name: "BadQueryString" }],
+	});
+	expect(result).toEqual({
+		type: "query",
+		description: "Find posts matching search criteria",
+		parameters: {
+			type: "params",
+			properties: {
+				q: { type: "string", required: true },
+				sort: { type: "string", enum: ["top", "latest"], default: "latest" },
+				limit: { type: "integer", minimum: 1, maximum: 100, default: 25 },
+				cursor: { type: "string" },
+			},
+			required: ["q"],
+		},
+		output: {
+			encoding: "application/json",
+			schema: {
+				type: "object",
+				properties: {
+					cursor: { type: "string" },
+					hitsTotal: { type: "integer" },
+					posts: {
+						type: "array",
+						items: { type: "ref", ref: "app.bsky.feed.defs#postView" },
+						required: true,
+					},
+				},
+				required: ["posts"],
+			},
+		},
+		errors: [{ name: "BadQueryString" }],
+	});
+});
+
+test("lx.procedure() basic", () => {
+	const result = lx.procedure();
+	expect(result).toEqual({ type: "procedure" });
+});
+
+test("lx.procedure() with description", () => {
+	const result = lx.procedure({ description: "Create a new post" });
+	expect(result).toEqual({
+		type: "procedure",
+		description: "Create a new post",
+	});
+});
+
+test("lx.procedure() with parameters", () => {
+	const result = lx.procedure({
+		parameters: lx.params({
+			validate: lx.boolean({ default: true }),
+		}),
+	});
+	expect(result).toEqual({
+		type: "procedure",
+		parameters: {
+			type: "params",
+			properties: {
+				validate: { type: "boolean", default: true },
+			},
+		},
+	});
+});
+
+test("lx.procedure() with input", () => {
+	const result = lx.procedure({
+		input: {
+			encoding: "application/json",
+			schema: lx.object({
+				text: lx.string({ required: true, maxGraphemes: 300 }),
+				createdAt: lx.string({ format: "datetime" }),
+			}),
+		},
+	});
+	expect(result).toEqual({
+		type: "procedure",
+		input: {
+			encoding: "application/json",
+			schema: {
+				type: "object",
+				properties: {
+					text: { type: "string", required: true, maxGraphemes: 300 },
+					createdAt: { type: "string", format: "datetime" },
+				},
+				required: ["text"],
+			},
+		},
+	});
+});
+
+test("lx.procedure() with output", () => {
+	const result = lx.procedure({
+		output: {
+			encoding: "application/json",
+			schema: lx.object({
+				uri: lx.string({ required: true }),
+				cid: lx.string({ required: true }),
+			}),
+		},
+	});
+	expect(result).toEqual({
+		type: "procedure",
+		output: {
+			encoding: "application/json",
+			schema: {
+				type: "object",
+				properties: {
+					uri: { type: "string", required: true },
+					cid: { type: "string", required: true },
+				},
+				required: ["uri", "cid"],
+			},
+		},
+	});
+});
+
+test("lx.procedure() with errors", () => {
+	const result = lx.procedure({
+		errors: [
+			{ name: "InvalidRequest" },
+			{ name: "RateLimitExceeded", description: "Too many requests" },
+		],
+	});
+	expect(result).toEqual({
+		type: "procedure",
+		errors: [
+			{ name: "InvalidRequest" },
+			{ name: "RateLimitExceeded", description: "Too many requests" },
+		],
+	});
+});
+
+test("lx.procedure() real-world example: createPost", () => {
+	const result = lx.procedure({
+		description: "Create a post",
+		input: {
+			encoding: "application/json",
+			schema: lx.object({
+				repo: lx.string({ required: true }),
+				collection: lx.string({ required: true }),
+				record: lx.unknown({ required: true }),
+				validate: lx.boolean({ default: true }),
+			}),
+		},
+		output: {
+			encoding: "application/json",
+			schema: lx.object({
+				uri: lx.string({ required: true }),
+				cid: lx.string({ required: true }),
+			}),
+		},
+		errors: [{ name: "InvalidSwap" }, { name: "InvalidRecord" }],
+	});
+	expect(result).toEqual({
+		type: "procedure",
+		description: "Create a post",
+		input: {
+			encoding: "application/json",
+			schema: {
+				type: "object",
+				properties: {
+					repo: { type: "string", required: true },
+					collection: { type: "string", required: true },
+					record: { type: "unknown", required: true },
+					validate: { type: "boolean", default: true },
+				},
+				required: ["repo", "collection", "record"],
+			},
+		},
+		output: {
+			encoding: "application/json",
+			schema: {
+				type: "object",
+				properties: {
+					uri: { type: "string", required: true },
+					cid: { type: "string", required: true },
+				},
+				required: ["uri", "cid"],
+			},
+		},
+		errors: [{ name: "InvalidSwap" }, { name: "InvalidRecord" }],
+	});
+});
+
+test("lx.subscription() basic", () => {
+	const result = lx.subscription();
+	expect(result).toEqual({ type: "subscription" });
+});
+
+test("lx.subscription() with description", () => {
+	const result = lx.subscription({
+		description: "Repository event stream",
+	});
+	expect(result).toEqual({
+		type: "subscription",
+		description: "Repository event stream",
+	});
+});
+
+test("lx.subscription() with parameters", () => {
+	const result = lx.subscription({
+		parameters: lx.params({
+			cursor: lx.integer(),
+		}),
+	});
+	expect(result).toEqual({
+		type: "subscription",
+		parameters: {
+			type: "params",
+			properties: {
+				cursor: { type: "integer" },
+			},
+		},
+	});
+});
+
+test("lx.subscription() with message", () => {
+	const result = lx.subscription({
+		message: {
+			schema: lx.union(["#commit", "#identity", "#account"]),
+		},
+	});
+	expect(result).toEqual({
+		type: "subscription",
+		message: {
+			schema: {
+				type: "union",
+				refs: ["#commit", "#identity", "#account"],
+			},
+		},
+	});
+});
+
+test("lx.subscription() with message description", () => {
+	const result = lx.subscription({
+		message: {
+			description: "Event message types",
+			schema: lx.union(["#commit", "#handle", "#migrate"]),
+		},
+	});
+	expect(result).toEqual({
+		type: "subscription",
+		message: {
+			description: "Event message types",
+			schema: {
+				type: "union",
+				refs: ["#commit", "#handle", "#migrate"],
+			},
+		},
+	});
+});
+
+test("lx.subscription() with errors", () => {
+	const result = lx.subscription({
+		errors: [
+			{ name: "FutureCursor" },
+			{ name: "ConsumerTooSlow", description: "Consumer is too slow" },
+		],
+	});
+	expect(result).toEqual({
+		type: "subscription",
+		errors: [
+			{ name: "FutureCursor" },
+			{ name: "ConsumerTooSlow", description: "Consumer is too slow" },
+		],
+	});
+});
+
+test("lx.subscription() real-world example: subscribeRepos", () => {
+	const result = lx.subscription({
+		description: "Repository event stream, aka Firehose endpoint",
+		parameters: lx.params({
+			cursor: lx.integer(),
+		}),
+		message: {
+			description: "Represents an update of repository state",
+			schema: lx.union([
+				"#commit",
+				"#identity",
+				"#account",
+				"#handle",
+				"#migrate",
+				"#tombstone",
+				"#info",
+			]),
+		},
+		errors: [{ name: "FutureCursor" }, { name: "ConsumerTooSlow" }],
+	});
+	expect(result).toEqual({
+		type: "subscription",
+		description: "Repository event stream, aka Firehose endpoint",
+		parameters: {
+			type: "params",
+			properties: {
+				cursor: {
+					type: "integer",
+				},
+			},
+		},
+		message: {
+			description: "Represents an update of repository state",
+			schema: {
+				type: "union",
+				refs: [
+					"#commit",
+					"#identity",
+					"#account",
+					"#handle",
+					"#migrate",
+					"#tombstone",
+					"#info",
+				],
+			},
+		},
+		errors: [{ name: "FutureCursor" }, { name: "ConsumerTooSlow" }],
+	});
+});

packages/prototypey/tsconfig.json

···
+{
+	"compilerOptions": {
+		"declaration": true,
+		"declarationMap": true,
+		"esModuleInterop": true,
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+		"noEmit": true,
+		"resolveJsonModule": true,
+		"noErrorTruncation": true,
+		"skipLibCheck": true,
+		"strict": true,
+		"target": "ES2022",
+		"allowImportingTsExtensions": true
+	},
+	"include": ["src", "tests"]
+}

packages/prototypey/tsdown.config.ts

···
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+	dts: true,
+	entry: ["src/index.ts"],
+	outDir: "lib",
+	unbundle: true,
+});

packages/prototypey/vitest.config.ts

···
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		include: ["tests/*.test.ts"],
+		globalSetup: ["setup-vitest.ts"],
+	},
+});

pnpm-lock.yaml

···
 importers:
 
   .:
+    devDependencies:
+      '@eslint/js':
+        specifier: 9.29.0
+        version: 9.29.0
+      eslint:
+        specifier: 9.29.0
+        version: 9.29.0(jiti@2.6.1)
+      prettier:
+        specifier: 3.6.1
+        version: 3.6.1
+      typescript-eslint:
+        specifier: 8.35.0
+        version: 8.35.0(eslint@9.29.0(jiti@2.6.1))(typescript@5.8.3)
+
+  packages/cli:
     dependencies:
+      prototypey:
+        specifier: workspace:*
+        version: link:../prototypey
       sade:
         specifier: ^1.8.1
         version: 1.8.1
···
         specifier: ^0.2.15
         version: 0.2.15
     devDependencies:
+      '@types/node':
+        specifier: 24.0.4
+        version: 24.0.4
+      tsdown:
+        specifier: 0.12.7
+        version: 0.12.7(typescript@5.8.3)
+      typescript:
+        specifier: 5.8.3
+        version: 5.8.3
+
+  packages/prototypey:
+    devDependencies:
       '@ark/attest':
         specifier: ^0.49.0
         version: 0.49.0(typescript@5.8.3)
-      '@eslint/js':
-        specifier: 9.29.0
-        version: 9.29.0
       '@types/node':
         specifier: 24.0.4
         version: 24.0.4
-      eslint:
-        specifier: 9.29.0
-        version: 9.29.0(jiti@2.6.1)
-      prettier:
-        specifier: 3.6.1
-        version: 3.6.1
       tsdown:
         specifier: 0.12.7
         version: 0.12.7(typescript@5.8.3)
       typescript:
         specifier: 5.8.3
         version: 5.8.3
-      typescript-eslint:
-        specifier: 8.35.0
-        version: 8.35.0(eslint@9.29.0(jiti@2.6.1))(typescript@5.8.3)
       vitest:
         specifier: ^3.2.4
         version: 3.2.4(@types/node@24.0.4)(jiti@2.6.1)

pnpm-workspace.yaml

···
+packages:
+  - 'packages/*'