remove gen-inferred

this will be back later, but the initial take on it
is way wrong

package.json

···
 	},
 	"scripts": {
 		"build": "pnpm -r build",
-		"codegen:samples": "node packages/cli/src/index.ts gen-inferred ./generated/inferred './samples/*.json'",
 		"format": "prettier . --list-different",
 		"format:fix": "prettier . --write",
 		"lint": "pnpm -r lint",

packages/cli/README.md

···
 
 ## Commands
 
-### `gen-inferred`
-
-Generate type-inferred TypeScript code from JSON lexicon schemas.
-
-**Usage:**
-
-```bash
-prototypey gen-inferred <outdir> <schemas...>
-```
-
-**Arguments:**
-
-- `outdir` - Output directory for generated TypeScript files
-- `schemas...` - One or more glob patterns matching lexicon JSON schema files
-
-**Example:**
-
-```bash
-prototypey gen-inferred ./generated/inferred ./lexicons/**/*.json
-```
-
-**What it does:**
-
-- Reads ATProto lexicon JSON schemas
-- Generates TypeScript types that match the schema structure
-- Organizes output files by namespace (e.g., `app.bsky.feed.post` → `app/bsky/feed/post.ts`)
-- Provides typescript definitions of the lexicons for inference and later: validation
-
 ### `gen-emit`
 
 Emit JSON lexicon schemas from authored TypeScript files.
···
 
 1. **Author lexicons in TypeScript** using the `prototypey` library
 2. **Emit to JSON** with `gen-emit` for runtime validation and API contracts
-3. **Generate inferred types** with `gen-inferred` for consuming code
 
 ```bash
 # Write your lexicons in TypeScript
···
 
 # Emit JSON schemas
 prototypey gen-emit ./schemas ./src/lexicons/**/*.ts
-
-# Generate TypeScript types from schemas
-prototypey gen-inferred ./generated ./schemas/**/*.json
 ```
 
 ## Requirements

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

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

packages/cli/src/index.ts

···
 import { readFile } from "node:fs/promises";
 import sade from "sade";
-import { genInferred } from "./commands/gen-inferred.ts";
 import { genEmit } from "./commands/gen-emit.ts";
 
 const pkg = JSON.parse(
···
 const prog = sade("prototypey");
 
 prog.version(pkg.version).describe("atproto lexicon typescript toolkit");
-
-prog
-	.command("gen-inferred <outdir> <schemas...>")
-	.describe("Generate type-inferred code from lexicon schemas")
-	.example("gen-inferred ./generated/inferred ./lexicons/**/*.json")
-	.action(genInferred);
 
 prog
 	.command("gen-emit <outdir> <sources...>")

packages/cli/src/templates/inferred.ts

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

packages/cli/tests/commands/gen-inferred.test.ts

···
-import { expect, test, describe, beforeEach, afterEach } from "vitest";
-import { mkdir, writeFile, rm, readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { genInferred } from "../../src/commands/gen-inferred.ts";
-import { tmpdir } from "node:os";
-
-describe("genInferred", () => {
-	let testDir: string;
-	let outDir: string;
-	let schemasDir: string;
-
-	beforeEach(async () => {
-		// Create a temporary directory for test files
-		testDir = join(tmpdir(), `prototypey-inferred-test-${Date.now()}`);
-		outDir = join(testDir, "output");
-		schemasDir = join(testDir, "schemas");
-		await mkdir(testDir, { recursive: true });
-		await mkdir(outDir, { recursive: true });
-		await mkdir(schemasDir, { recursive: true });
-	});
-
-	afterEach(async () => {
-		// Clean up test directory
-		await rm(testDir, { recursive: true, force: true });
-	});
-
-	test("generates inferred types from a simple schema", async () => {
-		// Create a test schema file
-		const schemaFile = join(schemasDir, "app.bsky.actor.profile.json");
-		await writeFile(
-			schemaFile,
-			JSON.stringify(
-				{
-					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,
-									},
-								},
-							},
-						},
-					},
-				},
-				null,
-				"\t",
-			),
-		);
-
-		// Run the inferred command
-		await genInferred(outDir, schemaFile);
-
-		// Read the generated TypeScript file
-		const outputFile = join(outDir, "app/bsky/actor/profile.ts");
-		const content = await readFile(outputFile, "utf-8");
-
-		// Verify the generated code structure
-		expect(content).toContain("// Generated by prototypey - DO NOT EDIT");
-		expect(content).toContain("// Source: app.bsky.actor.profile");
-		expect(content).toContain('import type { Infer } from "prototypey"');
-		expect(content).toContain('with { type: "json" }');
-		expect(content).toContain("export type Profile = Infer<typeof schema>");
-		expect(content).toContain("export const ProfileSchema = schema");
-		expect(content).toContain(
-			"export function isProfile(v: unknown): v is Profile",
-		);
-		expect(content).toContain('v.$type === "app.bsky.actor.profile"');
-	});
-
-	test("generates correct directory structure from NSID", async () => {
-		// Create a test schema with nested NSID
-		const schemaFile = join(schemasDir, "app.bsky.feed.post.json");
-		await writeFile(
-			schemaFile,
-			JSON.stringify({
-				lexicon: 1,
-				id: "app.bsky.feed.post",
-				defs: {
-					main: {
-						type: "record",
-						key: "tid",
-						record: {
-							type: "object",
-							properties: {
-								text: { type: "string" },
-							},
-						},
-					},
-				},
-			}),
-		);
-
-		await genInferred(outDir, schemaFile);
-
-		// Verify the directory structure matches NSID
-		const outputFile = join(outDir, "app/bsky/feed/post.ts");
-		const content = await readFile(outputFile, "utf-8");
-
-		expect(content).toBeTruthy();
-		expect(content).toContain("export type Post = Infer<typeof schema>");
-	});
-
-	test("handles multiple schema files with glob patterns", async () => {
-		// Create multiple schema files
-		await writeFile(
-			join(schemasDir, "app.bsky.actor.profile.json"),
-			JSON.stringify({
-				lexicon: 1,
-				id: "app.bsky.actor.profile",
-				defs: { main: { type: "record" } },
-			}),
-		);
-
-		await writeFile(
-			join(schemasDir, "app.bsky.feed.post.json"),
-			JSON.stringify({
-				lexicon: 1,
-				id: "app.bsky.feed.post",
-				defs: { main: { type: "record" } },
-			}),
-		);
-
-		// Run with glob pattern
-		await genInferred(outDir, `${schemasDir}/*.json`);
-
-		// Verify both files were created
-		const profileContent = await readFile(
-			join(outDir, "app/bsky/actor/profile.ts"),
-			"utf-8",
-		);
-		const postContent = await readFile(
-			join(outDir, "app/bsky/feed/post.ts"),
-			"utf-8",
-		);
-
-		expect(profileContent).toContain("export type Profile");
-		expect(postContent).toContain("export type Post");
-	});
-
-	test("generates correct relative import path", async () => {
-		// Create a deeply nested schema
-		const schemaFile = join(schemasDir, "com.atproto.repo.createRecord.json");
-		await writeFile(
-			schemaFile,
-			JSON.stringify({
-				lexicon: 1,
-				id: "com.atproto.repo.createRecord",
-				defs: {
-					main: {
-						type: "procedure",
-						input: { encoding: "application/json" },
-					},
-				},
-			}),
-		);
-
-		await genInferred(outDir, schemaFile);
-
-		// Read generated file and check the import path is relative
-		const outputFile = join(outDir, "com/atproto/repo/createRecord.ts");
-		const content = await readFile(outputFile, "utf-8");
-
-		// The import should be relative to the generated file location
-		expect(content).toContain('import schema from "');
-		expect(content).toContain('.json" with { type: "json" }');
-		// Should navigate up from com/atproto/repo/ to schemas/
-		expect(content).toMatch(/import schema from ".*createRecord\.json"/);
-	});
-
-	test("generates proper type name from NSID", async () => {
-		// Test various NSID formats
-		const testCases = [
-			{ id: "app.bsky.feed.post", expectedType: "Post" },
-			{ id: "com.atproto.repo.createRecord", expectedType: "CreateRecord" },
-			{ id: "app.bsky.actor.profile", expectedType: "Profile" },
-			{
-				id: "app.bsky.feed.searchPosts",
-				expectedType: "SearchPosts",
-			},
-		];
-
-		for (const { id, expectedType } of testCases) {
-			const schemaFile = join(schemasDir, `${id}.json`);
-			await writeFile(
-				schemaFile,
-				JSON.stringify({
-					lexicon: 1,
-					id,
-					defs: { main: { type: "record" } },
-				}),
-			);
-
-			const testOutDir = join(testDir, `out-${id}`);
-			await mkdir(testOutDir, { recursive: true });
-			await genInferred(testOutDir, schemaFile);
-
-			const nsidParts = id.split(".");
-			const outputFile = join(testOutDir, ...nsidParts) + ".ts";
-			const content = await readFile(outputFile, "utf-8");
-
-			expect(content).toContain(`export type ${expectedType}`);
-			expect(content).toContain(`export const ${expectedType}Schema`);
-			expect(content).toContain(`export function is${expectedType}`);
-		}
-	});
-
-	test("handles schema without id gracefully", async () => {
-		// Create an invalid schema without id
-		const schemaFile = join(schemasDir, "invalid.json");
-		await writeFile(
-			schemaFile,
-			JSON.stringify({
-				lexicon: 1,
-				defs: { main: { type: "record" } },
-			}),
-		);
-
-		// Should not throw, but should skip the file
-		await expect(genInferred(outDir, schemaFile)).resolves.not.toThrow();
-
-		// Output directory should be empty or not contain generated files
-		const files = await readFile(outDir, "utf-8").catch(() => null);
-		expect(files).toBeNull();
-	});
-
-	test("handles schema without defs gracefully", async () => {
-		// Create an invalid schema without defs
-		const schemaFile = join(schemasDir, "invalid2.json");
-		await writeFile(
-			schemaFile,
-			JSON.stringify({
-				lexicon: 1,
-				id: "app.test.invalid",
-			}),
-		);
-
-		// Should not throw, but should skip the file
-		await expect(genInferred(outDir, schemaFile)).resolves.not.toThrow();
-	});
-
-	test("processes array of schema patterns", async () => {
-		// Create schemas in different directories
-		const schemasDir1 = join(testDir, "schemas1");
-		const schemasDir2 = join(testDir, "schemas2");
-		await mkdir(schemasDir1, { recursive: true });
-		await mkdir(schemasDir2, { recursive: true });
-
-		await writeFile(
-			join(schemasDir1, "app.one.json"),
-			JSON.stringify({
-				lexicon: 1,
-				id: "app.one",
-				defs: { main: { type: "record" } },
-			}),
-		);
-
-		await writeFile(
-			join(schemasDir2, "app.two.json"),
-			JSON.stringify({
-				lexicon: 1,
-				id: "app.two",
-				defs: { main: { type: "record" } },
-			}),
-		);
-
-		// Run with array of patterns
-		await genInferred(outDir, [
-			`${schemasDir1}/*.json`,
-			`${schemasDir2}/*.json`,
-		]);
-
-		// Verify both were generated
-		const oneContent = await readFile(join(outDir, "app/one.ts"), "utf-8");
-		const twoContent = await readFile(join(outDir, "app/two.ts"), "utf-8");
-
-		expect(oneContent).toContain("export type One");
-		expect(twoContent).toContain("export type Two");
-	});
-
-	test("generates code with all required components", async () => {
-		// Create a comprehensive schema
-		const schemaFile = join(schemasDir, "app.test.complete.json");
-		await writeFile(
-			schemaFile,
-			JSON.stringify({
-				lexicon: 1,
-				id: "app.test.complete",
-				defs: {
-					main: {
-						type: "record",
-						key: "tid",
-						record: {
-							type: "object",
-							required: ["text"],
-							properties: {
-								text: { type: "string", maxLength: 300 },
-								tags: { type: "array", items: { type: "string" } },
-							},
-						},
-					},
-				},
-			}),
-		);
-
-		await genInferred(outDir, schemaFile);
-
-		const outputFile = join(outDir, "app/test/complete.ts");
-		const content = await readFile(outputFile, "utf-8");
-
-		// Check all required exports
-		expect(content).toContain('import type { Infer } from "prototypey"');
-		expect(content).toContain("export type Complete = Infer<typeof schema>");
-		expect(content).toContain("export const CompleteSchema = schema");
-		expect(content).toContain(
-			"export function isComplete(v: unknown): v is Complete",
-		);
-
-		// Check type guard implementation
-		expect(content).toContain('typeof v === "object"');
-		expect(content).toContain("v !== null");
-		expect(content).toContain('"$type" in v');
-		expect(content).toContain('v.$type === "app.test.complete"');
-
-		// Check comments
-		expect(content).toContain("// Generated by prototypey - DO NOT EDIT");
-		expect(content).toContain("// Source: app.test.complete");
-		expect(content).toContain(
-			"* Type-inferred from lexicon schema: app.test.complete",
-		);
-		expect(content).toContain("* The lexicon schema object");
-		expect(content).toContain("* Type guard to check if a value is a Complete");
-	});
-
-	test("handles kebab-case and mixed-case NSID parts", async () => {
-		// Test NSID with different casing
-		const schemaFile = join(schemasDir, "app.test.myCustomType.json");
-		await writeFile(
-			schemaFile,
-			JSON.stringify({
-				lexicon: 1,
-				id: "app.test.myCustomType",
-				defs: { main: { type: "record" } },
-			}),
-		);
-
-		await genInferred(outDir, schemaFile);
-
-		const outputFile = join(outDir, "app/test/myCustomType.ts");
-		const content = await readFile(outputFile, "utf-8");
-
-		// Should convert to PascalCase
-		expect(content).toContain("export type MyCustomType");
-		expect(content).toContain("export const MyCustomTypeSchema");
-		expect(content).toContain("export function isMyCustomType");
-	});
-});

packages/cli/tests/integration/cli.test.ts

···
 		expect(stdout).toContain(`prototypey, ${pkg.version}`);
 	});
 
-	test("shows help for gen-inferred command", async () => {
-		const { stdout, stderr } = await runCLI(["gen-inferred", "--help"]);
-		expect(stderr).toBe("");
-		expect(stdout).toContain("gen-inferred <outdir> <schemas...>");
-		expect(stdout).toContain(
-			"Generate type-inferred code from lexicon schemas",
-		);
-	});
-
 	test("shows help for gen-emit command", async () => {
 		const { stdout, stderr } = await runCLI(["gen-emit", "--help"]);
 		expect(stderr).toBe("");
···
 		expect(code).toBe(1);
 		expect(stderr).toContain("Invalid command: unknown-command");
 		expect(stderr).toContain("Run `$ prototypey --help` for more info");
-	});
-
-	test("handles missing arguments", async () => {
-		const { stdout, stderr, code } = await runCLI(["gen-inferred"]);
-		expect(code).toBe(1);
-		expect(stderr).toContain("Insufficient arguments!");
-		expect(stderr).toContain(
-			"Run `$ prototypey gen-inferred --help` for more info",
-		);
 	});
 });

packages/cli/tests/integration/error-handling.test.ts

···
 		await rm(testDir, { recursive: true, force: true });
 	});
 
-	test("handles non-existent schema files gracefully", async () => {
-		const { stdout, stderr, code } = await runCLI([
-			"gen-inferred",
-			outDir,
-			join(schemasDir, "non-existent.json"),
-		]);
-
-		expect(code).toBe(0); // Should not crash
-		expect(stdout).toContain("No schema files found matching patterns");
-		expect(stderr).toBe("");
-	});
-
-	test("handles invalid JSON schema files", async () => {
-		// Create an invalid JSON file
-		const invalidSchema = join(schemasDir, "invalid.json");
-		await writeFile(invalidSchema, "not valid json");
-
-		const { stdout, stderr, code } = await runCLI([
-			"gen-inferred",
-			outDir,
-			invalidSchema,
-		]);
-
-		expect(code).toBe(1); // Should exit with error
-		expect(stderr).toContain("Error generating inferred types");
-	});
-
-	test("handles schema files with missing id", async () => {
-		// Create a schema with missing id
-		const schemaFile = join(schemasDir, "missing-id.json");
-		await writeFile(
-			schemaFile,
-			JSON.stringify({
-				lexicon: 1,
-				defs: { main: { type: "record" } },
-			}),
-		);
-
-		const { stdout, stderr, code } = await runCLI([
-			"gen-inferred",
-			outDir,
-			schemaFile,
-		]);
-
-		expect(code).toBe(0); // Should not crash
-		expect(stdout).toContain("Found 1 schema file(s)");
-		expect(stdout).toContain("Generated inferred types in");
-		// Should skip the invalid file silently
-	});
-
-	test("handles schema files with missing defs", async () => {
-		// Create a schema with missing defs
-		const schemaFile = join(schemasDir, "missing-defs.json");
-		await writeFile(
-			schemaFile,
-			JSON.stringify({
-				lexicon: 1,
-				id: "app.test.missing",
-			}),
-		);
-
-		const { stdout, stderr, code } = await runCLI([
-			"gen-inferred",
-			outDir,
-			schemaFile,
-		]);
-
-		expect(code).toBe(0); // Should not crash
-		expect(stdout).toContain("Found 1 schema file(s)");
-		expect(stdout).toContain("Generated inferred types in");
-		// Should skip the invalid file silently
-	});
-
 	test("handles non-existent source files for gen-emit", async () => {
 		const { stdout, stderr, code } = await runCLI([
 			"gen-emit",
···
 		expect(code).toBe(0); // Should not crash
 		expect(stdout).toContain("Found 1 source file(s)");
 		expect(stderr).toContain("No lexicons found");
-	});
-
-	test("handles permission errors when writing output", async () => {
-		// This test might be platform-specific, so we'll make it lenient
-		// Create a schema file first
-		const schemaFile = join(schemasDir, "test.json");
-		await writeFile(
-			schemaFile,
-			JSON.stringify({
-				lexicon: 1,
-				id: "app.test.permission",
-				defs: { main: { type: "record" } },
-			}),
-		);
-
-		// Try to write to a directory that might have permission issues
-		// We'll use a path that likely won't exist and is invalid
-		const invalidOutDir = "/invalid/path/that/does/not/exist";
-
-		const { stdout, stderr, code } = await runCLI([
-			"gen-inferred",
-			invalidOutDir,
-			schemaFile,
-		]);
-
-		// Should handle the error gracefully
-		expect(code).toBe(1);
-		expect(stderr).toContain("Error generating inferred types");
 	});
 });

packages/cli/tests/integration/filesystem.test.ts

···
 			// Ignore cleanup errors
 		}
 	});
-
-	test("creates nested output directories when they don't exist", async () => {
-		// Create a schema file
-		const schemaFile = join(schemasDir, "test.json");
-		await writeFile(
-			schemaFile,
-			JSON.stringify({
-				lexicon: 1,
-				id: "app.deeply.nested.schema",
-				defs: { main: { type: "record" } },
-			}),
-		);
-
-		// Use a deeply nested output directory that doesn't exist
-		const deepOutDir = join(outDir, "very", "deeply", "nested", "path");
-
-		const { stdout, stderr, code } = await runCLI([
-			"gen-inferred",
-			deepOutDir,
-			schemaFile,
-		]);
-
-		expect(code).toBe(0);
-		expect(stderr).toBe("");
-		expect(stdout).toContain(
-			"app.deeply.nested.schema -> app/deeply/nested/schema.ts",
-		);
-
-		// Verify the file was created in the deeply nested path
-		const generatedFile = join(deepOutDir, "app/deeply/nested/schema.ts");
-		await access(generatedFile, constants.F_OK);
-	});
-
-	test("handles special characters in NSID correctly", async () => {
-		// Create a schema with special characters in the name
-		const schemaFile = join(schemasDir, "special.json");
-		await writeFile(
-			schemaFile,
-			JSON.stringify({
-				lexicon: 1,
-				id: "app.test.special-name_with.mixedChars123",
-				defs: { main: { type: "record" } },
-			}),
-		);
-
-		const { stdout, stderr, code } = await runCLI([
-			"gen-inferred",
-			outDir,
-			schemaFile,
-		]);
-
-		expect(code).toBe(0);
-		expect(stderr).toBe("");
-		// Should convert to proper PascalCase
-		expect(stdout).toContain(
-			"app.test.special-name_with.mixedChars123 -> app/test/special-name_with/mixedChars123.ts",
-		);
-	});
-
-	test("handles very long NSID paths", async () => {
-		// Create a schema with a very long NSID
-		const longNSID = "com." + "verylongdomainname.".repeat(10) + "test";
-		const schemaFile = join(schemasDir, "long.json");
-		await writeFile(
-			schemaFile,
-			JSON.stringify({
-				lexicon: 1,
-				id: longNSID,
-				defs: { main: { type: "record" } },
-			}),
-		);
-
-		const { stdout, stderr, code } = await runCLI([
-			"gen-inferred",
-			outDir,
-			schemaFile,
-		]);
-
-		expect(code).toBe(0);
-		expect(stderr).toBe("");
-		expect(stdout).toContain(`Found 1 schema file(s)`);
-	});
-
-	test("handles existing files gracefully", async () => {
-		// Create a schema file
-		const schemaFile = join(schemasDir, "test.json");
-		await writeFile(
-			schemaFile,
-			JSON.stringify({
-				lexicon: 1,
-				id: "app.test.overwrite",
-				defs: { main: { type: "record" } },
-			}),
-		);
-
-		// Run CLI once
-		await runCLI(["gen-inferred", outDir, schemaFile]);
-
-		// Verify file exists
-		const generatedFile = join(outDir, "app/test/overwrite.ts");
-		await access(generatedFile, constants.F_OK);
-
-		// Run CLI again (should overwrite)
-		const { stdout, stderr, code } = await runCLI([
-			"gen-inferred",
-			outDir,
-			schemaFile,
-		]);
-
-		expect(code).toBe(0);
-		expect(stderr).toBe("");
-		expect(stdout).toContain("app.test.overwrite -> app/test/overwrite.ts");
-	});
-
-	test("handles read-only output directory gracefully", async () => {
-		// This test might be platform-specific and could fail on some systems
-		// We'll make it lenient to not fail the test suite
-
-		// Create a schema file
-		const schemaFile = join(schemasDir, "test.json");
-		await writeFile(
-			schemaFile,
-			JSON.stringify({
-				lexicon: 1,
-				id: "app.test.permission",
-				defs: { main: { type: "record" } },
-			}),
-		);
-
-		// Create output directory and make it read-only
-		const readOnlyDir = join(outDir, "readonly");
-		await mkdir(readOnlyDir, { recursive: true });
-
-		// Try to make read-only (might not work on all systems)
-		try {
-			await chmod(readOnlyDir, 0o444);
-		} catch (error) {
-			// Ignore if we can't change permissions
-		}
-
-		const { stdout, stderr, code } = await runCLI([
-			"gen-inferred",
-			readOnlyDir,
-			schemaFile,
-		]);
-
-		// Should handle the error gracefully
-		// On some systems this might succeed, on others fail - we just want it to not crash
-		expect([0, 1]).toContain(code);
-	});
 });

packages/cli/tests/integration/workflow.test.ts

···
 		await rm(testDir, { recursive: true, force: true });
 	});
 
-	test("complete workflow: JSON schema -> inferred types", async () => {
-		// Step 1: Create JSON schema file directly (avoiding dynamic import issues)
-		const schemaPath = join(schemasDir, "app.test.profile.json");
-		await writeFile(
-			schemaPath,
-			JSON.stringify(
-				{
-					lexicon: 1,
-					id: "app.test.profile",
-					defs: {
-						main: {
-							type: "record",
-							key: "self",
-							record: {
-								type: "object",
-								properties: {
-									displayName: { type: "string", maxLength: 64 },
-									description: { type: "string", maxLength: 256 },
-								},
-							},
-						},
-					},
-				},
-				null,
-				2,
-			),
-		);
-
-		// Step 2: Generate inferred TypeScript from JSON schema
-		const inferResult = await runCLI([
-			"gen-inferred",
-			generatedDir,
-			schemaPath,
-		]);
-
-		console.log("Infer result code:", inferResult.code);
-		console.log("Infer stdout:", inferResult.stdout);
-		console.log("Infer stderr:", inferResult.stderr);
-
-		expect(inferResult.code).toBe(0);
-		expect(inferResult.stdout).toContain("Generated inferred types in");
-		expect(inferResult.stdout).toContain(
-			"app.test.profile -> app/test/profile.ts",
-		);
-
-		// Verify generated TypeScript file
-		const generatedPath = join(generatedDir, "app/test/profile.ts");
-		const generatedContent = await readFile(generatedPath, "utf-8");
-		expect(generatedContent).toContain(
-			'import type { Infer } from "prototypey"',
-		);
-		expect(generatedContent).toContain(
-			"export type Profile = Infer<typeof schema>",
-		);
-		expect(generatedContent).toContain("export const ProfileSchema = schema");
-		expect(generatedContent).toContain(
-			"export function isProfile(v: unknown): v is Profile",
-		);
-	});
-
 	test("workflow with multiple schemas", async () => {
 		// Create multiple JSON schema files
 		const postSchema = join(schemasDir, "app.test.post.json");
···
 				null,
 				2,
 			),
-		);
-
-		// Generate inferred types
-		const inferResult = await runCLI([
-			"gen-inferred",
-			generatedDir,
-			`${schemasDir}/*.json`,
-		]);
-		expect(inferResult.code).toBe(0);
-		expect(inferResult.stdout).toContain("app.test.post -> app/test/post.ts");
-		expect(inferResult.stdout).toContain(
-			"app.test.searchPosts -> app/test/searchPosts.ts",
-		);
-
-		// Verify both generated files exist and have correct content
-		const postContent = await readFile(
-			join(generatedDir, "app/test/post.ts"),
-			"utf-8",
-		);
-		const searchContent = await readFile(
-			join(generatedDir, "app/test/searchPosts.ts"),
-			"utf-8",
-		);
-
-		expect(postContent).toContain("export type Post = Infer<typeof schema>");
-		expect(searchContent).toContain(
-			"export type SearchPosts = Infer<typeof schema>",
 		);
 	});
 });

packages/cli/tests/performance/large-schema-set.test.ts

···
-import { expect, test, describe, beforeEach, afterEach } from "vitest";
-import { mkdir, writeFile, rm } from "node:fs/promises";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { runCLI } from "../test-utils.js";
-
-describe("CLI Performance", () => {
-	let testDir: string;
-	let outDir: string;
-	let schemasDir: string;
-
-	beforeEach(async () => {
-		// Create a temporary directory for test files
-		testDir = join(tmpdir(), `prototypey-perf-test-${Date.now()}`);
-		outDir = join(testDir, "output");
-		schemasDir = join(testDir, "schemas");
-		await mkdir(testDir, { recursive: true });
-		await mkdir(outDir, { recursive: true });
-		await mkdir(schemasDir, { recursive: true });
-	});
-
-	afterEach(async () => {
-		// Clean up test directory
-		await rm(testDir, { recursive: true, force: true });
-	});
-
-	test("handles large number of schemas efficiently", async () => {
-		// Create 50 schema files
-		const schemaCount = 50;
-		const schemaFiles = [];
-
-		for (let i = 0; i < schemaCount; i++) {
-			const schemaFile = join(schemasDir, `test${i}.json`);
-			await writeFile(
-				schemaFile,
-				JSON.stringify({
-					lexicon: 1,
-					id: `app.test.schema${i}`,
-					defs: {
-						main: {
-							type: "record",
-							key: "tid",
-							record: {
-								type: "object",
-								properties: {
-									name: { type: "string", maxLength: 64 },
-									value: { type: "integer" },
-								},
-							},
-						},
-					},
-				}),
-			);
-			schemaFiles.push(schemaFile);
-		}
-
-		const startTime = Date.now();
-		const { stdout, stderr, code } = await runCLI([
-			"gen-inferred",
-			outDir,
-			`${schemasDir}/*.json`,
-		]);
-		const endTime = Date.now();
-
-		const duration = endTime - startTime;
-
-		expect(code).toBe(0);
-		expect(stdout).toContain(`Found ${schemaCount} schema file(s)`);
-		expect(stderr).toBe("");
-
-		// Should complete within reasonable time (less than 5 seconds for 50 files)
-		expect(duration).toBeLessThan(5000);
-
-		// Verify some generated files exist
-		expect(stdout).toContain("app.test.schema0 -> app/test/schema0.ts");
-		expect(stdout).toContain("app.test.schema49 -> app/test/schema49.ts");
-	});
-
-	test("memory usage stays reasonable with large schemas", async () => {
-		// Create a schema with complex nested structure
-		const complexSchema = join(schemasDir, "complex.json");
-		await writeFile(
-			complexSchema,
-			JSON.stringify({
-				lexicon: 1,
-				id: "app.test.complex",
-				defs: {
-					main: {
-						type: "record",
-						key: "tid",
-						record: {
-							type: "object",
-							properties: {
-								// Create a deeply nested structure
-								level1: {
-									type: "object",
-									properties: {
-										level2: {
-											type: "object",
-											properties: {
-												level3: {
-													type: "object",
-													properties: {
-														level4: {
-															type: "object",
-															properties: {
-																items: {
-																	type: "array",
-																	items: {
-																		type: "object",
-																		properties: {
-																			id: { type: "string" },
-																			data: { type: "string" },
-																			metadata: {
-																				type: "object",
-																				properties: {
-																					created: {
-																						type: "string",
-																						format: "datetime",
-																					},
-																					updated: {
-																						type: "string",
-																						format: "datetime",
-																					},
-																					tags: {
-																						type: "array",
-																						items: { type: "string" },
-																					},
-																				},
-																			},
-																		},
-																	},
-																},
-															},
-														},
-													},
-												},
-											},
-										},
-									},
-								},
-							},
-						},
-					},
-				},
-			}),
-		);
-
-		const startTime = Date.now();
-		const { stdout, stderr, code } = await runCLI([
-			"gen-inferred",
-			outDir,
-			complexSchema,
-		]);
-		const endTime = Date.now();
-
-		const duration = endTime - startTime;
-
-		expect(code).toBe(0);
-		expect(stdout).toContain("Found 1 schema file(s)");
-		expect(stdout).toContain("app.test.complex -> app/test/complex.ts");
-		expect(stderr).toBe("");
-
-		// Should complete within reasonable time (less than 2 seconds)
-		expect(duration).toBeLessThan(2000);
-	});
-
-	test("concurrent processing of multiple commands", async () => {
-		// Create test schemas
-		const schema1 = join(schemasDir, "test1.json");
-		const schema2 = join(schemasDir, "test2.json");
-
-		await writeFile(
-			schema1,
-			JSON.stringify({
-				lexicon: 1,
-				id: "app.test.concurrent1",
-				defs: {
-					main: { type: "record", key: "tid", record: { type: "object" } },
-				},
-			}),
-		);
-
-		await writeFile(
-			schema2,
-			JSON.stringify({
-				lexicon: 1,
-				id: "app.test.concurrent2",
-				defs: {
-					main: { type: "record", key: "tid", record: { type: "object" } },
-				},
-			}),
-		);
-
-		// Run two CLI commands concurrently
-		const [result1, result2] = await Promise.all([
-			runCLI(["gen-inferred", join(outDir, "out1"), schema1]),
-			runCLI(["gen-inferred", join(outDir, "out2"), schema2]),
-		]);
-
-		expect(result1.code).toBe(0);
-		expect(result2.code).toBe(0);
-		expect(result1.stdout).toContain(
-			"app.test.concurrent1 -> app/test/concurrent1.ts",
-		);
-		expect(result2.stdout).toContain(
-			"app.test.concurrent2 -> app/test/concurrent2.ts",
-		);
-	});
-});

packages/cli/tests/unit/template-edge-cases.test.ts

···
-import { expect, test, describe } from "vitest";
-import { generateInferredCode } from "../../src/templates/inferred.ts";
-
-describe("Template Edge Cases", () => {
-	test("handles NSID with trailing numbers correctly", () => {
-		const schema = {
-			lexicon: 1,
-			id: "app.test.v1",
-			defs: { main: { type: "record" } },
-		};
-
-		const code = generateInferredCode(schema, "/test/v1.json", "/output");
-		expect(code).toContain("export type V1 = Infer<typeof schema>");
-		expect(code).toContain("export const V1Schema = schema");
-		expect(code).toContain("export function isV1(v: unknown): v is V1");
-	});
-
-	test("handles NSID with multiple consecutive separators", () => {
-		const schema = {
-			lexicon: 1,
-			id: "app.test.my--double--dash",
-			defs: { main: { type: "record" } },
-		};
-
-		const code = generateInferredCode(schema, "/test/double.json", "/output");
-		expect(code).toContain("export type MyDoubleDash = Infer<typeof schema>");
-	});
-
-	test("handles single character NSID parts", () => {
-		const schema = {
-			lexicon: 1,
-			id: "a.b.c",
-			defs: { main: { type: "record" } },
-		};
-
-		const code = generateInferredCode(schema, "/test/single.json", "/output");
-		expect(code).toContain("export type C = Infer<typeof schema>");
-	});
-
-	test("handles NSID with underscores and mixed case", () => {
-		const schema = {
-			lexicon: 1,
-			id: "app.test.my_custom_Type_Name",
-			defs: { main: { type: "record" } },
-		};
-
-		const code = generateInferredCode(schema, "/test/custom.json", "/output");
-		expect(code).toContain(
-			"export type MyCustomTypeName = Infer<typeof schema>",
-		);
-	});
-
-	test("handles very long NSID name", () => {
-		const longName = "a".repeat(100);
-		const schema = {
-			lexicon: 1,
-			id: `app.test.${longName}`,
-			defs: { main: { type: "record" } },
-		};
-
-		const code = generateInferredCode(schema, "/test/long.json", "/output");
-		// Should not crash and should generate valid TypeScript
-		expect(code).toContain("export type");
-		expect(code).toContain("Infer<typeof schema>");
-	});
-
-	test("handles schema with no main def", () => {
-		const schema = {
-			lexicon: 1,
-			id: "app.test.no-main",
-			defs: {
-				other: { type: "object" },
-			},
-		};
-
-		const code = generateInferredCode(schema, "/test/no-main.json", "/output");
-		// Should still generate valid code even without main def
-		expect(code).toContain("export type NoMain = Infer<typeof schema>");
-		// The path will be relative with ../../../ prefix
-		expect(code).toContain(
-			'import schema from "../../../test/no-main.json" with { type: "json" };',
-		);
-	});
-
-	test("generates correct relative paths for deeply nested output", () => {
-		const schema = {
-			lexicon: 1,
-			id: "app.bsky.feed.post",
-			defs: { main: { type: "record" } },
-		};
-
-		const code = generateInferredCode(
-			schema,
-			"/project/schemas/feed.json",
-			"/project/generated/inferred",
-		);
-
-		// Should have correct relative import path
-		expect(code).toContain(
-			'import schema from "../../../../../schemas/feed.json" with { type: "json" };',
-		);
-	});
-
-	test("handles special characters in import paths", () => {
-		const schema = {
-			lexicon: 1,
-			id: "app.test.special",
-			defs: { main: { type: "record" } },
-		};
-
-		const code = generateInferredCode(
-			schema,
-			"/project/schemas with spaces/special[chars].json",
-			"/project/generated",
-		);
-
-		// Should handle spaces and special characters in paths
-		expect(code).toContain(
-			'import schema from "../../../schemas with spaces/special[chars].json" with { type: "json" };',
-		);
-	});
-});

packages/prototypey/README.md

···
 
 The `prototypey` package includes a CLI with two main commands:
 
-#### `gen-inferred` - Generate TypeScript from JSON schemas
-
-```bash
-prototypey gen-inferred <outdir> <schemas...>
-```
-
-Reads ATProto lexicon JSON schemas and generates TypeScript types.
-
-**Example:**
-
-```bash
-prototypey gen-inferred ./generated/inferred ./lexicons/**/*.json
-```
-
 #### `gen-emit` - Emit JSON schemas from TypeScript
 
 ```bash