@deepseek-ai/dsh-typert-generator 0.2.1-alpha.2 → 0.2.1-alpha.4

package/lib/types/build-output-guard.js

@@ -0,0 +1,193 @@
+/**
+ * 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
+ */
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import ts from 'typescript';
+/**
+ * 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.
+ */
+export function findBuildOutputLoads(program, root, host) {
+    const classifier = new BuildOutputClassifier(root);
+    const outputs = 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;
+            const importers = resolved === undefined ? undefined : outputs.get(classifier.canonical(resolved.resolvedFileName));
+            importers?.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.
+ */
+export 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 !== undefined)
+                continue;
+            const packageRoot = classifier.linkedWorkspacePackage(sourceFile.fileName, packageNameOf(specifier));
+            if (packageRoot === undefined)
+                continue;
+            const source = exportSource(packageRoot, specifier);
+            found.push({
+                file: classifier.display(sourceFile.fileName),
+                specifier,
+                source: source === undefined ? undefined : classifier.display(source),
+            });
+        }
+    }
+    return found.sort((left, right) => left.file.localeCompare(right.file) || left.specifier.localeCompare(right.specifier));
+}
+function packageNameOf(specifier) {
+    const parts = specifier.split('/');
+    return parts.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) {
+        // The error names the import without a suggested source path.
+        return undefined;
+    }
+    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 undefined;
+    const stem = join(packageRoot, 'src', types.slice('./lib/types/'.length).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] : undefined;
+}
+/**
+ * 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.
+ */
+class BuildOutputClassifier {
+    root;
+    packageRoots = new Map();
+    realPaths = 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 !== undefined)
+            return cached;
+        let real = absolute;
+        try {
+            real = realpathSync.native(absolute);
+        }
+        catch (_missingPath) {
+            // A path that does not exist, such as an unresolved candidate, keeps its resolved spelling.
+        }
+        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 !== undefined && relative(packageRoot, real).split(sep)[0] === 'lib';
+    }
+    sourceFor(file) {
+        const real = this.canonical(file);
+        const packageRoot = this.packageRoot(dirname(real));
+        if (packageRoot === undefined)
+            return undefined;
+        const [lib, types, ...rest] = relative(packageRoot, real).split(sep);
+        const last = rest.at(-1);
+        if (lib !== 'lib' || types !== 'types' || last === undefined)
+            return undefined;
+        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 === undefined ? undefined : 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 : undefined;
+            }
+            if (this.canonical(directory) === this.realRoot || dirname(directory) === directory)
+                return undefined;
+            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
+                ? undefined
+                : this.packageRoot(dirname(directory));
+        this.packageRoots.set(directory, found);
+        return found;
+    }
+}
+//# sourceMappingURL=build-output-guard.js.map

package/lib/types/emitter.d.ts

@@ -44,6 +44,9 @@ export declare class FaceModelEmitter {
     private renderJs;
     private renderDts;
     private emitRemote;
+    private remoteMethodTypes;
+    private remoteInputType;
+    private remoteInfoLiteral;
     private invocationLiteral;
     private renderRemoteDts;
     private pushRemoteSignature;

package/lib/types/emitter.js

@@ -8,6 +8,7 @@ import { posix } from 'node:path';
 import { GenMapping, addMapping, toEncodedMap } from '@jridgewell/gen-mapping';
 import { TypeGraphRenderer } from "./renderer.js";
 import { childTypeNodeIds } from "./model.js";
+import { projectToolSchema, ToolSchemaError } from "./tool-schema.js";
 /** Failure to project a modeled construct into an emitted artifact. */
 export class TypertEmitError extends Error {
     name = 'TypertEmitError';
@@ -34,8 +35,7 @@ export class FaceModelEmitter {
         if (packageModel === undefined) {
             throw new TypertEmitError(`typert emitter(${this.face.face}): package ${packageName} is not modeled on this face`);
         }
-        const schemas = new SchemaEmitter(this.renderer, packageModel.schemas, invocationBoundaryRoots(packageModel.invocations));
-        const schemaArtifact = schemas.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);
@@ -109,6 +109,9 @@ export class FaceModelEmitter {
         ];
         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('');
@@ -116,6 +119,8 @@ export class FaceModelEmitter {
             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(packageModel.name)},`);
@@ -125,11 +130,10 @@ export class FaceModelEmitter {
             lines.push(`    { name: ${quote(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`;
@@ -163,38 +167,53 @@ export class FaceModelEmitter {
         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(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));
+        const entries = 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 === undefined ? '' : `, ${this.renderer.renderType(invocation.uplink.boundary.type, names)}`;
+            const mode = invocation.mode === 'stream' ? `, ${quote('stream')}${uplink}`
+                : containsBytes(this.renderer, invocation.result.codecType) ? `, 'unary', never, RemoteDecoded<${result}>` : '';
+            return `  readonly ${quote(`${invocation.namespace}/${invocation.method}`)}: TypertRemoteMethod<${input}, ${result}${mode}>`;
+        });
+        return `{\n${entries.join('\n')}\n}`;
+    }
+    remoteInputType(invocation, names) {
+        return `{ ${invocation.parameters.map(parameter => `readonly ${quote(parameter.wire)}${parameter.boundary.acceptsUndefined ? '?' : ''}: ${this.renderer.renderType(parameter.boundary.type, names)}`).join('; ')} }`;
+    }
+    remoteInfoLiteral(packageModel, schemas) {
+        return [
+            'createTypertRemoteInfo({',
+            `  package: ${quote(packageModel.name)},`,
+            '  methods: {',
+            ...packageModel.invocations.map(invocation => `    ${quote(`${invocation.namespace}/${invocation.method}`)}: ${indent(this.invocationLiteral(invocation, schemas), 4).trimStart()},`),
+            '  },',
+            '}, z)',
+        ].join('\n');
+    }
     invocationLiteral(invocation, schemas) {
         const lines = [
             '{',
-            `  id: ${quote(invocation.id)},`,
             `  service: ${quote(invocation.service)},`,
-            `  namespace: ${quote(invocation.namespace)},`,
-            `  method: ${quote(invocation.method)},`,
+            ...(invocation.description === undefined ? [] : [`  description: ${quote(invocation.description)},`]),
         ];
         if (invocation.implementation !== undefined) {
             lines.push(`  implementation: ${quote(invocation.implementation)},`);
@@ -222,13 +241,18 @@ export class FaceModelEmitter {
         invocation.parameters.forEach((parameter, index) => {
             lines.push('    {');
             lines.push(`      name: ${quote(parameter.name)},`);
-            lines.push(`      wire: ${quote(parameter.wire)},`);
+            if (parameter.wire !== parameter.name)
+                lines.push(`      wire: ${quote(parameter.wire)},`);
+            if (parameter.description !== undefined)
+                lines.push(`      description: ${quote(parameter.description)},`);
             lines.push(`      source: ${quote(parameter.source)},`);
             if (parameter.lookup !== undefined)
                 lines.push(`      lookup: ${quote(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)), undefined, toolProjection(() => projectToolSchema(this.renderer, parameter.boundary.codecType, strict, parameter.boundary.acceptsUndefined))), 6).trimStart()},`);
+            }
             lines.push('    },');
         });
         lines.push('  ],');
@@ -240,7 +264,8 @@ export class FaceModelEmitter {
         if (invocation.cancellation !== undefined) {
             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');
@@ -262,9 +287,11 @@ export class FaceModelEmitter {
         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' });
@@ -273,12 +300,6 @@ export class FaceModelEmitter {
             lines.push(`import type { ${names.join(', ')} } from ${quote(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 !== undefined);
@@ -310,7 +331,7 @@ export class FaceModelEmitter {
         }
         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 {
@@ -385,6 +406,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(error.message)}`;
+    }
+}
+function invocationSchemas(renderer, schemas, roots) {
+    const identifiers = 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),
+    };
+}
 class ResultEncoderEmitter {
     renderer;
     names = new Map();
@@ -504,13 +546,15 @@ class SchemaEmitter {
     renderer;
     schemas;
     boundaries;
+    options;
     names = new Map();
     boundaryNames = new Map();
     declarations;
-    constructor(renderer, schemas, boundaries) {
+    constructor(renderer, schemas, boundaries, options = {}, identifiers = new Set()) {
         this.renderer = renderer;
         this.schemas = schemas;
         this.boundaries = boundaries;
+        this.options = options;
         const declarations = new Map();
         for (const schema of schemas) {
             for (const declaration of renderer.declarationClosureForTypes([schema.type])) {
@@ -523,9 +567,8 @@ class SchemaEmitter {
             }
         }
         this.declarations = renderer.graph.declarations.filter(declaration => declarations.has(declaration.id));
-        const identifiers = 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))
@@ -552,7 +595,7 @@ class SchemaEmitter {
             if (encode !== undefined)
                 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());
         const exports = this.schemas.map((model) => ({
@@ -570,12 +613,15 @@ class SchemaEmitter {
     declarationDefinition(declaration) {
         const name = this.schemaName(declaration.id);
         if (declaration.typeParameters.length === 0) {
-            return `let ${name}$value\nconst ${name} = () => (${name}$value ??= ${this.declarationSchema(declaration, new Map())})`;
+            return this.cachedFactory(name, this.declarationSchema(declaration, 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');
@@ -594,6 +640,8 @@ class SchemaEmitter {
     }
     typeSchema(id, substitutions = 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})`;
@@ -715,6 +763,8 @@ class SchemaEmitter {
     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')
@@ -731,29 +781,75 @@ class SchemaEmitter {
                 if (member.signature.parameters.length !== 1 || parameter === undefined) {
                     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`);
-            // Freezing a union may freeze its populated Uint8Array member.
-            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(member.jsonName ?? member.name)}: ${property}`);
+            properties.push(member);
         }
         if (indices.length > 1)
             this.fail(subject, 'object type has more than one JSON index signature');
         // A unique-symbol-only object is a compile-time marker and imposes no JSON shape.
         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) => {
+            // Freezing a union may freeze its populated Uint8Array member.
+            const type = this.options.closedObjects && stringIndexType !== undefined
+                ? 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(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 === undefined)
             return object;
         if (properties.length === 0)
             return index;
+        // Named keys enforce both their declared type and the index value; the catchall checks other keys.
+        if (this.options.closedObjects && stringIndexValue !== undefined)
+            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 === undefined)) {
+            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 === undefined)
+                    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(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);
         const declaration = this.renderer.declaration(model.symbol);
@@ -822,6 +918,7 @@ function invocationBoundaryRoots(invocations) {
         }
         invocation.parameters.forEach((parameter, index) => {
             result.push({ key: parameterBoundaryKey(invocation, index), type: parameter.boundary.codecType });
+            result.push({ key: parameterBoundaryKey(invocation, index, true), type: parameter.boundary.codecType, closedObjects: true });
         });
         if (invocation.uplink !== undefined) {
             result.push({ key: uplinkBoundaryKey(invocation), type: invocation.uplink.boundary.codecType });
@@ -836,8 +933,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`;
@@ -865,12 +962,14 @@ function containsBytes(renderer, id, nested = true, visited = new Set()) {
         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(boundary.typeSymbol)},`,
         `  create: ${schema},`,
+        ...(description === undefined ? [] : [`  description: ${quote(description)},`]),
+        ...(projection === undefined ? [] : [`  ${projection},`]),
         ...(encoder === undefined ? [] : [
             `  decode: value => ${schema}().parse(value),`,
             `  encode: (value, writeBytes) => ${encoder}(value, writeBytes, [], new Map()),`,
@@ -906,7 +1005,8 @@ function allocateRemoteImportNames(imports) {
         'RemoteDecoded',
         'RemoteResult',
         'RemoteStreamHandle',
-        'TypertRemoteContribution',
+        'TypertRemoteInfo',
+        'TypertRemoteMethod',
         'TYPERT_REMOTE',
     ]);
     const names = new Map();

package/lib/types/index.d.ts

@@ -10,7 +10,8 @@ export { FaceModelEmitter, TypertEmitError } from './emitter.ts';
 export type { ModelEmitResult } from './emitter.ts';
 export * from './cordis-catalog.ts';
 export { TypeGraphRenderer, TypeGraphRenderError } from './renderer.ts';
-export { WorkspaceTypertGenerator } from './workspace.ts';
-export type { WorkspaceEmitResult } from './workspace.ts';
+export { findWorkspaceRoot, WorkspaceTypertGenerator } from './workspace.ts';
+export type { WorkspaceEmitResult, WorkspaceTypertGeneratorOptions } from './workspace.ts';
+export { writePackageArtifacts, writeWorkspaceArtifacts } from './artifact-files.ts';
 export type * from './model.ts';
 //# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -8,5 +8,6 @@ export { WorkspaceAnalyzer, WorkspaceCaches, TypertAnalysisError } from "./analy
 export { FaceModelEmitter, TypertEmitError } from "./emitter.js";
 export * from "./cordis-catalog.js";
 export { TypeGraphRenderer, TypeGraphRenderError } from "./renderer.js";
-export { WorkspaceTypertGenerator } from "./workspace.js";
+export { findWorkspaceRoot, WorkspaceTypertGenerator } from "./workspace.js";
+export { writePackageArtifacts, writeWorkspaceArtifacts } from "./artifact-files.js";
 //# sourceMappingURL=index.js.map