@atcute/lex-cli 2.2.1 → 2.3.0

package/dist/lexicon-metadata.d.ts

@@ -0,0 +1,37 @@
+import * as v from 'valibot';
+/**
+ * Schema for a single lexicon mapping entry
+ */
+declare const lexiconMappingEntry: v.ObjectSchema<{
+    readonly type: v.PicklistSchema<["namespace", "named"], undefined>;
+    readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "path must be \".\" or start with \"./\"">]>;
+}, undefined>;
+/**
+ * Schema for the atcute:lexicons field in package.json
+ */
+declare const atcuteLexiconsField: v.ObjectSchema<{
+    readonly mappings: v.OptionalSchema<v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "invalid NSID pattern (must be valid NSID or end with .*)">]>, v.ObjectSchema<{
+        readonly type: v.PicklistSchema<["namespace", "named"], undefined>;
+        readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "path must be \".\" or start with \"./\"">]>;
+    }, undefined>, undefined>, undefined>;
+}, undefined>;
+/**
+ * Schema for package.json with atcute:lexicons field
+ */
+export declare const packageJsonSchema: v.LooseObjectSchema<{
+    readonly 'atcute:lexicons': v.OptionalSchema<v.ObjectSchema<{
+        readonly mappings: v.OptionalSchema<v.RecordSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.CheckAction<string, "invalid NSID pattern (must be valid NSID or end with .*)">]>, v.ObjectSchema<{
+            readonly type: v.PicklistSchema<["namespace", "named"], undefined>;
+            readonly path: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "path must be \".\" or start with \"./\"">]>;
+        }, undefined>, undefined>, undefined>;
+    }, undefined>, undefined>;
+}, undefined>;
+export type LexiconMappingEntry = v.InferOutput<typeof lexiconMappingEntry>;
+export type AtcuteLexiconsField = v.InferOutput<typeof atcuteLexiconsField>;
+export type PackageJsonWithLexicons = v.InferOutput<typeof packageJsonSchema>;
+/**
+ * Validates a package.json object against the schema
+ */
+export declare const validatePackageJson: (data: unknown) => v.SafeParseResult<typeof packageJsonSchema>;
+export {};
+//# sourceMappingURL=lexicon-metadata.d.ts.map

package/dist/lexicon-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexicon-metadata.d.ts","sourceRoot":"","sources":["../src/lexicon-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAmB7B;;GAEG;AACH,QAAA,MAAM,mBAAmB;;;aAGvB,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,mBAAmB;;;;;aAUvB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB;;;;;;;aAE5B,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAC5E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAC5E,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE9E;;GAEG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAM,OAAO,KAAG,CAAC,CAAC,eAAe,CAAC,OAAO,iBAAiB,CAE7F,CAAC"}

package/dist/lexicon-metadata.js

@@ -0,0 +1,42 @@
+import * as v from 'valibot';
+import { isNsid } from '@atcute/lexicons/syntax';
+/**
+ * Validates if a string is a valid NSID pattern (exact or wildcard)
+ * - Exact: "com.atproto.repo.getRecord"
+ * - Wildcard: "com.atproto.*"
+ */
+const isValidLexiconPattern = (pattern) => {
+    if (pattern.endsWith('.*')) {
+        // For wildcards, remove the .* and validate the prefix as an NSID segment
+        const prefix = pattern.slice(0, -2);
+        // Add a dummy segment to make it a valid NSID for validation
+        return isNsid(prefix + '.x');
+    }
+    return isNsid(pattern);
+};
+/**
+ * Schema for a single lexicon mapping entry
+ */
+const lexiconMappingEntry = v.object({
+    type: v.picklist(['namespace', 'named']),
+    path: v.pipe(v.string(), v.regex(/^\.$|^\.\//, `path must be "." or start with "./"`)),
+});
+/**
+ * Schema for the atcute:lexicons field in package.json
+ */
+const atcuteLexiconsField = v.object({
+    mappings: v.optional(v.record(v.pipe(v.string(), v.check(isValidLexiconPattern, `invalid NSID pattern (must be valid NSID or end with .*)`)), lexiconMappingEntry)),
+});
+/**
+ * Schema for package.json with atcute:lexicons field
+ */
+export const packageJsonSchema = v.looseObject({
+    'atcute:lexicons': v.optional(atcuteLexiconsField),
+});
+/**
+ * Validates a package.json object against the schema
+ */
+export const validatePackageJson = (data) => {
+    return v.safeParse(packageJsonSchema, data);
+};
+//# sourceMappingURL=lexicon-metadata.js.map

package/dist/lexicon-metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lexicon-metadata.js","sourceRoot":"","sources":["../src/lexicon-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAE7B,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AAEjD;;;;GAIG;AACH,MAAM,qBAAqB,GAAG,CAAC,OAAe,EAAW,EAAE;IAC1D,IAAI,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QAC5B,0EAA0E;QAC1E,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACpC,6DAA6D;QAC7D,OAAO,MAAM,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC9B,CAAC;IACD,OAAO,MAAM,CAAC,OAAO,CAAC,CAAC;AACxB,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IACpC,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IACxC,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,YAAY,EAAE,qCAAqC,CAAC,CAAC;CACtF,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IACpC,QAAQ,EAAE,CAAC,CAAC,QAAQ,CACnB,CAAC,CAAC,MAAM,CACP,CAAC,CAAC,IAAI,CACL,CAAC,CAAC,MAAM,EAAE,EACV,CAAC,CAAC,KAAK,CAAC,qBAAqB,EAAE,0DAA0D,CAAC,CAC1F,EACD,mBAAmB,CACnB,CACD;CACD,CAAC,CAAC;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,WAAW,CAAC;IAC9C,iBAAiB,EAAE,CAAC,CAAC,QAAQ,CAAC,mBAAmB,CAAC;CAClD,CAAC,CAAC;AAMH;;GAEG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,IAAa,EAA+C,EAAE;IACjG,OAAO,CAAC,CAAC,SAAS,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAC;AAC7C,CAAC,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@atcute/lex-cli",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "description": "cli tool to generate type definitions for atcute",
   "license": "0BSD",
   "repository": {
@@ -13,7 +13,8 @@
     "src/",
     "!src/**/*.bench.ts",
     "!src/**/*.test.ts",
-    "cli.mjs"
+    "cli.mjs",
+    "schema/"
   ],
   "bin": "./cli.mjs",
   "exports": {
@@ -21,17 +22,21 @@
   },
   "dependencies": {
     "@badrap/valita": "^0.4.6",
-    "@externdefs/collider": "^0.3.0",
+    "@optique/core": "^0.6.1",
+    "@optique/run": "^0.6.1",
     "picocolors": "^1.1.1",
     "prettier": "^3.6.2",
-    "@atcute/lexicon-doc": "^1.1.2"
+    "valibot": "^1.0.0",
+    "@atcute/lexicon-doc": "^1.1.3"
   },
   "devDependencies": {
     "@types/node": "^22.18.0",
+    "@valibot/to-json-schema": "^1.3.0",
     "@atcute/lexicons": "^1.2.2"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "pnpm run generate:schema && tsc",
+    "generate:schema": "node scripts/generate-schema.ts",
     "prepublish": "rm -rf dist; pnpm run build"
   }
 }

package/schema/lexicon-package.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://unpkg.com/@atcute/lex-cli/schema/lexicon-package.schema.json",
+  "title": "package.json with atcute:lexicons",
+  "description": "JSON Schema for package.json with atcute:lexicons field for lexicon import mappings",
+  "type": "object",
+  "properties": {
+    "atcute:lexicons": {
+      "type": "object",
+      "properties": {
+        "mappings": {
+          "type": "object",
+          "additionalProperties": {
+            "type": "object",
+            "properties": {
+              "type": {
+                "enum": [
+                  "namespace",
+                  "named"
+                ]
+              },
+              "path": {
+                "type": "string",
+                "pattern": "^\\.$|^\\.\\/"
+              }
+            },
+            "required": [
+              "type",
+              "path"
+            ]
+          }
+        }
+      },
+      "required": []
+    }
+  },
+  "required": []
+}

package/src/cli.ts

@@ -2,108 +2,202 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import * as url from 'node:url';
 
-import { Builtins, Command, Option, Program } from '@externdefs/collider';
+import { object } from '@optique/core/constructs';
+import { command, constant, option } from '@optique/core/primitives';
+import { run } from '@optique/run';
+import { path as pathParser } from '@optique/run/valueparser';
 import pc from 'picocolors';
 
 import { lexiconDoc, type LexiconDoc } from '@atcute/lexicon-doc';
 
-import { generateLexiconApi } from './codegen.js';
+import { generateLexiconApi, type ImportMapping } from './codegen.js';
 import type { LexiconConfig } from './index.js';
+import { validatePackageJson } from './lexicon-metadata.js';
+
+/**
+ * Resolves package imports to ImportMapping[]
+ */
+const resolveImportsToMappings = async (
+	imports: string[],
+	configDirname: string,
+): Promise<ImportMapping[]> => {
+	const mappings: ImportMapping[] = [];
+
+	for (const packageName of imports) {
+		// Walk up from config directory to find package in node_modules
+		let packageJson: unknown;
+		let currentDir = configDirname;
+		let found = false;
+
+		while (currentDir !== path.dirname(currentDir)) {
+			const candidatePath = path.join(currentDir, 'node_modules', packageName, 'package.json');
+			try {
+				const content = await fs.readFile(candidatePath, 'utf8');
+				packageJson = JSON.parse(content);
+				found = true;
+				break;
+			} catch (err: any) {
+				// Only continue to parent if file not found
+				if (err.code !== 'ENOENT') {
+					console.error(pc.bold(pc.red(`failed to read package.json for "${packageName}":`)));
+					console.error(err);
+					process.exit(1);
+				}
 
-const program = new Program({ binaryName: 'lex-cli' });
+				// Not found, try parent directory
+				currentDir = path.dirname(currentDir);
+			}
+		}
 
-program.register(Builtins.HelpCommand);
+		if (!found) {
+			console.error(pc.bold(pc.red(`failed to resolve package "${packageName}"`)));
+			console.error(`Could not find package in node_modules starting from ${configDirname}`);
+			process.exit(1);
+		}
 
-program.register(
-	class GenerateCommand extends Command {
-		static override paths = [['generate']];
+		// Validate package.json
+		const result = validatePackageJson(packageJson);
+		if (!result.success) {
+			console.error(pc.bold(pc.red(`invalid atcute:lexicons in "${packageName}":`)));
+			console.error(result.issues);
+			process.exit(1);
+		}
 
-		static override usage = Command.Usage({
-			description: `Generates TypeScript schema`,
-		});
+		const lexicons = result.output['atcute:lexicons'];
+		if (!lexicons?.mappings) {
+			continue;
+		}
 
-		config = Option.String(['-c', '--config'], {
-			required: true,
-			description: `Config file`,
-		});
+		// Convert mapping to ImportMapping[]
+		for (const [pattern, entry] of Object.entries(lexicons.mappings)) {
+			const isWildcard = pattern.endsWith('.*');
+
+			mappings.push({
+				nsid: [pattern],
+				imports: (nsid: string) => {
+					// Check if pattern matches
+					if (isWildcard) {
+						if (!nsid.startsWith(pattern.slice(0, -1))) {
+							throw new Error(`NSID ${nsid} does not match pattern ${pattern}`);
+						}
+					} else {
+						if (nsid !== pattern) {
+							throw new Error(`NSID ${nsid} does not match pattern ${pattern}`);
+						}
+					}
 
-		async execute(): Promise<number | void> {
-			const configFilename = path.resolve(this.config);
-			const configDirname = path.dirname(configFilename);
+					const nsidPrefix = isWildcard ? pattern.slice(0, -2) : pattern;
+					const nsidRemainder = isWildcard ? nsid.slice(nsidPrefix.length + 1) : '';
 
-			let config: LexiconConfig;
-			try {
-				const configURL = url.pathToFileURL(configFilename);
-				const configMod = (await import(configURL.href)) as { default: LexiconConfig };
-				config = configMod.default;
-			} catch (err) {
-				console.error(pc.bold(pc.red(`failed to import config:`)));
-				console.error(err);
-
-				return 1;
-			}
+					let expandedPath = entry.path
+						.replaceAll('{{nsid}}', nsid.replaceAll('.', '/'))
+						.replaceAll('{{nsid_remainder}}', nsidRemainder.replaceAll('.', '/'))
+						.replaceAll('{{nsid_prefix}}', nsidPrefix.replaceAll('.', '/'));
 
-			const documents: LexiconDoc[] = [];
+					if (expandedPath === '.') {
+						expandedPath = packageName;
+					} else if (expandedPath.startsWith('./')) {
+						expandedPath = `${packageName}/${expandedPath.slice(2)}`;
+					}
 
-			for await (const filename of fs.glob(config.files, { cwd: configDirname })) {
-				let source: string;
-				try {
-					source = await fs.readFile(path.join(configDirname, filename), 'utf8');
-				} catch (err) {
-					console.error(pc.bold(pc.red(`file read error with "${filename}"`)));
-					console.error(err);
+					return {
+						type: entry.type,
+						from: expandedPath,
+					};
+				},
+			});
+		}
+	}
 
-					return 1;
-				}
+	return mappings;
+};
 
-				let json: unknown;
-				try {
-					json = JSON.parse(source);
-				} catch (err) {
-					console.error(pc.bold(pc.red(`json parse error in "${filename}"`)));
-					console.error(err);
+const parser = command(
+	'generate',
+	object({
+		type: constant('generate'),
+		config: option('-c', '--config', pathParser({ metavar: 'CONFIG' })),
+	}),
+);
 
-					return 1;
-				}
+const result = run(parser, { programName: 'lex-cli' });
 
-				const result = lexiconDoc.try(json, { mode: 'strip' });
-				if (!result.ok) {
-					console.error(pc.bold(pc.red(`schema validation failed for "${filename}"`)));
-					console.error(result.message);
+if (result.type === 'generate') {
+	const configFilename = path.resolve(result.config);
+	const configDirname = path.dirname(configFilename);
 
-					for (const issue of result.issues) {
-						console.log(`- ${issue.code} at .${issue.path.join('.')}`);
-					}
+	let config: LexiconConfig;
+	try {
+		const configURL = url.pathToFileURL(configFilename);
+		const configMod = (await import(configURL.href)) as { default: LexiconConfig };
+		config = configMod.default;
+	} catch (err) {
+		console.error(pc.bold(pc.red(`failed to import config:`)));
+		console.error(err);
 
-					return 1;
-				}
+		process.exit(1);
+	}
 
-				documents.push(result.value);
-			}
+	// Resolve imports to mappings
+	const importMappings = config.imports ? await resolveImportsToMappings(config.imports, configDirname) : [];
+	const allMappings = [...importMappings, ...(config.mappings ?? [])];
 
-			const result = await generateLexiconApi({
-				documents: documents,
-				mappings: config.mappings ?? [],
-				modules: {
-					importSuffix: config.modules?.importSuffix ?? '.js',
-				},
-				prettier: {
-					cwd: process.cwd(),
-				},
-			});
+	const documents: LexiconDoc[] = [];
+
+	for await (const filename of fs.glob(config.files, { cwd: configDirname })) {
+		let source: string;
+		try {
+			source = await fs.readFile(path.join(configDirname, filename), 'utf8');
+		} catch (err) {
+			console.error(pc.bold(pc.red(`file read error with "${filename}"`)));
+			console.error(err);
+
+			process.exit(1);
+		}
 
-			const outdir = path.join(configDirname, config.outdir);
+		let json: unknown;
+		try {
+			json = JSON.parse(source);
+		} catch (err) {
+			console.error(pc.bold(pc.red(`json parse error in "${filename}"`)));
+			console.error(err);
 
-			for (const file of result.files) {
-				const filename = path.join(outdir, file.filename);
-				const dirname = path.dirname(filename);
+			process.exit(1);
+		}
+
+		const result = lexiconDoc.try(json, { mode: 'strip' });
+		if (!result.ok) {
+			console.error(pc.bold(pc.red(`schema validation failed for "${filename}"`)));
+			console.error(result.message);
 
-				await fs.mkdir(dirname, { recursive: true });
-				await fs.writeFile(filename, file.code);
+			for (const issue of result.issues) {
+				console.log(`- ${issue.code} at .${issue.path.join('.')}`);
 			}
+
+			process.exit(1);
 		}
-	},
-);
 
-const exitCode = await program.run(process.argv.slice(2));
-process.exitCode = exitCode;
+		documents.push(result.value);
+	}
+
+	const generationResult = await generateLexiconApi({
+		documents: documents,
+		mappings: allMappings,
+		modules: {
+			importSuffix: config.modules?.importSuffix ?? '.js',
+		},
+		prettier: {
+			cwd: process.cwd(),
+		},
+	});
+
+	const outdir = path.join(configDirname, config.outdir);
+
+	for (const file of generationResult.files) {
+		const filename = path.join(outdir, file.filename);
+		const dirname = path.dirname(filename);
+
+		await fs.mkdir(dirname, { recursive: true });
+		await fs.writeFile(filename, file.code);
+	}
+}

package/src/codegen.ts

@@ -11,6 +11,8 @@ import type {
 	LexPrimitive,
 	LexRecord,
 	LexRefVariant,
+	LexUnknown,
+	LexUserType,
 	LexXrpcBody,
 	LexXrpcParameters,
 	LexXrpcProcedure,
@@ -564,6 +566,11 @@ const generateObject = (
 			call = `${PURE} v.optional(${call})`;
 		}
 
+		const jsdoc = generateJsdocField(propSpec);
+		if (jsdoc.length !== 0) {
+			inner += `\n${jsdoc}\n`;
+		}
+
 		if (lazy) {
 			inner += `get ${lit(prop)} () { return ${call} },`;
 		} else {
@@ -574,6 +581,112 @@ const generateObject = (
 	return `${PURE} v.object({\n${inner}})`;
 };
 
+const IS_DEPRECATED_PREFIX_RE = /^\s*(?:\(deprecated\)|deprecated[.:;])/i;
+const IS_DEPRECATED_SUFFIX_RE = /\b(?:deprecated(?::[^]+)?)\s*$/i;
+
+const generateJsdocField = (spec: LexUserType | LexRefVariant | LexUnknown) => {
+	const lines: string[] = [];
+
+	if ('description' in spec && spec.description) {
+		let desc = spec.description
+			.replace(/\*\//g, '*\\/')
+			.replace(/@/g, '\\@')
+			.replace(/\r?\n/g, ' ')
+			.replace(/\s+/g, ' ')
+			.trim();
+
+		if (desc) {
+			lines.push(desc);
+		}
+
+		if (IS_DEPRECATED_PREFIX_RE.test(desc) || IS_DEPRECATED_SUFFIX_RE.test(desc)) {
+			lines.push(`@deprecated`);
+		}
+	}
+
+	// Add annotations based on property spec type
+	switch (spec.type) {
+		case 'boolean': {
+			if (spec.default !== undefined) {
+				lines.push(`@default ${lit(spec.default)}`);
+			}
+			break;
+		}
+		case 'string': {
+			if (spec.minLength !== undefined) {
+				lines.push(`@minLength ${spec.minLength}`);
+			}
+			if (spec.maxLength !== undefined) {
+				lines.push(`@maxLength ${spec.maxLength}`);
+			}
+			if (spec.minGraphemes !== undefined) {
+				lines.push(`@minGraphemes ${spec.minGraphemes}`);
+			}
+			if (spec.maxGraphemes !== undefined) {
+				lines.push(`@maxGraphemes ${spec.maxGraphemes}`);
+			}
+			if (spec.default !== undefined) {
+				lines.push(`@default ${lit(spec.default)}`);
+			}
+			break;
+		}
+		case 'integer': {
+			if (spec.minimum !== undefined) {
+				lines.push(`@minimum ${spec.minimum}`);
+			}
+			if (spec.maximum !== undefined) {
+				lines.push(`@maximum ${spec.maximum}`);
+			}
+			if (spec.default !== undefined) {
+				lines.push(`@default ${lit(spec.default)}`);
+			}
+			break;
+		}
+		case 'bytes': {
+			if (spec.minLength !== undefined) {
+				lines.push(`@minLength ${spec.minLength}`);
+			}
+			if (spec.maxLength !== undefined) {
+				lines.push(`@maxLength ${spec.maxLength}`);
+			}
+			break;
+		}
+		case 'array': {
+			if (spec.minLength !== undefined) {
+				lines.push(`@minLength ${spec.minLength}`);
+			}
+			if (spec.maxLength !== undefined) {
+				lines.push(`@maxLength ${spec.maxLength}`);
+			}
+			break;
+		}
+		case 'blob': {
+			if (spec.accept) {
+				const accept = spec.accept.map((mime) => mime.replace(/\*\//g, '*\\/')).join(', ');
+				lines.push(`@accept ${accept}`);
+			}
+			if (spec.maxSize !== undefined) {
+				lines.push(`@maxSize ${spec.maxSize}`);
+			}
+			break;
+		}
+	}
+
+	let res = ``;
+	if (lines.length > 0) {
+		res += `/**\n`;
+
+		for (let idx = 0, len = lines.length; idx < len; idx++) {
+			const line = lines[idx];
+			res += ` * ${line}\n`;
+		}
+
+		res += `*/`;
+	}
+
+	return res;
+};
+
 const generateType = (
 	imports: ImportSet,
 	defUri: string,
@@ -678,7 +791,13 @@ const generateType = (
 			}
 
 			if (spec.enum !== undefined) {
-				return `${PURE} v.literalEnum(${lit(spec.enum.toSorted())})`;
+				let call = `${PURE} v.literalEnum(${lit(spec.enum.toSorted())})`;
+
+				if (spec.default !== undefined) {
+					call = `${PURE} v.optional(${call}, ${lit(spec.default)})`;
+				}
+
+				return call;
 			}
 
 			let pipe: string[] = [];
@@ -709,7 +828,13 @@ const generateType = (
 			}
 
 			if (spec.enum !== undefined) {
-				return `${PURE} v.literalEnum(${lit(spec.enum.toSorted())})`;
+				let call = `${PURE} v.literalEnum(${lit(spec.enum.toSorted())})`;
+
+				if (spec.default !== undefined) {
+					call = `${PURE} v.optional(${call}, ${lit(spec.default)})`;
+				}
+
+				return call;
 			}
 
 			let pipe: string[] = [];

package/src/index.ts

@@ -3,6 +3,7 @@ import type { ImportMapping } from './codegen.js';
 export interface LexiconConfig {
 	outdir: string;
 	files: string[];
+	imports?: string[];
 	mappings?: ImportMapping[];
 	modules?: {
 		importSuffix?: string;