@deepseek-ai/dsh-typert-generator 0.1.2-rc.1 → 0.1.5-alpha.1

package/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/typert/generator/README.md
-README.md: a3deccbb9ba0847d02b532732a87ec52da1a2d7c
-README.zh.md: 5983a4d9ecc7914320718338931d354a8e85d032
+README.md: 48d79dfc44f6c2f658e8aa13836e5044d6cbf25d
+README.zh.md: e546661fe297d09367185585e43d486cd417090d

package/README.md

@@ -9,7 +9,7 @@ English | [中文](README.zh.md)
 
 ## Summary
 
-`dsh-typert-generator` turns source TypeScript into compiler-independent data and runnable artifacts at build time: it analyzes a workspace's package type trees, produces a `FaceModel` and type graph, and emits executable JavaScript with supported Zod schemas and a `TYPERT` reflection contribution, plus matching declarations. It is a build-time library, not a plugin — it never runs inside a live agent session. The repository's Host tsdown runs it automatically; a business package opts in by exporting `./typert` and `./client/typert` entries, and the generator validates those exports and published file lists. Static consumers can also call the analyzer directly for type inspection or catalog generation without publishing anything.
+`dsh-typert-generator` lets maintainers turn public TypeScript types into build artifacts and compiler-independent models. Packages opt in through the `./typert` and optional `./client/typert` exports, and generation rejects declarations, publish lists, Remote exports, or Zod projections that it cannot represent correctly. Repository builds can emit executable schemas and matching declarations, while tools can call `WorkspaceAnalyzer` for inspection or catalog generation without publishing artifacts. Generation runs only at build time and never in a live agent session.
 
 ## Table of Contents
 
@@ -79,7 +79,7 @@ The generator is built on one separation: extraction and emission are decoupled
 
 ### Analysis and faces
 
-Host and client are independent TypeScript programs. Direct project references establish compiler-face membership, while `dsh.client` package subpaths establish runtime-face contribution; `package.json#exports` marks every cross-package public boundary, and imports or re-exports are the only cross-face edges. `check` mode fails on syntax or semantic diagnostics, missing public annotations, private cross-package references, and reachable declaration merges the model cannot retain losslessly; `write` mode inserts checker-derived annotations and returns a clean check-mode model. Types owned by NPM dependencies remain `external` references instead of being expanded.
+Host and client are independent TypeScript programs. Direct project references establish compiler-face membership, while `dsh.client` package subpaths establish runtime-face contribution; `package.json#exports` marks every cross-package public boundary, and imports or re-exports are the only cross-face edges. A relative import that resolves inside the referencing package is followed through that module's re-exports until a package specifier appears, so package-local forwarding modules keep their original declaration references; a relative import that resolves into another package fails. `check` mode fails on syntax or semantic diagnostics, missing public annotations, private cross-package references, and reachable declaration merges the model cannot retain losslessly; `write` mode inserts checker-derived annotations and returns a clean check-mode model. Types owned by NPM dependencies remain `external` references instead of being expanded.
 
 ### Emission and publication contract
 

package/README.zh.md

@@ -9,7 +9,7 @@ kind: "package-library"
 
 ## 概述
 
-`dsh-typert-generator` 在构建时把源代码 TypeScript 转换为与编译器无关的数据与可运行产物：它分析工作区各包的类型树，生成 `FaceModel` 与类型图，并输出包含受支持 Zod schema 与 `TYPERT` 反射贡献的可执行 JavaScript，以及配套声明文件。它是构建时库而非插件——绝不会在实时 agent 会话中运行。仓库的 Host tsdown 会自动运行它；业务包通过导出 `./typert` 与 `./client/typert` 入口选择加入，生成器会校验这些导出与发布文件清单。静态消费方也可以直接调用分析器进行类型检查或目录生成，无需发布任何内容。
+`dsh-typert-generator` 让维护者把公开的 TypeScript 类型转换为构建产物和与编译器无关的模型。包通过 `./typert` 和可选的 `./client/typert` 导出选择加入；如果声明、发布清单、Remote 导出或 Zod 投影无法被正确表示，生成过程就会失败。仓库构建可以生成可执行 schema 与配套声明，工具也可以调用 `WorkspaceAnalyzer` 完成检查或目录生成而不发布产物。生成过程只在构建时运行，绝不会进入实时 agent 会话。
 
 ## 目录
 
@@ -79,7 +79,7 @@ files:
 
 ### 分析与 face
 
-Host 与 Client 是两个独立的 TypeScript 程序。直接项目引用确定编译器 face 的成员归属，`dsh.client` 包子路径则确定运行时 face 的贡献；`package.json#exports` 划定所有跨包公开边界，跨 face 的边只能来自导入或重新导出。`check` 模式遇到语法或语义诊断、缺失的公开类型标注、跨包私有引用，以及模型无法无损保留的可达声明合并时都会失败；`write` 模式插入类型检查器推导出的标注，并返回无诊断的 check 模式模型。NPM 依赖拥有的类型继续以 `external` 引用表示，不会被展开。
+Host 与 Client 是两个独立的 TypeScript 程序。直接项目引用确定编译器 face 的成员归属，`dsh.client` 包子路径则确定运行时 face 的贡献；`package.json#exports` 划定所有跨包公开边界，跨 face 的边只能来自导入或重新导出。解析到本包内部模块的相对导入会沿该模块的重新导出继续追踪，直到出现包说明符，因此包内转发模块保留原始声明引用；解析到其他包的相对导入会失败。`check` 模式遇到语法或语义诊断、缺失的公开类型标注、跨包私有引用，以及模型无法无损保留的可达声明合并时都会失败；`write` 模式插入类型检查器推导出的标注，并返回无诊断的 check 模式模型。NPM 依赖拥有的类型继续以 `external` 引用表示，不会被展开。
 
 ### 生成与发布约定
 

package/lib/index.js

@@ -148,15 +148,17 @@ var WorkspaceAnalyzer = class WorkspaceAnalyzer {
 					incremental: false,
 					noEmit: true
 				};
+				const host = this.caches.programHost(face, options);
 				const program = ts.createProgram({
 					rootNames,
 					options,
-					host: this.caches.programHost(face, options)
+					host
 				});
 				faces.push(new FaceAnalyzer({
 					root: this.options.root,
 					face,
 					program,
+					host,
 					registrations,
 					allRegistrations: this.registrations,
 					mode: this.options.mode,
@@ -355,6 +357,7 @@ var FaceAnalyzer = class {
 	root;
 	face;
 	program;
+	host;
 	checker;
 	registrations;
 	allRegistrations;
@@ -373,6 +376,7 @@ var FaceAnalyzer = class {
 		this.root = options.root;
 		this.face = options.face;
 		this.program = options.program;
+		this.host = options.host;
 		this.checker = options.program.getTypeChecker();
 		this.registrations = options.registrations;
 		this.allRegistrations = options.allRegistrations;
@@ -524,15 +528,78 @@ var FaceAnalyzer = class {
 			reachable.set(fileName, sourceFile);
 			for (const statement of sourceFile.statements) {
 				if (!ts.isImportDeclaration(statement) && !ts.isExportDeclaration(statement) || statement.moduleSpecifier === void 0 || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
-				const resolved = ts.resolveModuleName(statement.moduleSpecifier.text, sourceFile.fileName, this.program.getCompilerOptions(), ts.sys).resolvedModule;
-				if (resolved === void 0) continue;
-				const resolvedPath = realPath(resolved.resolvedFileName);
-				if (!isWithin(resolvedPath, registration.root)) continue;
+				const resolvedPath = this.resolveImport(statement.moduleSpecifier.text, sourceFile.fileName);
+				if (resolvedPath === void 0 || !isWithin(resolvedPath, registration.root)) continue;
 				queue.push(this.sourceFiles.get(resolvedPath));
 			}
 		}
 		return [...reachable.values()].sort((left, right) => left.fileName.localeCompare(right.fileName));
 	}
+	resolveImport(specifier, fromFile) {
+		const resolved = ts.resolveModuleName(specifier, fromFile, this.program.getCompilerOptions(), this.host, this.host.getModuleResolutionCache?.()).resolvedModule;
+		return resolved === void 0 ? void 0 : realPath(resolved.resolvedFileName);
+	}
+	/**
+	* Follow the import that names `symbol` at `site` through modules of the
+	* referencing package until a package specifier appears. Each forwarding
+	* module and requested export name pair is entered once; its explicit export
+	* edges are tried before its star edges. A relative specifier that resolves
+	* outside `from`, a namespace hop, or a module with no edge leading to a
+	* package specifier yields undefined.
+	*/
+	packageImportOf(site, moduleSpecifier, symbol, from) {
+		const visited = /* @__PURE__ */ new Map();
+		const walk = (sourceFile, specifier, name) => {
+			const module = moduleIdentity(specifier);
+			if (module !== void 0) return {
+				module,
+				name
+			};
+			const resolvedPath = this.resolveImport(specifier, sourceFile.fileName);
+			if (resolvedPath === void 0 || !isWithin(resolvedPath, from.root)) return void 0;
+			const names = visited.get(resolvedPath);
+			if (names?.has(name)) return void 0;
+			if (names === void 0) visited.set(resolvedPath, new Set([name]));
+			else names.add(name);
+			const forward = this.sourceFiles.get(resolvedPath);
+			for (const edge of this.forwardedExports(forward, name, symbol)) {
+				const found = walk(forward, edge.specifier, edge.name);
+				if (found !== void 0) return found;
+			}
+		};
+		return walk(site.getSourceFile(), moduleSpecifier, authoredExportName(site, moduleSpecifier));
+	}
+	/** Export edges of `sourceFile` that carry `name`: explicit edges in source order, then star edges exporting `symbol`. */
+	forwardedExports(sourceFile, name, symbol) {
+		const explicit = [];
+		const stars = [];
+		for (const statement of sourceFile.statements) {
+			if (!ts.isExportDeclaration(statement) || statement.exportClause === void 0 && statement.moduleSpecifier === void 0 || statement.exportClause !== void 0 && ts.isNamespaceExport(statement.exportClause)) continue;
+			if (statement.exportClause === void 0) {
+				const specifier = statement.moduleSpecifier.text;
+				if (this.moduleExports(statement.moduleSpecifier).find((candidate) => candidate.name === name && this.resolveSymbol(candidate) === symbol) !== void 0) stars.push({
+					specifier,
+					name
+				});
+				continue;
+			}
+			const element = statement.exportClause.elements.find((candidate) => candidate.name.text === name);
+			if (element === void 0) continue;
+			if (statement.moduleSpecifier !== void 0) {
+				explicit.push({
+					specifier: statement.moduleSpecifier.text,
+					name: element.propertyName?.text ?? name
+				});
+				continue;
+			}
+			const binding = importBindingOf(sourceFile, element.propertyName?.text ?? name);
+			if (binding?.name !== void 0) explicit.push({
+				specifier: binding.specifier,
+				name: binding.name
+			});
+		}
+		return [...explicit, ...stars];
+	}
 	collectServices(context, records) {
 		const bySymbol = /* @__PURE__ */ new Map();
 		for (const record of records) {
@@ -1760,14 +1827,13 @@ var FaceAnalyzer = class {
 			name: symbol.name
 		};
 		const moduleSpecifier = moduleSpecifierOf(site);
-		const module = moduleSpecifier === void 0 ? void 0 : moduleIdentity(moduleSpecifier);
 		const from = this.registrationForFile(site.getSourceFile().fileName);
 		const owner = this.registrationForFile(declaration.getSourceFile().fileName);
 		if (owner !== void 0) {
 			if (owner.name !== from.name) {
-				if (module === void 0) this.fail(site, `reference to ${symbol.name} crosses a package without an explicit package import`);
-				const exportName = authoredExportName(site, moduleSpecifier);
-				if (this.packageExportName(module, symbol, owner.face, exportName) === void 0) this.fail(site, `package reference ${exportName} is not exported by ${module.package} at ${module.subpath}`);
+				const imported = moduleSpecifier === void 0 ? void 0 : this.packageImportOf(site, moduleSpecifier, symbol, from);
+				if (imported === void 0) this.fail(site, `reference to ${symbol.name} crosses a package without an explicit package import`);
+				if (this.packageExportName(imported.module, symbol, owner.face, imported.name) === void 0) this.fail(site, `package reference ${imported.name} is not exported by ${imported.module.package} at ${imported.module.subpath}`);
 			}
 			const typeDeclaration = declaration;
 			if (!this.declarationStates.has(this.symbolId(symbol))) this.ensureDeclaration(symbol, typeDeclaration);
@@ -1776,11 +1842,12 @@ var FaceAnalyzer = class {
 				symbol: this.symbolId(symbol)
 			};
 		}
-		const otherFace = (module === void 0 ? [] : [...new Set(this.allRegistrations.filter((candidate) => candidate.name === module.package).map((candidate) => candidate.face))]).find((face) => face !== this.face);
-		if (otherFace !== void 0 && module !== void 0) {
-			const requestedName = authoredExportName(site, moduleSpecifier);
-			const exportName = this.packageExportName(module, symbol, otherFace, requestedName);
-			if (exportName === void 0) this.fail(site, `cross-face reference ${requestedName} is not exported by ${module.package} at ${module.subpath}`);
+		const imported = moduleSpecifier === void 0 ? void 0 : this.packageImportOf(site, moduleSpecifier, symbol, from);
+		const otherFace = (imported === void 0 ? [] : [...new Set(this.allRegistrations.filter((candidate) => candidate.name === imported.module.package).map((candidate) => candidate.face))]).find((face) => face !== this.face);
+		if (otherFace !== void 0 && imported !== void 0) {
+			const { module } = imported;
+			const exportName = this.packageExportName(module, symbol, otherFace, imported.name);
+			if (exportName === void 0) this.fail(site, `cross-face reference ${imported.name} is not exported by ${module.package} at ${module.subpath}`);
 			this.recordCrossFaceLink(from.name, otherFace, module, exportName);
 			return {
 				kind: "cross-face",
@@ -1790,10 +1857,10 @@ var FaceAnalyzer = class {
 				name: exportName
 			};
 		}
-		if (module !== void 0) return {
+		if (imported !== void 0) return {
 			kind: "external",
-			module: module.package,
-			subpath: module.subpath,
+			module: imported.module.package,
+			subpath: imported.module.subpath,
 			name: symbol.name
 		};
 		const external = externalModuleIdentityForFile(declaration.getSourceFile().fileName);
@@ -1826,6 +1893,7 @@ var FaceAnalyzer = class {
 	}
 	packageExportName(module, symbol, face, requestedName) {
 		const registration = this.allRegistrations.find((candidate) => candidate.face === face && candidate.name === module.package);
+		if (registration === void 0) return void 0;
 		const target = packageExportTargets(registration.manifest).find(([subpath]) => subpath === module.subpath)?.[1];
 		if (target === void 0) return void 0;
 		const sourceFile = this.sourceFiles.get(realPath(sourcePathForExport(registration.root, target)));
@@ -2203,30 +2271,37 @@ function moduleSpecifierOf(node) {
 	const symbol = ts.isTypeReferenceNode(node) ? node.typeName : node.expression;
 	const sourceFile = node.getSourceFile();
 	const first = ts.isIdentifier(symbol) ? symbol.text : symbol.getFirstToken(sourceFile)?.getText(sourceFile);
-	for (const statement of sourceFile.statements) {
-		if (!ts.isImportDeclaration(statement) || statement.importClause === void 0 || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
-		if (statement.importClause.name?.text === first) return statement.moduleSpecifier.text;
-		const bindings = statement.importClause.namedBindings;
-		if (bindings !== void 0 && ts.isNamespaceImport(bindings) && bindings.name.text === first) return statement.moduleSpecifier.text;
-		if (bindings !== void 0 && ts.isNamedImports(bindings) && bindings.elements.some((element) => element.name.text === first)) return statement.moduleSpecifier.text;
-	}
+	return first === void 0 ? void 0 : importBindingOf(sourceFile, first)?.specifier;
 }
 function authoredExportName(node, moduleSpecifier) {
 	if (ts.isImportTypeNode(node)) return node.qualifier.getText().split(".")[0];
 	const referenced = ts.isTypeReferenceNode(node) ? node.typeName.getText().split(".") : node.expression.getText().split(".");
 	const localName = referenced[0];
-	for (const statement of node.getSourceFile().statements) {
-		if (!ts.isImportDeclaration(statement) || statement.importClause === void 0 || !ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== moduleSpecifier) continue;
-		if (statement.importClause.name?.text === localName) return "default";
+	const binding = importBindingOf(node.getSourceFile(), localName);
+	/* v8 ignore next -- moduleSpecifierOf returns only the import inspected by importBindingOf. */
+	if (binding === void 0) throw new TypertAnalysisError(`typert: cannot recover export name for ${localName} from ${moduleSpecifier}`);
+	return binding.name ?? referenced[1];
+}
+function importBindingOf(sourceFile, localName) {
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement) || statement.importClause === void 0 || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+		const specifier = statement.moduleSpecifier.text;
+		if (statement.importClause.name?.text === localName) return {
+			specifier,
+			name: "default"
+		};
 		const bindings = statement.importClause.namedBindings;
-		if (bindings !== void 0 && ts.isNamedImports(bindings)) {
-			const imported = bindings.elements.find((element) => element.name.text === localName);
-			if (imported !== void 0) return imported.propertyName?.text ?? imported.name.text;
+		if (bindings === void 0) continue;
+		if (ts.isNamespaceImport(bindings)) {
+			if (bindings.name.text === localName) return { specifier };
+			continue;
 		}
-		if (bindings !== void 0 && ts.isNamespaceImport(bindings) && bindings.name.text === localName) return referenced[1];
+		const element = bindings.elements.find((candidate) => candidate.name.text === localName);
+		if (element !== void 0) return {
+			specifier,
+			name: element.propertyName?.text ?? element.name.text
+		};
 	}
-	/* v8 ignore next -- moduleSpecifierOf returns only the matching import inspected by this loop. */
-	throw new TypertAnalysisError(`typert: cannot recover export name for ${localName} from ${moduleSpecifier}`);
 }
 function importTypeAttributesText(node) {
 	const sourceFile = node.getSourceFile();

package/lib/types/analyzer.js

@@ -164,15 +164,13 @@ export class WorkspaceAnalyzer {
                     incremental: false,
                     noEmit: true,
                 };
-                const program = ts.createProgram({
-                    rootNames,
-                    options,
-                    host: this.caches.programHost(face, options),
-                });
+                const host = this.caches.programHost(face, options);
+                const program = ts.createProgram({ rootNames, options, host });
                 faces.push(new FaceAnalyzer({
                     root: this.options.root,
                     face,
                     program,
+                    host,
                     registrations,
                     allRegistrations: this.registrations,
                     mode: this.options.mode,
@@ -425,6 +423,7 @@ class FaceAnalyzer {
     root;
     face;
     program;
+    host;
     checker;
     registrations;
     allRegistrations;
@@ -443,6 +442,7 @@ class FaceAnalyzer {
         this.root = options.root;
         this.face = options.face;
         this.program = options.program;
+        this.host = options.host;
         this.checker = options.program.getTypeChecker();
         this.registrations = options.registrations;
         this.allRegistrations = options.allRegistrations;
@@ -651,17 +651,82 @@ class FaceAnalyzer {
                     || statement.moduleSpecifier === undefined
                     || !ts.isStringLiteral(statement.moduleSpecifier))
                     continue;
-                const resolved = ts.resolveModuleName(statement.moduleSpecifier.text, sourceFile.fileName, this.program.getCompilerOptions(), ts.sys).resolvedModule;
-                if (resolved === undefined)
-                    continue;
-                const resolvedPath = realPath(resolved.resolvedFileName);
-                if (!isWithin(resolvedPath, registration.root))
+                const resolvedPath = this.resolveImport(statement.moduleSpecifier.text, sourceFile.fileName);
+                if (resolvedPath === undefined || !isWithin(resolvedPath, registration.root))
                     continue;
                 queue.push(this.sourceFiles.get(resolvedPath));
             }
         }
         return [...reachable.values()].sort((left, right) => left.fileName.localeCompare(right.fileName));
     }
+    resolveImport(specifier, fromFile) {
+        const resolved = ts.resolveModuleName(specifier, fromFile, this.program.getCompilerOptions(), this.host, this.host.getModuleResolutionCache?.()).resolvedModule;
+        return resolved === undefined ? undefined : realPath(resolved.resolvedFileName);
+    }
+    /**
+     * Follow the import that names `symbol` at `site` through modules of the
+     * referencing package until a package specifier appears. Each forwarding
+     * module and requested export name pair is entered once; its explicit export
+     * edges are tried before its star edges. A relative specifier that resolves
+     * outside `from`, a namespace hop, or a module with no edge leading to a
+     * package specifier yields undefined.
+     */
+    packageImportOf(site, moduleSpecifier, symbol, from) {
+        const visited = new Map();
+        const walk = (sourceFile, specifier, name) => {
+            const module = moduleIdentity(specifier);
+            if (module !== undefined)
+                return { module, name };
+            const resolvedPath = this.resolveImport(specifier, sourceFile.fileName);
+            if (resolvedPath === undefined || !isWithin(resolvedPath, from.root))
+                return undefined;
+            const names = visited.get(resolvedPath);
+            if (names?.has(name))
+                return undefined;
+            if (names === undefined)
+                visited.set(resolvedPath, new Set([name]));
+            else
+                names.add(name);
+            const forward = this.sourceFiles.get(resolvedPath);
+            for (const edge of this.forwardedExports(forward, name, symbol)) {
+                const found = walk(forward, edge.specifier, edge.name);
+                if (found !== undefined)
+                    return found;
+            }
+            return undefined;
+        };
+        return walk(site.getSourceFile(), moduleSpecifier, authoredExportName(site, moduleSpecifier));
+    }
+    /** Export edges of `sourceFile` that carry `name`: explicit edges in source order, then star edges exporting `symbol`. */
+    forwardedExports(sourceFile, name, symbol) {
+        const explicit = [];
+        const stars = [];
+        for (const statement of sourceFile.statements) {
+            if (!ts.isExportDeclaration(statement)
+                || (statement.exportClause === undefined && statement.moduleSpecifier === undefined)
+                || (statement.exportClause !== undefined && ts.isNamespaceExport(statement.exportClause)))
+                continue;
+            if (statement.exportClause === undefined) {
+                const specifier = statement.moduleSpecifier.text;
+                const exported = this.moduleExports(statement.moduleSpecifier)
+                    .find(candidate => candidate.name === name && this.resolveSymbol(candidate) === symbol);
+                if (exported !== undefined)
+                    stars.push({ specifier, name });
+                continue;
+            }
+            const element = statement.exportClause.elements.find(candidate => candidate.name.text === name);
+            if (element === undefined)
+                continue;
+            if (statement.moduleSpecifier !== undefined) {
+                explicit.push({ specifier: statement.moduleSpecifier.text, name: element.propertyName?.text ?? name });
+                continue;
+            }
+            const binding = importBindingOf(sourceFile, element.propertyName?.text ?? name);
+            if (binding?.name !== undefined)
+                explicit.push({ specifier: binding.specifier, name: binding.name });
+        }
+        return [...explicit, ...stars];
+    }
     collectServices(context, records) {
         const bySymbol = new Map();
         for (const record of records) {
@@ -2125,17 +2190,18 @@ class FaceAnalyzer {
             return { kind: 'standard', name: symbol.name };
         }
         const moduleSpecifier = moduleSpecifierOf(site);
-        const module = moduleSpecifier === undefined ? undefined : moduleIdentity(moduleSpecifier);
         const from = this.registrationForFile(site.getSourceFile().fileName);
         const owner = this.registrationForFile(declaration.getSourceFile().fileName);
         if (owner !== undefined) {
             if (owner.name !== from.name) {
-                if (module === undefined) {
+                const imported = moduleSpecifier === undefined
+                    ? undefined
+                    : this.packageImportOf(site, moduleSpecifier, symbol, from);
+                if (imported === undefined) {
                     this.fail(site, `reference to ${symbol.name} crosses a package without an explicit package import`);
                 }
-                const exportName = authoredExportName(site, moduleSpecifier);
-                if (this.packageExportName(module, symbol, owner.face, exportName) === undefined) {
-                    this.fail(site, `package reference ${exportName} is not exported by ${module.package} at ${module.subpath}`);
+                if (this.packageExportName(imported.module, symbol, owner.face, imported.name) === undefined) {
+                    this.fail(site, `package reference ${imported.name} is not exported by ${imported.module.package} at ${imported.module.subpath}`);
                 }
             }
             const typeDeclaration = declaration;
@@ -2143,15 +2209,18 @@ class FaceAnalyzer {
                 this.ensureDeclaration(symbol, typeDeclaration);
             return { kind: 'declaration', symbol: this.symbolId(symbol) };
         }
-        const packageFaces = module === undefined
+        const imported = moduleSpecifier === undefined
+            ? undefined
+            : this.packageImportOf(site, moduleSpecifier, symbol, from);
+        const packageFaces = imported === undefined
             ? []
-            : [...new Set(this.allRegistrations.filter(candidate => candidate.name === module.package).map(candidate => candidate.face))];
+            : [...new Set(this.allRegistrations.filter(candidate => candidate.name === imported.module.package).map(candidate => candidate.face))];
         const otherFace = packageFaces.find(face => face !== this.face);
-        if (otherFace !== undefined && module !== undefined) {
-            const requestedName = authoredExportName(site, moduleSpecifier);
-            const exportName = this.packageExportName(module, symbol, otherFace, requestedName);
+        if (otherFace !== undefined && imported !== undefined) {
+            const { module } = imported;
+            const exportName = this.packageExportName(module, symbol, otherFace, imported.name);
             if (exportName === undefined) {
-                this.fail(site, `cross-face reference ${requestedName} is not exported by ${module.package} at ${module.subpath}`);
+                this.fail(site, `cross-face reference ${imported.name} is not exported by ${module.package} at ${module.subpath}`);
             }
             this.recordCrossFaceLink(from.name, otherFace, module, exportName);
             return {
@@ -2162,11 +2231,11 @@ class FaceAnalyzer {
                 name: exportName,
             };
         }
-        if (module !== undefined) {
+        if (imported !== undefined) {
             return {
                 kind: 'external',
-                module: module.package,
-                subpath: module.subpath,
+                module: imported.module.package,
+                subpath: imported.module.subpath,
                 name: symbol.name,
             };
         }
@@ -2202,6 +2271,8 @@ class FaceAnalyzer {
     }
     packageExportName(module, symbol, face, requestedName) {
         const registration = this.allRegistrations.find(candidate => candidate.face === face && candidate.name === module.package);
+        if (registration === undefined)
+            return undefined;
         const target = packageExportTargets(registration.manifest)
             .find(([subpath]) => subpath === module.subpath)?.[1];
         if (target === undefined)
@@ -2678,21 +2749,7 @@ function moduleSpecifierOf(node) {
         : node.expression;
     const sourceFile = node.getSourceFile();
     const first = ts.isIdentifier(symbol) ? symbol.text : symbol.getFirstToken(sourceFile)?.getText(sourceFile);
-    for (const statement of sourceFile.statements) {
-        if (!ts.isImportDeclaration(statement) || statement.importClause === undefined
-            || !ts.isStringLiteral(statement.moduleSpecifier))
-            continue;
-        if (statement.importClause.name?.text === first)
-            return statement.moduleSpecifier.text;
-        const bindings = statement.importClause.namedBindings;
-        if (bindings !== undefined && ts.isNamespaceImport(bindings) && bindings.name.text === first) {
-            return statement.moduleSpecifier.text;
-        }
-        if (bindings !== undefined && ts.isNamedImports(bindings)
-            && bindings.elements.some(element => element.name.text === first))
-            return statement.moduleSpecifier.text;
-    }
-    return undefined;
+    return first === undefined ? undefined : importBindingOf(sourceFile, first)?.specifier;
 }
 function authoredExportName(node, moduleSpecifier) {
     if (ts.isImportTypeNode(node))
@@ -2701,26 +2758,33 @@ function authoredExportName(node, moduleSpecifier) {
         ? node.typeName.getText().split('.')
         : node.expression.getText().split('.');
     const localName = referenced[0];
-    for (const statement of node.getSourceFile().statements) {
-        if (!ts.isImportDeclaration(statement)
-            || statement.importClause === undefined
-            || !ts.isStringLiteral(statement.moduleSpecifier)
-            || statement.moduleSpecifier.text !== moduleSpecifier)
+    const binding = importBindingOf(node.getSourceFile(), localName);
+    /* v8 ignore next -- moduleSpecifierOf returns only the import inspected by importBindingOf. */
+    if (binding === undefined)
+        throw new TypertAnalysisError(`typert: cannot recover export name for ${localName} from ${moduleSpecifier}`);
+    return binding.name ?? referenced[1];
+}
+function importBindingOf(sourceFile, localName) {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) || statement.importClause === undefined
+            || !ts.isStringLiteral(statement.moduleSpecifier))
             continue;
+        const specifier = statement.moduleSpecifier.text;
         if (statement.importClause.name?.text === localName)
-            return 'default';
+            return { specifier, name: 'default' };
         const bindings = statement.importClause.namedBindings;
-        if (bindings !== undefined && ts.isNamedImports(bindings)) {
-            const imported = bindings.elements.find(element => element.name.text === localName);
-            if (imported !== undefined)
-                return imported.propertyName?.text ?? imported.name.text;
-        }
-        if (bindings !== undefined && ts.isNamespaceImport(bindings) && bindings.name.text === localName) {
-            return referenced[1];
+        if (bindings === undefined)
+            continue;
+        if (ts.isNamespaceImport(bindings)) {
+            if (bindings.name.text === localName)
+                return { specifier };
+            continue;
         }
+        const element = bindings.elements.find(candidate => candidate.name.text === localName);
+        if (element !== undefined)
+            return { specifier, name: element.propertyName?.text ?? element.name.text };
     }
-    /* v8 ignore next -- moduleSpecifierOf returns only the matching import inspected by this loop. */
-    throw new TypertAnalysisError(`typert: cannot recover export name for ${localName} from ${moduleSpecifier}`);
+    return undefined;
 }
 function importTypeAttributesText(node) {
     const sourceFile = node.getSourceFile();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-typert-generator",
   "description": "TypeScript project analyzer and model-driven Typert artifact generator",
-  "version": "0.1.2-rc.1",
+  "version": "0.1.5-alpha.1",
   "publishConfig": {
     "access": "public"
   },
@@ -40,8 +40,8 @@
   },
   "devDependencies": {
     "zod": "^4.4.3",
-    "@deepseek-ai/dsh-tool-cordis": "^0.1.2-rc.1",
-    "@deepseek-ai/dsh-typert-registry": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-tool-cordis": "^0.1.5-alpha.1",
+    "@deepseek-ai/dsh-typert-registry": "^0.1.5-alpha.1",
     "@deepseek-ai/cordis": "^4.0.2"
   }
 }