@deepseek-ai/dsh-typert-generator 0.2.1-alpha.1 → 0.2.1-alpha.3

package/lib/index.js

@@ -1,8 +1,177 @@
-import { existsSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
-import { dirname, extname, join, posix, relative, resolve, sep } from "node:path";
+import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, extname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 import ts from "typescript";
 import { Buffer } from "node:buffer";
 import { GenMapping, addMapping, toEncodedMap } from "@jridgewell/gen-mapping";
+//#region lib/types/build-output-guard.js
+/**
+* Detection of workspace build outputs loaded into an analyzed face program,
+* and of workspace imports that resolve to nothing. Typert reads workspace
+* packages only from source when a caller rejects build outputs, so its
+* result cannot depend on whether, or when, package compilation ran: an
+* import that reaches `lib/` on a compiled tree resolves to nothing on a
+* clean one, and both are rejected.
+* @module @deepseek-ai/dsh-typert-generator/build-output-guard
+*/
+/**
+* List the program files that a workspace package holds under its `lib/`
+* directory. A package is the nearest directory with a `package.json` at or
+* below `root`; files under `node_modules` are external. Importers are found
+* by resolving each program file's import specifiers again, so this pass
+* costs extra only when an output is present.
+* @param program - the analyzed face program.
+* @param root - workspace root.
+* @param host - module resolution host of the program.
+* @returns loads in file-path order; empty when every workspace file comes from source.
+*/
+function findBuildOutputLoads(program, root, host) {
+	const classifier = new BuildOutputClassifier(root);
+	const outputs = /* @__PURE__ */ new Map();
+	for (const sourceFile of program.getSourceFiles()) if (classifier.isBuildOutput(sourceFile.fileName)) outputs.set(classifier.canonical(sourceFile.fileName), []);
+	if (outputs.size === 0) return [];
+	const options = program.getCompilerOptions();
+	for (const sourceFile of program.getSourceFiles()) {
+		if (!classifier.isWorkspaceFile(sourceFile.fileName) || classifier.isBuildOutput(sourceFile.fileName)) continue;
+		for (const { fileName: specifier } of ts.preProcessFile(sourceFile.text, true, true).importedFiles) {
+			const resolved = ts.resolveModuleName(specifier, sourceFile.fileName, options, host).resolvedModule;
+			(resolved === void 0 ? void 0 : outputs.get(classifier.canonical(resolved.resolvedFileName)))?.push({
+				file: classifier.display(sourceFile.fileName),
+				specifier
+			});
+		}
+	}
+	return [...outputs].sort(([left], [right]) => left.localeCompare(right)).map(([file, importers]) => ({
+		file: classifier.display(file),
+		importers,
+		source: classifier.sourceFor(file)
+	}));
+}
+/**
+* List the imports in workspace program files that name a workspace package
+* and resolve to nothing. A workspace package is one whose `node_modules` link,
+* found from the importing file's directories, leads inside `root` outside any
+* `node_modules`; without that link or a `paths` alias the package cannot be
+* identified, and type checking reports the import. The source of a subpath is
+* derived from the package's `exports` `types` condition under `lib/types/`.
+* @param program - the analyzed face program.
+* @param root - workspace root.
+* @param host - module resolution host of the program.
+* @returns unresolved imports in file and specifier order.
+*/
+function findUnresolvedWorkspaceImports(program, root, host) {
+	const classifier = new BuildOutputClassifier(root);
+	const options = program.getCompilerOptions();
+	const cache = ts.createModuleResolutionCache(root, (file) => file, options);
+	const found = [];
+	for (const sourceFile of program.getSourceFiles()) {
+		if (!classifier.isWorkspaceFile(sourceFile.fileName) || classifier.isBuildOutput(sourceFile.fileName)) continue;
+		for (const { fileName: specifier } of ts.preProcessFile(sourceFile.text, true, true).importedFiles) {
+			if (specifier.startsWith(".") || isAbsolute(specifier) || specifier.includes(":")) continue;
+			if (ts.resolveModuleName(specifier, sourceFile.fileName, options, host, cache).resolvedModule !== void 0) continue;
+			const packageRoot = classifier.linkedWorkspacePackage(sourceFile.fileName, packageNameOf(specifier));
+			if (packageRoot === void 0) continue;
+			const source = exportSource(packageRoot, specifier);
+			found.push({
+				file: classifier.display(sourceFile.fileName),
+				specifier,
+				source: source === void 0 ? void 0 : classifier.display(source)
+			});
+		}
+	}
+	return found.sort((left, right) => left.file.localeCompare(right.file) || left.specifier.localeCompare(right.specifier));
+}
+function packageNameOf(specifier) {
+	return specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/");
+}
+function exportSource(packageRoot, specifier) {
+	const packageName = packageNameOf(specifier);
+	const subpath = specifier === packageName ? "." : `.${specifier.slice(packageName.length)}`;
+	let manifest;
+	try {
+		manifest = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf8"));
+	} catch (_unreadableManifest) {
+		return;
+	}
+	const entry = property(property(manifest, "exports"), subpath);
+	const types = typeof entry === "string" ? entry : property(entry, "types");
+	if (typeof types !== "string" || !types.startsWith("./lib/types/")) return void 0;
+	const stem = join(packageRoot, "src", types.slice(12).replace(/\.d\.([cm]?)ts$/u, ".$1ts"));
+	return [stem, `${stem}x`].find((candidate) => existsSync(candidate));
+}
+function property(value, key) {
+	return typeof value === "object" && value !== null ? value[key] : void 0;
+}
+/**
+* Classifies program files by their real paths, because module resolution
+* reports symbolic-link targets and Windows long names while the workspace
+* root may be spelled through a link or an 8.3 short name; reported paths are
+* spelled under the caller's root.
+*/
+var BuildOutputClassifier = class {
+	root;
+	packageRoots = /* @__PURE__ */ new Map();
+	realPaths = /* @__PURE__ */ new Map();
+	realRoot;
+	constructor(root) {
+		this.root = root;
+		this.realRoot = this.canonical(root);
+	}
+	canonical(file) {
+		const absolute = resolve(file);
+		const cached = this.realPaths.get(absolute);
+		if (cached !== void 0) return cached;
+		let real = absolute;
+		try {
+			real = realpathSync.native(absolute);
+		} catch (_missingPath) {}
+		this.realPaths.set(absolute, real);
+		return real;
+	}
+	display(file) {
+		const path = relative(this.realRoot, this.canonical(file));
+		return path.startsWith("..") || isAbsolute(path) ? resolve(file) : join(this.root, path);
+	}
+	isWorkspaceFile(file) {
+		const path = relative(this.realRoot, this.canonical(file));
+		return path !== "" && !path.startsWith("..") && !isAbsolute(path) && !path.split(sep).includes("node_modules");
+	}
+	isBuildOutput(file) {
+		if (!this.isWorkspaceFile(file)) return false;
+		const real = this.canonical(file);
+		const packageRoot = this.packageRoot(dirname(real));
+		return packageRoot !== void 0 && relative(packageRoot, real).split(sep)[0] === "lib";
+	}
+	sourceFor(file) {
+		const real = this.canonical(file);
+		const packageRoot = this.packageRoot(dirname(real));
+		if (packageRoot === void 0) return void 0;
+		const [lib, types, ...rest] = relative(packageRoot, real).split(sep);
+		const last = rest.at(-1);
+		if (lib !== "lib" || types !== "types" || last === void 0) return void 0;
+		const stem = join(packageRoot, "src", ...rest.slice(0, -1), last.replace(/\.d\.([cm]?)ts$/u, ".$1ts"));
+		const source = [stem, `${stem}x`].find((candidate) => existsSync(candidate));
+		return source === void 0 ? void 0 : this.display(source);
+	}
+	linkedWorkspacePackage(importer, packageName) {
+		let directory = dirname(resolve(importer));
+		for (;;) {
+			const link = join(directory, "node_modules", packageName);
+			if (existsSync(link)) {
+				const target = this.canonical(link);
+				return this.isWorkspaceFile(join(target, "package.json")) ? target : void 0;
+			}
+			if (this.canonical(directory) === this.realRoot || dirname(directory) === directory) return void 0;
+			directory = dirname(directory);
+		}
+	}
+	packageRoot(directory) {
+		if (this.packageRoots.has(directory)) return this.packageRoots.get(directory);
+		const found = existsSync(join(directory, "package.json")) ? directory : directory === this.realRoot || dirname(directory) === directory ? void 0 : this.packageRoot(dirname(directory));
+		this.packageRoots.set(directory, found);
+		return found;
+	}
+};
+//#endregion
 //#region lib/types/analyzer.js
 /**
 * TypeScript project analyzer for the compiler-independent Typert model.
@@ -47,6 +216,7 @@ var WorkspaceCaches = class {
 	configs = /* @__PURE__ */ new Map();
 	/** Registration inventories keyed by root and aggregate config paths. */
 	registrations = /* @__PURE__ */ new Map();
+	aggregates = /* @__PURE__ */ new Map();
 	hosts = /* @__PURE__ */ new Map();
 	/**
 	* Parse one tsconfig once per workspace snapshot.
@@ -62,6 +232,26 @@ var WorkspaceCaches = class {
 		return parsed;
 	}
 	/**
+	* Read one face aggregate tsconfig once per workspace snapshot. An aggregate
+	* that declares `references` is parsed without expanding its `include`
+	* patterns, which affect neither its options nor its references.
+	* @param path - absolute aggregate config path.
+	* @returns the memoized compiler options and project references.
+	*/
+	aggregate(path) {
+		let aggregate = this.aggregates.get(path);
+		if (aggregate === void 0) {
+			const { parsed } = parseConfig(path, true);
+			aggregate = {
+				path,
+				options: parsed.options,
+				projectReferences: parsed.projectReferences ?? []
+			};
+			this.aggregates.set(path, aggregate);
+		}
+		return aggregate;
+	}
+	/**
 	* Return the shared compiler host for one face. Every program of one face
 	* is built from the same aggregate compiler options (the first call wins),
 	* so parsed source files, binder state, and module resolutions are safe to
@@ -121,6 +311,7 @@ var WorkspaceAnalyzer = class WorkspaceAnalyzer {
 			faces: options.faces ?? ["host", "client"],
 			checkDiagnostics: options.checkDiagnostics ?? true,
 			mode: options.mode ?? "check",
+			rejectBuildOutputs: options.rejectBuildOutputs ?? false,
 			...options.packages === void 0 ? {} : { packages: options.packages }
 		};
 		this.caches = options.caches ?? new WorkspaceCaches();
@@ -140,10 +331,10 @@ var WorkspaceAnalyzer = class WorkspaceAnalyzer {
 				if (registrations.length === 0) continue;
 				if (this.options.checkDiagnostics) for (const registration of registrations) this.checkProject(registration);
 				const aggregatePath = resolve(this.options.root, face === "host" ? this.options.hostConfig : this.options.clientConfig);
-				const aggregate = this.caches.config(aggregatePath);
+				const aggregate = this.caches.aggregate(aggregatePath);
 				const rootNames = [...new Set(registrations.flatMap((registration) => registration.config.parsed.fileNames))];
 				const options = {
-					...aggregate.parsed.options,
+					...aggregate.options,
 					composite: false,
 					incremental: false,
 					noEmit: true
@@ -154,6 +345,7 @@ var WorkspaceAnalyzer = class WorkspaceAnalyzer {
 					options,
 					host
 				});
+				if (this.options.rejectBuildOutputs) rejectBuildOutputLoads(face, this.options.root, aggregatePath, findBuildOutputLoads(program, this.options.root, host), findUnresolvedWorkspaceImports(program, this.options.root, host));
 				faces.push(new FaceAnalyzer({
 					root: this.options.root,
 					face,
@@ -210,10 +402,11 @@ var WorkspaceAnalyzer = class WorkspaceAnalyzer {
 	/**
 	* Discover package faces from public-export-reachable Cordis augmentations
 	* and explicit `@typert` roots without constructing a type-checker program.
+	* @param includeManifest - optional `package.json` predicate; a rejected package's sources and project config are not read.
 	* @returns contributors grouped by package with deterministic face order.
 	*/
-	discoverPackages() {
-		const registrations = this.loadRegistrations().filter((registration) => this.options.faces.includes(registration.face)).filter((registration) => this.registrationHasSurface(registration));
+	discoverPackages(includeManifest) {
+		const registrations = this.loadRegistrations().filter((registration) => this.options.faces.includes(registration.face) && (includeManifest === void 0 || includeManifest(registration.manifest))).filter((registration) => this.registrationHasSurface(registration));
 		const packages = /* @__PURE__ */ new Map();
 		for (const registration of registrations) {
 			const current = packages.get(registration.name) ?? {
@@ -272,36 +465,31 @@ var WorkspaceAnalyzer = class WorkspaceAnalyzer {
 		for (const face of ["host", "client"]) {
 			const aggregatePath = resolve(this.options.root, face === "host" ? this.options.hostConfig : this.options.clientConfig);
 			if (!existsSync(aggregatePath)) continue;
-			const aggregate = this.caches.config(aggregatePath);
-			for (const reference of aggregate.parsed.projectReferences ?? []) {
+			const aggregate = this.caches.aggregate(aggregatePath);
+			for (const reference of aggregate.projectReferences) {
 				const configPath = projectConfigPath(reference.path);
 				const packageRoot = dirname(configPath);
 				if (!isWithin(realPath(packageRoot), join(this.options.root, "packages")) && !(includeVendor && isWithin(realPath(packageRoot), join(this.options.root, "vendor")))) continue;
 				const manifestPath = join(packageRoot, "package.json");
 				if (!existsSync(manifestPath)) continue;
 				const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
-				if (typeof manifest.name !== "string") continue;
-				const registration = {
-					face,
-					name: manifest.name,
-					root: realPath(packageRoot),
-					config: this.caches.config(configPath),
-					manifest
-				};
-				if (!isDualFacePackage(manifest)) registrations.push(registration);
-				else if (configPath === join(packageRoot, "tsconfig.json")) registrations.push({
-					...registration,
-					face: "host",
-					exportSubpaths: hostExportSubpaths(manifest)
-				}, {
-					...registration,
-					face: "client",
-					exportSubpaths: clientExportSubpaths(manifest)
-				});
-				else registrations.push({
-					...registration,
-					exportSubpaths: face === "host" ? hostExportSubpaths(manifest) : clientExportSubpaths(manifest)
+				const name = manifest.name;
+				if (typeof name !== "string") continue;
+				const root = realPath(packageRoot);
+				const caches = this.caches;
+				const register = (registrationFace, exportSubpaths) => ({
+					face: registrationFace,
+					name,
+					root,
+					get config() {
+						return caches.config(configPath);
+					},
+					manifest,
+					...exportSubpaths === void 0 ? {} : { exportSubpaths }
 				});
+				if (!isDualFacePackage(manifest)) registrations.push(register(face));
+				else if (configPath === join(packageRoot, "tsconfig.json")) registrations.push(register("host", hostExportSubpaths(manifest)), register("client", clientExportSubpaths(manifest)));
+				else registrations.push(register(face, face === "host" ? hostExportSubpaths(manifest) : clientExportSubpaths(manifest)));
 			}
 		}
 		const inventory = uniqueBy(registrations, (registration) => `${registration.face}\0${registration.name}`).sort((left, right) => left.face.localeCompare(right.face) || left.name.localeCompare(right.name));
@@ -370,6 +558,9 @@ var FaceAnalyzer = class {
 	nodes = /* @__PURE__ */ new Map();
 	exportsByPackage = /* @__PURE__ */ new Map();
 	nodeOrdinals = /* @__PURE__ */ new Map();
+	/** Registration and package lookups per source path; the registration set is fixed per analyzer. */
+	registrationByFile = /* @__PURE__ */ new Map();
+	packageNameByFile = /* @__PURE__ */ new Map();
 	staticLookups;
 	staticContexts;
 	constructor(options) {
@@ -696,6 +887,7 @@ var FaceAnalyzer = class {
 		if (hasModifier(method, ts.SyntaxKind.AbstractKeyword) || method.body === void 0) this.fail(method, "Remote methods must have a concrete implementation");
 		if (!ts.isIdentifier(method.name)) this.fail(method, "Remote method names must be identifiers");
 		if ((method.typeParameters?.length ?? 0) > 0) this.fail(method, "generic Remote methods are not supported");
+		const documentation = documentationOf(method);
 		const methodName = method.name.text;
 		const exportedMethod = invocation.exportName ?? methodName;
 		const lookups = this.lookupDeclarations();
@@ -744,7 +936,11 @@ var FaceAnalyzer = class {
 			}
 			if (wires.has(modeled.wire)) this.fail(parameter, `duplicate Remote wire field ${modeled.wire}`);
 			wires.add(modeled.wire);
-			parameters.push(modeled);
+			const description = documentation.tags.find((tag) => tag.name === "param" && tag.argument === modeled.name)?.comment?.replace(/^[-—–]\s*/, "");
+			parameters.push({
+				...modeled,
+				...description === void 0 ? {} : { description }
+			});
 		}
 		let receiver = { kind: "direct" };
 		if (invocation.kind === "context") {
@@ -777,6 +973,7 @@ var FaceAnalyzer = class {
 		const { result: resultType, uplink: uplinkType } = this.remoteResultType(method, mode);
 		const uplink = uplinkType === void 0 ? void 0 : { boundary: this.remoteBoundary(uplinkType, `${registration.name}#${binding.namespace}/${exportedMethod}:uplink`, false, "undefined") };
 		return {
+			...documentation,
 			id: `${registration.name}#${binding.namespace}/${exportedMethod}`,
 			service: binding.service,
 			namespace: binding.namespace,
@@ -863,28 +1060,27 @@ var FaceAnalyzer = class {
 						kind: "direct",
 						exportName
 					};
-				} else {
-					if (!ts.isObjectLiteralExpression(argument) || argument.properties.length !== 1) this.fail(argument, "Remote() options must contain exactly mode: \"stream\"");
-					const [property] = argument.properties;
-					if (property === void 0) this.fail(argument, "Remote() options must contain exactly mode: \"stream\"");
-					const mode = ts.isPropertyAssignment(property) && memberName(property.name) === "mode" ? stringLiteralValue(property.initializer) : void 0;
-					if (mode !== "stream") this.fail(property, "Remote() options must contain exactly mode: \"stream\"");
-					marker = {
-						kind: "direct",
-						mode
-					};
-				}
+				} else marker = {
+					kind: "direct",
+					...this.remoteOptions(argument, "Remote")
+				};
 			} else if (ts.isCallExpression(expression) && this.isTypeMetaSymbol(expression.expression, "RemoteScope")) {
-				if (expression.arguments.length < 1 || expression.arguments.length > 2) this.fail(expression, "RemoteScope() requires a Context key and optional exported method name");
+				if (expression.arguments.length < 1 || expression.arguments.length > 2) this.fail(expression, "RemoteScope() requires a Context key and an optional exported method name or options object");
 				const context = stringLiteralValue(expression.arguments[0]);
 				if (context === void 0 || !isRemoteSegment(context)) this.fail(expression.arguments[0] ?? expression, "RemoteScope() key must be a string literal containing only RPC endpoint segment characters");
-				const exportArgument = expression.arguments[1];
-				const exportName = exportArgument === void 0 ? void 0 : stringLiteralValue(exportArgument);
-				if (exportArgument !== void 0 && (exportName === void 0 || !isRemoteSegment(exportName))) this.fail(exportArgument, "RemoteScope() name must be a string literal containing only RPC endpoint segment characters");
-				marker = {
+				const option = expression.arguments[1];
+				const exportName = option === void 0 ? void 0 : stringLiteralValue(option);
+				if (option === void 0 || exportName !== void 0) {
+					if (exportName !== void 0 && !isRemoteSegment(exportName)) this.fail(option ?? expression, "RemoteScope() name must be a string literal containing only RPC endpoint segment characters");
+					marker = {
+						kind: "context",
+						context,
+						...exportName === void 0 ? {} : { exportName }
+					};
+				} else marker = {
 					kind: "context",
 					context,
-					...exportName === void 0 ? {} : { exportName }
+					...this.remoteOptions(option, "RemoteScope")
 				};
 			} else continue;
 			if (found !== void 0) this.fail(decorator, "a method can have only one Remote invocation decorator");
@@ -893,6 +1089,34 @@ var FaceAnalyzer = class {
 		return found;
 	}
 	/**
+	* Read the options object of `@Remote` or `@RemoteScope`. `resources`
+	* accepts any expression: its readers run only at runtime, where the
+	* Gateway reads them from the prototype descriptor, so generation records
+	* nothing for them.
+	*/
+	remoteOptions(argument, decorator) {
+		const requirement = decorator === "Remote" ? "Remote() options require name, mode: \"stream\", or resources" : "RemoteScope() options require name or resources";
+		if (!ts.isObjectLiteralExpression(argument) || argument.properties.length === 0) this.fail(argument, requirement);
+		let options = {};
+		for (const property of argument.properties) {
+			if (!ts.isPropertyAssignment(property)) this.fail(property, `${decorator}() options must use named values`);
+			const name = memberName(property.name);
+			if (decorator === "Remote" && name === "mode" && stringLiteralValue(property.initializer) === "stream") options = {
+				...options,
+				mode: "stream"
+			};
+			else if (name === "name") {
+				const value = stringLiteralValue(property.initializer);
+				if (value === void 0 || !isRemoteSegment(value)) this.fail(property, `${decorator}() name must be an endpoint segment`);
+				options = {
+					...options,
+					exportName: value
+				};
+			} else if (name !== "resources") this.fail(property, requirement);
+		}
+		return options;
+	}
+	/**
 	* The item types a Remote method's authored return type declares. Unary
 	* methods unwrap `Promise<T>`; stream methods unwrap `Iterable<Out>`,
 	* `AsyncIterable<Out>`, or the protocol's `RemoteStream<Out, In>`, whose
@@ -1061,6 +1285,13 @@ var FaceAnalyzer = class {
 					completed.set(type, id);
 					return id;
 				};
+				const alias = type.aliasSymbol;
+				const aliasDeclaration = alias === void 0 ? void 0 : preferredDeclaration(this.resolveSymbol(alias));
+				if (alias?.name === "JsonValue" && aliasDeclaration !== void 0 && this.registrationForFile(aliasDeclaration.getSourceFile().fileName)?.name === "@deepseek-ai/dsh-util-values") return add({
+					kind: "keyword",
+					name: "unknown",
+					json: true
+				});
 				const flags = type.flags;
 				if (this.isRemoteByteArray(type)) return add({
 					kind: "reference",
@@ -1149,8 +1380,19 @@ var FaceAnalyzer = class {
 						text: String(value)
 					});
 				}
-				if (type.isUnionOrIntersection()) return add({
-					kind: (flags & ts.TypeFlags.Union) !== 0 ? "union" : "intersection",
+				if (type.isIntersection()) {
+					const material = type.types.filter((member) => !this.isRemotePhantomConstraint(member));
+					if (material.length === 1) {
+						const projected = convert(material[0]);
+						const { id: _projectedId, ...value } = this.nodes.get(projected);
+						return add(value);
+					}
+					if (!material.every((member) => (member.flags & ts.TypeFlags.Object) !== 0 && !this.checker.isArrayType(member) && !this.checker.isTupleType(member))) return add({
+						kind: "intersection",
+						types: material.map(convert)
+					});
+				} else if (type.isUnion()) return add({
+					kind: "union",
 					types: type.types.map(convert)
 				});
 				if ((flags & ts.TypeFlags.TypeParameter) !== 0) this.fail(authoredType, "Remote codec contains an unresolved type parameter");
@@ -1188,7 +1430,7 @@ var FaceAnalyzer = class {
 					const propertyType = this.checker.getTypeOfSymbolAtLocation(property, declaration ?? authoredType);
 					const symbolKey = property.getName();
 					members.push({
-						...EMPTY_DOCUMENTATION,
+						...declaration === void 0 ? EMPTY_DOCUMENTATION : documentationOf(declaration),
 						id: `${id}#${symbolKey}`,
 						name: symbolKey,
 						...symbolKey.startsWith("__@") ? { computed: "symbol" } : {},
@@ -1954,12 +2196,19 @@ var FaceAnalyzer = class {
 		return `${this.packageNameForFile(declaration.getSourceFile().fileName)}:${location.file}#${symbol.name}`;
 	}
 	registrationForFile(file) {
+		if (this.registrationByFile.has(file)) return this.registrationByFile.get(file);
 		const path = realPath(file);
-		return this.allRegistrations.find((registration) => registration.face === this.face && isWithin(path, registration.root));
+		const registration = this.allRegistrations.find((registration) => registration.face === this.face && isWithin(path, registration.root));
+		this.registrationByFile.set(file, registration);
+		return registration;
 	}
 	packageNameForFile(file) {
+		const cached = this.packageNameByFile.get(file);
+		if (cached !== void 0) return cached;
 		const path = realPath(file);
-		return this.allRegistrations.find((registration) => isWithin(path, registration.root))?.name ?? "<external>";
+		const name = this.allRegistrations.find((registration) => isWithin(path, registration.root))?.name ?? "<external>";
+		this.packageNameByFile.set(file, name);
+		return name;
 	}
 	allocateNodeId(site) {
 		const location = this.locationKey(site);
@@ -2021,11 +2270,20 @@ function mergeWorkspaceModels(models) {
 		crossFaceLinks: [...links.values()].sort(compareCrossFaceLinks)
 	};
 }
-function parseConfig(path) {
+/** {@link ts.sys} config reads without directory listing, so `include` patterns match no files. */
+const UNLISTED_CONFIG_HOST = {
+	useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
+	readDirectory: () => [],
+	fileExists: (file) => ts.sys.fileExists(file),
+	readFile: (file) => ts.sys.readFile(file)
+};
+function parseConfig(path, aggregate = false) {
 	const compilerPath = path.split(sep).join("/");
 	const read = ts.readConfigFile(compilerPath, (file) => ts.sys.readFile(file));
 	if (read.error !== void 0) throw new TypertAnalysisError(formatDiagnostic(read.error));
-	const parsed = ts.parseJsonConfigFileContent(read.config, ts.sys, dirname(compilerPath), void 0, compilerPath);
+	const raw = read.config;
+	const host = aggregate && typeof raw === "object" && raw !== null && Object.hasOwn(raw, "references") ? UNLISTED_CONFIG_HOST : ts.sys;
+	const parsed = ts.parseJsonConfigFileContent(read.config, host, dirname(compilerPath), void 0, compilerPath);
 	if (parsed.errors.length > 0) throw new TypertAnalysisError(parsed.errors.map(formatDiagnostic).join("\n"));
 	return {
 		path,
@@ -2140,7 +2398,8 @@ function declarationText(declaration) {
 function classShape(node) {
 	const nonPublic = (member) => (ts.canHaveModifiers(member) ? ts.getModifiers(member) : void 0)?.some((modifier) => modifier.kind === ts.SyntaxKind.PrivateKeyword || modifier.kind === ts.SyntaxKind.ProtectedKeyword) ?? false;
 	const members = node.members.flatMap((member) => {
-		if (nonPublic(member) || ts.isPropertyDeclaration(member) && ts.isPrivateIdentifier(member.name)) return [];
+		const name = ts.getNameOfDeclaration(member);
+		if (ts.isClassStaticBlockDeclaration(member) || nonPublic(member) || name !== void 0 && ts.isPrivateIdentifier(name)) return [];
 		if (ts.isMethodDeclaration(member)) return [ts.factory.updateMethodDeclaration(member, member.modifiers, member.asteriskToken, member.name, member.questionToken, member.typeParameters, member.parameters, member.type, void 0)];
 		if (ts.isConstructorDeclaration(member)) return [ts.factory.updateConstructorDeclaration(member, member.modifiers, member.parameters, void 0)];
 		if (ts.isGetAccessorDeclaration(member)) return [ts.factory.updateGetAccessorDeclaration(member, member.modifiers, member.name, member.parameters, member.type, void 0)];
@@ -2383,8 +2642,14 @@ function formatProgramDiagnostic(root, face, diagnostic) {
 	return `typert(${face}): ${slash(relative(root, diagnostic.file.fileName))}:${String(position.line + 1)}:${String(position.character + 1)}: TypeScript TS${String(diagnostic.code)}: ${message}`;
 }
 const realPathCache = /* @__PURE__ */ new Map();
+/** Normalized form per requested path; `resolve` reads only the process working directory. */
+const absolutePathCache = /* @__PURE__ */ new Map();
 function realPath(path) {
-	const absolute = resolve(path);
+	let absolute = absolutePathCache.get(path);
+	if (absolute === void 0) {
+		absolute = resolve(path);
+		absolutePathCache.set(path, absolute);
+	}
 	const cached = realPathCache.get(absolute);
 	if (cached !== void 0) return cached;
 	if (!existsSync(absolute)) return absolute;
@@ -2400,6 +2665,33 @@ function isWithin(path, root) {
 function slash(value) {
 	return value.replaceAll("\\", "/");
 }
+function rejectBuildOutputLoads(face, root, aggregatePath, loads, unresolved) {
+	if (loads.length === 0 && unresolved.length === 0) return;
+	const path = (file) => slash(relative(root, file));
+	const config = path(aggregatePath);
+	const lines = [];
+	const addAlias = (specifier, source) => {
+		lines.push(`    add ${JSON.stringify(specifier)}: [${JSON.stringify(`./${path(source)}`)}] to the compilerOptions.paths of ${config} or the config it extends`);
+	};
+	if (unresolved.length > 0) {
+		lines.push(`typert(${face}): the ${face} program cannot resolve workspace imports, which would analyze as unknown types; map each import below to source:`);
+		for (const entry of unresolved) {
+			lines.push(`  '${entry.specifier}' imported by ${path(entry.file)}`);
+			if (entry.source === void 0) lines.push(`    add a compilerOptions.paths alias for it to ${config} or the config it extends`);
+			else addAlias(entry.specifier, entry.source);
+		}
+	}
+	if (loads.length > 0) lines.push(`typert(${face}): the ${face} program loads workspace build outputs instead of source; resolve each import below to source so that generation does not depend on package compilation:`);
+	for (const load of loads) {
+		lines.push(`  ${path(load.file)}`);
+		if (load.importers.length === 0) lines.push("    no program source imports it directly; another build output or a reference directive loads it");
+		for (const importer of load.importers) lines.push(`    imported as '${importer.specifier}' by ${path(importer.file)}`);
+		const specifiers = [...new Set(load.importers.map((importer) => importer.specifier))];
+		if (load.source === void 0) lines.push("    no workspace source compiles to it; import a source module instead");
+		else for (const specifier of specifiers) addAlias(specifier, load.source);
+	}
+	throw new TypertAnalysisError(lines.join("\n"));
+}
 function uniqueBy(values, key) {
 	const result = /* @__PURE__ */ new Map();
 	for (const value of values) if (!result.has(key(value))) result.set(key(value), value);
@@ -2755,6 +3047,148 @@ function assertNever(value) {
 	throw new TypeGraphRenderError(`unsupported model variant ${JSON.stringify(value)}`);
 }
 //#endregion
+//#region lib/types/tool-schema.js
+/** Lossless projection into the harness tool-schema subset. */
+/** A resolved codec whose type the tool-schema subset cannot represent without weakening constraints. */
+var ToolSchemaError = class extends Error {
+	name = "ToolSchemaError";
+};
+/**
+* Project one resolved type into the tool-schema subset that `@deepseek-ai/dsh-tools`
+* enforces on tool parameters, tool output, and the generated PTC SDK. A type the
+* subset cannot express without weakening constraints raises {@link ToolSchemaError},
+* which callers report as an absent projection rather than a narrower schema.
+* @param renderer - complete analyzed type graph.
+* @param type - resolved wire type.
+* @param closedObjects - close declared request objects with `additionalProperties: false`.
+* @param optional - omit a top-level undefined alternative supplied by an optional argument.
+* @returns an acyclic schema in the tool-schema subset.
+*/
+function projectToolSchema(renderer, type, closedObjects = false, optional = false) {
+	const active = /* @__PURE__ */ new Set();
+	const fail = (subject) => {
+		throw new ToolSchemaError(`typert tool schema: ${subject}`);
+	};
+	const project = (id, optional = false) => {
+		const node = renderer.node(id);
+		if (node.json) return {};
+		if (active.has(id)) return fail("recursive selected type requires a supported JSON value declaration");
+		active.add(id);
+		try {
+			switch (node.kind) {
+				case "keyword":
+					if ([
+						"string",
+						"number",
+						"boolean"
+					].includes(node.name)) return { type: node.name };
+					return fail(`unsupported ${node.name} value`);
+				case "literal":
+					if (typeof node.value === "bigint") return fail("bigint is not JSON");
+					return {
+						type: node.value === null ? "null" : typeof node.value,
+						const: node.value
+					};
+				case "parenthesized": return project(node.type, optional);
+				case "array": return {
+					type: "array",
+					items: project(node.element)
+				};
+				case "object": return object(node.members);
+				case "reference": {
+					if (node.target.kind !== "declaration" || node.arguments.length !== 0) return fail(`unsupported selected reference ${node.name}`);
+					const declaration = renderer.declaration(node.target.symbol);
+					const schema = declaration.kind === "alias" && declaration.type !== void 0 ? project(declaration.type, optional) : object(declaration.members);
+					if (declaration.extends.length > 0) return fail("unresolved inherited selected type");
+					return declaration.description === void 0 ? schema : {
+						...schema,
+						description: declaration.description
+					};
+				}
+				case "union": return union(node.types.filter((item) => {
+					const branch = renderer.node(item);
+					return !(optional && branch.kind === "keyword" && branch.name === "undefined");
+				}).map((item) => project(item)));
+				default: return fail(`unsupported selected ${node.kind} type`);
+			}
+		} finally {
+			active.delete(id);
+		}
+	};
+	const object = (members) => {
+		const properties = {};
+		const required = [];
+		let indexed = false;
+		for (const member of members) {
+			if (member.static || member.visibility !== "public" || member.computed === "symbol") continue;
+			if (member.kind === "index") {
+				const key = member.signature.parameters[0];
+				if (key === void 0 || project(key.type).type !== "string" || Object.keys(project(member.signature.returns)).length !== 0) return fail("selected dictionaries require string keys and unconstrained JSON values");
+				indexed = true;
+				continue;
+			}
+			if (member.kind !== "property" || member.computed === "dynamic") return fail(`unsupported member ${member.name}`);
+			const name = member.jsonName ?? member.name;
+			const schema = project(member.type, member.optional);
+			properties[name] = member.description === void 0 ? schema : {
+				...schema,
+				description: member.description
+			};
+			if (!member.optional) required.push(name);
+		}
+		return {
+			type: "object",
+			properties,
+			required,
+			additionalProperties: indexed || !closedObjects
+		};
+	};
+	const union = (input) => {
+		if (input.some((branch) => Object.keys(branch).length === 0)) return {};
+		const branches = [];
+		for (const branch of input) {
+			const previous = branch.type !== void 0 && !["object", "array"].includes(branch.type) ? branches.find((candidate) => candidate.type === branch.type) : void 0;
+			if (previous === void 0) {
+				branches.push(branch);
+				continue;
+			}
+			const values = literals(previous);
+			const next = literals(branch);
+			if (values === void 0 || next === void 0) {
+				delete previous.const;
+				delete previous.enum;
+			} else {
+				delete previous.const;
+				previous.enum = [...new Set([...values, ...next])];
+			}
+		}
+		if (branches.length === 1) return branches[0];
+		if (branches.length === 0) return fail("empty selected union");
+		for (const [index, left] of branches.entries()) for (const right of branches.slice(index + 1)) if (!disjoint(left, right)) return fail("selected union branches overlap or have no required discriminator");
+		return { oneOf: branches };
+	};
+	return project(type, optional);
+}
+function literals(schema) {
+	if (schema.const !== void 0) return [schema.const];
+	return schema.enum;
+}
+function disjoint(left, right) {
+	if (left.oneOf !== void 0) return left.oneOf.every((branch) => disjoint(branch, right));
+	if (right.oneOf !== void 0) return right.oneOf.every((branch) => disjoint(left, branch));
+	if (left.type !== right.type) return left.type !== void 0 && right.type !== void 0;
+	if (left.type !== "object" || right.type !== "object") return false;
+	return (left.required ?? []).some((name) => {
+		if (!right.required?.includes(name)) return false;
+		const a = left.properties?.[name];
+		const b = right.properties?.[name];
+		if (a === void 0 || b === void 0) return false;
+		const first = literals(a);
+		const second = literals(b);
+		return first !== void 0 && second !== void 0 && first.every((value) => !second.includes(value));
+	});
+}
+//#endregion
 //#region lib/types/emitter.js
 /**
 * Model-driven Typert artifact emitter. It consumes only FaceModel and
@@ -2785,7 +3219,7 @@ var FaceModelEmitter = class {
 	emit(packageName) {
 		const packageModel = this.face.packages.find((candidate) => candidate.name === packageName);
 		if (packageModel === void 0) throw new TypertEmitError(`typert emitter(${this.face.face}): package ${packageName} is not modeled on this face`);
-		const schemaArtifact = new SchemaEmitter(this.renderer, packageModel.schemas, invocationBoundaryRoots(packageModel.invocations)).emit();
+		const schemaArtifact = invocationSchemas(this.renderer, packageModel.schemas, invocationBoundaryRoots(packageModel.invocations));
 		const runtimeModel = this.runtimeModel(packageModel);
 		const js = this.renderJs(packageModel, schemaArtifact, runtimeModel);
 		const dts = this.renderDts(packageModel, schemaArtifact);
@@ -2850,10 +3284,12 @@ var FaceModelEmitter = class {
 	renderJs(packageModel, schemas, runtimeModel) {
 		const lines = ["/* Generated by @deepseek-ai/dsh-typert-generator from FaceModel — do not edit. */"];
 		if (schemas.definitions.length > 0) lines.push("import { z } from 'zod'", "");
+		if (packageModel.invocations.length > 0) lines.push("import { createTypertRemoteInfo } from '@deepseek-ai/dsh-typert-protocol/remote-info'", "");
 		lines.push(...schemas.definitions);
 		if (schemas.definitions.length > 0) lines.push("");
 		for (const schema of schemas.exports) lines.push(`export const ${schema.exportName} = ${schema.internalName}`);
 		if (schemas.exports.length > 0) lines.push("");
+		if (packageModel.invocations.length > 0) lines.push(`const $remote = ${this.remoteInfoLiteral(packageModel, schemas)}`, "");
 		const model = JSON.stringify(runtimeModel, null, 2);
 		lines.push("export const TYPERT = {");
 		lines.push(`  package: ${quote$1(packageModel.name)},`);
@@ -2861,9 +3297,8 @@ var FaceModelEmitter = class {
 		lines.push("  schemas: [");
 		for (const schema of schemas.exports) lines.push(`    { name: ${quote$1(schema.exportName)}, create: ${schema.exportName} },`);
 		lines.push("  ],");
-		lines.push("  invocations: [");
-		for (const invocation of packageModel.invocations) lines.push(`${indent(this.invocationLiteral(invocation, schemas), 4)},`);
-		lines.push("  ],");
+		if (packageModel.invocations.length > 0) lines.push("  get invocations() { return $remote.descriptors },");
+		else lines.push("  invocations: [", "  ],");
 		lines.push(`  model: ${indent(model, 2).trimStart()},`);
 		lines.push("}");
 		return `${lines.join("\n")}\n`;
@@ -2886,32 +3321,47 @@ var FaceModelEmitter = class {
 		return `${lines.join("\n")}\n`;
 	}
 	emitRemote(packageModel) {
-		const schemas = new SchemaEmitter(this.renderer, [], invocationBoundaryRoots(packageModel.invocations)).emit();
+		const schemas = invocationSchemas(this.renderer, [], invocationBoundaryRoots(packageModel.invocations));
 		const lines = ["/* Generated by @deepseek-ai/dsh-typert-generator from the Host FaceModel — do not edit. */"];
 		if (schemas.definitions.length > 0) lines.push("import { z } from 'zod'", "");
+		lines.push("import { createTypertRemoteInfo } from '@deepseek-ai/dsh-typert-protocol/remote-info'", "");
 		lines.push(...schemas.definitions);
 		if (schemas.definitions.length > 0) lines.push("");
-		lines.push("export const TYPERT_REMOTE = {");
-		lines.push(`  package: ${quote$1(packageModel.name)},`);
-		lines.push("  descriptors: [");
-		for (const invocation of packageModel.invocations) lines.push(`${indent(this.invocationLiteral(invocation, schemas), 4)},`);
-		lines.push("  ],");
-		lines.push("}");
-		lines.push("");
+		lines.push(`export const TYPERT_REMOTE = ${this.remoteInfoLiteral(packageModel, schemas)}`, "");
 		lines.push("export default TYPERT_REMOTE");
-		const declaration = this.renderRemoteDts(packageModel);
 		return {
 			js: `${lines.join("\n")}\n`,
-			...declaration
+			...this.renderRemoteDts(packageModel)
 		};
 	}
+	remoteMethodTypes(packageModel) {
+		const names = allocateRemoteImportNames(remoteImports(packageModel.invocations));
+		return `{\n${packageModel.invocations.filter((invocation) => invocation.invocation.kind === "direct").map((invocation) => {
+			const input = this.remoteInputType(invocation, names);
+			const result = this.renderer.renderType(invocation.result.type, names);
+			const uplink = invocation.uplink === void 0 ? "" : `, ${this.renderer.renderType(invocation.uplink.boundary.type, names)}`;
+			const mode = invocation.mode === "stream" ? `, ${quote$1("stream")}${uplink}` : containsBytes(this.renderer, invocation.result.codecType) ? `, 'unary', never, RemoteDecoded<${result}>` : "";
+			return `  readonly ${quote$1(`${invocation.namespace}/${invocation.method}`)}: TypertRemoteMethod<${input}, ${result}${mode}>`;
+		}).join("\n")}\n}`;
+	}
+	remoteInputType(invocation, names) {
+		return `{ ${invocation.parameters.map((parameter) => `readonly ${quote$1(parameter.wire)}${parameter.boundary.acceptsUndefined ? "?" : ""}: ${this.renderer.renderType(parameter.boundary.type, names)}`).join("; ")} }`;
+	}
+	remoteInfoLiteral(packageModel, schemas) {
+		return [
+			"createTypertRemoteInfo({",
+			`  package: ${quote$1(packageModel.name)},`,
+			"  methods: {",
+			...packageModel.invocations.map((invocation) => `    ${quote$1(`${invocation.namespace}/${invocation.method}`)}: ${indent(this.invocationLiteral(invocation, schemas), 4).trimStart()},`),
+			"  },",
+			"}, z)"
+		].join("\n");
+	}
 	invocationLiteral(invocation, schemas) {
 		const lines = [
 			"{",
-			`  id: ${quote$1(invocation.id)},`,
 			`  service: ${quote$1(invocation.service)},`,
-			`  namespace: ${quote$1(invocation.namespace)},`,
-			`  method: ${quote$1(invocation.method)},`
+			...invocation.description === void 0 ? [] : [`  description: ${quote$1(invocation.description)},`]
 		];
 		if (invocation.implementation !== void 0) lines.push(`  implementation: ${quote$1(invocation.implementation)},`);
 		if (invocation.mode !== void 0) lines.push(`  mode: ${quote$1(invocation.mode)},`);
@@ -2934,11 +3384,12 @@ var FaceModelEmitter = class {
 		invocation.parameters.forEach((parameter, index) => {
 			lines.push("    {");
 			lines.push(`      name: ${quote$1(parameter.name)},`);
-			lines.push(`      wire: ${quote$1(parameter.wire)},`);
+			if (parameter.wire !== parameter.name) lines.push(`      wire: ${quote$1(parameter.wire)},`);
+			if (parameter.description !== void 0) lines.push(`      description: ${quote$1(parameter.description)},`);
 			lines.push(`      source: ${quote$1(parameter.source)},`);
 			if (parameter.lookup !== void 0) lines.push(`      lookup: ${quote$1(parameter.lookup)},`);
 			if (parameter.boundary.acceptsUndefined) lines.push("      acceptsUndefined: true,");
-			lines.push(`      codec: ${indent(strictCodec(parameter.boundary, schemas.boundary(parameterBoundaryKey(invocation, index))), 6).trimStart()},`);
+			for (const strict of [false, true]) lines.push(`      ${strict ? "strictCodec" : "codec"}: ${indent(strictCodec(parameter.boundary, schemas.boundary(parameterBoundaryKey(invocation, index, strict)), void 0, toolProjection(() => projectToolSchema(this.renderer, parameter.boundary.codecType, strict, parameter.boundary.acceptsUndefined))), 6).trimStart()},`);
 			lines.push("    },");
 		});
 		lines.push("  ],");
@@ -2948,7 +3399,8 @@ var FaceModelEmitter = class {
 			lines.push("  },");
 		}
 		if (invocation.cancellation !== void 0) lines.push("  cancellation: { parameter: 'signal' },");
-		lines.push(`  result: ${indent(strictCodec(invocation.result, schemas.boundary(resultBoundaryKey(invocation)), schemas.encoder(resultBoundaryKey(invocation))), 2).trimStart()},`);
+		const returns = invocation.tags.find((tag) => tag.name === "returns" || tag.name === "return")?.comment?.replace(/^[-—–]\s*/, "");
+		lines.push(`  result: ${indent(strictCodec(invocation.result, schemas.boundary(resultBoundaryKey(invocation)), schemas.encoder(resultBoundaryKey(invocation)), toolProjection(() => projectToolSchema(this.renderer, invocation.result.codecType)), returns), 2).trimStart()},`);
 		lines.push(`  sourceLocation: ${JSON.stringify(invocation.location)},`);
 		lines.push("}");
 		return lines.join("\n");
@@ -2968,9 +3420,11 @@ var FaceModelEmitter = class {
 		const lines = [
 			"/* Generated by @deepseek-ai/dsh-typert-generator from the Host FaceModel — do not edit. */",
 			"import type {",
+			...packageModel.invocations.some((invocation) => containsBytes(this.renderer, invocation.result.codecType)) ? ["  RemoteDecoded,"] : [],
 			"  RemoteResult,",
 			...packageModel.invocations.some((invocation) => invocation.mode === "stream") ? ["  RemoteStreamHandle,"] : [],
-			"  TypertRemoteContribution,",
+			"  TypertRemoteInfo,",
+			...packageModel.invocations.some((invocation) => invocation.invocation.kind === "direct") ? ["  TypertRemoteMethod,"] : [],
 			"} from '@deepseek-ai/dsh-typert-protocol'"
 		];
 		const sourceMap = new GenMapping({ file: "typert.remote-client.d.ts" });
@@ -2979,12 +3433,6 @@ var FaceModelEmitter = class {
 			lines.push(`import type { ${names.join(", ")} } from ${quote$1(specifier)}`);
 		}
 		lines.push("");
-		if (packageModel.invocations.some((invocation) => containsBytes(this.renderer, invocation.result.codecType))) {
-			lines.push("type RemoteDecoded<Value> = Value extends Uint8Array ? Uint8Array<ArrayBuffer>");
-			lines.push("  : Value extends string | number | boolean | null | undefined ? Value");
-			lines.push("  : { [Key in keyof Value]: RemoteDecoded<Value[Key]> }");
-			lines.push("");
-		}
 		lines.push("declare module '@deepseek-ai/dsh-typert-protocol' {");
 		const direct = packageModel.invocations.filter((invocation) => invocation.invocation.kind === "direct");
 		const scoped = packageModel.invocations.filter((invocation) => invocation.invocation.kind === "context" || invocation.scope !== void 0);
@@ -3008,7 +3456,7 @@ var FaceModelEmitter = class {
 		}
 		lines.push("}");
 		lines.push("");
-		lines.push("export declare const TYPERT_REMOTE: TypertRemoteContribution");
+		lines.push(`export declare const TYPERT_REMOTE: TypertRemoteInfo<${this.remoteMethodTypes(packageModel)}>`);
 		lines.push("export default TYPERT_REMOTE");
 		lines.push("//# sourceMappingURL=typert.remote-client.d.ts.map");
 		return {
@@ -3075,6 +3523,27 @@ function uniqueNamespaces(invocations) {
 function remoteNamespaceInterface(namespace) {
 	return `TypertRemoteNamespace$${Buffer.from(namespace, "utf8").toString("hex")}`;
 }
+function toolProjection(project) {
+	try {
+		return `jsonSchema: ${JSON.stringify(project())}`;
+	} catch (error) {
+		if (!(error instanceof ToolSchemaError)) throw error;
+		return `jsonSchemaError: ${quote$1(error.message)}`;
+	}
+}
+function invocationSchemas(renderer, schemas, roots) {
+	const identifiers = /* @__PURE__ */ new Set();
+	const ordinary = new SchemaEmitter(renderer, schemas, roots.filter((root) => !root.closedObjects), {}, identifiers).emit();
+	const closedRoots = roots.filter((root) => root.closedObjects);
+	const closed = new SchemaEmitter(renderer, [], closedRoots, { closedObjects: true }, identifiers).emit();
+	const keys = new Set(closedRoots.map((root) => root.key));
+	return {
+		definitions: [...ordinary.definitions, ...closed.definitions],
+		exports: ordinary.exports,
+		boundary: (key) => keys.has(key) ? closed.boundary(key) : ordinary.boundary(key),
+		encoder: (key) => keys.has(key) ? closed.encoder(key) : ordinary.encoder(key)
+	};
+}
 var ResultEncoderEmitter = class {
 	renderer;
 	names = /* @__PURE__ */ new Map();
@@ -3173,20 +3642,21 @@ var SchemaEmitter = class {
 	renderer;
 	schemas;
 	boundaries;
+	options;
 	names = /* @__PURE__ */ new Map();
 	boundaryNames = /* @__PURE__ */ new Map();
 	declarations;
-	constructor(renderer, schemas, boundaries) {
+	constructor(renderer, schemas, boundaries, options = {}, identifiers = /* @__PURE__ */ new Set()) {
 		this.renderer = renderer;
 		this.schemas = schemas;
 		this.boundaries = boundaries;
+		this.options = options;
 		const declarations = /* @__PURE__ */ new Map();
 		for (const schema of schemas) for (const declaration of renderer.declarationClosureForTypes([schema.type])) declarations.set(declaration.id, declaration);
 		for (const boundary of boundaries) for (const declaration of renderer.declarationClosureForTypes([boundary.type])) declarations.set(declaration.id, declaration);
 		this.declarations = renderer.graph.declarations.filter((declaration) => declarations.has(declaration.id));
-		const identifiers = /* @__PURE__ */ new Set();
 		for (const declaration of this.declarations) {
-			const base = `${safeIdentifier(declaration.name)}$schema`;
+			const base = `${options.closedObjects ? "closed$" : ""}${safeIdentifier(declaration.name)}$schema`;
 			let name = base;
 			let suffix = 2;
 			while (identifiers.has(name)) name = `${base}${String(suffix++)}`;
@@ -3210,7 +3680,7 @@ var SchemaEmitter = class {
 			const encode = encoder.reference(boundary.type);
 			if (encode !== void 0) encoders.set(boundary.key, encode);
 			const name = this.boundaryName(boundary.key);
-			definitions.push(`let ${name}$value\nconst ${name} = () => (${name}$value ??= ${this.typeSchema(boundary.type)})`);
+			definitions.push(this.cachedFactory(name, this.typeSchema(boundary.type)));
 		}
 		definitions.push(...encoder.definitions());
 		return {
@@ -3226,11 +3696,14 @@ var SchemaEmitter = class {
 	}
 	declarationDefinition(declaration) {
 		const name = this.schemaName(declaration.id);
-		if (declaration.typeParameters.length === 0) return `let ${name}$value\nconst ${name} = () => (${name}$value ??= ${this.declarationSchema(declaration, /* @__PURE__ */ new Map())})`;
+		if (declaration.typeParameters.length === 0) return this.cachedFactory(name, this.declarationSchema(declaration, /* @__PURE__ */ new Map()));
 		const parameters = declaration.typeParameters.map((parameter, index) => [`type${String(index)}$schema`, parameter.id]);
 		const substitutions = new Map(parameters.map(([schema, id]) => [id, schema]));
 		return `const ${name} = (${parameters.map(([schema]) => schema).join(", ")}) => ${this.declarationSchema(declaration, substitutions)}`;
 	}
+	cachedFactory(name, expression) {
+		return `let ${name}$value\nconst ${name} = () => (${name}$value ??= ${expression})`;
+	}
 	declarationSchema(declaration, substitutions) {
 		if (declaration.kind === "enum") this.fail(declaration.name, "enum declarations have no Zod projection");
 		if (declaration.kind === "alias") {
@@ -3243,6 +3716,7 @@ var SchemaEmitter = class {
 	}
 	typeSchema(id, substitutions = /* @__PURE__ */ new Map()) {
 		const node = this.renderer.node(id);
+		if (node.json) return "z.json()";
 		switch (node.kind) {
 			case "keyword": return this.keywordSchema(node.name);
 			case "literal": return `z.literal(${node.text})`;
@@ -3340,6 +3814,8 @@ var SchemaEmitter = class {
 	objectSchema(members, subject, substitutions) {
 		const properties = [];
 		const indices = [];
+		let stringIndexValue;
+		let stringIndexType;
 		let symbolMembers = 0;
 		for (const member of members) {
 			if (member.static || member.visibility !== "public") continue;
@@ -3351,22 +3827,53 @@ var SchemaEmitter = class {
 			if (member.kind === "index") {
 				const parameter = member.signature.parameters[0];
 				if (member.signature.parameters.length !== 1 || parameter === void 0) this.fail(subject, "index signature must have exactly one key parameter");
-				indices.push(this.readonly(`z.record(${this.typeSchema(parameter.type, substitutions)}, ${this.typeSchema(member.signature.returns, substitutions)})`, member.readonly));
+				const key = this.typeSchema(parameter.type, substitutions);
+				const value = this.typeSchema(member.signature.returns, substitutions);
+				if (key === "z.string()") {
+					stringIndexValue = value;
+					stringIndexType = member.signature.returns;
+				}
+				indices.push(this.readonly(`z.record(${key}, ${value})`, member.readonly));
 				continue;
 			}
 			if (member.kind !== "property") this.fail(subject, `${member.kind} member ${member.name} is not data-schema projectable`);
-			const schema = this.readonly(this.typeSchema(member.type, substitutions), member.readonly && !containsBytes(this.renderer, member.type, false));
-			const property = this.describe(this.optional(schema, member.optional), member);
-			properties.push(`${quote$1(member.jsonName ?? member.name)}: ${property}`);
+			properties.push(member);
 		}
 		if (indices.length > 1) this.fail(subject, "object type has more than one JSON index signature");
 		if (properties.length === 0 && indices.length === 0 && symbolMembers > 0) return "z.unknown()";
-		const object = `z.object({${properties.length === 0 ? "" : `\n${properties.map((property) => `  ${property},`).join("\n")}\n`}})`;
+		const fields = properties.map((member) => {
+			const type = this.options.closedObjects && stringIndexType !== void 0 ? this.indexedPropertySchema(member.type, stringIndexType, substitutions) : this.typeSchema(member.type, substitutions);
+			const schema = this.readonly(type, member.readonly && !containsBytes(this.renderer, member.type, false));
+			return `${quote$1(member.jsonName ?? member.name)}: ${this.describe(this.optional(schema, member.optional), member)}`;
+		});
+		const object = `z.${this.options.closedObjects && indices.length === 0 ? "strictObject" : "object"}({${fields.length === 0 ? "" : `\n${fields.map((field) => `  ${field},`).join("\n")}\n`}})`;
 		const index = indices[0];
 		if (index === void 0) return object;
 		if (properties.length === 0) return index;
+		if (this.options.closedObjects && stringIndexValue !== void 0) return `${object}.catchall(${stringIndexValue})`;
 		return `z.intersection(${object}, ${index})`;
 	}
+	indexedPropertySchema(declared, indexed, substitutions) {
+		if (declared === indexed) return this.typeSchema(declared, substitutions);
+		const own = this.renderer.node(declared);
+		const value = this.renderer.node(indexed);
+		if (own.kind === "union") return `z.union([${own.types.map((type) => this.indexedPropertySchema(type, indexed, substitutions)).join(", ")}])`;
+		if (value.kind === "union") return `z.union([${value.types.map((type) => this.indexedPropertySchema(declared, type, substitutions)).join(", ")}])`;
+		const ownProperties = own.kind === "object" ? own.members.filter((member) => member.kind === "property") : [];
+		const valueProperties = value.kind === "object" ? value.members.filter((member) => member.kind === "property") : [];
+		if (own.kind === "object" && value.kind === "object" && !own.json && !value.json && ownProperties.length === own.members.length && valueProperties.length === value.members.length && [...ownProperties, ...valueProperties].every((member) => !member.static && member.visibility === "public" && member.computed === void 0)) {
+			const indexedFields = new Map(valueProperties.map((member) => [member.jsonName ?? member.name, member]));
+			const overlaps = ownProperties.flatMap((member) => {
+				const inherited = indexedFields.get(member.jsonName ?? member.name);
+				if (inherited === void 0) return [];
+				const combined = this.indexedPropertySchema(member.type, inherited.type, substitutions);
+				const schema = this.readonly(this.optional(combined, member.optional && inherited.optional), (member.readonly || inherited.readonly) && !containsBytes(this.renderer, member.type, false));
+				return [`${quote$1(member.jsonName ?? member.name)}: ${this.describe(schema, member)}`];
+			});
+			return `z.strictObject({ ...${this.typeSchema(indexed, substitutions)}.shape, ...${this.typeSchema(declared, substitutions)}.shape${overlaps.length === 0 ? "" : `, ${overlaps.join(", ")}`} })`;
+		}
+		return `z.intersection(${this.typeSchema(declared, substitutions)}, ${this.typeSchema(indexed, substitutions)})`;
+	}
 	exportSchemaName(model) {
 		const name = this.schemaName(model.symbol);
 		if (this.renderer.declaration(model.symbol).typeParameters.length > 0) this.fail(model.export.name, "generic schema exports require a concrete declaration");
@@ -3434,6 +3941,11 @@ function invocationBoundaryRoots(invocations) {
 				key: parameterBoundaryKey(invocation, index),
 				type: parameter.boundary.codecType
 			});
+			result.push({
+				key: parameterBoundaryKey(invocation, index, true),
+				type: parameter.boundary.codecType,
+				closedObjects: true
+			});
 		});
 		if (invocation.uplink !== void 0) result.push({
 			key: uplinkBoundaryKey(invocation),
@@ -3452,8 +3964,8 @@ function contextBoundaryKey(invocation) {
 function uplinkBoundaryKey(invocation) {
 	return `${invocation.id}:uplink`;
 }
-function parameterBoundaryKey(invocation, index) {
-	return `${invocation.id}:parameter:${String(index)}`;
+function parameterBoundaryKey(invocation, index, strict = false) {
+	return `${invocation.id}:parameter:${String(index)}${strict ? ":strict" : ""}`;
 }
 function resultBoundaryKey(invocation) {
 	return `${invocation.id}:result`;
@@ -3474,12 +3986,14 @@ function containsBytes(renderer, id, nested = true, visited = /* @__PURE__ */ ne
 	if (node.kind === "object" && node.members.some((member) => containsBytes(renderer, member.kind === "property" ? member.type : member.signature.returns, nested, visited))) return true;
 	return childTypeNodeIds(node).some((child) => containsBytes(renderer, child, nested, visited));
 }
-function strictCodec(boundary, schema, encoder) {
+function strictCodec(boundary, schema, encoder, projection, description) {
 	return [
 		"{",
 		"  mode: 'strict',",
 		`  typeSymbol: ${quote$1(boundary.typeSymbol)},`,
 		`  create: ${schema},`,
+		...description === void 0 ? [] : [`  description: ${quote$1(description)},`],
+		...projection === void 0 ? [] : [`  ${projection},`],
 		...encoder === void 0 ? [] : [`  decode: value => ${schema}().parse(value),`, `  encode: (value, writeBytes) => ${encoder}(value, writeBytes, [], new Map()),`],
 		"}"
 	].join("\n");
@@ -3506,7 +4020,8 @@ function allocateRemoteImportNames(imports) {
 		"RemoteDecoded",
 		"RemoteResult",
 		"RemoteStreamHandle",
-		"TypertRemoteContribution",
+		"TypertRemoteInfo",
+		"TypertRemoteMethod",
 		"TYPERT_REMOTE"
 	]);
 	const names = /* @__PURE__ */ new Map();
@@ -4274,34 +4789,38 @@ var WorkspaceTypertGenerator = class {
 	* Find public package faces that contribute Cordis services/events or
 	* explicitly tagged Typert roots.
 	* @param faces - optional independent program faces to inspect.
+	* @param includeManifest - optional `package.json` predicate; a rejected package's sources and project config are not read.
 	* @returns discovered packages in stable package-name order.
 	*/
-	discover(faces) {
+	discover(faces, includeManifest) {
 		return new WorkspaceAnalyzer({
 			root: this.root,
 			caches: this.caches,
 			...faces === void 0 ? {} : { faces }
-		}).discoverPackages();
+		}).discoverPackages(includeManifest);
 	}
 	/**
 	* Generate all discovered contributors, or an explicit package subset.
-	* @param packages - optional exact package names for a focused pass.
+	* @param packages - optional exact package names to emit; every pass includes the same face-wide declaration merges.
 	* @param faces - optional independent program faces to analyze.
 	* @returns one artifact per package face.
 	*/
 	generate(packages, faces) {
-		const selected = packages ?? this.discover(faces).map((candidate) => candidate.package);
+		const contributors = this.discover(faces).map((candidate) => candidate.package);
+		const selected = new Set(packages ?? contributors);
 		const workspace = new WorkspaceAnalyzer({
 			root: this.root,
-			packages: selected,
+			packages: contributors,
 			caches: this.caches,
 			...faces === void 0 ? {} : { faces },
-			...this.options.checkDiagnostics === void 0 ? {} : { checkDiagnostics: this.options.checkDiagnostics }
+			...this.options.checkDiagnostics === void 0 ? {} : { checkDiagnostics: this.options.checkDiagnostics },
+			...this.options.rejectBuildOutputs === void 0 ? {} : { rejectBuildOutputs: this.options.rejectBuildOutputs }
 		}).analyze();
 		const artifacts = [];
 		for (const face of workspace.faces) {
 			const emitter = new FaceModelEmitter(face);
 			for (const packageModel of face.packages) {
+				if (!selected.has(packageModel.name)) continue;
 				const artifact = {
 					...emitter.emit(packageModel.name),
 					packageRoot: packageModel.root
@@ -4312,6 +4831,16 @@ var WorkspaceTypertGenerator = class {
 		}
 		return artifacts;
 	}
+	/**
+	* Generate every explicit contributor: a package whose manifest declares a
+	* Typert artifact export and whose public graph has a Typert surface.
+	* @param faces - optional independent program faces to analyze.
+	* @returns one artifact per contributor face.
+	*/
+	generateContributors(faces) {
+		const packages = this.discover(faces, (manifest) => hasTypertExport(manifest.exports)).map((candidate) => candidate.package);
+		return packages.length === 0 ? [] : this.generate(packages, faces);
+	}
 	validateExport(artifact) {
 		const manifestPath = resolve(this.root, artifact.packageRoot, "package.json");
 		const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
@@ -4338,10 +4867,90 @@ var WorkspaceTypertGenerator = class {
 		for (const file of remoteFiles) if (!files.includes(file)) throw new TypertAnalysisError(`typert(host): ${artifact.package} package files must include ${file}`);
 	}
 };
+/**
+* Find the workspace root that Typert generation runs against: the nearest
+* directory at or above `start` that holds both `tsconfig.host.json` and
+* `packages/`. The analyzer registers projects under `<root>/packages`, so a
+* package's own `tsconfig.host.json` face leaf does not qualify.
+* @param start - directory to search from, such as a bundle output or a working directory.
+* @returns the absolute workspace root.
+* @throws If no ancestor of `start` qualifies.
+*/
+function findWorkspaceRoot(start) {
+	let current = resolve(start);
+	while (!existsSync(join(current, "tsconfig.host.json")) || !existsSync(join(current, "packages"))) {
+		const parent = dirname(current);
+		if (parent === current) throw new Error(`typert-generator: cannot find workspace root above ${start}`);
+		current = parent;
+	}
+	return current;
+}
+/**
+* Whether a `package.json#exports` field declares a Typert artifact subpath
+* (`./typert`, `./client/typert`, or `./remote`).
+* @param exportsField - the manifest's `exports` value.
+* @returns true when the package opts in to Typert publication.
+*/
+function hasTypertExport(exportsField) {
+	if (exportsField === null || typeof exportsField !== "object" || Array.isArray(exportsField)) return false;
+	return Object.hasOwn(exportsField, "./typert") || Object.hasOwn(exportsField, "./client/typert") || Object.hasOwn(exportsField, "./remote");
+}
 function sameExport(actual, expected) {
 	if (actual === null || typeof actual !== "object" || Array.isArray(actual)) return false;
 	const value = actual;
 	return value.types === expected.types && value.default === expected.default;
 }
 //#endregion
-export { CordisCatalogProjector, FaceModelEmitter, REGION_BEGIN, REGION_END, TypeGraphRenderError, TypeGraphRenderer, TypertAnalysisError, TypertEmitError, WorkspaceAnalyzer, WorkspaceCaches, WorkspaceTypertGenerator, collectEvents, collectServices, projectCordisCatalog, renderInheritedPage, renderPageRegion };
+//#region lib/types/artifact-files.js
+/**
+* Package-local files of generated Typert artifacts. The tsdown plugin and
+* standalone workspace generation both write through this module, so a pass
+* over the same artifacts leaves the same bytes on disk.
+* @module @deepseek-ai/dsh-typert-generator/artifact-files
+*/
+const REMOTE_CLIENT_FILES = [
+	"typert.remote-client.js",
+	"typert.remote-client.d.ts",
+	"typert.remote-client.d.ts.map"
+];
+/**
+* Write one package's artifacts under `<packageDir>/lib`: `typert.<face>.js`
+* and `typert.<face>.d.ts` per artifact, plus the three
+* `typert.remote-client.*` files when an artifact carries Remote methods. A
+* Host artifact without Remote methods removes any Remote client files left
+* by an earlier pass. Files are written one by one, so a failed write can
+* leave this package's outputs partially replaced.
+* @param packageDir - absolute package root.
+* @param artifacts - artifacts of that package only.
+* @throws A file-system error when the output directory or a file cannot be written.
+*/
+function writePackageArtifacts(packageDir, artifacts) {
+	const output = join(packageDir, "lib");
+	mkdirSync(output, { recursive: true });
+	let emittedRemote = false;
+	for (const artifact of artifacts) {
+		writeFileSync(join(output, `typert.${artifact.face}.js`), artifact.js);
+		writeFileSync(join(output, `typert.${artifact.face}.d.ts`), artifact.dts);
+		if (artifact.remote !== void 0) {
+			emittedRemote = true;
+			writeFileSync(join(output, "typert.remote-client.js"), artifact.remote.js);
+			writeFileSync(join(output, "typert.remote-client.d.ts"), artifact.remote.dts);
+			writeFileSync(join(output, "typert.remote-client.d.ts.map"), artifact.remote.dtsMap);
+		}
+	}
+	if (!emittedRemote && artifacts.some((artifact) => artifact.face === "host")) for (const file of REMOTE_CLIENT_FILES) rmSync(join(output, file), { force: true });
+}
+/**
+* Write every artifact of one workspace pass into its own package, in
+* artifact order, with {@link writePackageArtifacts}. A failed write stops
+* the pass; earlier packages keep their new files and later ones keep their
+* previous files.
+* @param root - workspace root that each artifact's `packageRoot` is relative to.
+* @param artifacts - artifacts returned by one `WorkspaceTypertGenerator` pass.
+* @throws A file-system error when an output directory or file cannot be written.
+*/
+function writeWorkspaceArtifacts(root, artifacts) {
+	for (const artifact of artifacts) writePackageArtifacts(join(root, artifact.packageRoot), [artifact]);
+}
+//#endregion
+export { CordisCatalogProjector, FaceModelEmitter, REGION_BEGIN, REGION_END, TypeGraphRenderError, TypeGraphRenderer, TypertAnalysisError, TypertEmitError, WorkspaceAnalyzer, WorkspaceCaches, WorkspaceTypertGenerator, collectEvents, collectServices, findWorkspaceRoot, projectCordisCatalog, renderInheritedPage, renderPageRegion, writePackageArtifacts, writeWorkspaceArtifacts };