cleanup old files

.gitignore

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

aislop/plan-emit.md

···
 
 ```json
 {
-  "bin": {
-    "prototypey": "./lib/cli/index.js"
-  },
-  "scripts": {
-    "codegen": "prototypey gen-inferred ./generated/inferred ./lexicons/**/*.json"
-  }
+	"bin": {
+		"prototypey": "./lib/cli/index.js"
+	},
+	"scripts": {
+		"codegen": "prototypey gen-inferred ./generated/inferred ./lexicons/**/*.json"
+	}
 }
 ```
 
···
 
 ```typescript
 // Example output: generated/inferred/app/bsky/feed/post.ts
-import type { Infer } from 'prototypey'
-import schema from '../../../../lexicons/app/bsky/feed/post.json' with { type: 'json' }
+import type { Infer } from "prototypey";
+import schema from "../../../../lexicons/app/bsky/feed/post.json" with { type: "json" };
 
-export type Post = Infer<typeof schema>
+export type Post = Infer<typeof schema>;
 
 // Minimal runtime helpers
-export const PostSchema = schema
+export const PostSchema = schema;
 export const isPost = (v: unknown): v is Post => {
-  return typeof v === 'object' && v !== null && '$type' in v &&
-    v.$type === 'app.bsky.feed.post'
-}
+	return (
+		typeof v === "object" &&
+		v !== null &&
+		"$type" in v &&
+		v.$type === "app.bsky.feed.post"
+	);
+};
 ```
 
 Benefits:
···
 
 ```json
 {
-  "dependencies": {
-    "@atproto/lexicon": "^0.3.0"
-  },
-  "devDependencies": {
-    "@atproto/lex-cli": "^0.9.1",
-    "commander": "^12.0.0",
-    "glob": "^10.0.0"
-  },
-  "peerDependencies": {
-    "typescript": ">=5.0.0"
-  }
+	"dependencies": {
+		"@atproto/lexicon": "^0.3.0"
+	},
+	"devDependencies": {
+		"@atproto/lex-cli": "^0.9.1",
+		"commander": "^12.0.0",
+		"glob": "^10.0.0"
+	},
+	"peerDependencies": {
+		"typescript": ">=5.0.0"
+	}
 }
 ```
 
···
 
 ```json
 {
-  "scripts": {
-    "build": "tsdown",
-    "build:cli": "tsdown --entry src/cli/index.ts --format esm --dts false",
-    "codegen:samples": "prototypey gen-inferred ./generated/samples ./samples/*.json",
-    "prepack": "pnpm build && pnpm build:cli"
-  }
+	"scripts": {
+		"build": "tsdown",
+		"build:cli": "tsdown --entry src/cli/index.ts --format esm --dts false",
+		"codegen:samples": "prototypey gen-inferred ./generated/samples ./samples/*.json",
+		"prepack": "pnpm build && pnpm build:cli"
+	}
 }
 ```
 
···
 
 ```json
 {
-  "lexicons": "./lexicons",
-  "output": {
-    "inferred": "./generated/inferred",
-    "types": "./generated/types"
-  },
-  "include": ["**/*.json"],
-  "exclude": ["**/node_modules/**"]
+	"lexicons": "./lexicons",
+	"output": {
+		"inferred": "./generated/inferred",
+		"types": "./generated/types"
+	},
+	"include": ["**/*.json"],
+	"exclude": ["**/node_modules/**"]
 }
 ```
 
···
 
 1. ✅ **Phase 1**: Basic CLI structure + Track B (inferred generation) - COMPLETE
 2. ✅ **Phase 2**: File organization + output directory structure - COMPLETE
-3. ✅ **Phase 3**: Convert to pnpm workspaces monorepo - COMPLETE
+3. ✅ **Phase 3**: Convert to pnpm workspaces monorepo - COMPLETE - this was marked complete but we still have src and packages
 4. **Phase 4**: Track A (standard generation, delegate to lex-cli)
 5. **Phase 5**: Configuration file support
 6. **Phase 6**: Documentation + examples
···
 ### ✅ Completed (2025-10-16)
 
 **Tech Stack Choices:**
+
 - Used `sade` instead of `commander` (modern, minimal CLI framework from awesome-e18e)
 - Used `tinyglobby` instead of `glob` (faster, modern alternative)
 - Built with `tsdown` for CLI bundling
 
 **Structure Created:**
+
 ```
 prototypey/
 ├── src/cli/
···
 ```
 
 **Generated Code Pattern:**
+
 ```typescript
 // generated/inferred/app/bsky/actor/profile.ts
 import type { Infer } from "prototypey";
···
 ```
 
 **CLI Usage:**
+
 ```bash
 # Build CLI
 pnpm build:cli
···
 ```
 
 **Key Features:**
+
 - Converts NSID to file paths: `app.bsky.feed.post` → `app/bsky/feed/post.ts`
 - Generates minimal runtime code with type inference
 - Auto-creates directory structure
···
 - Type guard functions for runtime checks
 
 **Testing:**
+
 - Successfully generated types from sample lexicons
 - Runtime validation works (tested with node)
 - Schema imports work correctly with JSON modules
···
 ### Package Configurations
 
 **Root `pnpm-workspace.yaml`:**
+
 ```yaml
 packages:
-  - '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"
-  }
+	"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"
-  }
+	"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"
-  }
+	"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"
+	}
 }
 ```
 
···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import { ValidationResult, BlobRef } from '@atproto/lexicon'
-import { lexicons } from '../../../../lexicons'
-import { isObj, hasProp } from '../../../../util'
-import { CID } from 'multiformats/cid'
+import { ValidationResult, BlobRef } from "@atproto/lexicon";
+import { lexicons } from "../../../../lexicons";
+import { isObj, hasProp } from "../../../../util";
+import { CID } from "multiformats/cid";
 
 export interface Main {
-  $type?: 'app.bsky.richtext.facet'
-  index: ByteSlice
-  features: (Mention | Link | Tag | { $type: string; [k: string]: unknown })[]
-  [k: string]: unknown
+	$type?: "app.bsky.richtext.facet";
+	index: ByteSlice;
+	features: (Mention | Link | Tag | { $type: string; [k: string]: unknown })[];
+	[k: string]: unknown;
 }
 
 export function isMain(v: unknown): v is Main {
-  return (
-    isObj(v) &&
-    hasProp(v, '$type') &&
-    (v.$type === 'app.bsky.richtext.facet#main' ||
-      v.$type === 'app.bsky.richtext.facet')
-  )
+	return (
+		isObj(v) &&
+		hasProp(v, "$type") &&
+		(v.$type === "app.bsky.richtext.facet#main" ||
+			v.$type === "app.bsky.richtext.facet")
+	);
 }
 
 export function validateMain(v: unknown): ValidationResult {
-  return lexicons.validate('app.bsky.richtext.facet#main', v)
+	return lexicons.validate("app.bsky.richtext.facet#main", v);
 }
 ```
 
···
 
 ```json
 {
-  "scripts": {
-    "codegen": "lex gen-api --yes ./src/client ../../lexicons/com/atproto/*/* ../../lexicons/app/bsky/*/*",
-    "build": "tsc --build tsconfig.build.json"
-  },
-  "devDependencies": {
-    "@atproto/lex-cli": "^0.9.1"
-  }
+	"scripts": {
+		"codegen": "lex gen-api --yes ./src/client ../../lexicons/com/atproto/*/* ../../lexicons/app/bsky/*/*",
+		"build": "tsc --build tsconfig.build.json"
+	},
+	"devDependencies": {
+		"@atproto/lex-cli": "^0.9.1"
+	}
 }
 ```
 

src/cli/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}`);
-}

src/cli/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);

src/cli/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("");
-}

src/index.ts

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

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
-	>;

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,
-		});
-	},
-};

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];
-} & {};

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,
-						},
-					},
-				},
-			},
-		},
-	});
-});

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");
-});

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");
-});

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"]);

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
-}`);
-});

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" }],
-	});
-});