@atcute/lex-cli 2.4.0 → 2.5.1

package/dist/shared-options.d.ts

@@ -0,0 +1,6 @@
+export declare const sharedOptions: import("@optique/core/parser").Parser<{
+    readonly config: string | undefined;
+}, {
+    readonly config: [import("@optique/core/valueparser").ValueParserResult<string> | undefined] | undefined;
+}>;
+//# sourceMappingURL=shared-options.d.ts.map

package/dist/shared-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-options.d.ts","sourceRoot":"","sources":["../src/shared-options.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,aAAa;;;;EAMxB,CAAC"}

package/dist/shared-options.js

@@ -0,0 +1,11 @@
+import { object } from '@optique/core/constructs';
+import { message } from '@optique/core/message';
+import { optional } from '@optique/core/modifiers';
+import { option } from '@optique/core/primitives';
+import { path as pathParser } from '@optique/run/valueparser';
+export const sharedOptions = object(`Global options`, {
+    config: optional(option('-c', '--config', pathParser({ metavar: 'CONFIG' }), {
+        description: message `path to the lexicon configuration file. defaults to searching for lex.config.js or lex.config.ts in the current directory.`,
+    })),
+});
+//# sourceMappingURL=shared-options.js.map

package/dist/shared-options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-options.js","sourceRoot":"","sources":["../src/shared-options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAClD,OAAO,EAAE,IAAI,IAAI,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE9D,MAAM,CAAC,MAAM,aAAa,GAAG,MAAM,CAAC,gBAAgB,EAAE;IACrD,MAAM,EAAE,QAAQ,CACf,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,UAAU,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,EAAE;QAC3D,WAAW,EAAE,OAAO,CAAA,4HAA4H;KAChJ,CAAC,CACF;CACD,CAAC,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@atcute/lex-cli",
-  "version": "2.4.0",
+  "version": "2.5.1",
   "description": "cli tool to generate type definitions for atcute",
   "license": "0BSD",
   "repository": {
@@ -22,19 +22,22 @@
   },
   "dependencies": {
     "@badrap/valita": "^0.4.6",
-    "@optique/core": "^0.6.2",
-    "@optique/run": "^0.6.2",
+    "@optique/core": "^0.6.3",
+    "@optique/run": "^0.6.3",
     "picocolors": "^1.1.1",
-    "prettier": "^3.6.2",
-    "@atcute/lexicon-doc": "^2.0.2"
+    "prettier": "^3.7.1",
+    "@atcute/lexicon-doc": "^2.0.5",
+    "@atcute/identity": "^1.1.3",
+    "@atcute/identity-resolver": "^1.2.0",
+    "@atcute/lexicon-resolver": "^0.1.5",
+    "@atcute/lexicons": "^1.2.5"
   },
   "devDependencies": {
-    "@types/node": "^22.19.0",
-    "tschema": "^3.2.0",
-    "@atcute/lexicons": "^1.2.5"
+    "@types/node": "^22.19.1",
+    "tschema": "^3.2.0"
   },
   "scripts": {
-    "build": "pnpm run generate:schema && tsc",
+    "build": "pnpm run generate:schema && tsgo",
     "generate:schema": "node scripts/generate-schema.js",
     "prepublish": "rm -rf dist; pnpm run build"
   }

package/src/cli.ts

@@ -1,219 +1,18 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-
-import { lexiconDoc, refineLexiconDoc, type LexiconDoc } from '@atcute/lexicon-doc';
-
-import { object } from '@optique/core/constructs';
-import { command, constant, option } from '@optique/core/primitives';
 import { or } from '@optique/core/constructs';
 import { run } from '@optique/run';
-import { path as pathParser } from '@optique/run/valueparser';
-import pc from 'picocolors';
-
-import { generateLexiconApi, type ImportMapping } from './codegen.js';
-import { loadConfig } from './config.js';
-import { packageJsonSchema } from './lexicon-metadata.js';
-import { runPull } from './pull.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);
-				}
-
-				// Not found, try parent directory
-				currentDir = path.dirname(currentDir);
-			}
-		}
-
-		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);
-		}
-
-		// Validate package.json
-		const result = packageJsonSchema.try(packageJson, { mode: 'passthrough' });
-		if (!result.ok) {
-			console.error(pc.bold(pc.red(`invalid atcute:lexicons in "${packageName}":`)));
-			console.error(result.message);
-
-			for (const issue of result.issues) {
-				console.log(`- ${issue.code} at .${issue.path.join('.')}`);
-			}
-
-			process.exit(1);
-		}
-
-		const lexicons = result.value['atcute:lexicons'];
-		if (!lexicons?.mappings) {
-			continue;
-		}
-
-		// 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}`);
-						}
-					}
-
-					const nsidPrefix = isWildcard ? pattern.slice(0, -2) : pattern;
-					const nsidRemainder = isWildcard ? nsid.slice(nsidPrefix.length + 1) : '';
-
-					let expandedPath = entry.path
-						.replaceAll('{{nsid}}', nsid.replaceAll('.', '/'))
-						.replaceAll('{{nsid_remainder}}', nsidRemainder.replaceAll('.', '/'))
-						.replaceAll('{{nsid_prefix}}', nsidPrefix.replaceAll('.', '/'));
-
-					if (expandedPath === '.') {
-						expandedPath = packageName;
-					} else if (expandedPath.startsWith('./')) {
-						expandedPath = `${packageName}/${expandedPath.slice(2)}`;
-					}
-
-					return {
-						type: entry.type,
-						from: expandedPath,
-					};
-				},
-			});
-		}
-	}
 
-	return mappings;
-};
+import { exportCommandSchema, runExport } from './commands/export.js';
+import { generateCommandSchema, runGenerate } from './commands/generate.js';
+import { pullCommandSchema, runPull } from './commands/pull.js';
 
-const parser = or(
-	command(
-		'generate',
-		object({
-			type: constant('generate'),
-			config: option('-c', '--config', pathParser({ metavar: 'CONFIG' })),
-		}),
-	),
-	command(
-		'pull',
-		object({
-			type: constant('pull'),
-			config: option('-c', '--config', pathParser({ metavar: 'CONFIG' })),
-		}),
-	),
-);
+const parser = or(generateCommandSchema, pullCommandSchema, exportCommandSchema);
 
-const result = run(parser, { programName: 'lex-cli' });
+const result = run(parser, { programName: 'lex-cli', help: 'both' });
 
 if (result.type === 'generate') {
-	const config = await loadConfig(result.config);
-
-	// Resolve imports to mappings
-	const importMappings = config.imports ? await resolveImportsToMappings(config.imports, config.root) : [];
-	const allMappings = [...importMappings, ...(config.mappings ?? [])];
-
-	const documents: LexiconDoc[] = [];
-
-	for await (const filename of fs.glob(config.files, { cwd: config.root })) {
-		let source: string;
-		try {
-			source = await fs.readFile(path.join(config.root, filename), 'utf8');
-		} catch (err) {
-			console.error(pc.bold(pc.red(`file read error with "${filename}"`)));
-			console.error(err);
-
-			process.exit(1);
-		}
-
-		let json: unknown;
-		try {
-			json = JSON.parse(source);
-		} catch (err) {
-			console.error(pc.bold(pc.red(`json parse error in "${filename}"`)));
-			console.error(err);
-
-			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);
-
-			for (const issue of result.issues) {
-				console.log(`- ${issue.code} at .${issue.path.join('.')}`);
-			}
-
-			process.exit(1);
-		}
-
-		const issues = refineLexiconDoc(result.value, true);
-		if (issues.length > 0) {
-			console.error(pc.bold(pc.red(`lint validation failed for "${filename}"`)));
-
-			for (const issue of issues) {
-				console.log(`- ${issue.message} at .${issue.path.join('.')}`);
-			}
-
-			process.exit(1);
-		}
-
-		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(config.root, 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);
-	}
+	await runGenerate(result);
 } else if (result.type === 'pull') {
-	const config = await loadConfig(result.config);
-	await runPull(config);
+	await runPull(result);
+} else if (result.type === 'export') {
+	await runExport(result);
 }

package/src/codegen.ts

@@ -49,6 +49,33 @@ type Literal = string | number | boolean;
 
 const lit: (val: Literal | Literal[]) => string = JSON.stringify;
 
+interface LexPath {
+	nsid: string;
+	defId: string;
+}
+
+const toLexUri = (path: LexPath): string => {
+	const { nsid, defId } = path;
+	return defId === 'main' ? nsid : `${nsid}#${defId}`;
+};
+
+const resolvePath = (from: LexPath, ref: string): LexPath => {
+	const index = ref.indexOf('#');
+
+	// nsid (no hash)
+	if (index === -1) {
+		return { nsid: ref, defId: 'main' };
+	}
+
+	// #defId (local ref)
+	if (index === 0) {
+		return { nsid: from.nsid, defId: ref.slice(1) };
+	}
+
+	// nsid#defId (full ref)
+	return { nsid: ref.slice(0, index), defId: ref.slice(index + 1) };
+};
+
 const resolveExternalImport = (nsid: string, mappings: ImportMapping[]): ImportMapping | undefined => {
 	return mappings.find((mapping) => {
 		return mapping.nsid.some((pattern) => {
@@ -111,7 +138,7 @@ export const generateLexiconApi = async (opts: LexiconApiOptions): Promise<Lexic
 
 		for (const defId of sortedDefIds) {
 			const def = doc.defs[defId];
-			const defUri = `${doc.id}#${defId}`;
+			const path: LexPath = { nsid: doc.id, defId };
 
 			const camelcased = toCamelCase(defId);
 			const varname = `${camelcased}Schema`;
@@ -119,59 +146,59 @@ export const generateLexiconApi = async (opts: LexiconApiOptions): Promise<Lexic
 			let result: string;
 			switch (def.type) {
 				case 'query': {
-					result = generateXrpcQuery(imports, defUri, def);
+					result = generateXrpcQuery(imports, path, def);
 
 					file.imports += `import type {} from '@atcute/lexicons/ambient';\n`;
 
 					file.ambients += `declare module '@atcute/lexicons/ambient' {\n`;
 					file.ambients += `  interface XRPCQueries {\n`;
-					file.ambients += `    ${lit(stripMainHash(defUri))}: ${camelcased}Schema;\n`;
+					file.ambients += `    ${lit(toLexUri(path))}: ${camelcased}Schema;\n`;
 					file.ambients += `  }\n`;
 					file.ambients += `}`;
 					break;
 				}
 				case 'procedure': {
-					result = generateXrpcProcedure(imports, defUri, def);
+					result = generateXrpcProcedure(imports, path, def);
 
 					file.imports += `import type {} from '@atcute/lexicons/ambient';\n`;
 
 					file.ambients += `declare module '@atcute/lexicons/ambient' {\n`;
 					file.ambients += `  interface XRPCProcedures {\n`;
-					file.ambients += `    ${lit(stripMainHash(defUri))}: ${camelcased}Schema;\n`;
+					file.ambients += `    ${lit(toLexUri(path))}: ${camelcased}Schema;\n`;
 					file.ambients += `  }\n`;
 					file.ambients += `}`;
 					break;
 				}
 				case 'subscription': {
-					result = generateXrpcSubscription(imports, defUri, def);
+					result = generateXrpcSubscription(imports, path, def);
 
 					file.imports += `import type {} from '@atcute/lexicons/ambient';\n`;
 
 					file.ambients += `declare module '@atcute/lexicons/ambient' {\n`;
 					file.ambients += `  interface XRPCSubscriptions {\n`;
-					file.ambients += `    ${lit(stripMainHash(defUri))}: ${camelcased}Schema;\n`;
+					file.ambients += `    ${lit(toLexUri(path))}: ${camelcased}Schema;\n`;
 					file.ambients += `  }\n`;
 					file.ambients += `}`;
 					break;
 				}
 				case 'object': {
-					result = generateObject(imports, defUri, def);
+					result = generateObject(imports, path, def);
 					break;
 				}
 				case 'record': {
-					result = generateRecord(imports, defUri, def);
+					result = generateRecord(imports, path, def);
 
 					file.imports += `import type {} from '@atcute/lexicons/ambient';\n`;
 
 					file.ambients += `declare module '@atcute/lexicons/ambient' {\n`;
 					file.ambients += `  interface Records {\n`;
-					file.ambients += `    ${lit(stripMainHash(defUri))}: ${camelcased}Schema;\n`;
+					file.ambients += `    ${lit(toLexUri(path))}: ${camelcased}Schema;\n`;
 					file.ambients += `  }\n`;
 					file.ambients += `}`;
 					break;
 				}
 				case 'token': {
-					result = `${PURE} v.literal(${lit(stripMainHash(defUri))})`;
+					result = `${PURE} v.literal(${lit(toLexUri(path))})`;
 					break;
 				}
 				case 'permission-set': {
@@ -179,7 +206,7 @@ export const generateLexiconApi = async (opts: LexiconApiOptions): Promise<Lexic
 					continue;
 				}
 				default: {
-					result = generateType(imports, defUri, def);
+					result = generateType(imports, path, def);
 					break;
 				}
 			}
@@ -372,42 +399,42 @@ export const generateLexiconApi = async (opts: LexiconApiOptions): Promise<Lexic
 	return { files };
 };
 
-const generateXrpcQuery = (imports: ImportSet, defUri: string, spec: LexXrpcQuery): string => {
-	const params = generateXrpcParameters(imports, defUri, spec.parameters);
-	const output = generateXrpcBody(imports, defUri, spec.output);
+const generateXrpcQuery = (imports: ImportSet, path: LexPath, spec: LexXrpcQuery): string => {
+	const params = generateXrpcParameters(imports, path, spec.parameters);
+	const output = generateXrpcBody(imports, path, spec.output);
 
-	return `${PURE} v.query(${lit(stripMainHash(defUri))}, {\n"params": ${params}, "output": ${output} })`;
+	return `${PURE} v.query(${lit(toLexUri(path))}, {\n"params": ${params}, "output": ${output} })`;
 };
 
-const generateXrpcProcedure = (imports: ImportSet, defUri: string, spec: LexXrpcProcedure): string => {
-	const params = generateXrpcParameters(imports, defUri, spec.parameters);
-	const input = generateXrpcBody(imports, defUri, spec.input);
-	const output = generateXrpcBody(imports, defUri, spec.output);
+const generateXrpcProcedure = (imports: ImportSet, path: LexPath, spec: LexXrpcProcedure): string => {
+	const params = generateXrpcParameters(imports, path, spec.parameters);
+	const input = generateXrpcBody(imports, path, spec.input);
+	const output = generateXrpcBody(imports, path, spec.output);
 
-	return `${PURE} v.procedure(${lit(stripMainHash(defUri))}, {\n"params": ${params}, "input": ${input}, "output": ${output} })`;
+	return `${PURE} v.procedure(${lit(toLexUri(path))}, {\n"params": ${params}, "input": ${input}, "output": ${output} })`;
 };
 
-const generateXrpcSubscription = (imports: ImportSet, defUri: string, spec: LexXrpcSubscription): string => {
+const generateXrpcSubscription = (imports: ImportSet, path: LexPath, spec: LexXrpcSubscription): string => {
 	const schema = spec.message?.schema;
 
-	const params = generateXrpcParameters(imports, defUri, spec.parameters);
+	const params = generateXrpcParameters(imports, path, spec.parameters);
 
 	let inner = ``;
 
 	inner += `"params": ${params},`;
 
 	if (schema) {
-		const res = generateType(imports, defUri, schema);
+		const res = generateType(imports, path, schema);
 
 		inner += `get "message" () { return ${res} },`;
 	} else {
 		inner += `"message": null,`;
 	}
 
-	return `${PURE} v.subscription(${lit(stripMainHash(defUri))}, {\n${inner}})`;
+	return `${PURE} v.subscription(${lit(toLexUri(path))}, {\n${inner}})`;
 };
 
-const generateXrpcBody = (imports: ImportSet, defUri: string, spec: LexXrpcBody | undefined): string => {
+const generateXrpcBody = (imports: ImportSet, path: LexPath, spec: LexXrpcBody | undefined): string => {
 	if (spec === undefined) {
 		return `null`;
 	}
@@ -421,11 +448,11 @@ const generateXrpcBody = (imports: ImportSet, defUri: string, spec: LexXrpcBody
 		inner += `"type": "lex",`;
 
 		if (schema.type === 'object') {
-			const res = generateObject(imports, defUri, schema, 'none');
+			const res = generateObject(imports, path, schema, 'none');
 
 			inner += `"schema": ${res},`;
 		} else {
-			const res = generateType(imports, defUri, schema);
+			const res = generateType(imports, path, schema);
 
 			inner += `get "schema" () { return ${res} },`;
 		}
@@ -452,7 +479,7 @@ const generateXrpcBody = (imports: ImportSet, defUri: string, spec: LexXrpcBody
 
 const generateXrpcParameters = (
 	imports: ImportSet,
-	defUri: string,
+	path: LexPath,
 	spec: LexXrpcParameters | undefined,
 ): string => {
 	if (spec === undefined) {
@@ -489,11 +516,11 @@ const generateXrpcParameters = (
 		properties: transformedProperties ?? originalProperties,
 	};
 
-	return generateObject(imports, defUri, mask, 'none');
+	return generateObject(imports, path, mask, 'none');
 };
 
-const generateRecord = (imports: ImportSet, defUri: string, spec: LexRecord): string => {
-	const schema = generateObject(imports, defUri, spec.record, 'required');
+const generateRecord = (imports: ImportSet, path: LexPath, spec: LexRecord): string => {
+	const schema = generateObject(imports, path, spec.record, 'required');
 
 	let key = `${PURE} v.string()`;
 	if (spec.key) {
@@ -511,7 +538,7 @@ const generateRecord = (imports: ImportSet, defUri: string, spec: LexRecord): st
 
 const generateObject = (
 	imports: ImportSet,
-	defUri: string,
+	path: LexPath,
 	spec: LexObject,
 	writeType: 'required' | 'optional' | 'none' = 'optional',
 ): string => {
@@ -522,11 +549,11 @@ const generateObject = (
 
 	switch (writeType) {
 		case 'optional': {
-			inner += `"$type": ${PURE} v.optional(${PURE} v.literal(${lit(stripMainHash(defUri))})),`;
+			inner += `"$type": ${PURE} v.optional(${PURE} v.literal(${lit(toLexUri(path))})),`;
 			break;
 		}
 		case 'required': {
-			inner += `"$type": ${PURE} v.literal(${lit(stripMainHash(defUri))}),`;
+			inner += `"$type": ${PURE} v.literal(${lit(toLexUri(path))}),`;
 			break;
 		}
 	}
@@ -544,10 +571,10 @@ const generateObject = (
 
 	for (const [prop, propSpec] of sortedEntries) {
 		const lazy = isRefVariant(propSpec.type === 'array' ? propSpec.items : propSpec);
-		const optional = !required.has(prop) && !('default' in propSpec);
+		const optional = !required.has(prop) && !('default' in propSpec && propSpec.default !== undefined);
 		const nulled = nullable.has(prop);
 
-		let call = generateType(imports, defUri, propSpec, lazy);
+		let call = generateType(imports, path, propSpec, lazy);
 
 		if (nulled) {
 			call = `${PURE} v.nullable(${call})`;
@@ -678,62 +705,50 @@ const generateJsdocField = (spec: LexUserType | LexRefVariant | LexUnknown) => {
 	return res;
 };
 
-const generateType = (imports: ImportSet, defUri: string, spec: LexDefinableField, lazy = false): string => {
+const generateType = (imports: ImportSet, path: LexPath, spec: LexDefinableField, lazy = false): string => {
 	switch (spec.type) {
 		// LexRefVariant
 		case 'ref': {
-			const ref = spec.ref;
-
-			if (ref.startsWith('#')) {
-				const id = ref.slice(1);
-
-				return `${toCamelCase(id)}Schema`;
-			} else {
-				const [ns, id = 'main'] = ref.split('#');
-				if (ns === stripHash(defUri)) {
-					return `${toCamelCase(id)}Schema`;
-				}
-
-				imports.add(ns);
+			const refPath = resolvePath(path, spec.ref);
 
-				return `${toTitleCase(ns)}.${toCamelCase(id)}Schema`;
+			if (refPath.nsid === path.nsid) {
+				return `${toCamelCase(refPath.defId)}Schema`;
 			}
+
+			imports.add(refPath.nsid);
+			return `${toTitleCase(refPath.nsid)}.${toCamelCase(refPath.defId)}Schema`;
 		}
 		case 'union': {
-			const normalizedRefs = spec.refs
-				.map((ref): string => {
-					if (ref.startsWith('#')) {
-						return ref;
+			const refs = spec.refs
+				.map((ref) => {
+					const refPath = resolvePath(path, ref);
+					return { path: refPath, uri: toLexUri(refPath) };
+				})
+				.sort((a, b) => {
+					if (a.uri < b.uri) {
+						return -1;
 					}
-
-					const [ns, id = 'main'] = ref.split('#');
-					if (ns === stripHash(defUri)) {
-						return `#${id}`;
+					if (a.uri > b.uri) {
+						return 1;
 					}
 
-					return `${ns}#${id}`;
+					return 0;
 				})
-				.sort();
-
-			const refs = normalizedRefs.map((ref): string => {
-				if (ref.startsWith('#')) {
-					const id = ref.slice(1);
-
-					return `${toCamelCase(id)}Schema`;
-				} else {
-					const [ns, id = 'main'] = ref.split('#');
-					imports.add(ns);
+				.map(({ path: refPath }): string => {
+					if (refPath.nsid === path.nsid) {
+						return `${toCamelCase(refPath.defId)}Schema`;
+					}
 
-					return `${toTitleCase(ns)}.${toCamelCase(id)}Schema`;
-				}
-			});
+					imports.add(refPath.nsid);
+					return `${toTitleCase(refPath.nsid)}.${toCamelCase(refPath.defId)}Schema`;
+				});
 
 			return `${PURE} v.variant([${refs.join(', ')}]${spec.closed ? `, true` : ``})`;
 		}
 
 		// LexArray
 		case 'array': {
-			let item = generateType(imports, defUri, spec.items);
+			let item = generateType(imports, path, spec.items);
 			if (!lazy && (spec.items.type === 'ref' || spec.items.type === 'union')) {
 				item = `(() => { return ${item}; })`;
 			}
@@ -924,19 +939,6 @@ const isRefVariant = (spec: LexDefinableField): spec is LexRefVariant => {
 	return type === 'ref' || type === 'union';
 };
 
-const stripHash = (defUri: string): string => {
-	const index = defUri.indexOf('#');
-	if (index === -1) {
-		return defUri;
-	}
-
-	return defUri.slice(0, index);
-};
-
-const stripMainHash = (defUri: string): string => {
-	return defUri.endsWith('#main') ? defUri.slice(0, -'#main'.length) : defUri;
-};
-
 const toTitleCase = (v: string): string => {
 	v = v.replace(/^([a-z])/gi, (_, g) => g.toUpperCase());
 	v = v.replace(/[.#-]([a-z])/gi, (_, g) => g.toUpperCase());