@deepseek-ai/dsh-typert-generator 0.0.1-rc.1

package/lib/types/analyzer.js

@@ -0,0 +1,2723 @@
+/**
+ * TypeScript project analyzer for the compiler-independent Typert model.
+ * Programs, symbols, and syntax nodes remain extraction-only implementation
+ * details; callers receive only the model declared in {@link ./model.ts}.
+ * @module @deepseek-ai/dsh-typert-generator/analyzer
+ */
+import { existsSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { dirname, extname, join, relative, resolve, sep } from 'node:path';
+import ts from 'typescript';
+/** Analysis failure with a source-oriented diagnostic. */
+export class TypertAnalysisError extends Error {
+    name = 'TypertAnalysisError';
+}
+class SourceEditQueued extends Error {
+}
+const EMPTY_DOCUMENTATION = { tags: [] };
+/**
+ * Process-wide parse cache for the bundled TypeScript default libraries.
+ * `typescript/lib/lib.*.d.ts` content is immutable for the process lifetime,
+ * so parses are shared across every {@link WorkspaceCaches} instance; the key
+ * carries the parse-affecting settings, keeping reuse exact.
+ */
+const defaultLibraryParses = new Map();
+function defaultLibraryKey(fileName, languageVersionOrOptions) {
+    const options = typeof languageVersionOrOptions === 'object'
+        ? languageVersionOrOptions
+        : { languageVersion: languageVersionOrOptions };
+    return [
+        fileName,
+        String(options.languageVersion),
+        String(options.impliedNodeFormat ?? ''),
+        String(options.jsDocParsingMode ?? ''),
+    ].join('\0');
+}
+/**
+ * Shared memo over one immutable workspace snapshot. Passing one instance to
+ * several analyzers (the batched and write-mode children reuse their parent's
+ * automatically) reuses parsed tsconfigs, the registration inventory, and
+ * per-face compiler hosts whose parsed and bound source files and module
+ * resolutions carry across programs. Callers that mutate workspace files
+ * between analyses must start from a fresh instance; write-mode source edits
+ * invalidate themselves through {@link invalidate}.
+ */
+export class WorkspaceCaches {
+    /** Parsed tsconfig files by absolute config path. */
+    configs = new Map();
+    /** Registration inventories keyed by root and aggregate config paths. */
+    registrations = new Map();
+    hosts = new Map();
+    /**
+     * Parse one tsconfig once per workspace snapshot.
+     * @param path - absolute config path.
+     * @returns the memoized parse result.
+     */
+    config(path) {
+        let parsed = this.configs.get(path);
+        if (parsed === undefined) {
+            parsed = parseConfig(path);
+            this.configs.set(path, parsed);
+        }
+        return parsed;
+    }
+    /**
+     * 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
+     * reuse across the face's batched programs.
+     * @param face - the face whose programs share this host.
+     * @param options - the face's effective compiler options.
+     * @returns a compiler host with source-file and module-resolution caches.
+     */
+    programHost(face, options) {
+        let entry = this.hosts.get(face);
+        if (entry === undefined) {
+            const host = ts.createCompilerHost(options);
+            const files = new Map();
+            const resolutionCache = ts.createModuleResolutionCache(host.getCurrentDirectory(), fileName => host.getCanonicalFileName(fileName), options);
+            const base = host.getSourceFile.bind(host);
+            // The snapshot contract makes shouldCreateNewSourceFile irrelevant: it
+            // only fires under oldProgram reuse, which these fresh programs never
+            // request, and invalidate() is the one supported re-read path.
+            host.getSourceFile = (fileName, languageVersionOrOptions, onError) => {
+                if (isStandardLibraryFile(fileName)) {
+                    const key = defaultLibraryKey(fileName, languageVersionOrOptions);
+                    if (!defaultLibraryParses.has(key)) {
+                        defaultLibraryParses.set(key, base(fileName, languageVersionOrOptions, onError));
+                    }
+                    return defaultLibraryParses.get(key);
+                }
+                if (!files.has(fileName))
+                    files.set(fileName, base(fileName, languageVersionOrOptions, onError));
+                return files.get(fileName);
+            };
+            host.getModuleResolutionCache = () => resolutionCache;
+            entry = { host, files };
+            this.hosts.set(face, entry);
+        }
+        return entry.host;
+    }
+    /**
+     * Drop cached parses of one edited source file so the next analysis reads
+     * the written content.
+     * @param file - path of the edited file.
+     */
+    invalidate(file) {
+        const target = realPath(file);
+        for (const { files } of this.hosts.values()) {
+            for (const key of [...files.keys()]) {
+                if (realPath(key) === target)
+                    files.delete(key);
+            }
+        }
+    }
+}
+/** Analyze host and client as independent TypeScript programs. */
+export class WorkspaceAnalyzer {
+    options;
+    queuedEdit;
+    crossFaceLinks = new Map();
+    checkedProjects = new Set();
+    registrations = [];
+    caches;
+    constructor(options) {
+        this.options = {
+            root: realPath(options.root),
+            hostConfig: options.hostConfig ?? 'tsconfig.host.json',
+            clientConfig: options.clientConfig ?? 'tsconfig.client.json',
+            faces: options.faces ?? ['host', 'client'],
+            checkDiagnostics: options.checkDiagnostics ?? true,
+            mode: options.mode ?? 'check',
+            ...(options.packages === undefined ? {} : { packages: options.packages }),
+        };
+        this.caches = options.caches ?? new WorkspaceCaches();
+    }
+    /**
+     * Build the workspace model. Write mode applies inferred annotations and then
+     * returns a fresh check-mode analysis of the edited projects.
+     * @returns the independent face models and their explicit cross-face links.
+     */
+    analyze() {
+        this.registrations = this.loadRegistrations();
+        const selected = this.options.packages === undefined
+            ? undefined
+            : new Set(this.options.packages);
+        const faces = [];
+        try {
+            for (const face of this.options.faces) {
+                const registrations = this.registrations.filter(registration => registration.face === face && (selected === undefined || selected.has(registration.name)));
+                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 rootNames = [...new Set(registrations.flatMap(registration => registration.config.parsed.fileNames))];
+                const options = {
+                    ...aggregate.parsed.options,
+                    composite: false,
+                    incremental: false,
+                    noEmit: true,
+                };
+                const program = ts.createProgram({
+                    rootNames,
+                    options,
+                    host: this.caches.programHost(face, options),
+                });
+                faces.push(new FaceAnalyzer({
+                    root: this.options.root,
+                    face,
+                    program,
+                    registrations,
+                    allRegistrations: this.registrations,
+                    mode: this.options.mode,
+                    queueEdit: (edit) => { this.queueEdit(edit); },
+                    crossFaceLinks: this.crossFaceLinks,
+                }).analyze());
+            }
+        }
+        catch (error) {
+            if (!(error instanceof SourceEditQueued) || this.options.mode !== 'write' || this.queuedEdit === undefined)
+                throw error;
+        }
+        if (this.queuedEdit !== undefined) {
+            this.applyEdit(this.queuedEdit);
+            return new WorkspaceAnalyzer({ ...this.options, caches: this.caches, mode: 'write' }).analyze();
+        }
+        if (this.options.mode === 'write') {
+            return new WorkspaceAnalyzer({ ...this.options, caches: this.caches, mode: 'check' }).analyze();
+        }
+        return {
+            faces,
+            crossFaceLinks: [...this.crossFaceLinks.values()].sort(compareCrossFaceLinks),
+        };
+    }
+    /**
+     * Analyze an explicit package selection through bounded compiler programs.
+     * The resulting model is identical in shape to {@link analyze}; stable graph
+     * ids let repeated dependency declarations merge without flattening types.
+     * @param batchSize - maximum selected packages in one face program.
+     * @returns one merged workspace model.
+     */
+    analyzeInBatches(batchSize = 8) {
+        if (this.options.packages === undefined) {
+            throw new TypertAnalysisError('typert: batched analysis requires an explicit package selection');
+        }
+        if (!Number.isInteger(batchSize) || batchSize < 1) {
+            throw new TypertAnalysisError(`typert: batch size must be a positive integer, received ${String(batchSize)}`);
+        }
+        const batches = [];
+        for (let index = 0; index < this.options.packages.length; index += batchSize) {
+            batches.push(new WorkspaceAnalyzer({
+                ...this.options,
+                caches: this.caches,
+                packages: this.options.packages.slice(index, index + batchSize),
+            }).analyze());
+        }
+        return mergeWorkspaceModels(batches);
+    }
+    /**
+     * Discover package faces from public-export-reachable Cordis augmentations
+     * and explicit `@typert` roots without constructing a type-checker program.
+     * @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));
+        const packages = new Map();
+        for (const registration of registrations) {
+            const current = packages.get(registration.name) ?? {
+                root: slash(relative(this.options.root, registration.root)),
+                faces: new Set(),
+            };
+            current.faces.add(registration.face);
+            packages.set(registration.name, current);
+        }
+        return [...packages]
+            .map(([packageName, value]) => ({
+            package: packageName,
+            root: value.root,
+            faces: [...value.faces].sort(),
+        }))
+            .sort((left, right) => left.package.localeCompare(right.package));
+    }
+    /**
+     * Index top-level exported type declarations without promoting them to graph
+     * roots. Consumers use this lexical index for ambiguity checks while all
+     * semantic traversal continues through {@link TypeGraph}.
+     * @returns declarations from the selected faces and package projects.
+     */
+    indexSourceDeclarations() {
+        const selected = this.options.packages === undefined ? undefined : new Set(this.options.packages);
+        const declarations = [];
+        for (const registration of this.loadRegistrations()) {
+            if (!this.options.faces.includes(registration.face)
+                || (selected !== undefined && !selected.has(registration.name)))
+                continue;
+            for (const file of registration.config.parsed.fileNames) {
+                const relativeFile = slash(relative(this.options.root, file));
+                if (!existsSync(file)
+                    || !isWithin(realPath(file), join(registration.root, 'src'))
+                    || !/\.(?:cts|mts|ts)$/.test(file))
+                    continue;
+                const sourceFile = ts.createSourceFile(file, readFileSync(file, 'utf8'), ts.ScriptTarget.Latest, true);
+                for (const statement of sourceFile.statements) {
+                    if (!isTypeDeclaration(statement)
+                        || statement.name === undefined
+                        || !hasModifier(statement, ts.SyntaxKind.ExportKeyword))
+                        continue;
+                    const position = sourceFile.getLineAndCharacterOfPosition(statement.getStart(sourceFile));
+                    declarations.push({
+                        face: registration.face,
+                        package: registration.name,
+                        name: statement.name.text,
+                        kind: ts.isClassDeclaration(statement)
+                            ? 'class'
+                            : ts.isInterfaceDeclaration(statement)
+                                ? 'interface'
+                                : ts.isTypeAliasDeclaration(statement)
+                                    ? 'alias'
+                                    : 'enum',
+                        location: {
+                            file: relativeFile,
+                            line: position.line + 1,
+                            column: position.character + 1,
+                        },
+                        text: declarationText(statement),
+                    });
+                }
+            }
+        }
+        return uniqueBy(declarations, declaration => `${declaration.face}\0${declaration.location.file}\0${String(declaration.location.line)}\0${declaration.name}`)
+            .sort((left, right) => left.face.localeCompare(right.face)
+            || left.location.file.localeCompare(right.location.file)
+            || left.location.line - right.location.line);
+    }
+    loadRegistrations() {
+        const inventoryKey = `${this.options.root}\0${this.options.hostConfig}\0${this.options.clientConfig}`;
+        const cached = this.caches.registrations.get(inventoryKey);
+        if (cached !== undefined)
+            return cached;
+        const registrations = [];
+        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 configPath = projectConfigPath(reference.path);
+                const packageRoot = dirname(configPath);
+                if (!isWithin(realPath(packageRoot), join(this.options.root, 'packages')))
+                    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 inventory = uniqueBy(registrations, registration => `${registration.face}\0${registration.name}`)
+            .sort((left, right) => left.face.localeCompare(right.face) || left.name.localeCompare(right.name));
+        this.caches.registrations.set(inventoryKey, inventory);
+        return inventory;
+    }
+    entrySourcePaths(registration) {
+        return packageExportTargets(registration.manifest)
+            .filter(([subpath, target]) => (registration.exportSubpaths === undefined
+            || registration.exportSubpaths.includes(subpath))
+            && !target.includes('*')
+            && subpath !== './package.json'
+            && subpath !== './typert'
+            && subpath !== './client/typert'
+            && subpath !== './remote'
+            && !target.endsWith('.json'))
+            .map(([, target]) => sourcePathForExport(registration.root, target))
+            .filter(existsSync);
+    }
+    registrationHasSurface(registration) {
+        const seen = new Set();
+        const queue = this.entrySourcePaths(registration);
+        while (queue.length > 0) {
+            const file = realPath(queue.shift());
+            if (seen.has(file) || !isWithin(file, registration.root))
+                continue;
+            seen.add(file);
+            const source = readFileSync(file, 'utf8');
+            const sourceFile = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true);
+            if (sourceFileHasSurface(sourceFile))
+                return true;
+            for (const imported of ts.preProcessFile(source).importedFiles) {
+                const resolved = ts.resolveModuleName(imported.fileName, file, registration.config.parsed.options, ts.sys).resolvedModule;
+                if (resolved !== undefined && isWithin(resolved.resolvedFileName, registration.root)) {
+                    queue.push(resolved.resolvedFileName);
+                }
+            }
+        }
+        return false;
+    }
+    checkProject(registration) {
+        if (this.checkedProjects.has(registration.config.path))
+            return;
+        this.checkedProjects.add(registration.config.path);
+        const program = ts.createProgram({
+            rootNames: registration.config.parsed.fileNames,
+            options: {
+                ...registration.config.parsed.options,
+                composite: false,
+                incremental: false,
+                noEmit: true,
+                // Source-plane workspace aliases resolve referenced packages to source.
+                // Widen only this diagnostic program's root so those imports do not
+                // produce an artificial TS6059 before Typert checks the public edge.
+                rootDir: this.options.root,
+            },
+        });
+        const diagnostics = [
+            ...program.getSyntacticDiagnostics(),
+            ...program.getSemanticDiagnostics(),
+        ].filter((diagnostic) => diagnostic.file !== undefined
+            && diagnostic.start !== undefined
+            && isWithin(diagnostic.file.fileName, registration.root));
+        if (diagnostics.length === 0)
+            return;
+        throw new TypertAnalysisError(diagnostics
+            .map(diagnostic => formatProgramDiagnostic(this.options.root, registration.face, diagnostic))
+            .join('\n'));
+    }
+    queueEdit(edit) {
+        this.queuedEdit = edit;
+    }
+    applyEdit(edit) {
+        const source = readFileSync(edit.file, 'utf8');
+        writeFileSync(edit.file, source.slice(0, edit.position) + edit.text + source.slice(edit.position));
+        this.caches.invalidate(edit.file);
+    }
+}
+class FaceAnalyzer {
+    root;
+    face;
+    program;
+    checker;
+    registrations;
+    allRegistrations;
+    mode;
+    queueEdit;
+    crossFaceLinks;
+    sourceFiles = new Map();
+    declarations = new Map();
+    declarationStates = new Set();
+    nodes = new Map();
+    exportsByPackage = new Map();
+    nodeOrdinals = new Map();
+    staticLookups;
+    staticContexts;
+    constructor(options) {
+        this.root = options.root;
+        this.face = options.face;
+        this.program = options.program;
+        this.checker = options.program.getTypeChecker();
+        this.registrations = options.registrations;
+        this.allRegistrations = options.allRegistrations;
+        this.mode = options.mode;
+        this.queueEdit = options.queueEdit;
+        this.crossFaceLinks = options.crossFaceLinks;
+        for (const sourceFile of this.program.getSourceFiles()) {
+            this.sourceFiles.set(realPath(sourceFile.fileName), sourceFile);
+        }
+    }
+    analyze() {
+        for (const registration of this.registrations) {
+            this.exportsByPackage.set(registration.name, this.collectExports(registration));
+        }
+        const packages = this.registrations
+            .map(registration => this.analyzePackage(registration))
+            .filter(hasPackageSurface);
+        this.validateInvocationIdentity(packages);
+        return {
+            face: this.face,
+            packages,
+            graph: {
+                declarations: [...this.declarations.values()].sort((left, right) => left.id.localeCompare(right.id)),
+                nodes: [...this.nodes.values()].sort((left, right) => left.id.localeCompare(right.id)),
+            },
+        };
+    }
+    analyzePackage(registration) {
+        const records = this.exportsByPackage.get(registration.name);
+        const reachable = this.reachableFiles(registration, records.map(record => record.sourceFile));
+        const services = [];
+        const events = [];
+        for (const sourceFile of reachable) {
+            for (const statement of sourceFile.statements) {
+                if (!ts.isModuleDeclaration(statement)
+                    || !ts.isStringLiteral(statement.name)
+                    || statement.name.text !== '@deepseek-ai/cordis'
+                    || statement.body === undefined
+                    || !ts.isModuleBlock(statement.body))
+                    continue;
+                for (const member of statement.body.statements) {
+                    if (!ts.isInterfaceDeclaration(member))
+                        continue;
+                    if (member.name.text === 'Context') {
+                        services.push(...this.collectServices(member, records));
+                    }
+                    else if (member.name.text === 'Events') {
+                        events.push(...this.collectEvents(member));
+                    }
+                }
+            }
+        }
+        const explicitServices = this.collectExplicitServices(records);
+        const objects = [];
+        const schemas = [];
+        const seenBusinessSymbols = new Set();
+        for (const record of records) {
+            const declaration = record.declaration;
+            if (!isTypeDeclaration(declaration))
+                continue;
+            if (this.registrationForFile(declaration.getSourceFile().fileName) === undefined)
+                continue;
+            const symbol = this.resolveSymbol(record.symbol);
+            const symbolId = this.symbolId(symbol);
+            if (seenBusinessSymbols.has(symbolId))
+                continue;
+            const mode = typertMode(declaration);
+            if (mode !== 'object' && mode !== 'schema')
+                continue;
+            seenBusinessSymbols.add(symbolId);
+            this.ensureDeclaration(symbol, declaration);
+            const documentation = documentationOf(declaration);
+            if (mode === 'object') {
+                objects.push({
+                    ...documentation,
+                    export: record.model,
+                    symbol: symbolId,
+                    passing: 'reference',
+                });
+            }
+            else {
+                schemas.push({
+                    ...documentation,
+                    export: record.model,
+                    symbol: symbolId,
+                    type: this.referenceNode(symbol, declaration),
+                });
+            }
+        }
+        return {
+            name: registration.name,
+            root: slash(relative(this.root, registration.root)),
+            exports: records.map(record => record.model)
+                .sort((left, right) => left.subpath.localeCompare(right.subpath) || left.name.localeCompare(right.name)),
+            services: uniqueBy([...explicitServices, ...services], service => service.key)
+                .sort((left, right) => left.key.localeCompare(right.key)),
+            events: uniqueBy(events, event => event.name).sort((left, right) => left.name.localeCompare(right.name)),
+            objects: objects.sort((left, right) => left.export.name.localeCompare(right.export.name)),
+            schemas: schemas.sort((left, right) => left.export.name.localeCompare(right.export.name)),
+            invocations: this.face === 'host'
+                ? this.collectInvocations(registration, reachable).sort((left, right) => left.id.localeCompare(right.id))
+                : [],
+        };
+    }
+    collectExports(registration) {
+        const targets = packageExportTargets(registration.manifest)
+            .filter(([subpath]) => registration.exportSubpaths === undefined
+            || registration.exportSubpaths.includes(subpath));
+        const records = [];
+        for (const [subpath, target] of targets) {
+            if (target.includes('*') || subpath === './package.json'
+                || subpath === './typert' || subpath === './client/typert' || subpath === './remote'
+                // Data exports (bundle patch lists, JSON manifests) carry no TypeScript API.
+                || target.endsWith('.json') || target.endsWith('.yml') || target.endsWith('.yaml'))
+                continue;
+            const sourcePath = sourcePathForExport(registration.root, target);
+            const sourceFile = this.sourceFiles.get(realPath(sourcePath));
+            if (sourceFile === undefined) {
+                throw new TypertAnalysisError(`typert(${this.face}): ${registration.name} export ${subpath} resolves to missing source ${sourcePath}`);
+            }
+            const moduleSymbol = this.checker.getSymbolAtLocation(sourceFile);
+            if (moduleSymbol === undefined)
+                continue;
+            for (const exported of this.checker.getExportsOfModule(moduleSymbol)) {
+                const symbol = this.resolveSymbol(exported);
+                const declaration = preferredDeclaration(symbol);
+                const aliases = exported === symbol || exported.name === symbol.name
+                    ? [exported.name]
+                    : [exported.name, symbol.name];
+                records.push({
+                    model: {
+                        subpath,
+                        name: exported.name,
+                        symbol: this.symbolId(symbol),
+                        aliases,
+                    },
+                    symbol,
+                    declaration,
+                    sourceFile,
+                });
+            }
+        }
+        const unique = uniqueBy(records, record => `${record.model.subpath}\0${record.model.name}`);
+        this.collectCrossFaceReExports(registration, unique);
+        return unique;
+    }
+    collectCrossFaceReExports(registration, records) {
+        const publicSymbols = new Set(records.map(record => record.symbol));
+        const entryFiles = uniqueBy(records, record => record.sourceFile.fileName).map(record => record.sourceFile);
+        for (const sourceFile of this.reachableFiles(registration, entryFiles)) {
+            for (const statement of sourceFile.statements) {
+                if (!ts.isExportDeclaration(statement)
+                    || statement.moduleSpecifier === undefined
+                    || !ts.isStringLiteral(statement.moduleSpecifier))
+                    continue;
+                const module = moduleIdentity(statement.moduleSpecifier.text);
+                if (module === undefined)
+                    continue;
+                const toFace = this.allRegistrations
+                    .find(candidate => candidate.name === module.package && candidate.face !== this.face)?.face;
+                if (toFace === undefined)
+                    continue;
+                if (statement.exportClause !== undefined && ts.isNamespaceExport(statement.exportClause)) {
+                    const namespace = this.resolveSymbol(this.checker.getSymbolAtLocation(statement.exportClause.name));
+                    if (publicSymbols.has(namespace)) {
+                        this.fail(statement.exportClause, 'cross-face namespace re-exports are not supported');
+                    }
+                    continue;
+                }
+                const exports = statement.exportClause === undefined
+                    ? this.moduleExports(statement.moduleSpecifier)
+                        .map(symbol => ({ symbol: this.resolveSymbol(symbol), requestedName: symbol.name, site: statement }))
+                    : statement.exportClause.elements.map(element => ({
+                        symbol: this.resolveSymbol(this.checker.getSymbolAtLocation(element.name)),
+                        requestedName: element.propertyName?.text ?? element.name.text,
+                        site: element,
+                    }));
+                for (const exported of exports) {
+                    if (!publicSymbols.has(exported.symbol))
+                        continue;
+                    const name = this.packageExportName(module, exported.symbol, toFace, exported.requestedName);
+                    if (name === undefined) {
+                        this.fail(exported.site, `cross-face re-export ${exported.requestedName} is not exported by ${module.package} at ${module.subpath}`);
+                    }
+                    this.recordCrossFaceLink(registration.name, toFace, module, name);
+                }
+            }
+        }
+    }
+    moduleExports(moduleSpecifier) {
+        /* v8 ignore next -- a semantically valid export declaration from a resolved module always has a module symbol. */
+        const moduleSymbol = this.checker.getSymbolAtLocation(moduleSpecifier);
+        return this.checker.getExportsOfModule(moduleSymbol);
+    }
+    reachableFiles(registration, entryFiles) {
+        const reachable = new Map();
+        const queue = [...entryFiles];
+        while (queue.length > 0) {
+            const sourceFile = queue.shift();
+            const fileName = realPath(sourceFile.fileName);
+            if (reachable.has(fileName) || !isWithin(fileName, registration.root))
+                continue;
+            reachable.set(fileName, sourceFile);
+            for (const statement of sourceFile.statements) {
+                if ((!ts.isImportDeclaration(statement) && !ts.isExportDeclaration(statement))
+                    || statement.moduleSpecifier === undefined
+                    || !ts.isStringLiteral(statement.moduleSpecifier))
+                    continue;
+                const resolved = ts.resolveModuleName(statement.moduleSpecifier.text, sourceFile.fileName, this.program.getCompilerOptions(), ts.sys).resolvedModule;
+                if (resolved === undefined)
+                    continue;
+                const resolvedPath = realPath(resolved.resolvedFileName);
+                if (!isWithin(resolvedPath, registration.root))
+                    continue;
+                queue.push(this.sourceFiles.get(resolvedPath));
+            }
+        }
+        return [...reachable.values()].sort((left, right) => left.fileName.localeCompare(right.fileName));
+    }
+    collectServices(context, records) {
+        const bySymbol = new Map();
+        for (const record of records) {
+            const id = this.symbolId(record.symbol);
+            const matches = bySymbol.get(id) ?? [];
+            matches.push(record);
+            bySymbol.set(id, matches);
+        }
+        const result = [];
+        for (const member of context.members) {
+            if (!ts.isPropertySignature(member) || member.type === undefined)
+                continue;
+            const symbol = this.symbolAtType(member.type);
+            if (symbol === undefined)
+                continue;
+            const symbolId = this.symbolId(symbol);
+            const exported = bySymbol.get(symbolId)?.find(record => record.model.name === symbol.name)
+                ?? bySymbol.get(symbolId)?.find(record => record.model.name !== 'default')
+                ?? bySymbol.get(symbolId)?.[0];
+            if (exported === undefined)
+                continue;
+            const declaration = preferredDeclaration(symbol);
+            if (declaration === undefined || (!ts.isClassDeclaration(declaration) && !ts.isInterfaceDeclaration(declaration))) {
+                this.fail(member, `service ${memberName(member.name)} does not resolve to an exported class or interface`);
+            }
+            const model = this.ensureDeclaration(symbol, declaration);
+            const exposed = model.members
+                .filter(exposableMember)
+                .map(publicMember => publicMember.id);
+            result.push({
+                ...documentationOf(declaration),
+                key: memberName(member.name),
+                symbol: symbolId,
+                export: exported.model,
+                members: exposed,
+                location: this.location(member),
+            });
+        }
+        return result;
+    }
+    collectExplicitServices(records) {
+        const result = [];
+        const seen = new Set();
+        for (const record of records) {
+            const tag = typertServiceTag(record.declaration);
+            if (tag === undefined)
+                continue;
+            const words = (ts.getTextOfJSDocComment(tag.comment) ?? '').trim().split(/\s+/);
+            if (words.length !== 2 || !isRemoteSegment(words[1] ?? '')) {
+                this.fail(tag, '@typert service requires exactly one nonempty Cordis service key without "/"');
+            }
+            if (!ts.isClassDeclaration(record.declaration)) {
+                this.fail(record.declaration, '@typert service requires an exported class');
+            }
+            const symbol = this.resolveSymbol(record.symbol);
+            const symbolId = this.symbolId(symbol);
+            if (seen.has(symbolId))
+                continue;
+            seen.add(symbolId);
+            const model = this.ensureDeclaration(symbol, record.declaration);
+            result.push({
+                ...documentationOf(record.declaration),
+                key: words[1],
+                symbol: symbolId,
+                export: record.model,
+                members: model.members.filter(exposableMember).map(member => member.id),
+                location: this.location(record.declaration),
+            });
+        }
+        return result;
+    }
+    collectInvocations(registration, reachable) {
+        const result = [];
+        for (const sourceFile of reachable) {
+            for (const statement of sourceFile.statements) {
+                if (!ts.isClassDeclaration(statement))
+                    continue;
+                const marked = statement.members.flatMap((member) => {
+                    const invocation = this.remoteMarker(member);
+                    if (invocation === undefined)
+                        return [];
+                    if (!ts.isMethodDeclaration(member)) {
+                        this.fail(member, 'Remote decorators require a public instance method');
+                    }
+                    return [{ method: member, invocation }];
+                });
+                const first = marked[0];
+                if (first === undefined)
+                    continue;
+                const binding = this.gatewayBinding(statement);
+                if (binding === undefined) {
+                    this.fail(first.method, 'Remote methods require GatewayService or readonly typertGateway = bindTypeRTGateway(this, serviceKey)');
+                }
+                for (const { method, invocation } of marked) {
+                    result.push(this.invocationModel(registration, binding, method, invocation));
+                }
+            }
+        }
+        return result;
+    }
+    invocationModel(registration, binding, method, invocation) {
+        if (visibilityOf(method) !== 'public' || hasModifier(method, ts.SyntaxKind.StaticKeyword)) {
+            this.fail(method, 'Remote decorators require a public instance method');
+        }
+        if (hasModifier(method, ts.SyntaxKind.AbstractKeyword) || method.body === undefined) {
+            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 methodName = method.name.text;
+        const exportedMethod = invocation.exportName ?? methodName;
+        const lookups = this.lookupDeclarations();
+        const lookupByHost = new Map(lookups.map(lookup => [lookup.hostSymbol, lookup]));
+        const parameters = [];
+        let cancellation;
+        const wires = new Set();
+        for (const [parameterIndex, parameter] of method.parameters.entries()) {
+            if (!ts.isIdentifier(parameter.name)) {
+                this.fail(parameter, 'Remote parameters must use identifier bindings');
+            }
+            if (parameter.dotDotDotToken !== undefined)
+                this.fail(parameter, 'Remote parameters cannot be rest parameters');
+            if (parameter.initializer !== undefined)
+                this.fail(parameter, 'Remote parameters cannot have default values');
+            if (parameter.questionToken !== undefined)
+                this.fail(parameter, 'Remote parameters cannot be optional');
+            if (parameter.name.text === 'this')
+                this.fail(parameter, 'Remote methods cannot declare an explicit this parameter');
+            const authoredType = this.requiredType(parameter, parameter.type, 'parameter');
+            const cancellationName = parameter.name.text === 'signal';
+            const cancellationType = this.isGlobalAbortSignal(authoredType);
+            if (cancellationName || cancellationType) {
+                if (!cancellationName || !cancellationType) {
+                    this.fail(parameter, 'Remote cancellation must use a parameter named signal with the global AbortSignal type');
+                }
+                if (parameterIndex !== method.parameters.length - 1) {
+                    this.fail(parameter, 'Remote cancellation signal must be the final parameter');
+                }
+                cancellation = { parameter: 'signal' };
+                continue;
+            }
+            const hostSymbol = this.symbolAtType(authoredType);
+            const lookup = hostSymbol === undefined ? undefined : lookupByHost.get(this.symbolId(hostSymbol));
+            let modeled;
+            if (lookup !== undefined) {
+                if (parameter.name.text !== lookup.key) {
+                    this.fail(parameter, `lookup parameter for ${lookup.key} must also be named ${lookup.key}`);
+                }
+                const boundary = this.remoteBoundary(lookup.wireType, `${registration.name}#${binding.namespace}/${exportedMethod}:${lookup.key}Id`, true);
+                modeled = {
+                    name: parameter.name.text,
+                    wire: `${lookup.key}Id`,
+                    source: 'lookup',
+                    lookup: lookup.key,
+                    boundary,
+                };
+            }
+            else {
+                if (hostSymbol !== undefined && this.isWorkspaceClass(hostSymbol)) {
+                    this.fail(parameter, `non-JSON class parameter ${hostSymbol.name} requires a TypeRTLookupMap entry`);
+                }
+                modeled = {
+                    name: parameter.name.text,
+                    wire: parameter.name.text,
+                    source: 'json',
+                    boundary: this.remoteBoundary(authoredType, `${registration.name}#${binding.namespace}/${exportedMethod}:${parameter.name.text}`, false),
+                };
+            }
+            if (wires.has(modeled.wire))
+                this.fail(parameter, `duplicate Remote wire field ${modeled.wire}`);
+            wires.add(modeled.wire);
+            parameters.push(modeled);
+        }
+        let receiver = { kind: 'direct' };
+        if (invocation.kind === 'context') {
+            const context = this.contextDeclarations().get(invocation.context);
+            if (context === undefined) {
+                this.fail(method, `Remote Scope ${invocation.context} has no TypeRTContextMap entry`);
+            }
+            const wire = `${invocation.context}Id`;
+            if (wires.has(wire))
+                this.fail(method, `Remote Scope wire field ${wire} conflicts with a method parameter`);
+            receiver = {
+                kind: 'context',
+                context: invocation.context,
+                wire,
+                boundary: this.remoteBoundary(context.wireType, `${registration.name}#${binding.namespace}/${exportedMethod}:${wire}`, true),
+            };
+        }
+        let scope;
+        if (invocation.kind === 'direct') {
+            const lookupParameters = parameters.filter(parameter => parameter.source === 'lookup');
+            const parameter = lookupParameters.length === 1 ? lookupParameters[0] : undefined;
+            const context = parameter?.lookup === undefined
+                ? undefined
+                : this.contextDeclarations().get(parameter.lookup);
+            if (parameter !== undefined && context !== undefined) {
+                const contextBoundary = this.remoteBoundary(context.wireType, `${registration.name}#${binding.namespace}/${exportedMethod}:scope:${context.key}`, true);
+                if (contextBoundary.typeSymbol !== parameter.boundary.typeSymbol) {
+                    this.fail(method, `Remote scope ${context.key} wire type ${contextBoundary.typeSymbol} does not match lookup wire type ${parameter.boundary.typeSymbol}`);
+                }
+                scope = { context: context.key, wire: parameter.wire };
+            }
+        }
+        const resultType = this.remoteResultType(method);
+        return {
+            id: `${registration.name}#${binding.namespace}/${exportedMethod}`,
+            service: binding.service,
+            namespace: binding.namespace,
+            method: exportedMethod,
+            ...(exportedMethod === methodName ? {} : { implementation: methodName }),
+            invocation: receiver,
+            ...(scope === undefined ? {} : { scope }),
+            parameters,
+            ...(cancellation === undefined ? {} : { cancellation }),
+            result: this.remoteBoundary(resultType, `${registration.name}#${binding.namespace}/${exportedMethod}:result`, false),
+            location: this.location(method.name),
+        };
+    }
+    gatewayBinding(declaration) {
+        const field = this.gatewayFieldBinding(declaration);
+        const base = this.gatewayServiceBinding(declaration);
+        if (field !== undefined && base !== undefined) {
+            this.fail(field.site, 'GatewayService subclasses must not declare a second typertGateway binding');
+        }
+        return field ?? base;
+    }
+    gatewayFieldBinding(declaration) {
+        const candidates = declaration.members.filter((member) => ts.isPropertyDeclaration(member) && memberName(member.name) === 'typertGateway');
+        const [property, duplicate] = candidates;
+        if (property === undefined)
+            return undefined;
+        if (duplicate !== undefined)
+            this.fail(duplicate, 'Service has more than one typertGateway field');
+        if (visibilityOf(property) !== 'public'
+            || hasModifier(property, ts.SyntaxKind.StaticKeyword)
+            || !hasModifier(property, ts.SyntaxKind.ReadonlyKeyword)) {
+            this.fail(property, 'typertGateway must be a public readonly instance field');
+        }
+        if (property.initializer === undefined
+            || !ts.isCallExpression(property.initializer)
+            || !this.isTypeMetaSymbol(property.initializer.expression, 'bindTypeRTGateway')) {
+            this.fail(property, 'typertGateway must call bindTypeRTGateway()');
+        }
+        const call = property.initializer;
+        if (call.arguments.length < 2 || call.arguments.length > 3) {
+            this.fail(call, 'bindTypeRTGateway() requires this, service key, and an optional options object');
+        }
+        if (call.arguments[0]?.kind !== ts.SyntaxKind.ThisKeyword) {
+            this.fail(call.arguments[0] ?? call, 'bindTypeRTGateway() first argument must be this');
+        }
+        return this.gatewayBindingArguments(call, property);
+    }
+    gatewayServiceBinding(declaration) {
+        const heritage = (declaration.heritageClauses ?? [])
+            .filter(clause => clause.token === ts.SyntaxKind.ExtendsKeyword)
+            .flatMap(clause => [...clause.types])
+            .find(type => this.isTypeMetaSymbol(type.expression, 'GatewayService'));
+        if (heritage === undefined)
+            return undefined;
+        const constructor = declaration.members.find(ts.isConstructorDeclaration);
+        if (constructor?.body === undefined) {
+            this.fail(heritage, 'GatewayService subclasses must declare a constructor with super(ctx, serviceKey)');
+        }
+        const call = constructor.body.statements.flatMap((statement) => {
+            if (!ts.isExpressionStatement(statement) || !ts.isCallExpression(statement.expression))
+                return [];
+            return statement.expression.expression.kind === ts.SyntaxKind.SuperKeyword ? [statement.expression] : [];
+        })[0];
+        if (call === undefined) {
+            this.fail(constructor, 'GatewayService constructor must call super(ctx, serviceKey) directly');
+        }
+        if (call.arguments.length < 2 || call.arguments.length > 3) {
+            this.fail(call, 'GatewayService super() requires context, service key, and an optional options object');
+        }
+        return this.gatewayBindingArguments(call, heritage);
+    }
+    gatewayBindingArguments(call, site) {
+        const serviceArgument = call.arguments[1];
+        if (serviceArgument === undefined)
+            this.fail(call, 'Gateway service key must be a string literal');
+        const service = stringLiteralValue(serviceArgument);
+        if (service === undefined)
+            this.fail(serviceArgument, 'Gateway service key must be a string literal');
+        let namespace = service;
+        const options = call.arguments[2];
+        if (options !== undefined) {
+            if (!ts.isObjectLiteralExpression(options)) {
+                this.fail(options, 'bindTypeRTGateway() options must be an object literal');
+            }
+            for (const propertyOption of options.properties) {
+                if (!ts.isPropertyAssignment(propertyOption)
+                    || memberName(propertyOption.name) !== 'namespace') {
+                    this.fail(propertyOption, 'bindTypeRTGateway() only supports a namespace option');
+                }
+                const value = stringLiteralValue(propertyOption.initializer);
+                if (value === undefined)
+                    this.fail(propertyOption.initializer, 'Gateway namespace must be a string literal');
+                namespace = value;
+            }
+        }
+        if (!isRemoteSegment(service))
+            this.fail(serviceArgument, 'Gateway service key must contain only RPC endpoint segment characters');
+        if (!isRemoteSegment(namespace))
+            this.fail(options ?? call, 'Gateway namespace must contain only RPC endpoint segment characters');
+        return { service, namespace, site };
+    }
+    remoteMarker(member) {
+        let found;
+        for (const decorator of ts.canHaveDecorators(member) ? ts.getDecorators(member) ?? [] : []) {
+            const expression = decorator.expression;
+            let marker;
+            if (this.isTypeMetaSymbol(expression, 'Remote')) {
+                marker = { kind: 'direct' };
+            }
+            else if (ts.isCallExpression(expression)
+                && this.isTypeMetaSymbol(expression.expression, 'Remote')) {
+                if (expression.arguments.length !== 1)
+                    this.fail(expression, 'Remote() requires one exported method name');
+                const exportName = stringLiteralValue(expression.arguments[0]);
+                if (exportName === undefined || !isRemoteSegment(exportName)) {
+                    this.fail(expression.arguments[0] ?? expression, 'Remote() name must be a string literal containing only RPC endpoint segment characters');
+                }
+                marker = { kind: 'direct', exportName };
+            }
+            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');
+                }
+                const context = stringLiteralValue(expression.arguments[0]);
+                if (context === undefined || !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 === undefined ? undefined : stringLiteralValue(exportArgument);
+                if (exportArgument !== undefined && (exportName === undefined || !isRemoteSegment(exportName))) {
+                    this.fail(exportArgument, 'RemoteScope() name must be a string literal containing only RPC endpoint segment characters');
+                }
+                marker = { kind: 'context', context, ...exportName === undefined ? {} : { exportName } };
+            }
+            else {
+                continue;
+            }
+            if (found !== undefined)
+                this.fail(decorator, 'a method can have only one Remote invocation decorator');
+            found = marker;
+        }
+        return found;
+    }
+    remoteResultType(method) {
+        const authored = this.requiredType(method, method.type, 'return');
+        if (!ts.isTypeReferenceNode(authored))
+            return authored;
+        const symbol = this.checker.getSymbolAtLocation(authored.typeName);
+        const resolved = symbol === undefined ? undefined : this.resolveSymbol(symbol);
+        const resultType = authored.typeArguments?.[0];
+        if (resolved?.name !== 'Promise' || resultType === undefined || authored.typeArguments?.length !== 1)
+            return authored;
+        const declaration = preferredDeclaration(resolved);
+        if (declaration === undefined || !isStandardLibraryFile(declaration.getSourceFile().fileName))
+            return authored;
+        return resultType;
+    }
+    isGlobalAbortSignal(type) {
+        const symbol = this.symbolAtType(type);
+        if (symbol?.name !== 'AbortSignal')
+            return false;
+        return symbol.declarations?.some(declaration => isStandardLibraryFile(declaration.getSourceFile().fileName)) === true;
+    }
+    lookupDeclarations() {
+        if (this.staticLookups !== undefined)
+            return this.staticLookups;
+        const byKey = new Map();
+        const byHost = new Map();
+        for (const declaration of this.typeMetaMapMembers('TypeRTLookupMap')) {
+            if (!ts.isPropertySignature(declaration) || declaration.type === undefined) {
+                this.fail(declaration, 'TypeRTLookupMap entries must be required properties');
+            }
+            const key = memberName(declaration.name);
+            if (!isRemoteSegment(key))
+                this.fail(declaration.name, 'TypeRTLookupMap key must contain only RPC endpoint segment characters');
+            if (!ts.isTypeReferenceNode(declaration.type)
+                || !this.isTypeMetaSymbol(declaration.type.typeName, 'TypeRTLookup')
+                || declaration.type.typeArguments?.length !== 2) {
+                this.fail(declaration.type, 'TypeRTLookupMap values must be TypeRTLookup<Host, Wire>');
+            }
+            const hostType = declaration.type.typeArguments[0];
+            const wireType = declaration.type.typeArguments[1];
+            if (hostType === undefined || wireType === undefined) {
+                this.fail(declaration.type, 'TypeRTLookupMap values must be TypeRTLookup<Host, Wire>');
+            }
+            const host = this.symbolAtType(hostType);
+            if (host === undefined)
+                this.fail(hostType, 'TypeRTLookup Host must be a named type');
+            const entry = {
+                key,
+                hostSymbol: this.symbolId(host),
+                wireType,
+                site: declaration,
+            };
+            if (byKey.has(key))
+                this.fail(declaration, `duplicate TypeRTLookupMap key ${key}`);
+            if (byHost.has(entry.hostSymbol))
+                this.fail(declaration, `Host type ${host.name} has more than one TypeRT lookup`);
+            byKey.set(key, entry);
+            byHost.set(entry.hostSymbol, entry);
+        }
+        this.staticLookups = [...byKey.values()];
+        return this.staticLookups;
+    }
+    contextDeclarations() {
+        if (this.staticContexts !== undefined)
+            return this.staticContexts;
+        const result = new Map();
+        for (const declaration of this.typeMetaMapMembers('TypeRTContextMap')) {
+            if (!ts.isPropertySignature(declaration) || declaration.type === undefined) {
+                this.fail(declaration, 'TypeRTContextMap entries must be required properties');
+            }
+            const key = memberName(declaration.name);
+            if (!isRemoteSegment(key))
+                this.fail(declaration.name, 'TypeRTContextMap key must contain only RPC endpoint segment characters');
+            if (!ts.isTypeReferenceNode(declaration.type)
+                || !this.isTypeMetaSymbol(declaration.type.typeName, 'TypeRTContext')
+                || declaration.type.typeArguments?.length !== 1) {
+                this.fail(declaration.type, 'TypeRTContextMap values must be TypeRTContext<Wire>');
+            }
+            if (result.has(key))
+                this.fail(declaration, `duplicate TypeRTContextMap key ${key}`);
+            const wireType = declaration.type.typeArguments[0];
+            if (wireType === undefined)
+                this.fail(declaration.type, 'TypeRTContextMap values must be TypeRTContext<Wire>');
+            result.set(key, {
+                key,
+                wireType,
+                site: declaration,
+            });
+        }
+        this.staticContexts = result;
+        return result;
+    }
+    typeMetaMapMembers(name) {
+        const result = [];
+        for (const sourceFile of this.program.getSourceFiles()) {
+            for (const statement of sourceFile.statements) {
+                if (!ts.isModuleDeclaration(statement)
+                    || !ts.isStringLiteral(statement.name)
+                    || statement.name.text !== '@deepseek-ai/dsh-type-meta'
+                    || statement.body === undefined
+                    || !ts.isModuleBlock(statement.body))
+                    continue;
+                for (const nested of statement.body.statements) {
+                    if (ts.isInterfaceDeclaration(nested) && nested.name.text === name)
+                        result.push(...nested.members);
+                }
+            }
+        }
+        return result;
+    }
+    remoteBoundary(authoredType, fallbackTypeSymbol, requireNamed) {
+        const type = this.convertType(authoredType);
+        const codecType = this.resolvedRemoteCodecType(authoredType);
+        const rootSymbol = this.namedWorkspaceType(authoredType);
+        const imports = new Map();
+        const visit = (node) => {
+            if ((ts.isTypeReferenceNode(node) || ts.isImportTypeNode(node))) {
+                const symbol = ts.isTypeReferenceNode(node)
+                    ? this.checker.getSymbolAtLocation(node.typeName)
+                    : node.qualifier === undefined ? undefined : this.checker.getSymbolAtLocation(node.qualifier);
+                if (symbol !== undefined) {
+                    const resolved = this.resolveSymbol(symbol);
+                    const declaration = preferredDeclaration(resolved);
+                    if (declaration !== undefined
+                        && !isStandardLibraryFile(declaration.getSourceFile().fileName)
+                        && this.registrationForFile(declaration.getSourceFile().fileName) !== undefined) {
+                        const imported = this.publicRemoteType(resolved, node);
+                        imports.set(imported.symbol, imported);
+                    }
+                }
+            }
+            ts.forEachChild(node, visit);
+        };
+        visit(authoredType);
+        if (rootSymbol !== undefined) {
+            const imported = this.publicRemoteType(rootSymbol, authoredType);
+            return {
+                type,
+                codecType,
+                typeSymbol: `${imported.specifier}#${imported.name}`,
+                imports: [...imports.values()].sort((left, right) => left.specifier.localeCompare(right.specifier) || left.name.localeCompare(right.name)),
+            };
+        }
+        if (requireNamed)
+            this.fail(authoredType, 'lookup and Context wire types must be named public types');
+        return {
+            type,
+            codecType,
+            typeSymbol: fallbackTypeSymbol,
+            imports: [...imports.values()].sort((left, right) => left.specifier.localeCompare(right.specifier) || left.name.localeCompare(right.name)),
+        };
+    }
+    /**
+     * Project one authored Remote boundary through the complete face Program.
+     * Consumer declarations retain the authored alias, while codecs use this
+     * concrete graph so declaration-merged mapped and conditional types are
+     * validated without teaching the compiler-independent emitter TypeScript's
+     * type evaluator.
+     */
+    resolvedRemoteCodecType(authoredType) {
+        const resolvedType = this.checker.getTypeFromTypeNode(authoredType);
+        this.assertRemoteJsonType(resolvedType, authoredType, new Set(), false);
+        const completed = new Map();
+        const active = new Map();
+        const recursiveDeclarations = new Map();
+        const convert = (type) => {
+            const cached = completed.get(type);
+            if (cached !== undefined)
+                return cached;
+            const activeId = active.get(type);
+            if (activeId !== undefined) {
+                if (this.checker.isArrayType(type) || this.checker.isArrayLikeType(type)) {
+                    const element = this.checker.getIndexTypeOfType(type, ts.IndexKind.Number);
+                    const elementId = element === undefined ? undefined : active.get(element);
+                    if (element !== undefined && elementId !== undefined) {
+                        return this.addNode(authoredType, {
+                            kind: 'array',
+                            element: this.resolvedCycleReference(element, authoredType, elementId, recursiveDeclarations),
+                        });
+                    }
+                }
+                return this.resolvedCycleReference(type, authoredType, activeId, recursiveDeclarations);
+            }
+            const id = this.allocateNodeId(authoredType);
+            active.set(type, id);
+            try {
+                const add = (model) => {
+                    this.nodes.set(id, { id, ...model });
+                    completed.set(type, id);
+                    return id;
+                };
+                const flags = type.flags;
+                if ((flags & ts.TypeFlags.Any) !== 0)
+                    return add({ kind: 'keyword', name: 'any' });
+                if ((flags & ts.TypeFlags.Unknown) !== 0)
+                    return add({ kind: 'keyword', name: 'unknown' });
+                if ((flags & ts.TypeFlags.Never) !== 0)
+                    return add({ kind: 'keyword', name: 'never' });
+                if ((flags & ts.TypeFlags.String) !== 0)
+                    return add({ kind: 'keyword', name: 'string' });
+                if ((flags & ts.TypeFlags.Number) !== 0)
+                    return add({ kind: 'keyword', name: 'number' });
+                if ((flags & ts.TypeFlags.BigInt) !== 0)
+                    return add({ kind: 'keyword', name: 'bigint' });
+                if ((flags & ts.TypeFlags.Boolean) !== 0)
+                    return add({ kind: 'keyword', name: 'boolean' });
+                if ((flags & ts.TypeFlags.ESSymbol) !== 0)
+                    return add({ kind: 'keyword', name: 'symbol' });
+                if ((flags & ts.TypeFlags.Undefined) !== 0)
+                    return add({ kind: 'keyword', name: 'undefined' });
+                if ((flags & ts.TypeFlags.Void) !== 0)
+                    return add({ kind: 'keyword', name: 'void' });
+                if ((flags & ts.TypeFlags.Null) !== 0)
+                    return add({ kind: 'literal', value: null, text: 'null' });
+                if ((flags & ts.TypeFlags.StringLiteral) !== 0) {
+                    const value = type.value;
+                    return add({ kind: 'literal', value, text: JSON.stringify(value) });
+                }
+                if ((flags & ts.TypeFlags.NumberLiteral) !== 0) {
+                    const value = type.value;
+                    return add({ kind: 'literal', value, text: String(value) });
+                }
+                if ((flags & ts.TypeFlags.BigIntLiteral) !== 0) {
+                    const value = type.value;
+                    const text = `${value.negative ? '-' : ''}${value.base10Value}n`;
+                    return add({ kind: 'literal', value: BigInt(`${value.negative ? '-' : ''}${value.base10Value}`), text });
+                }
+                if ((flags & ts.TypeFlags.BooleanLiteral) !== 0) {
+                    const value = type.intrinsicName === 'true';
+                    return add({ kind: 'literal', value, text: String(value) });
+                }
+                if (type.isUnionOrIntersection()) {
+                    return add({
+                        kind: (flags & ts.TypeFlags.Union) !== 0 ? 'union' : 'intersection',
+                        types: type.types.map(convert),
+                    });
+                }
+                if ((flags & ts.TypeFlags.TypeParameter) !== 0) {
+                    this.fail(authoredType, 'Remote codec contains an unresolved type parameter');
+                }
+                if ((flags & ts.TypeFlags.Object) === 0) {
+                    this.fail(authoredType, `Remote codec type ${this.checker.typeToString(type, authoredType, ts.TypeFormatFlags.NoTruncation)} has no concrete Zod projection`);
+                }
+                if (this.checker.isTupleType(type)) {
+                    const reference = type;
+                    const target = reference.target;
+                    const arguments_ = this.checker.getTypeArguments(reference);
+                    return add({
+                        kind: 'tuple',
+                        elements: arguments_.map((argument, index) => {
+                            const elementFlags = target.elementFlags[index] ?? ts.ElementFlags.Required;
+                            return {
+                                type: convert(argument),
+                                optional: (elementFlags & ts.ElementFlags.Optional) !== 0,
+                                rest: (elementFlags & (ts.ElementFlags.Rest | ts.ElementFlags.Variadic)) !== 0,
+                            };
+                        }),
+                    });
+                }
+                if (this.checker.isArrayType(type) || this.checker.isArrayLikeType(type)) {
+                    const element = this.checker.getIndexTypeOfType(type, ts.IndexKind.Number);
+                    if (element === undefined)
+                        this.fail(authoredType, 'Remote codec array has no element type');
+                    return add({ kind: 'array', element: convert(element) });
+                }
+                if (type.getCallSignatures().length > 0 || type.getConstructSignatures().length > 0) {
+                    this.fail(authoredType, 'Remote codec cannot contain callable or constructable values');
+                }
+                const members = [];
+                for (const property of this.checker.getPropertiesOfType(type)) {
+                    const declaration = property.valueDeclaration ?? property.declarations?.[0];
+                    const propertyType = this.checker.getTypeOfSymbolAtLocation(property, declaration ?? authoredType);
+                    const symbolKey = property.getName();
+                    members.push({
+                        ...EMPTY_DOCUMENTATION,
+                        id: `${id}#${symbolKey}`,
+                        name: symbolKey,
+                        ...(symbolKey.startsWith('__@') ? { computed: 'symbol' } : {}),
+                        optional: (property.flags & ts.SymbolFlags.Optional) !== 0,
+                        readonly: declaration !== undefined && hasModifier(declaration, ts.SyntaxKind.ReadonlyKeyword),
+                        async: false,
+                        abstract: false,
+                        static: false,
+                        visibility: 'public',
+                        location: this.location(authoredType),
+                        text: '',
+                        kind: 'property',
+                        type: convert(propertyType),
+                    });
+                }
+                for (const [index, info] of this.checker.getIndexInfosOfType(type).entries()) {
+                    members.push({
+                        ...EMPTY_DOCUMENTATION,
+                        id: `${id}#index:${String(index)}`,
+                        name: '(index)',
+                        optional: false,
+                        readonly: info.isReadonly,
+                        async: false,
+                        abstract: false,
+                        static: false,
+                        visibility: 'public',
+                        location: this.location(authoredType),
+                        text: '',
+                        kind: 'index',
+                        signature: {
+                            typeParameters: [],
+                            parameters: [{
+                                    name: 'key',
+                                    binding: 'identifier',
+                                    type: convert(info.keyType),
+                                    optional: false,
+                                    rest: false,
+                                    receiver: false,
+                                }],
+                            returns: convert(info.type),
+                        },
+                    });
+                }
+                return add({ kind: 'object', members });
+            }
+            finally {
+                active.delete(type);
+            }
+        };
+        return convert(resolvedType);
+    }
+    assertRemoteJsonType(type, site, active, allowUndefined) {
+        const flags = type.flags;
+        if ((flags & ts.TypeFlags.Undefined) !== 0 && allowUndefined)
+            return;
+        if ((flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) !== 0) {
+            this.fail(site, `Remote boundary contains unconstrained ${this.checker.typeToString(type)} data`);
+        }
+        if ((flags & (ts.TypeFlags.BigIntLike | ts.TypeFlags.ESSymbolLike | ts.TypeFlags.Undefined | ts.TypeFlags.Void)) !== 0) {
+            this.fail(site, `Remote boundary contains non-JSON type ${this.checker.typeToString(type)}`);
+        }
+        if ((flags & (ts.TypeFlags.StringLike
+            | ts.TypeFlags.NumberLike
+            | ts.TypeFlags.BooleanLike
+            | ts.TypeFlags.Null
+            | ts.TypeFlags.Never)) !== 0)
+            return;
+        if (type.isUnion()) {
+            for (const member of type.types)
+                this.assertRemoteJsonType(member, site, active, allowUndefined);
+            return;
+        }
+        if (type.isIntersection()) {
+            const material = type.types.filter(member => !this.isRemotePhantomConstraint(member));
+            if (material.length === 0)
+                this.fail(site, 'Remote boundary contains a symbol-only object');
+            for (const member of material)
+                this.assertRemoteJsonType(member, site, active, false);
+            return;
+        }
+        if ((flags & ts.TypeFlags.TypeParameter) !== 0) {
+            this.fail(site, 'Remote boundary contains an unresolved type parameter');
+        }
+        if ((flags & ts.TypeFlags.Object) === 0) {
+            this.fail(site, `Remote boundary contains non-JSON type ${this.checker.typeToString(type)}`);
+        }
+        const symbol = type.getSymbol();
+        const declaration = symbol?.valueDeclaration ?? symbol?.declarations?.[0];
+        if (declaration !== undefined && (ts.isClassDeclaration(declaration) || ts.isClassExpression(declaration))) {
+            this.fail(site, `Remote boundary contains class instance ${symbol?.name ?? this.checker.typeToString(type)}`);
+        }
+        if (type.getCallSignatures().length > 0 || type.getConstructSignatures().length > 0) {
+            this.fail(site, 'Remote boundary contains callable or constructable data');
+        }
+        if (active.has(type))
+            return;
+        active.add(type);
+        try {
+            if (this.checker.isTupleType(type)) {
+                const reference = type;
+                const target = reference.target;
+                const arguments_ = this.checker.getTypeArguments(reference);
+                arguments_.forEach((argument, index) => {
+                    const elementFlags = target.elementFlags[index] ?? ts.ElementFlags.Required;
+                    this.assertRemoteJsonType(argument, site, active, (elementFlags & ts.ElementFlags.Optional) !== 0);
+                });
+                return;
+            }
+            if (this.checker.isArrayType(type) || this.checker.isArrayLikeType(type)) {
+                const element = this.checker.getIndexTypeOfType(type, ts.IndexKind.Number);
+                if (element === undefined)
+                    this.fail(site, 'Remote boundary array has no element type');
+                this.assertRemoteJsonType(element, site, active, false);
+                return;
+            }
+            const properties = this.checker.getPropertiesOfType(type);
+            if (properties.some(property => property.getName().startsWith('__@'))) {
+                this.fail(site, 'Remote boundary contains a symbol-keyed property');
+            }
+            for (const property of properties) {
+                const propertyDeclaration = property.valueDeclaration ?? property.declarations?.[0];
+                const propertyType = this.checker.getTypeOfSymbolAtLocation(property, propertyDeclaration ?? site);
+                this.assertRemoteJsonType(propertyType, site, active, (property.flags & ts.SymbolFlags.Optional) !== 0);
+            }
+            for (const info of this.checker.getIndexInfosOfType(type)) {
+                if ((info.keyType.flags & ts.TypeFlags.ESSymbolLike) !== 0) {
+                    this.fail(site, 'Remote boundary contains a symbol index signature');
+                }
+                this.assertRemoteJsonType(info.type, site, active, false);
+            }
+        }
+        finally {
+            active.delete(type);
+        }
+    }
+    isRemotePhantomConstraint(type) {
+        if ((type.flags & ts.TypeFlags.Unknown) !== 0)
+            return true;
+        if ((type.flags & ts.TypeFlags.Any) !== 0 || (type.flags & ts.TypeFlags.Object) === 0)
+            return false;
+        if (type.getCallSignatures().length > 0 || type.getConstructSignatures().length > 0)
+            return false;
+        if (this.checker.getIndexInfosOfType(type).length > 0)
+            return false;
+        return this.checker.getPropertiesOfType(type).every(property => property.getName().startsWith('__@'));
+    }
+    resolvedCycleReference(type, site, resolvedType, recursiveDeclarations) {
+        const symbol = type.aliasSymbol ?? type.getSymbol();
+        if (symbol === undefined)
+            this.fail(site, 'Remote codec contains an unnamed recursive type');
+        const resolved = this.resolveSymbol(symbol);
+        const declaration = preferredDeclaration(resolved);
+        if (declaration === undefined || isStandardLibraryFile(declaration.getSourceFile().fileName)) {
+            this.fail(site, `Remote codec recursive type ${resolved.name} has no workspace declaration`);
+        }
+        const owner = this.registrationForFile(declaration.getSourceFile().fileName);
+        if (owner === undefined)
+            this.fail(site, `Remote codec recursive type ${resolved.name} is not owned by this face`);
+        let id = recursiveDeclarations.get(type);
+        if (id === undefined) {
+            id = `${this.symbolId(resolved)}#remote-codec:${resolvedType}`;
+            recursiveDeclarations.set(type, id);
+            this.declarations.set(id, {
+                ...EMPTY_DOCUMENTATION,
+                id,
+                package: owner.name,
+                name: `${resolved.name}RemoteCodec`,
+                kind: 'alias',
+                abstract: false,
+                exported: false,
+                location: this.location(declaration),
+                text: '',
+                typeParameters: [],
+                extends: [],
+                implements: [],
+                members: [],
+                type: resolvedType,
+            });
+        }
+        return this.addNode(site, {
+            kind: 'reference',
+            name: `${resolved.name}RemoteCodec`,
+            target: { kind: 'declaration', symbol: id },
+            arguments: [],
+        });
+    }
+    namedWorkspaceType(node) {
+        if (!ts.isTypeReferenceNode(node) && !ts.isImportTypeNode(node))
+            return undefined;
+        const symbol = ts.isTypeReferenceNode(node)
+            ? this.checker.getSymbolAtLocation(node.typeName)
+            : node.qualifier === undefined ? undefined : this.checker.getSymbolAtLocation(node.qualifier);
+        if (symbol === undefined)
+            return undefined;
+        const resolved = this.resolveSymbol(symbol);
+        const declaration = preferredDeclaration(resolved);
+        if (declaration === undefined
+            || isStandardLibraryFile(declaration.getSourceFile().fileName)
+            || this.registrationForFile(declaration.getSourceFile().fileName) === undefined)
+            return undefined;
+        return resolved;
+    }
+    publicRemoteType(symbol, site) {
+        const declaration = preferredDeclaration(symbol);
+        if (declaration === undefined)
+            this.fail(site, `type ${symbol.name} has no declaration`);
+        const registration = this.registrationForFile(declaration.getSourceFile().fileName);
+        if (registration === undefined)
+            this.fail(site, `type ${symbol.name} is not owned by a workspace package`);
+        const candidates = [];
+        for (const [subpath, target] of packageExportTargets(registration.manifest)) {
+            if (subpath === '.' || subpath === './package.json' || subpath === './typert'
+                || subpath === './client/typert' || subpath === './remote' || target.includes('*'))
+                continue;
+            const sourceFile = this.sourceFiles.get(realPath(sourcePathForExport(registration.root, target)));
+            if (sourceFile === undefined)
+                continue;
+            const moduleSymbol = this.checker.getSymbolAtLocation(sourceFile);
+            if (moduleSymbol === undefined)
+                continue;
+            for (const exported of this.checker.getExportsOfModule(moduleSymbol)) {
+                if (this.resolveSymbol(exported) !== symbol)
+                    continue;
+                candidates.push({
+                    symbol: this.symbolId(symbol),
+                    specifier: packageExportSpecifier(registration.name, subpath),
+                    name: exported.name,
+                });
+            }
+        }
+        const selected = candidates.sort((left, right) => left.specifier.localeCompare(right.specifier) || left.name.localeCompare(right.name))[0];
+        if (selected === undefined) {
+            this.fail(site, `Remote boundary type ${symbol.name} must be exported from a public non-root type subpath`);
+        }
+        return selected;
+    }
+    isWorkspaceClass(symbol) {
+        const declaration = preferredDeclaration(symbol);
+        return declaration !== undefined
+            && ts.isClassDeclaration(declaration)
+            && this.registrationForFile(declaration.getSourceFile().fileName) !== undefined;
+    }
+    isTypeMetaSymbol(node, name) {
+        const symbol = this.checker.getSymbolAtLocation(node);
+        if (symbol === undefined)
+            return false;
+        const resolved = this.resolveSymbol(symbol);
+        if (resolved.name !== name)
+            return false;
+        const declaration = preferredDeclaration(resolved);
+        if (declaration === undefined)
+            return false;
+        const registration = this.registrationForFile(declaration.getSourceFile().fileName);
+        if (registration?.name === '@deepseek-ai/dsh-type-meta')
+            return true;
+        for (let current = declaration; current !== undefined; current = optionalParent(current)) {
+            if (ts.isModuleDeclaration(current)
+                && ts.isStringLiteral(current.name)
+                && current.name.text === '@deepseek-ai/dsh-type-meta')
+                return true;
+        }
+        return false;
+    }
+    validateInvocationIdentity(packages) {
+        const endpoints = new Map();
+        const ids = new Map();
+        for (const invocation of packages.flatMap(packageModel => packageModel.invocations)) {
+            const endpoint = `${invocation.namespace}/${invocation.method}`;
+            const existingEndpoint = endpoints.get(endpoint);
+            if (existingEndpoint !== undefined) {
+                throw new TypertAnalysisError(`typert(${this.face}): ${invocation.location.file}:${String(invocation.location.line)}:${String(invocation.location.column)}: Remote endpoint ${endpoint} conflicts with ${existingEndpoint.id}`);
+            }
+            const existingId = ids.get(invocation.id);
+            if (existingId !== undefined) {
+                throw new TypertAnalysisError(`typert(${this.face}): ${invocation.location.file}:${String(invocation.location.line)}:${String(invocation.location.column)}: Remote invocation id ${invocation.id} conflicts with ${existingId.id}`);
+            }
+            endpoints.set(endpoint, invocation);
+            ids.set(invocation.id, invocation);
+        }
+    }
+    collectEvents(events) {
+        const result = [];
+        for (const member of events.members) {
+            const documentation = documentationOf(member);
+            const mode = documentation.tags.find(tag => tag.name === 'mode')?.comment?.trim();
+            if (ts.isMethodSignature(member)) {
+                const signature = this.signature(member, member.type);
+                result.push({
+                    ...documentation,
+                    name: memberName(member.name),
+                    signature: this.addNode(member, { kind: 'function', signature }),
+                    text: memberText(member),
+                    ...(mode === undefined ? {} : { mode }),
+                    location: this.location(member),
+                });
+            }
+            else if (ts.isPropertySignature(member) && member.type !== undefined) {
+                result.push({
+                    ...documentation,
+                    name: memberName(member.name),
+                    signature: this.convertType(member.type),
+                    text: memberText(member),
+                    ...(mode === undefined ? {} : { mode }),
+                    location: this.location(member),
+                });
+            }
+        }
+        return result;
+    }
+    ensureDeclaration(symbol, selected) {
+        const resolved = this.resolveSymbol(symbol);
+        const id = this.symbolId(resolved);
+        const existing = this.declarations.get(id);
+        if (existing !== undefined)
+            return existing;
+        const declarationParts = resolved.declarations.filter(isTypeDeclaration);
+        if (declarationParts.length > 1 && !declarationParts.every(ts.isInterfaceDeclaration)) {
+            this.fail(selected, `merged ${ts.SyntaxKind[selected.kind]} declaration ${resolved.name} is not supported`);
+        }
+        if (selected.name === undefined) {
+            this.fail(selected, `anonymous ${ts.SyntaxKind[selected.kind]} cannot be represented as a named type declaration`);
+        }
+        const owner = this.registrationForFile(selected.getSourceFile().fileName);
+        this.declarationStates.add(id);
+        if (declarationParts.length > 1) {
+            const analyzedParts = declarationParts.map((declarationPart) => {
+                const part = declarationPart;
+                const partOwner = this.registrationForFile(part.getSourceFile().fileName);
+                if (partOwner === undefined) {
+                    this.fail(part, `merged interface ${resolved.name} contains a declaration outside this face`);
+                }
+                const typeParameters = this.typeParameters(part.typeParameters);
+                const heritage = this.heritage(part);
+                const members = this.members(part.members, id);
+                return {
+                    typeParameters,
+                    heritage,
+                    members,
+                    model: {
+                        ...documentationOf(part),
+                        package: partOwner.name,
+                        location: this.location(part),
+                        typeParameters,
+                        extends: heritage.extends,
+                        members: members.map(member => member.id),
+                    },
+                };
+            });
+            const parameters = this.mergeTypeParameters(analyzedParts.map(part => part.typeParameters), selected, resolved.name);
+            const model = {
+                ...documentationOf(selected),
+                id,
+                package: owner.name,
+                name: declarationName(selected),
+                kind: 'interface',
+                abstract: false,
+                exported: hasModifier(selected, ts.SyntaxKind.ExportKeyword),
+                location: this.location(selected),
+                text: declarationText(selected),
+                typeParameters: parameters,
+                extends: analyzedParts.flatMap(part => part.heritage.extends),
+                implements: [],
+                members: analyzedParts.flatMap(part => part.members),
+                parts: analyzedParts.map(part => part.model),
+            };
+            this.declarations.set(id, model);
+            this.declarationStates.delete(id);
+            return model;
+        }
+        const parameters = ts.isEnumDeclaration(selected) ? [] : this.typeParameters(selected.typeParameters);
+        const heritage = ts.isTypeAliasDeclaration(selected) || ts.isEnumDeclaration(selected)
+            ? { extends: [], implements: [] }
+            : this.heritage(selected);
+        const kind = ts.isClassDeclaration(selected)
+            ? 'class'
+            : ts.isInterfaceDeclaration(selected)
+                ? 'interface'
+                : ts.isTypeAliasDeclaration(selected)
+                    ? 'alias'
+                    : 'enum';
+        const model = {
+            ...documentationOf(selected),
+            id,
+            package: owner.name,
+            name: declarationName(selected),
+            kind,
+            abstract: hasModifier(selected, ts.SyntaxKind.AbstractKeyword),
+            exported: hasModifier(selected, ts.SyntaxKind.ExportKeyword),
+            location: this.location(selected),
+            text: declarationText(selected),
+            typeParameters: parameters,
+            extends: heritage.extends,
+            implements: heritage.implements,
+            members: ts.isTypeAliasDeclaration(selected) || ts.isEnumDeclaration(selected)
+                ? []
+                : this.members(selected.members, id),
+            ...(ts.isTypeAliasDeclaration(selected) ? { type: this.convertType(selected.type) } : {}),
+            ...(ts.isEnumDeclaration(selected) ? { enumMembers: this.enumMembers(selected) } : {}),
+        };
+        this.declarations.set(id, model);
+        this.declarationStates.delete(id);
+        return model;
+    }
+    enumMembers(declaration) {
+        return declaration.members.map(member => ({
+            ...documentationOf(member),
+            name: memberName(member.name),
+            ...(member.initializer === undefined ? {} : { initializer: member.initializer.getText() }),
+            location: this.location(member),
+        }));
+    }
+    heritage(declaration) {
+        const result = { extends: [], implements: [] };
+        for (const clause of declaration.heritageClauses ?? []) {
+            const target = clause.token === ts.SyntaxKind.ExtendsKeyword ? result.extends : result.implements;
+            for (const type of clause.types)
+                target.push(this.convertHeritage(type));
+        }
+        return result;
+    }
+    convertHeritage(node) {
+        const symbol = this.checker.getSymbolAtLocation(node.expression);
+        return this.addNode(node, {
+            kind: 'reference',
+            name: node.expression.getText(),
+            target: this.targetForReference(this.resolveSymbol(symbol), node),
+            arguments: node.typeArguments?.map(argument => this.convertType(argument)) ?? [],
+        });
+    }
+    members(members, ownerId) {
+        const result = [];
+        for (const member of members) {
+            if (ts.isPropertyDeclaration(member)
+                && memberName(member.name) === 'typertGateway'
+                && member.initializer !== undefined
+                && ts.isCallExpression(member.initializer)
+                && this.isTypeMetaSymbol(member.initializer.expression, 'bindTypeRTGateway'))
+                continue;
+            const visibility = visibilityOf(member);
+            const isStatic = hasModifier(member, ts.SyntaxKind.StaticKeyword);
+            if (visibility !== 'public' || isStatic || ts.isConstructorDeclaration(member))
+                continue;
+            const base = this.memberBase(member, ownerId, visibility, isStatic);
+            if (ts.isPropertySignature(member) || ts.isPropertyDeclaration(member)) {
+                const type = this.requiredType(member, member.type, 'property');
+                result.push({ ...base, kind: 'property', type: this.convertType(type) });
+            }
+            else if (ts.isMethodSignature(member) || ts.isMethodDeclaration(member)) {
+                result.push({ ...base, kind: 'method', signature: this.signature(member, member.type) });
+            }
+            else if (ts.isGetAccessorDeclaration(member)) {
+                result.push({ ...base, kind: 'getter', signature: this.signature(member, member.type) });
+            }
+            else if (ts.isSetAccessorDeclaration(member)) {
+                result.push({ ...base, kind: 'setter', signature: this.signature(member, member.type) });
+            }
+            else if (ts.isCallSignatureDeclaration(member)) {
+                result.push({ ...base, kind: 'call', signature: this.signature(member, member.type) });
+            }
+            else if (ts.isConstructSignatureDeclaration(member)) {
+                result.push({ ...base, kind: 'construct', signature: this.signature(member, member.type) });
+            }
+            else if (ts.isIndexSignatureDeclaration(member)) {
+                result.push({ ...base, kind: 'index', signature: this.signature(member, member.type) });
+            }
+        }
+        return result;
+    }
+    memberBase(member, ownerId, visibility, isStatic) {
+        const identity = member.name !== undefined
+            ? this.memberIdentity(member.name)
+            : {
+                name: ts.isCallSignatureDeclaration(member)
+                    ? '(call)'
+                    : ts.isConstructSignatureDeclaration(member)
+                        ? '(construct)'
+                        : '(index)',
+            };
+        return {
+            ...documentationOf(member),
+            id: `${ownerId}#${identity.name}@${String(member.getStart())}`,
+            ...identity,
+            optional: 'questionToken' in member && member.questionToken !== undefined,
+            readonly: hasModifier(member, ts.SyntaxKind.ReadonlyKeyword),
+            async: hasModifier(member, ts.SyntaxKind.AsyncKeyword),
+            abstract: hasModifier(member, ts.SyntaxKind.AbstractKeyword),
+            static: isStatic,
+            visibility,
+            location: this.location(member),
+            text: memberText(member),
+        };
+    }
+    memberIdentity(name) {
+        if (!ts.isComputedPropertyName(name))
+            return { name: memberName(name) };
+        const expression = name.expression;
+        if (ts.isStringLiteral(expression) || ts.isNumericLiteral(expression)
+            || ts.isNoSubstitutionTemplateLiteral(expression)) {
+            return { name: memberName(name), jsonName: expression.text };
+        }
+        const type = this.checker.getTypeAtLocation(expression);
+        return {
+            name: memberName(name),
+            computed: (type.flags & ts.TypeFlags.UniqueESSymbol) !== 0 ? 'symbol' : 'dynamic',
+        };
+    }
+    signature(node, explicitReturn) {
+        const parameters = node.parameters.map(parameter => ({
+            name: memberName(parameter.name),
+            binding: ts.isIdentifier(parameter.name)
+                ? 'identifier'
+                : ts.isObjectBindingPattern(parameter.name)
+                    ? 'object'
+                    : 'array',
+            type: this.convertType(this.requiredType(parameter, parameter.type, 'parameter')),
+            optional: parameter.questionToken !== undefined || parameter.initializer !== undefined,
+            rest: parameter.dotDotDotToken !== undefined,
+            receiver: ts.isIdentifier(parameter.name) && parameter.name.text === 'this',
+            ...(parameter.initializer === undefined ? {} : { initializer: parameter.initializer.getText() }),
+        }));
+        return {
+            typeParameters: this.typeParameters(node.typeParameters),
+            parameters,
+            returns: ts.isSetAccessorDeclaration(node)
+                ? this.addNode(node, { kind: 'keyword', name: 'void' })
+                : this.convertType(this.requiredType(node, explicitReturn, 'return')),
+        };
+    }
+    typeParameters(parameters) {
+        return parameters?.map(parameter => ({
+            id: `${this.locationKey(parameter)}#${parameter.name.text}`,
+            name: parameter.name.text,
+            const: hasModifier(parameter, ts.SyntaxKind.ConstKeyword),
+            ...(parameter.constraint === undefined ? {} : { constraint: this.convertType(parameter.constraint) }),
+            ...(parameter.default === undefined ? {} : { default: this.convertType(parameter.default) }),
+            ...(hasModifier(parameter, ts.SyntaxKind.InKeyword) && hasModifier(parameter, ts.SyntaxKind.OutKeyword)
+                ? { variance: 'in-out' }
+                : hasModifier(parameter, ts.SyntaxKind.InKeyword)
+                    ? { variance: 'in' }
+                    : hasModifier(parameter, ts.SyntaxKind.OutKeyword)
+                        ? { variance: 'out' }
+                        : {}),
+        })) ?? [];
+    }
+    mergeTypeParameters(parts, site, declarationName) {
+        const first = parts[0];
+        return first.map((parameter, index) => {
+            const peers = parts.map(part => part[index]);
+            const constraint = peers.find(peer => peer.constraint !== undefined)?.constraint;
+            const fallback = peers.find(peer => peer.default !== undefined)?.default;
+            const variances = [...new Set(peers.flatMap(peer => peer.variance === undefined ? [] : [peer.variance]))];
+            if (variances.length > 1) {
+                this.fail(site, `merged interface ${declarationName} has incompatible variance modifiers`);
+            }
+            return {
+                id: parameter.id,
+                name: parameter.name,
+                const: peers.some(peer => peer.const),
+                ...(constraint === undefined ? {} : { constraint }),
+                ...(fallback === undefined ? {} : { default: fallback }),
+                ...(variances[0] === undefined ? {} : { variance: variances[0] }),
+            };
+        });
+    }
+    requiredType(owner, type, purpose) {
+        if (type !== undefined)
+            return type;
+        if (this.mode === 'check') {
+            this.fail(owner, `public ${purpose} is missing an explicit type annotation`);
+        }
+        const inferred = this.inferType(owner, purpose);
+        const rendered = ts.createPrinter().printNode(ts.EmitHint.Unspecified, inferred, owner.getSourceFile());
+        const position = annotationPosition(owner, purpose);
+        this.queueEdit({ file: realPath(owner.getSourceFile().fileName), position, text: `: ${rendered}` });
+        throw new SourceEditQueued();
+    }
+    inferType(owner, purpose) {
+        let type;
+        if (purpose === 'return') {
+            const signature = this.checker.getSignatureFromDeclaration(owner);
+            type = this.checker.getReturnTypeOfSignature(signature);
+        }
+        else {
+            type = this.checker.getTypeAtLocation(owner);
+        }
+        return this.checker.typeToTypeNode(type, owner, ts.NodeBuilderFlags.NoTruncation | ts.NodeBuilderFlags.UseAliasDefinedOutsideCurrentScope);
+    }
+    convertType(node) {
+        const id = this.allocateNodeId(node);
+        const add = (model) => {
+            this.nodes.set(id, { id, ...model });
+            return id;
+        };
+        const keyword = keywordName(node.kind);
+        if (keyword !== undefined)
+            return add({ kind: 'keyword', name: keyword });
+        if (ts.isParenthesizedTypeNode(node)) {
+            return add({ kind: 'parenthesized', type: this.convertType(node.type) });
+        }
+        if (ts.isLiteralTypeNode(node))
+            return add(literalModel(node));
+        if (ts.isTypeReferenceNode(node)) {
+            const symbol = this.checker.getSymbolAtLocation(node.typeName);
+            return add({
+                kind: 'reference',
+                name: node.typeName.getText(),
+                target: this.targetForReference(this.resolveSymbol(symbol), node),
+                arguments: node.typeArguments?.map(argument => this.convertType(argument)) ?? [],
+            });
+        }
+        if (ts.isUnionTypeNode(node) || ts.isIntersectionTypeNode(node)) {
+            return add({
+                kind: ts.isUnionTypeNode(node) ? 'union' : 'intersection',
+                types: node.types.map(type => this.convertType(type)),
+            });
+        }
+        if (ts.isArrayTypeNode(node))
+            return add({ kind: 'array', element: this.convertType(node.elementType) });
+        if (ts.isTupleTypeNode(node)) {
+            return add({
+                kind: 'tuple',
+                elements: node.elements.map((element) => {
+                    const named = ts.isNamedTupleMember(element) ? element : undefined;
+                    const raw = named?.type ?? element;
+                    const optional = named?.questionToken !== undefined || ts.isOptionalTypeNode(raw);
+                    const rest = named?.dotDotDotToken !== undefined || ts.isRestTypeNode(raw);
+                    const type = ts.isOptionalTypeNode(raw) || ts.isRestTypeNode(raw) ? raw.type : raw;
+                    return {
+                        ...(named === undefined ? {} : { name: named.name.text }),
+                        type: this.convertType(type),
+                        optional,
+                        rest,
+                    };
+                }),
+            });
+        }
+        if (ts.isTypeLiteralNode(node))
+            return add({ kind: 'object', members: this.members(node.members, id) });
+        if (ts.isFunctionTypeNode(node)) {
+            return add({ kind: 'function', signature: this.signature(node, node.type) });
+        }
+        if (ts.isConstructorTypeNode(node)) {
+            return add({
+                kind: 'constructor',
+                abstract: hasModifier(node, ts.SyntaxKind.AbstractKeyword),
+                signature: this.signature(node, node.type),
+            });
+        }
+        if (ts.isIndexedAccessTypeNode(node)) {
+            return add({
+                kind: 'indexed-access',
+                object: this.convertType(node.objectType),
+                index: this.convertType(node.indexType),
+            });
+        }
+        if (ts.isTypeOperatorNode(node)) {
+            return add({
+                kind: 'operator',
+                operator: ts.tokenToString(node.operator),
+                type: this.convertType(node.type),
+            });
+        }
+        if (ts.isConditionalTypeNode(node)) {
+            return add({
+                kind: 'conditional',
+                check: this.convertType(node.checkType),
+                extends: this.convertType(node.extendsType),
+                whenTrue: this.convertType(node.trueType),
+                whenFalse: this.convertType(node.falseType),
+            });
+        }
+        if (ts.isInferTypeNode(node)) {
+            return add({ kind: 'infer', parameter: this.typeParameters(ts.factory.createNodeArray([node.typeParameter]))[0] });
+        }
+        if (ts.isMappedTypeNode(node)) {
+            const parameter = this.typeParameters(ts.factory.createNodeArray([node.typeParameter]))[0];
+            return add({
+                kind: 'mapped',
+                parameter,
+                ...(node.nameType === undefined ? {} : { nameType: this.convertType(node.nameType) }),
+                ...(node.type === undefined ? {} : { value: this.convertType(node.type) }),
+                readonly: modifierMode(node.readonlyToken),
+                optional: modifierMode(node.questionToken),
+            });
+        }
+        if (ts.isTemplateLiteralTypeNode(node)) {
+            return add({
+                kind: 'template-literal',
+                head: node.head.text,
+                spans: node.templateSpans.map(span => ({ type: this.convertType(span.type), text: span.literal.text })),
+            });
+        }
+        if (ts.isTypeQueryNode(node)) {
+            return add({
+                kind: 'type-query',
+                expression: node.exprName.getText(),
+                arguments: node.typeArguments?.map(argument => this.convertType(argument)) ?? [],
+            });
+        }
+        if (ts.isImportTypeNode(node)) {
+            const argument = node.argument;
+            const symbol = node.qualifier === undefined ? undefined : this.checker.getSymbolAtLocation(node.qualifier);
+            return add({
+                kind: 'import-type',
+                module: argument.literal.text,
+                ...(node.qualifier === undefined ? {} : { qualifier: node.qualifier.getText() }),
+                arguments: node.typeArguments?.map(argument => this.convertType(argument)) ?? [],
+                typeof: node.isTypeOf,
+                ...(node.attributes === undefined ? {} : { attributes: importTypeAttributesText(node) }),
+                ...(symbol === undefined ? {} : { target: this.targetForReference(this.resolveSymbol(symbol), node) }),
+            });
+        }
+        if (ts.isTypePredicateNode(node)) {
+            return add({
+                kind: 'predicate',
+                asserts: node.assertsModifier !== undefined,
+                parameter: node.parameterName.getText(),
+                ...(node.type === undefined ? {} : { type: this.convertType(node.type) }),
+            });
+        }
+        /* v8 ignore else -- every source TypeNode kind accepted by TypeScript is handled above; this arm keeps
+         * future compiler kinds fail-loud. */
+        if (ts.isThisTypeNode(node))
+            return add({ kind: 'this' });
+        /* v8 ignore next -- paired with the exhaustive TypeNode guard above. */
+        this.fail(node, `unsupported TypeScript type node ${ts.SyntaxKind[node.kind]}`);
+    }
+    addNode(site, model) {
+        const id = this.allocateNodeId(site);
+        this.nodes.set(id, { id, ...model });
+        return id;
+    }
+    referenceNode(symbol, site) {
+        return this.addNode(site, {
+            kind: 'reference',
+            name: symbol.name,
+            target: { kind: 'declaration', symbol: this.symbolId(symbol) },
+            arguments: [],
+        });
+    }
+    targetForReference(symbol, site) {
+        const declaration = preferredDeclaration(symbol);
+        /* v8 ignore next -- a symbol from a semantically valid source type reference always has a declaration. */
+        if (declaration === undefined)
+            this.fail(site, `type symbol ${symbol.name} has no declaration`);
+        if (ts.isTypeParameterDeclaration(declaration)) {
+            return {
+                kind: 'type-parameter',
+                parameter: `${this.locationKey(declaration)}#${declaration.name.text}`,
+            };
+        }
+        if (isStandardLibraryFile(declaration.getSourceFile().fileName)) {
+            return { kind: 'standard', name: symbol.name };
+        }
+        const moduleSpecifier = moduleSpecifierOf(site);
+        const module = moduleSpecifier === undefined ? undefined : moduleIdentity(moduleSpecifier);
+        const from = this.registrationForFile(site.getSourceFile().fileName);
+        const owner = this.registrationForFile(declaration.getSourceFile().fileName);
+        if (owner !== undefined) {
+            if (owner.name !== from.name) {
+                if (module === undefined) {
+                    this.fail(site, `reference to ${symbol.name} crosses a package without an explicit package import`);
+                }
+                const exportName = authoredExportName(site, moduleSpecifier);
+                if (this.packageExportName(module, symbol, owner.face, exportName) === undefined) {
+                    this.fail(site, `package reference ${exportName} is not exported by ${module.package} at ${module.subpath}`);
+                }
+            }
+            const typeDeclaration = declaration;
+            if (!this.declarationStates.has(this.symbolId(symbol)))
+                this.ensureDeclaration(symbol, typeDeclaration);
+            return { kind: 'declaration', symbol: this.symbolId(symbol) };
+        }
+        const packageFaces = module === undefined
+            ? []
+            : [...new Set(this.allRegistrations.filter(candidate => candidate.name === module.package).map(candidate => candidate.face))];
+        const otherFace = packageFaces.find(face => face !== this.face);
+        if (otherFace !== undefined && module !== undefined) {
+            const requestedName = authoredExportName(site, moduleSpecifier);
+            const exportName = this.packageExportName(module, symbol, otherFace, requestedName);
+            if (exportName === undefined) {
+                this.fail(site, `cross-face reference ${requestedName} is not exported by ${module.package} at ${module.subpath}`);
+            }
+            this.recordCrossFaceLink(from.name, otherFace, module, exportName);
+            return {
+                kind: 'cross-face',
+                face: otherFace,
+                package: module.package,
+                subpath: module.subpath,
+                name: exportName,
+            };
+        }
+        if (module !== undefined) {
+            return {
+                kind: 'external',
+                module: module.package,
+                subpath: module.subpath,
+                name: symbol.name,
+            };
+        }
+        const external = externalModuleIdentityForFile(declaration.getSourceFile().fileName);
+        if (external !== undefined) {
+            return {
+                kind: 'external',
+                module: external.package,
+                subpath: external.subpath,
+                name: symbol.name,
+            };
+        }
+        this.fail(site, `reference to ${symbol.name} crosses a package or face without an explicit import`);
+    }
+    recordCrossFaceLink(fromPackage, toFace, module, name) {
+        const link = {
+            fromFace: this.face,
+            fromPackage,
+            toFace,
+            toPackage: module.package,
+            subpath: module.subpath,
+            name,
+        };
+        const key = [
+            link.fromFace,
+            link.fromPackage,
+            link.toFace,
+            link.toPackage,
+            link.subpath,
+            link.name,
+        ].join('\0');
+        this.crossFaceLinks.set(key, link);
+    }
+    packageExportName(module, symbol, face, requestedName) {
+        const registration = this.allRegistrations.find(candidate => candidate.face === face && candidate.name === module.package);
+        const target = packageExportTargets(registration.manifest)
+            .find(([subpath]) => subpath === module.subpath)?.[1];
+        if (target === undefined)
+            return undefined;
+        const sourceFile = this.sourceFiles.get(realPath(sourcePathForExport(registration.root, target)));
+        const moduleSymbol = this.checker.getSymbolAtLocation(sourceFile);
+        const exported = this.checker.getExportsOfModule(moduleSymbol)
+            .find(candidate => candidate.name === requestedName && this.resolveSymbol(candidate) === symbol);
+        return exported?.name;
+    }
+    symbolAtType(node) {
+        if (ts.isTypeReferenceNode(node)) {
+            return this.resolveSymbol(this.checker.getSymbolAtLocation(node.typeName));
+        }
+        const type = this.checker.getTypeAtLocation(node);
+        const symbol = type.aliasSymbol ?? type.getSymbol();
+        return symbol === undefined ? undefined : this.resolveSymbol(symbol);
+    }
+    resolveSymbol(symbol) {
+        return (symbol.flags & ts.SymbolFlags.Alias) === 0 ? symbol : this.checker.getAliasedSymbol(symbol);
+    }
+    symbolId(symbol) {
+        const declaration = preferredDeclaration(symbol);
+        if (declaration === undefined)
+            return `symbol:${symbol.name}`;
+        const location = this.location(declaration);
+        return `${this.packageNameForFile(declaration.getSourceFile().fileName)}:${location.file}#${symbol.name}`;
+    }
+    registrationForFile(file) {
+        const path = realPath(file);
+        return this.allRegistrations
+            .find(registration => registration.face === this.face && isWithin(path, registration.root));
+    }
+    packageNameForFile(file) {
+        const path = realPath(file);
+        return this.allRegistrations.find(registration => isWithin(path, registration.root))?.name ?? '<external>';
+    }
+    allocateNodeId(site) {
+        const location = this.locationKey(site);
+        const ordinal = (this.nodeOrdinals.get(location) ?? 0) + 1;
+        this.nodeOrdinals.set(location, ordinal);
+        return `type:${location}#${String(ordinal)}`;
+    }
+    locationKey(node) {
+        const location = this.location(node);
+        return `${location.file}:${String(location.line)}:${String(location.column)}`;
+    }
+    location(node) {
+        const sourceFile = node.getSourceFile();
+        const position = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+        return {
+            file: slash(relative(this.root, sourceFile.fileName)),
+            line: position.line + 1,
+            column: position.character + 1,
+        };
+    }
+    fail(node, message) {
+        const location = this.location(node);
+        throw new TypertAnalysisError(`typert(${this.face}): ${location.file}:${String(location.line)}:${String(location.column)}: ${message}`);
+    }
+}
+function mergeWorkspaceModels(models) {
+    const faces = new Map();
+    const links = new Map();
+    for (const model of models) {
+        for (const face of model.faces) {
+            const merged = faces.get(face.face) ?? {
+                packages: new Map(),
+                declarations: new Map(),
+                nodes: new Map(),
+            };
+            for (const packageModel of face.packages)
+                merged.packages.set(packageModel.name, packageModel);
+            for (const declaration of face.graph.declarations) {
+                if (!merged.declarations.has(declaration.id))
+                    merged.declarations.set(declaration.id, declaration);
+            }
+            for (const node of face.graph.nodes) {
+                if (!merged.nodes.has(node.id))
+                    merged.nodes.set(node.id, node);
+            }
+            faces.set(face.face, merged);
+        }
+        for (const link of model.crossFaceLinks) {
+            links.set([
+                link.fromFace,
+                link.fromPackage,
+                link.toFace,
+                link.toPackage,
+                link.subpath,
+                link.name,
+            ].join('\0'), link);
+        }
+    }
+    return {
+        faces: [...faces].sort(([left], [right]) => (left === 'host' ? 0 : 1) - (right === 'host' ? 0 : 1)).map(([face, model]) => ({
+            face,
+            packages: [...model.packages.values()].sort((left, right) => left.name.localeCompare(right.name)),
+            graph: {
+                declarations: [...model.declarations.values()].sort((left, right) => left.id.localeCompare(right.id)),
+                nodes: [...model.nodes.values()].sort((left, right) => left.id.localeCompare(right.id)),
+            },
+        })),
+        crossFaceLinks: [...links.values()].sort(compareCrossFaceLinks),
+    };
+}
+function parseConfig(path) {
+    const compilerPath = path.split(sep).join('/');
+    const read = ts.readConfigFile(compilerPath, file => ts.sys.readFile(file));
+    if (read.error !== undefined)
+        throw new TypertAnalysisError(formatDiagnostic(read.error));
+    const parsed = ts.parseJsonConfigFileContent(read.config, ts.sys, dirname(compilerPath), undefined, compilerPath);
+    if (parsed.errors.length > 0)
+        throw new TypertAnalysisError(parsed.errors.map(formatDiagnostic).join('\n'));
+    return { path, parsed };
+}
+function projectConfigPath(path) {
+    if (extname(path) === '.json')
+        return path;
+    return join(path, 'tsconfig.json');
+}
+function sourceFileHasSurface(sourceFile) {
+    for (const statement of sourceFile.statements) {
+        if ((ts.isClassDeclaration(statement)
+            || ts.isInterfaceDeclaration(statement)
+            || ts.isTypeAliasDeclaration(statement)
+            || ts.isEnumDeclaration(statement))
+            && (typertMode(statement) !== undefined || typertServiceTag(statement) !== undefined))
+            return true;
+        if (ts.isClassDeclaration(statement)) {
+            for (const member of statement.members) {
+                if (ts.isPropertyDeclaration(member)
+                    && memberName(member.name) === 'typertGateway'
+                    && member.initializer !== undefined
+                    && ts.isCallExpression(member.initializer)
+                    && expressionName(member.initializer.expression) === 'bindTypeRTGateway')
+                    return true;
+                for (const decorator of ts.canHaveDecorators(member) ? ts.getDecorators(member) ?? [] : []) {
+                    const expression = ts.isCallExpression(decorator.expression)
+                        ? decorator.expression.expression
+                        : decorator.expression;
+                    const name = expressionName(expression);
+                    if (name === 'Remote' || name === 'RemoteScope')
+                        return true;
+                }
+            }
+        }
+        if (!ts.isModuleDeclaration(statement)
+            || !ts.isStringLiteral(statement.name)
+            || statement.name.text !== '@deepseek-ai/cordis'
+            || statement.body === undefined
+            || !ts.isModuleBlock(statement.body))
+            continue;
+        if (statement.body.statements.some(member => ts.isInterfaceDeclaration(member)
+            && (member.name.text === 'Context' || member.name.text === 'Events')
+            && member.members.length > 0))
+            return true;
+    }
+    return false;
+}
+function hasPackageSurface(model) {
+    return model.services.length > 0
+        || model.events.length > 0
+        || model.objects.length > 0
+        || model.schemas.length > 0
+        || model.invocations.length > 0;
+}
+function isDualFacePackage(manifest) {
+    const dsh = manifest.dsh;
+    const client = dsh !== null && typeof dsh === 'object'
+        ? dsh.client
+        : undefined;
+    return client !== null
+        && typeof client === 'object'
+        && clientExportSubpaths(manifest).length > 0;
+}
+function hostExportSubpaths(manifest) {
+    return packageExportTargets(manifest)
+        .map(([subpath]) => subpath)
+        .filter(subpath => subpath !== './client'
+        && !subpath.startsWith('./client/')
+        && subpath !== './remote');
+}
+function clientExportSubpaths(manifest) {
+    return packageExportTargets(manifest)
+        .map(([subpath]) => subpath)
+        .filter(subpath => subpath === './client' || subpath.startsWith('./client/'));
+}
+function packageExportTargets(manifest) {
+    const exportsField = manifest.exports;
+    if (typeof exportsField === 'string')
+        return [['.', exportsField]];
+    if (exportsField === null || typeof exportsField !== 'object') {
+        const types = manifest.types;
+        return typeof types === 'string' ? [['.', types]] : [];
+    }
+    if (Array.isArray(exportsField)
+        || !Object.keys(exportsField).some(key => key.startsWith('.'))) {
+        const target = exportTarget(exportsField);
+        return target === undefined ? [] : [['.', target]];
+    }
+    const result = [];
+    for (const [subpath, value] of Object.entries(exportsField)) {
+        if (!subpath.startsWith('.'))
+            continue;
+        const target = exportTarget(value);
+        if (target !== undefined)
+            result.push([subpath, target]);
+    }
+    return result.sort(([left], [right]) => left.localeCompare(right));
+}
+function exportTarget(value) {
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value)) {
+        for (const candidate of value) {
+            const target = exportTarget(candidate);
+            if (target !== undefined)
+                return target;
+        }
+        return undefined;
+    }
+    if (value === null || typeof value !== 'object')
+        return undefined;
+    const conditions = value;
+    for (const key of ['types', 'import', 'default']) {
+        const target = exportTarget(conditions[key]);
+        if (target !== undefined)
+            return target;
+    }
+    for (const candidate of Object.values(conditions)) {
+        const target = exportTarget(candidate);
+        if (target !== undefined)
+            return target;
+    }
+    return undefined;
+}
+function sourcePathForExport(packageRoot, target) {
+    const normalized = target.replace(/^\.\//, '');
+    if (normalized.startsWith('lib/types/')) {
+        return resolve(packageRoot, 'src', normalized.slice('lib/types/'.length).replace(/\.d\.(?:mts|cts|ts)$/, '.ts'));
+    }
+    if (normalized.startsWith('lib/')) {
+        return resolve(packageRoot, 'src', normalized.slice('lib/'.length).replace(/\.(?:mjs|cjs|js|d\.ts)$/, '.ts'));
+    }
+    return resolve(packageRoot, normalized);
+}
+function preferredDeclaration(symbol) {
+    return symbol.declarations?.find(isTypeDeclaration)
+        ?? symbol.valueDeclaration
+        ?? symbol.declarations?.[0];
+}
+function optionalParent(node) {
+    return node.parent;
+}
+function isTypeDeclaration(node) {
+    return ts.isClassDeclaration(node)
+        || ts.isInterfaceDeclaration(node)
+        || ts.isTypeAliasDeclaration(node)
+        || ts.isEnumDeclaration(node);
+}
+function declarationName(declaration) {
+    return declaration.name.text;
+}
+function memberText(member) {
+    const sourceFile = member.getSourceFile();
+    const full = member.getText(sourceFile);
+    const body = member.body;
+    const signature = body === undefined ? full : full.slice(0, full.length - body.getText(sourceFile).length);
+    return signature.replace(/\s*;?\s*$/, '').replace(/\s+/g, ' ').trim();
+}
+function declarationText(declaration) {
+    const printer = ts.createPrinter({ removeComments: true });
+    const projected = ts.isClassDeclaration(declaration) ? classShape(declaration) : declaration;
+    return printer.printNode(ts.EmitHint.Unspecified, projected, declaration.getSourceFile()).replace(/\r/g, '');
+}
+function classShape(node) {
+    const nonPublic = (member) => (ts.canHaveModifiers(member) ? ts.getModifiers(member) : undefined)?.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 [];
+        if (ts.isMethodDeclaration(member)) {
+            return [ts.factory.updateMethodDeclaration(member, member.modifiers, member.asteriskToken, member.name, member.questionToken, member.typeParameters, member.parameters, member.type, undefined)];
+        }
+        if (ts.isConstructorDeclaration(member)) {
+            return [ts.factory.updateConstructorDeclaration(member, member.modifiers, member.parameters, undefined)];
+        }
+        if (ts.isGetAccessorDeclaration(member)) {
+            return [ts.factory.updateGetAccessorDeclaration(member, member.modifiers, member.name, member.parameters, member.type, undefined)];
+        }
+        if (ts.isSetAccessorDeclaration(member)) {
+            return [ts.factory.updateSetAccessorDeclaration(member, member.modifiers, member.name, member.parameters, undefined)];
+        }
+        if (ts.isPropertyDeclaration(member)) {
+            return [ts.factory.updatePropertyDeclaration(member, member.modifiers, member.name, member.questionToken ?? member.exclamationToken, member.type, undefined)];
+        }
+        return [member];
+    });
+    return ts.factory.updateClassDeclaration(node, node.modifiers, node.name, node.typeParameters, node.heritageClauses, members);
+}
+function documentationOf(node) {
+    const blocks = ts.getJSDocCommentsAndTags(node).filter(ts.isJSDoc);
+    const block = blocks.at(-1);
+    if (block === undefined)
+        return EMPTY_DOCUMENTATION;
+    const description = normalizedDocText(ts.getTextOfJSDocComment(block.comment));
+    const tags = ts.getJSDocTags(node).map((tag) => {
+        const named = tag;
+        const comment = normalizedDocText(ts.getTextOfJSDocComment(tag.comment));
+        return {
+            name: tag.tagName.text,
+            ...(named.name === undefined ? {} : { argument: named.name.getText() }),
+            ...(comment === undefined ? {} : { comment }),
+            text: tag.getText(tag.getSourceFile()).trim(),
+        };
+    });
+    return {
+        ...(description === undefined ? {} : {
+            description,
+            summary: firstSentence(description),
+        }),
+        tags,
+        jsDoc: rawJsDoc(node),
+    };
+}
+function normalizedDocText(value) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.replace(/\s+/g, ' ').trim();
+    /* v8 ignore next -- TypeScript represents whitespace-only JSDoc as undefined before this helper is called. */
+    return normalized.length === 0 ? undefined : normalized;
+}
+function firstSentence(value) {
+    return (/^(.*?[.!?])(?:\s|$)/.exec(value)?.[1] ?? value).trim();
+}
+function rawJsDoc(node) {
+    const sourceFile = node.getSourceFile();
+    const source = sourceFile.getFullText();
+    const ranges = ts.getLeadingCommentRanges(source, node.getFullStart());
+    const range = ranges.filter(candidate => source.slice(candidate.pos, candidate.pos + 3) === '/**').at(-1);
+    const raw = source.slice(range.pos, range.end);
+    const { line } = sourceFile.getLineAndCharacterOfPosition(range.pos);
+    const lineStart = sourceFile.getPositionOfLineAndCharacter(line, 0);
+    const indent = source.slice(lineStart, range.pos);
+    return raw.split('\n')
+        .map((text, index) => index > 0 && text.startsWith(indent) ? text.slice(indent.length) : text)
+        .join('\n');
+}
+function typertMode(node) {
+    for (const tag of ts.getJSDocTags(node)) {
+        if (tag.tagName.text !== 'typert')
+            continue;
+        const mode = (ts.getTextOfJSDocComment(tag.comment) ?? '').trim().split(/\s+/, 1)[0];
+        if (mode === 'object')
+            return 'object';
+        if (mode === '' || mode === 'schema' || mode === 'type')
+            return 'schema';
+    }
+    return undefined;
+}
+function typertServiceTag(node) {
+    return ts.getJSDocTags(node).find(tag => tag.tagName.text === 'typert'
+        && (ts.getTextOfJSDocComment(tag.comment) ?? '').trim().split(/\s+/, 1)[0] === 'service');
+}
+function memberName(name) {
+    if (ts.isIdentifier(name) || ts.isPrivateIdentifier(name) || ts.isStringLiteral(name)
+        || ts.isNumericLiteral(name) || ts.isNoSubstitutionTemplateLiteral(name))
+        return name.text;
+    if (ts.isComputedPropertyName(name))
+        return `[${name.expression.getText()}]`;
+    return name.getText();
+}
+function stringLiteralValue(node) {
+    return node !== undefined && (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
+        ? node.text
+        : undefined;
+}
+function isRemoteSegment(value) {
+    // Generation bootstraps workspace artifacts before dsh-type-meta is built,
+    // so this extraction-only copy must mirror isTypeRTRemoteSegment().
+    return value !== '.' && value !== '..' && /^[A-Za-z0-9_$.-]+$/.test(value);
+}
+function expressionName(node) {
+    if (ts.isIdentifier(node))
+        return node.text;
+    if (ts.isPropertyAccessExpression(node))
+        return node.name.text;
+    return undefined;
+}
+function packageExportSpecifier(packageName, subpath) {
+    return subpath === '.' ? packageName : `${packageName}${subpath.slice(1)}`;
+}
+function visibilityOf(node) {
+    if ('name' in node && node.name !== undefined && ts.isPrivateIdentifier(node.name))
+        return 'private';
+    if (hasModifier(node, ts.SyntaxKind.PrivateKeyword))
+        return 'private';
+    if (hasModifier(node, ts.SyntaxKind.ProtectedKeyword))
+        return 'protected';
+    return 'public';
+}
+function hasModifier(node, kind) {
+    return (ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined)?.some(modifier => modifier.kind === kind) ?? false;
+}
+function exposableMember(member) {
+    return member.visibility === 'public' && !member.static;
+}
+function keywordName(kind) {
+    switch (kind) {
+        case ts.SyntaxKind.AnyKeyword: return 'any';
+        case ts.SyntaxKind.BigIntKeyword: return 'bigint';
+        case ts.SyntaxKind.BooleanKeyword: return 'boolean';
+        case ts.SyntaxKind.NeverKeyword: return 'never';
+        case ts.SyntaxKind.NumberKeyword: return 'number';
+        case ts.SyntaxKind.ObjectKeyword: return 'object';
+        case ts.SyntaxKind.StringKeyword: return 'string';
+        case ts.SyntaxKind.SymbolKeyword: return 'symbol';
+        case ts.SyntaxKind.UndefinedKeyword: return 'undefined';
+        case ts.SyntaxKind.UnknownKeyword: return 'unknown';
+        case ts.SyntaxKind.VoidKeyword: return 'void';
+        default: return undefined;
+    }
+}
+function literalModel(node) {
+    const literal = node.literal;
+    if (ts.isStringLiteral(literal))
+        return { kind: 'literal', value: literal.text, text: literal.getText() };
+    if (ts.isNoSubstitutionTemplateLiteral(literal)) {
+        return { kind: 'literal', value: literal.text, text: literal.getText() };
+    }
+    if (ts.isNumericLiteral(literal))
+        return { kind: 'literal', value: Number(literal.text), text: literal.getText() };
+    if (ts.isBigIntLiteral(literal))
+        return { kind: 'literal', value: BigInt(literal.text.slice(0, -1)), text: literal.getText() };
+    if (literal.kind === ts.SyntaxKind.TrueKeyword)
+        return { kind: 'literal', value: true, text: 'true' };
+    if (literal.kind === ts.SyntaxKind.FalseKeyword)
+        return { kind: 'literal', value: false, text: 'false' };
+    if (literal.kind === ts.SyntaxKind.NullKeyword)
+        return { kind: 'literal', value: null, text: 'null' };
+    /* v8 ignore else -- all remaining LiteralTypeNode syntax is a signed numeric or bigint literal. */
+    if (ts.isPrefixUnaryExpression(literal)
+        && (ts.isNumericLiteral(literal.operand) || ts.isBigIntLiteral(literal.operand))) {
+        return {
+            kind: 'literal',
+            value: ts.isBigIntLiteral(literal.operand)
+                ? BigInt(literal.getText().slice(0, -1))
+                : Number(literal.getText()),
+            text: literal.getText(),
+        };
+    }
+    /* v8 ignore next -- TypeScript's LiteralTypeNode grammar is exhausted above; this contains future compiler syntax. */
+    throw new TypertAnalysisError(`typert: unsupported literal type ${literal.getText()}`);
+}
+function modifierMode(token) {
+    if (token?.kind === ts.SyntaxKind.PlusToken)
+        return 'add';
+    if (token?.kind === ts.SyntaxKind.MinusToken)
+        return 'remove';
+    return token === undefined ? 'preserve' : 'add';
+}
+function annotationPosition(node, purpose) {
+    if (purpose === 'return')
+        return node.parameters.end + 1;
+    return node.name.end;
+}
+function moduleSpecifierOf(node) {
+    if (ts.isImportTypeNode(node)) {
+        const argument = node.argument;
+        return argument.literal.text;
+    }
+    const symbol = ts.isTypeReferenceNode(node)
+        ? node.typeName
+        : node.expression;
+    const sourceFile = node.getSourceFile();
+    const first = ts.isIdentifier(symbol) ? symbol.text : symbol.getFirstToken(sourceFile)?.getText(sourceFile);
+    for (const statement of sourceFile.statements) {
+        if (!ts.isImportDeclaration(statement) || statement.importClause === undefined
+            || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        if (statement.importClause.name?.text === first)
+            return statement.moduleSpecifier.text;
+        const bindings = statement.importClause.namedBindings;
+        if (bindings !== undefined && ts.isNamespaceImport(bindings) && bindings.name.text === first) {
+            return statement.moduleSpecifier.text;
+        }
+        if (bindings !== undefined && ts.isNamedImports(bindings)
+            && bindings.elements.some(element => element.name.text === first))
+            return statement.moduleSpecifier.text;
+    }
+    return undefined;
+}
+function authoredExportName(node, moduleSpecifier) {
+    if (ts.isImportTypeNode(node))
+        return node.qualifier.getText().split('.')[0];
+    const referenced = ts.isTypeReferenceNode(node)
+        ? node.typeName.getText().split('.')
+        : node.expression.getText().split('.');
+    const localName = referenced[0];
+    for (const statement of node.getSourceFile().statements) {
+        if (!ts.isImportDeclaration(statement)
+            || statement.importClause === undefined
+            || !ts.isStringLiteral(statement.moduleSpecifier)
+            || statement.moduleSpecifier.text !== moduleSpecifier)
+            continue;
+        if (statement.importClause.name?.text === localName)
+            return 'default';
+        const bindings = statement.importClause.namedBindings;
+        if (bindings !== undefined && ts.isNamedImports(bindings)) {
+            const imported = bindings.elements.find(element => element.name.text === localName);
+            if (imported !== undefined)
+                return imported.propertyName?.text ?? imported.name.text;
+        }
+        if (bindings !== undefined && ts.isNamespaceImport(bindings) && bindings.name.text === localName) {
+            return referenced[1];
+        }
+    }
+    /* v8 ignore next -- moduleSpecifierOf returns only the matching import inspected by this loop. */
+    throw new TypertAnalysisError(`typert: cannot recover export name for ${localName} from ${moduleSpecifier}`);
+}
+function importTypeAttributesText(node) {
+    const sourceFile = node.getSourceFile();
+    const children = node.getChildren(sourceFile);
+    const comma = children.find(child => child.kind === ts.SyntaxKind.CommaToken);
+    const close = children.find(child => child.kind === ts.SyntaxKind.CloseParenToken);
+    return sourceFile.text.slice(comma.end, close.pos).trim();
+}
+function moduleIdentity(specifier) {
+    if (specifier.startsWith('.') || specifier.startsWith('/'))
+        return undefined;
+    const parts = specifier.split('/');
+    const packageLength = specifier.startsWith('@') ? 2 : 1;
+    const packageName = parts.slice(0, packageLength).join('/');
+    const rest = parts.slice(packageLength).join('/');
+    return {
+        package: packageName,
+        subpath: rest.length === 0 ? '.' : `./${rest}`,
+    };
+}
+function externalModuleIdentityForFile(file) {
+    const normalized = slash(file);
+    const marker = '/node_modules/';
+    const index = normalized.lastIndexOf(marker);
+    if (index < 0)
+        return undefined;
+    const parts = normalized.slice(index + marker.length).split('/');
+    const packageLength = parts[0].startsWith('@') ? 2 : 1;
+    const packageName = parts.slice(0, packageLength).join('/');
+    return { package: packageName, subpath: '.' };
+}
+function isStandardLibraryFile(file) {
+    const base = file.replaceAll('\\', '/');
+    return /\/typescript\/lib\/lib\.[^/]+\.d\.ts$/.test(base);
+}
+function formatDiagnostic(diagnostic) {
+    return ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+}
+function formatProgramDiagnostic(root, face, diagnostic) {
+    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+    const position = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+    const file = slash(relative(root, diagnostic.file.fileName));
+    return `typert(${face}): ${file}:${String(position.line + 1)}:${String(position.character + 1)}: TypeScript TS${String(diagnostic.code)}: ${message}`;
+}
+const realPathCache = new Map();
+function realPath(path) {
+    const absolute = resolve(path);
+    const cached = realPathCache.get(absolute);
+    if (cached !== undefined)
+        return cached;
+    // Only existing paths are memoized: a path can come into existence later,
+    // but an existing path's canonical form is stable for the process lifetime
+    // (analysis edits rewrite file contents, never the directory tree).
+    if (!existsSync(absolute))
+        return absolute;
+    const resolved = realpathSync(absolute);
+    realPathCache.set(absolute, resolved);
+    return resolved;
+}
+function isWithin(path, root) {
+    const absolute = realPath(path);
+    const parent = realPath(root);
+    return absolute === parent || absolute.startsWith(parent + sep);
+}
+function slash(value) {
+    return value.replaceAll('\\', '/');
+}
+function uniqueBy(values, key) {
+    const result = new Map();
+    for (const value of values)
+        if (!result.has(key(value)))
+            result.set(key(value), value);
+    return [...result.values()];
+}
+function compareCrossFaceLinks(left, right) {
+    return left.fromFace.localeCompare(right.fromFace)
+        || left.fromPackage.localeCompare(right.fromPackage)
+        || left.toFace.localeCompare(right.toFace)
+        || left.toPackage.localeCompare(right.toPackage)
+        || left.subpath.localeCompare(right.subpath)
+        || left.name.localeCompare(right.name);
+}
+//# sourceMappingURL=analyzer.js.map