rename namespace => lexicon

README.md

···
 **what you'd write:**
 
 ```typescript
-const profileNamespace = lx.namespace("app.bsky.actor.profile", {
+const profileNamespace = lx.lexicon("app.bsky.actor.profile", {
 	main: lx.record({
 		key: "self",
 		record: lx.object({

packages/cli/README.md

···
 
 **What it does:**
 
-- Scans TypeScript files for exported lexicon namespace definitions
-- Extracts the `.json` property from each namespace
+- Scans TypeScript files for exported lexicon definitions
+- Extracts the `.json` property from each lexicon
 - Emits properly formatted JSON lexicon schema files
 - Names output files by lexicon ID (e.g., `app.bsky.feed.post.json`)
 

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

···
 		// Dynamically import the module
 		const module = await import(fileUrl);
 
-		// Find all exported namespaces
-		const namespaces: LexiconNamespace[] = [];
+		// Find all exported lexicons
+		const lexicons: LexiconNamespace[] = [];
 		for (const key of Object.keys(module)) {
 			const exported = module[key];
-			// Check if it's a namespace with a json property
+			// Check if it's a lexicon with a json property
 			if (
 				exported &&
 				typeof exported === "object" &&
···
 				"id" in exported.json &&
 				"defs" in exported.json
 			) {
-				namespaces.push(exported as LexiconNamespace);
+				lexicons.push(exported as LexiconNamespace);
 			}
 		}
 
-		if (namespaces.length === 0) {
-			console.warn(`  ⚠ ${sourcePath}: No lexicon namespaces found`);
+		if (lexicons.length === 0) {
+			console.warn(`  ⚠ ${sourcePath}: No lexicon lexicons found`);
 			return;
 		}
 
-		// Emit JSON for each namespace
-		for (const namespace of namespaces) {
-			const { id } = namespace.json;
+		// Emit JSON for each lexicon
+		for (const lexicon of lexicons) {
+			const { id } = lexicon.json;
 			const outputPath = join(outdir, `${id}.json`);
 
 			// Write the JSON file
 			await writeFile(
 				outputPath,
-				JSON.stringify(namespace.json, null, "\t"),
+				JSON.stringify(lexicon.json, null, "\t"),
 				"utf-8",
 			);
 

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

···
 			`
 import { lx } from "prototypey";
 
-export const profileNamespace = lx.namespace("app.bsky.actor.profile", {
+export const profileNamespace = lx.lexicon("app.bsky.actor.profile", {
 	main: lx.record({
 		key: "self",
 		record: lx.object({
···
 			`
 import { lx } from "prototypey";
 
-export const profile = lx.namespace("app.bsky.actor.profile", {
+export const profile = lx.lexicon("app.bsky.actor.profile", {
 	main: lx.record({
 		key: "self",
 		record: lx.object({
···
 	}),
 });
 
-export const post = lx.namespace("app.bsky.feed.post", {
+export const post = lx.lexicon("app.bsky.feed.post", {
 	main: lx.record({
 		key: "tid",
 		record: lx.object({
···
 			join(lexicons, "profile.ts"),
 			`
 import { lx } from "prototypey";
-export const schema = lx.namespace("app.bsky.actor.profile", {
+export const schema = lx.lexicon("app.bsky.actor.profile", {
 	main: lx.record({ key: "self", record: lx.object({}) }),
 });
 `,
···
 			join(lexicons, "post.ts"),
 			`
 import { lx } from "prototypey";
-export const schema = lx.namespace("app.bsky.feed.post", {
+export const schema = lx.lexicon("app.bsky.feed.post", {
 	main: lx.record({ key: "tid", record: lx.object({}) }),
 });
 `,
···
 			`
 import { lx } from "prototypey";
 
-export const searchPosts = lx.namespace("app.bsky.feed.searchPosts", {
+export const searchPosts = lx.lexicon("app.bsky.feed.searchPosts", {
 	main: lx.query({
 		description: "Find posts matching search criteria",
 		parameters: lx.params({
···
 			`
 import { lx } from "prototypey";
 
-export const createPost = lx.namespace("com.atproto.repo.createRecord", {
+export const createPost = lx.lexicon("com.atproto.repo.createRecord", {
 	main: lx.procedure({
 		description: "Create a record",
 		input: {
···
 			`
 import { lx } from "prototypey";
 
-export const subscribeRepos = lx.namespace("com.atproto.sync.subscribeRepos", {
+export const subscribeRepos = lx.lexicon("com.atproto.sync.subscribeRepos", {
 	main: lx.subscription({
 		description: "Repository event stream",
 		parameters: lx.params({
···
 			`
 import { lx } from "prototypey";
 
-export const feedDefs = lx.namespace("app.bsky.feed.defs", {
+export const feedDefs = lx.lexicon("app.bsky.feed.defs", {
 	postView: lx.object({
 		uri: lx.string({ required: true, format: "at-uri" }),
 		cid: lx.string({ required: true, format: "cid" }),
···
 			`
 import { lx } from "prototypey";
 
-export const imagePost = lx.namespace("app.example.imagePost", {
+export const imagePost = lx.lexicon("app.example.imagePost", {
 	main: lx.record({
 		key: "tid",
 		record: lx.object({

packages/cli/tests/fixtures/simple-lexicon.ts

···
 import { lx } from "prototypey";
 
-export const profileNamespace = lx.namespace("app.bsky.actor.profile", {
+export const profileNamespace = lx.lexicon("app.bsky.actor.profile", {
 	main: lx.record({
 		key: "self",
 		record: lx.object({

packages/prototypey/src/lib.ts

···
 		} as T & { type: "subscription" };
 	},
 	/**
-	 * Creates a lexicon namespace document.
+	 * Creates a lexicon schema document.
 	 * @see https://atproto.com/specs/lexicon#lexicon-document
 	 */
-	namespace<ID extends string, D extends LexiconNamespace["defs"]>(
+	lexicon<ID extends string, D extends LexiconNamespace["defs"]>(
 		id: ID,
 		defs: D,
 	): Namespace<{ lexicon: 1; id: ID; defs: D }> {

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

···
 import { lx } from "../src/lib.ts";
 
 test("app.bsky.actor.profile", () => {
-	const profileNamespace = lx.namespace("app.bsky.actor.profile", {
+	const profileNamespace = lx.lexicon("app.bsky.actor.profile", {
 		main: lx.record({
 			key: "self",
 			record: lx.object({

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

···
 	});
 });
 
-test("app.bsky.actor.defs - full namespace", () => {
-	const actorDefs = lx.namespace("app.bsky.actor.defs", {
+test("app.bsky.actor.defs - full lexicon", () => {
+	const actorDefs = lx.lexicon("app.bsky.actor.defs", {
 		profileViewBasic: lx.object({
 			did: lx.string({ required: true, format: "did" }),
 			handle: lx.string({ required: true, format: "handle" }),

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

···
 	});
 });
 
-test("app.bsky.feed.defs - full namespace", () => {
-	const feedDefs = lx.namespace("app.bsky.feed.defs", {
+test("app.bsky.feed.defs - full lexicon", () => {
+	const feedDefs = lx.lexicon("app.bsky.feed.defs", {
 		postView: lx.object({
 			uri: lx.string({ required: true, format: "at-uri" }),
 			cid: lx.string({ required: true, format: "cid" }),

packages/prototypey/tests/infer.bench.ts

···
 import { lx } from "../src/lib.ts";
 
 bench("infer with simple object", () => {
-	const schema = lx.namespace("test.simple", {
+	const schema = lx.lexicon("test.simple", {
 		main: lx.object({
 			id: lx.string({ required: true }),
 			name: lx.string({ required: true }),
···
 }).types([741, "instantiations"]);
 
 bench("infer with complex nested structure", () => {
-	const schema = lx.namespace("test.complex", {
+	const schema = lx.lexicon("test.complex", {
 		user: lx.object({
 			handle: lx.string({ required: true }),
 			displayName: lx.string(),
···
 }).types([1040, "instantiations"]);
 
 bench("infer with circular reference", () => {
-	const ns = lx.namespace("test", {
+	const ns = lx.lexicon("test", {
 		user: lx.object({
 			name: lx.string({ required: true }),
 			posts: lx.array(lx.ref("#post")),
···
 	return ns.infer;
 }).types([692, "instantiations"]);
 
-bench("infer with app.bsky.feed.defs namespace", () => {
-	const schema = lx.namespace("app.bsky.feed.defs", {
+bench("infer with app.bsky.feed.defs lexicon", () => {
+	const schema = lx.lexicon("app.bsky.feed.defs", {
 		viewerState: lx.object({
 			repost: lx.string({ format: "at-uri" }),
 			like: lx.string({ format: "at-uri" }),

packages/prototypey/tests/infer.test.ts

···
 import { lx } from "../src/lib.ts";
 
 test("InferNS produces expected type shape", () => {
-	const exampleLexicon = lx.namespace("com.example.post", {
+	const exampleLexicon = lx.lexicon("com.example.post", {
 		main: lx.record({
 			key: "tid",
 			record: lx.object({
···
 });
 
 test("InferObject handles required fields", () => {
-	const schema = lx.namespace("test", {
+	const schema = lx.lexicon("test", {
 		main: lx.object({
 			required: lx.string({ required: true }),
 			optional: lx.string(),
···
 });
 
 test("InferObject handles nullable fields", () => {
-	const schema = lx.namespace("test", {
+	const schema = lx.lexicon("test", {
 		main: lx.object({
 			nullable: lx.string({ nullable: true, required: true }),
 		}),
···
 // ============================================================================
 
 test("InferType handles string primitive", () => {
-	const namespace = lx.namespace("test.string", {
+	const lexicon = lx.lexicon("test.string", {
 		main: lx.object({
 			simpleString: lx.string(),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.string"
   simpleString?: string | undefined
 }`);
 });
 
 test("InferType handles integer primitive", () => {
-	const namespace = lx.namespace("test.integer", {
+	const lexicon = lx.lexicon("test.integer", {
 		main: lx.object({
 			count: lx.integer(),
 			age: lx.integer({ minimum: 0, maximum: 120 }),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.integer"
   count?: number | undefined
   age?: number | undefined
···
 });
 
 test("InferType handles boolean primitive", () => {
-	const namespace = lx.namespace("test.boolean", {
+	const lexicon = lx.lexicon("test.boolean", {
 		main: lx.object({
 			isActive: lx.boolean(),
 			hasAccess: lx.boolean({ required: true }),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.boolean"
   isActive?: boolean | undefined
   hasAccess: boolean
···
 });
 
 test("InferType handles null primitive", () => {
-	const namespace = lx.namespace("test.null", {
+	const lexicon = lx.lexicon("test.null", {
 		main: lx.object({
 			nullValue: lx.null(),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.null"
   nullValue?: null | undefined
 }`);
 });
 
 test("InferType handles unknown primitive", () => {
-	const namespace = lx.namespace("test.unknown", {
+	const lexicon = lx.lexicon("test.unknown", {
 		main: lx.object({
 			metadata: lx.unknown(),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(
+	attest(lexicon.infer).type.toString.snap(
 		'{ $type: "test.unknown"; metadata?: unknown }',
 	);
 });
 
 test("InferType handles bytes primitive", () => {
-	const namespace = lx.namespace("test.bytes", {
+	const lexicon = lx.lexicon("test.bytes", {
 		main: lx.object({
 			data: lx.bytes(),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.bytes"
   data?: Uint8Array<ArrayBufferLike> | undefined
 }`);
 });
 
 test("InferType handles blob primitive", () => {
-	const namespace = lx.namespace("test.blob", {
+	const lexicon = lx.lexicon("test.blob", {
 		main: lx.object({
 			image: lx.blob({ accept: ["image/png", "image/jpeg"] }),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(
+	attest(lexicon.infer).type.toString.snap(
 		'{ $type: "test.blob"; image?: Blob | undefined }',
 	);
 });
···
 // ============================================================================
 
 test("InferToken handles basic token without enum", () => {
-	const namespace = lx.namespace("test.token", {
+	const lexicon = lx.lexicon("test.token", {
 		main: lx.object({
 			symbol: lx.token("A symbolic value"),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.token"
   symbol?: string | undefined
 }`);
···
 // ============================================================================
 
 test("InferArray handles string arrays", () => {
-	const namespace = lx.namespace("test.array.string", {
+	const lexicon = lx.lexicon("test.array.string", {
 		main: lx.object({
 			tags: lx.array(lx.string()),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.array.string"
   tags?: string[] | undefined
 }`);
 });
 
 test("InferArray handles integer arrays", () => {
-	const namespace = lx.namespace("test.array.integer", {
+	const lexicon = lx.lexicon("test.array.integer", {
 		main: lx.object({
 			scores: lx.array(lx.integer(), { minLength: 1, maxLength: 10 }),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.array.integer"
   scores?: number[] | undefined
 }`);
 });
 
 test("InferArray handles boolean arrays", () => {
-	const namespace = lx.namespace("test.array.boolean", {
+	const lexicon = lx.lexicon("test.array.boolean", {
 		main: lx.object({
 			flags: lx.array(lx.boolean()),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.array.boolean"
   flags?: boolean[] | undefined
 }`);
 });
 
 test("InferArray handles unknown arrays", () => {
-	const namespace = lx.namespace("test.array.unknown", {
+	const lexicon = lx.lexicon("test.array.unknown", {
 		main: lx.object({
 			items: lx.array(lx.unknown()),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.array.unknown"
   items?: unknown[] | undefined
 }`);
···
 // ============================================================================
 
 test("InferObject handles mixed optional and required fields", () => {
-	const namespace = lx.namespace("test.mixed", {
+	const lexicon = lx.lexicon("test.mixed", {
 		main: lx.object({
 			id: lx.string({ required: true }),
 			name: lx.string({ required: true }),
···
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.mixed"
   age?: number | undefined
   email?: string | undefined
···
 });
 
 test("InferObject handles all optional fields", () => {
-	const namespace = lx.namespace("test.allOptional", {
+	const lexicon = lx.lexicon("test.allOptional", {
 		main: lx.object({
 			field1: lx.string(),
 			field2: lx.integer(),
···
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.allOptional"
   field1?: string | undefined
   field2?: number | undefined
···
 });
 
 test("InferObject handles all required fields", () => {
-	const namespace = lx.namespace("test.allRequired", {
+	const lexicon = lx.lexicon("test.allRequired", {
 		main: lx.object({
 			field1: lx.string({ required: true }),
 			field2: lx.integer({ required: true }),
···
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.allRequired"
   field1: string
   field2: number
···
 // ============================================================================
 
 test("InferObject handles nullable optional field", () => {
-	const namespace = lx.namespace("test.nullableOptional", {
+	const lexicon = lx.lexicon("test.nullableOptional", {
 		main: lx.object({
 			description: lx.string({ nullable: true }),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.nullableOptional"
   description?: string | null | undefined
 }`);
 });
 
 test("InferObject handles multiple nullable fields", () => {
-	const namespace = lx.namespace("test.multipleNullable", {
+	const lexicon = lx.lexicon("test.multipleNullable", {
 		main: lx.object({
 			field1: lx.string({ nullable: true }),
 			field2: lx.integer({ nullable: true }),
···
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.multipleNullable"
   field1?: string | null | undefined
   field2?: number | null | undefined
···
 });
 
 test("InferObject handles nullable and required field", () => {
-	const namespace = lx.namespace("test.nullableRequired", {
+	const lexicon = lx.lexicon("test.nullableRequired", {
 		main: lx.object({
 			value: lx.string({ nullable: true, required: true }),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.nullableRequired"
   value: string | null
 }`);
 });
 
 test("InferObject handles mixed nullable, required, and optional", () => {
-	const namespace = lx.namespace("test.mixedNullable", {
+	const lexicon = lx.lexicon("test.mixedNullable", {
 		main: lx.object({
 			requiredNullable: lx.string({ required: true, nullable: true }),
 			optionalNullable: lx.string({ nullable: true }),
···
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.mixedNullable"
   optional?: string | undefined
   required: string
···
 // ============================================================================
 
 test("InferRef handles basic reference", () => {
-	const namespace = lx.namespace("test.ref", {
+	const lexicon = lx.lexicon("test.ref", {
 		main: lx.object({
 			post: lx.ref("com.example.post"),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.ref"
   post?:
     | { [x: string]: unknown; $type: "com.example.post" }
···
 });
 
 test("InferRef handles required reference", () => {
-	const namespace = lx.namespace("test.refRequired", {
+	const lexicon = lx.lexicon("test.refRequired", {
 		main: lx.object({
 			author: lx.ref("com.example.user", { required: true }),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.refRequired"
   author?:
     | { [x: string]: unknown; $type: "com.example.user" }
···
 });
 
 test("InferRef handles nullable reference", () => {
-	const namespace = lx.namespace("test.refNullable", {
+	const lexicon = lx.lexicon("test.refNullable", {
 		main: lx.object({
 			parent: lx.ref("com.example.node", { nullable: true }),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.refNullable"
   parent?:
     | { [x: string]: unknown; $type: "com.example.node" }
···
 // ============================================================================
 
 test("InferUnion handles basic union", () => {
-	const namespace = lx.namespace("test.union", {
+	const lexicon = lx.lexicon("test.union", {
 		main: lx.object({
 			content: lx.union(["com.example.text", "com.example.image"]),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.union"
   content?:
     | { [x: string]: unknown; $type: "com.example.text" }
···
 });
 
 test("InferUnion handles required union", () => {
-	const namespace = lx.namespace("test.unionRequired", {
+	const lexicon = lx.lexicon("test.unionRequired", {
 		main: lx.object({
 			media: lx.union(["com.example.video", "com.example.audio"], {
 				required: true,
···
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.unionRequired"
   media:
     | { [x: string]: unknown; $type: "com.example.video" }
···
 });
 
 test("InferUnion handles union with many types", () => {
-	const namespace = lx.namespace("test.unionMultiple", {
+	const lexicon = lx.lexicon("test.unionMultiple", {
 		main: lx.object({
 			attachment: lx.union([
 				"com.example.image",
···
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.unionMultiple"
   attachment?:
     | { [x: string]: unknown; $type: "com.example.image" }
···
 // ============================================================================
 
 test("InferParams handles basic params", () => {
-	const namespace = lx.namespace("test.params", {
+	const lexicon = lx.lexicon("test.params", {
 		main: lx.params({
 			limit: lx.integer(),
 			offset: lx.integer(),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.params"
   limit?: number | undefined
   offset?: number | undefined
···
 });
 
 test("InferParams handles required params", () => {
-	const namespace = lx.namespace("test.paramsRequired", {
+	const lexicon = lx.lexicon("test.paramsRequired", {
 		main: lx.params({
 			query: lx.string({ required: true }),
 			limit: lx.integer(),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.paramsRequired"
   limit?: number | undefined
   query: string
···
 // ============================================================================
 
 test("InferRecord handles record with object schema", () => {
-	const namespace = lx.namespace("test.record", {
+	const lexicon = lx.lexicon("test.record", {
 		main: lx.record({
 			key: "tid",
 			record: lx.object({
···
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.record"
   published?: boolean | undefined
   content: string
···
 // ============================================================================
 
 test("InferObject handles nested objects", () => {
-	const namespace = lx.namespace("test.nested", {
+	const lexicon = lx.lexicon("test.nested", {
 		main: lx.object({
 			user: lx.object({
 				name: lx.string({ required: true }),
···
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.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", {
+	const lexicon = lx.lexicon("test.deepNested", {
 		main: lx.object({
 			data: lx.object({
 				user: lx.object({
···
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.deepNested"
   data?:
     | {
···
 // ============================================================================
 
 test("InferArray handles arrays of objects", () => {
-	const namespace = lx.namespace("test.arrayOfObjects", {
+	const lexicon = lx.lexicon("test.arrayOfObjects", {
 		main: lx.object({
 			users: lx.array(
 				lx.object({
···
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.arrayOfObjects"
   users?: { id: string; name: string }[] | undefined
 }`);
···
 		matrix: lx.array(lx.array(lx.integer())),
 	});
 
-	const namespace = lx.namespace("test.nestedArrays", {
+	const lexicon = lx.lexicon("test.nestedArrays", {
 		main: schema,
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.nestedArrays"
   matrix?: number[][] | undefined
 }`);
 });
 
 test("InferArray handles arrays of refs", () => {
-	const namespace = lx.namespace("test.arrayOfRefs", {
+	const lexicon = lx.lexicon("test.arrayOfRefs", {
 		main: lx.object({
 			followers: lx.array(lx.ref("com.example.user")),
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.arrayOfRefs"
   followers?:
     | { [x: string]: unknown; $type: "com.example.user" }[]
···
 // ============================================================================
 
 test("InferObject handles complex nested structure", () => {
-	const namespace = lx.namespace("test.complex", {
+	const lexicon = lx.lexicon("test.complex", {
 		main: lx.object({
 			id: lx.string({ required: true }),
 			author: lx.object({
···
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "test.complex"
   tags?: string[] | undefined
   content?:
···
 // ============================================================================
 
 test("InferNS handles multiple defs in namespace", () => {
-	const namespace = lx.namespace("com.example.app", {
+	const lexicon = lx.lexicon("com.example.app", {
 		user: lx.object({
 			name: lx.string({ required: true }),
 			email: lx.string({ required: true }),
···
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap("never");
+	attest(lexicon.infer).type.toString.snap("never");
 });
 
 test("InferNS handles namespace with record and object defs", () => {
-	const namespace = lx.namespace("com.example.blog", {
+	const lexicon = lx.lexicon("com.example.blog", {
 		main: lx.record({
 			key: "tid",
 			record: lx.object({
···
 		}),
 	});
 
-	attest(namespace.infer).type.toString.snap(`{
+	attest(lexicon.infer).type.toString.snap(`{
   $type: "com.example.blog"
   title: string
   body: string
···
 // ============================================================================
 
 test("Local ref resolution: resolves refs to actual types", () => {
-	const ns = lx.namespace("test", {
+	const ns = lx.lexicon("test", {
 		user: lx.object({
 			name: lx.string({ required: true }),
 			email: lx.string({ required: true }),
···
 });
 
 test("Local ref resolution: refs in arrays", () => {
-	const ns = lx.namespace("test", {
+	const ns = lx.lexicon("test", {
 		user: lx.object({
 			name: lx.string({ required: true }),
 		}),
···
 });
 
 test("Local ref resolution: refs in unions", () => {
-	const ns = lx.namespace("test", {
+	const ns = lx.lexicon("test", {
 		text: lx.object({ content: lx.string({ required: true }) }),
 		image: lx.object({ url: lx.string({ required: true }) }),
 		main: lx.object({
···
 });
 
 test("Local ref resolution: nested refs", () => {
-	const ns = lx.namespace("test", {
+	const ns = lx.lexicon("test", {
 		profile: lx.object({
 			bio: lx.string({ required: true }),
 		}),
···
 // ============================================================================
 
 test("Edge case: circular reference detection", () => {
-	const ns = lx.namespace("test", {
+	const ns = lx.lexicon("test", {
 		main: lx.object({
 			value: lx.string({ required: true }),
 			parent: lx.ref("#main"),
···
 });
 
 test("Edge case: circular reference between multiple types", () => {
-	const ns = lx.namespace("test", {
+	const ns = lx.lexicon("test", {
 		user: lx.object({
 			name: lx.string({ required: true }),
 			posts: lx.array(lx.ref("#post")),
···
 });
 
 test("Edge case: missing reference detection", () => {
-	const ns = lx.namespace("test", {
+	const ns = lx.lexicon("test", {
 		main: lx.object({
 			author: lx.ref("#user", { required: true }),
 		}),

packages/site/src/components/Playground.tsx

···
 		const timeoutId = setTimeout(async () => {
 			try {
 				const nsMatch = code.match(
-					/const\s+ns\s*=\s*lx\.namespace\([^]*?\}\s*\);/,
+					/const\s+ns\s*=\s*lx\.lexicon\([^]*?\}\s*\);/,
 				);
 				if (!nsMatch) {
-					throw new Error("No namespace definition found");
+					throw new Error("No lexicon definition found");
 				}
 
 				const cleanedCode = nsMatch[0];
-				const wrappedCode = `${cleanedCode}\nreturn ns;`;
+				const wrappedCode = `${cleanedCode}\nreturn lex;`;
 				const fn = new Function("lx", wrappedCode);
 				const result = fn(lx);
 				let typeInfo = "// Hover over .infer in the editor to see the type";
···
 
 const DEFAULT_CODE = `import { lx, type Infer } from "prototypey";
 
-const ns = lx.namespace("app.bsky.actor.profile", {
+const lex = lx.lexicon("app.bsky.actor.profile", {
   main: lx.record({
     key: "self",
     record: lx.object({
···
   }),
 });
 
-type ProfileInferred = Infer<typeof ns>;
+type Profile = Infer<typeof lex>;
 
-const aProfile: ProfileInferred = {
+const aProfile: Profile = {
   $type: "app.bsky.actor.profile",
   displayName: "Benny Harvey"
 }`;

packages/site/tests/components/Playground.test.tsx

···
 		const inputEditor = editors[0] as HTMLTextAreaElement;
 
 		expect(inputEditor.value).toContain(
-			'lx.namespace("app.bsky.actor.profile"',
+			'lx.lexicon("app.bsky.actor.profile"',
 		);
 	});