semantifold 0.3.0 → 0.4.0

package/build/src/frontends/program.js

@@ -0,0 +1,989 @@
+// @ts-check
+import { isDenseArray } from "../array.js";
+import { isSafeSourcePath } from "../artifact-path.js";
+import { SemantifoldDiagnostic, semanticFailure, unsupportedCapability, unsupportedRole } from "../diagnostic.js";
+import { languageRegistry } from "../language-registry.js";
+import { normalizeCapabilityAuthority } from "../semantic/capabilities.js";
+import { moduleLocation } from "../semantic/location.js";
+import { annotateParsedModule } from "../semantic/provenance.js";
+import { moduleUncheckedErrorEffects, validateParsedModule } from "../semantic/validate.js";
+import { facadeCapabilityAuthority, resolveStdlibFacadeClosure, stdlibFacadeProgramDescriptor, stdlibFacadeRegistry } from "../stdlib-facades.js";
+import { inspectJavaScriptTypeScriptModule } from "./javascript-typescript.js";
+import { inspectJavaModule } from "./java.js";
+import { inspectPhpModule } from "./php.js";
+import { inspectRubyModule } from "./ruby.js";
+const programLanguages = new Set(["php", "ruby", "javascript", "typescript", "java"]);
+const moduleIdPattern = /^[a-z][a-z0-9_]*(?:[.-][a-z][a-z0-9_]*)*$/u;
+/** @typedef {{facade?: import("../stdlib-facades.js").StdlibFacadeRecord, filename: string, id: string, language: import("../semantic/types.js").SemanticLanguage, ownership: "application" | "facade", source: string}} ProgramSource */
+/** @typedef {{declarationLocation?: import("../semantic/types.js").SourceLocation, facade?: import("../stdlib-facades.js").StdlibFacadeRecord, importedName: string, importedNameLocation?: import("../semantic/types.js").SourceLocation, localName: string, localNameLocation?: import("../semantic/types.js").SourceLocation, location: import("../semantic/types.js").SourceLocation, namespace?: boolean, pathLocation: import("../semantic/types.js").SourceLocation, specifier: string, stdlibCandidate?: true, typeOnly: boolean}} ProgramImportRequest */
+/** @typedef {{importedName: string, localName: string, location: import("../semantic/types.js").SourceLocation, nativeName: string, symbolKind: import("../semantic/types.js").SemanticDeclarationKind, typeOnly: boolean}} ProgramNativeBinding */
+/** @typedef {{imports: ProgramImportRequest[], exports: {declarationLocation?: import("../semantic/types.js").SourceLocation, exportedName: string, exportedNameLocation?: import("../semantic/types.js").SourceLocation, localName: string, localNameLocation?: import("../semantic/types.js").SourceLocation, location: import("../semantic/types.js").SourceLocation, symbolKind?: import("../semantic/types.js").SemanticDeclarationKind, typeOnly: boolean}[], bindings?: ProgramNativeBinding[], nativeName?: string, nativeReferences?: {form: "constructor-call" | "receiver-call" | "unqualified-call", location: import("../semantic/types.js").SourceLocation, nativeModule: string, symbol: string}[]}} ProgramHeader */
+/**
+ * Parses an explicit caller-supplied multi-source program without filesystem discovery.
+ * @param {object} input - Program parse request.
+ * @param {string} input.entryModule - Sole entry module identity.
+ * @param {{filename: string, id: string, language: import("../semantic/types.js").SemanticLanguage, source: string}[]} input.sources - Complete source set.
+ * @param {Readonly<import("../semantic/types.js").CapabilityAuthority> | import("../semantic/types.js").CapabilityAuthorityInput} [input.capabilityAuthority] - Explicit compiler authority.
+ * @returns {import("../semantic/types.js").SemanticProgram} Resolved semantic program.
+ */
+export function parseProgramSource(input) {
+    if (!isPlainObject(input) || !isDenseArray(input.sources) || input.sources.length == 0 ||
+        typeof input.entryModule != "string")
+        invalidProgram("Program parsing requires a non-empty ordered source set and entry module.");
+    const applicationSources = input.sources.map((source, index) => validateSource(source, index));
+    const requestedAuthority = normalizeCapabilityAuthority(input.capabilityAuthority);
+    const sourceLanguages = new Set(applicationSources.map(({ language }) => language));
+    if (sourceLanguages.size != 1) {
+        semanticFailure(applicationSources[0].language, "MIXED_SOURCE_LANGUAGES", "A semantic program must use one source-language compatibility profile.", undefined);
+    }
+    if (requestedAuthority && !languageRegistry.record(applicationSources[0].language).features.effectfulCapabilitiesAndResources) {
+        unsupportedCapability(applicationSources[0].language, "Task 034 effectful capabilities and owned resources", moduleLocation(applicationSources[0].filename, applicationSources[0].source));
+    }
+    const byId = new Map();
+    const byFilename = new Map();
+    for (const source of applicationSources) {
+        if (byId.has(source.id))
+            semanticFailure(source.language, "DUPLICATE_MODULE", `Duplicate module identity '${source.id}'.`, undefined);
+        if (byFilename.has(source.filename))
+            semanticFailure(source.language, "DUPLICATE_MODULE", `Duplicate module filename '${source.filename}'.`, undefined);
+        byId.set(source.id, source);
+        byFilename.set(source.filename, source);
+    }
+    if (!byId.has(input.entryModule)) {
+        semanticFailure(applicationSources[0].language, "INVALID_ENTRY_MODULE", `Unknown entry module '${input.entryModule}'.`, undefined);
+    }
+    const headers = new Map(applicationSources.map((source) => [source.id, inspectSource(source)]));
+    const facadeRoots = resolveFacadeImports(applicationSources, headers);
+    const facadeRecords = resolveStdlibFacadeClosure(facadeRoots);
+    if (facadeRecords.length > 0 && requestedAuthority) {
+        const located = applicationSources.flatMap((source) => requiredMapValue(headers, source.id).imports)
+            .find(({ facade }) => facade)?.location;
+        facadeFailure(applicationSources[0].language, "STDLIB_FACADE_AUTHORITY_FORGED", "Programs resolved through compiler-owned facades cannot supply their own canonical capability authority.", located);
+    }
+    const facadeAuthority = facadeCapabilityAuthority(facadeRecords);
+    const authority = requestedAuthority ?? (facadeAuthority ? normalizeCapabilityAuthority(facadeAuthority.input) : undefined);
+    const facadeSources = facadeRecords.map((facade) => /** @type {ProgramSource} */ ({
+        facade,
+        filename: facade.source.filename,
+        id: facade.source.id,
+        language: facade.language,
+        ownership: "facade",
+        source: facade.source.content
+    }));
+    validateFacadeCollisions(applicationSources, headers, facadeSources);
+    const sources = [...applicationSources, ...facadeSources];
+    for (const source of facadeSources) {
+        byId.set(source.id, source);
+        byFilename.set(source.filename, source);
+        headers.set(source.id, inspectSource(source));
+    }
+    const registeredSources = sources.map((source, index) => ({
+        content: source.source,
+        filename: source.filename,
+        id: `source:${index}`,
+        language: source.language,
+        ownership: source.ownership
+    }));
+    const sourceIds = new Map(sources.map((source, index) => [source.id, `source:${index}`]));
+    validateNativeModuleIdentities(sources, headers);
+    /** @type {Map<string, {source: typeof sources[number], requests: (ReturnType<typeof inspectSource>["imports"][number] & {moduleId: string})[]}>} */
+    const graph = new Map();
+    for (const source of sources) {
+        const requests = requiredMapValue(headers, source.id).imports.map((request) => ({
+            ...request,
+            moduleId: request.facade?.source.id ?? resolveImportModule(source, request.specifier, request.pathLocation, byFilename, headers)
+        }));
+        graph.set(source.id, { requests, source });
+    }
+    const orderedIds = topologicalOrder(sources, graph);
+    /** @type {Map<string, import("../semantic/types.js").SemanticProgramModule>} */
+    const parsed = new Map();
+    /** @type {Map<string, Set<string>>} */
+    const callEffectsByDeclarationId = new Map();
+    for (const moduleId of orderedIds) {
+        const { requests, source } = requiredMapValue(graph, moduleId);
+        const sourceId = /** @type {string} */ (sourceIds.get(source.id));
+        const header = requiredMapValue(headers, moduleId);
+        const localNames = new Set();
+        const visibleFunctions = new Map();
+        const visibleCallEffects = new Map();
+        const visibleRecordsByName = new Map();
+        const visibleValueRecordsByName = new Map();
+        const visibleRecordsById = new Map();
+        const visibleClassesByName = new Map();
+        const visibleClassesById = new Map();
+        const visibleErrorsByName = new Map();
+        const visibleErrorsById = new Map();
+        const consumedBindings = new Set();
+        /** @type {import("../semantic/types.js").SemanticImport[]} */
+        const imports = [];
+        if (!source.facade && authority) {
+            const failureNames = new Set(header.imports.filter(({ facade }) => facade).flatMap(({ facade }) => facade?.publicDeclarations.flatMap((declaration) => declaration.kind == "function"
+                ? declaration.failures
+                : [...declaration.constructor.failures, ...declaration.methods.flatMap(({ failures }) => failures)]) ?? []));
+            for (const failure of authority.capabilities.flatMap(({ failures }) => failures)) {
+                if (!failureNames.has(failure.name))
+                    continue;
+                const declaration = /** @type {import("../semantic/types.js").ErrorDeclaration} */ ( /** @type {unknown} */(failure));
+                visibleErrorsByName.set(failure.name, declaration);
+                visibleErrorsById.set(failure.id, declaration);
+            }
+        }
+        for (const request of requests) {
+            const dependency = parsed.get(request.moduleId);
+            if (!dependency) {
+                throw new Error(`Dependency '${request.moduleId}' was not parsed before '${source.id}'.`);
+            }
+            const dependencyHeader = requiredMapValue(headers, request.moduleId);
+            const nativeBindingPrefix = request.facade?.nativeModules.find(({ identity }) => identity == request.specifier)?.identity ??
+                dependencyHeader.nativeName;
+            const nativeBindings = source.language == "php" && request.namespace
+                ? (header.bindings ?? []).filter(({ nativeName }) => nativeName.startsWith(`${nativeBindingPrefix}\\`))
+                : [];
+            const selectedExports = request.namespace && source.language == "php"
+                ? dependency.exports.filter(({ exportedName }) => nativeBindings.some(({ importedName }) => importedName == exportedName))
+                : request.namespace
+                    ? dependency.exports
+                    : dependency.exports.filter(({ exportedName }) => exportedName == request.importedName);
+            if (selectedExports.length == 0) {
+                semanticFailure(source.language, "UNRESOLVED_IMPORT", request.namespace
+                    ? `Imported module '${request.moduleId}' has no explicitly bound exports.`
+                    : `Module '${request.moduleId}' does not export '${request.importedName}'.`, request.location);
+            }
+            for (const exported of selectedExports) {
+                const nativeBinding = nativeBindings.find(({ importedName }) => importedName == exported.exportedName);
+                const localName = nativeBinding?.localName ?? (request.namespace
+                    ? qualifiedImportName(source.language, dependencyHeader.nativeName, exported)
+                    : request.localName);
+                const importLocation = nativeBinding?.location ?? request.location;
+                if (localNames.has(localName)) {
+                    semanticFailure(source.language, "DUPLICATE_IMPORT_BINDING", `Duplicate import binding '${localName}'.`, importLocation);
+                }
+                localNames.add(localName);
+                if (nativeBinding && nativeBinding.symbolKind != exported.symbolKind &&
+                    !(nativeBinding.symbolKind == "record" && exported.symbolKind == "error")) {
+                    semanticFailure(source.language, "IMPORT_KIND_MISMATCH", `Import '${nativeBinding.importedName}' has the wrong declaration kind.`, importLocation);
+                }
+                if (request.typeOnly && exported.symbolKind != "record") {
+                    semanticFailure(source.language, "IMPORT_KIND_MISMATCH", `Type import '${request.importedName}' does not name a record.`, importLocation);
+                }
+                if (nativeBinding)
+                    consumedBindings.add(nativeBinding);
+                const declaration = declarationFor(dependency, exported);
+                const typeOnly = nativeBinding?.typeOnly ?? request.typeOnly;
+                if (exported.symbolKind == "function") {
+                    visibleFunctions.set(localName, /** @type {import("../semantic/types.js").FunctionDeclaration} */ (declaration));
+                    visibleCallEffects.set(localName, new Set(callEffectsByDeclarationId.get(exported.declarationId) ?? []));
+                }
+                else if (exported.symbolKind == "record") {
+                    const record = /** @type {import("../semantic/types.js").RecordDeclaration} */ (declaration);
+                    visibleRecordsByName.set(localName, record);
+                    if (!typeOnly)
+                        visibleValueRecordsByName.set(localName, record);
+                    visibleRecordsById.set(/** @type {string} */ (record.id), record);
+                }
+                else if (exported.symbolKind == "class") {
+                    const declaration = /** @type {import("../semantic/types.js").ClassDeclaration} */ (declarationFor(dependency, exported));
+                    visibleClassesByName.set(localName, declaration);
+                    visibleClassesById.set(/** @type {string} */ (declaration.id), declaration);
+                }
+                else {
+                    const error = /** @type {import("../semantic/types.js").ErrorDeclaration} */ (declaration);
+                    visibleErrorsByName.set(localName, error);
+                    visibleErrorsById.set(/** @type {string} */ (error.id), error);
+                }
+                /** @type {Record<string, import("../semantic/types.js").SourceLocation>} */
+                const ranges = {
+                    declaration: request.declarationLocation ?? request.location,
+                    path: request.pathLocation
+                };
+                if (!request.namespace || nativeBinding || request.facade) {
+                    ranges.importedName = nativeBinding?.location ?? request.importedNameLocation ?? importLocation;
+                    ranges.localName = nativeBinding?.location ?? request.localNameLocation ?? importLocation;
+                }
+                imports.push({
+                    declarationId: exported.declarationId,
+                    importedName: exported.exportedName,
+                    kind: "Import",
+                    localName,
+                    location: importLocation,
+                    moduleId: request.moduleId,
+                    ...(request.facade ? { stdlibFacade: {
+                            facadeIdentity: request.facade.identity,
+                            facadeVersion: request.facade.version,
+                            nativeModule: request.specifier,
+                            nativeSymbol: exported.exportedName,
+                            schema: /** @type {const} */ ("SemantifoldStdlibFacadeResolution"),
+                            version: /** @type {const} */ (1)
+                        } } : {}),
+                    sourceProvenance: sourceAssociation(importLocation, ranges, sourceId),
+                    symbolKind: exported.symbolKind,
+                    typeOnly
+                });
+            }
+        }
+        const unconsumedBinding = (header.bindings ?? []).find((binding) => !consumedBindings.has(binding));
+        if (unconsumedBinding) {
+            semanticFailure(source.language, "UNRESOLVED_IMPORT", `Native import '${unconsumedBinding.nativeName}' has no matching required module.`, unconsumedBinding.location);
+        }
+        const frontend = /** @type {(input: object) => import("../semantic/types.js").SemanticModule} */ (languageRegistry.resolve(source.language, "frontend"));
+        const facadeModules = new Set(source.facade?.requirements.map(({ module }) => module) ?? []);
+        const moduleCapabilities = requestedAuthority?.capabilities ?? (source.facade?.requirements.length
+            ? authority?.modules?.filter(({ identity }) => facadeModules.has(identity)).flatMap(({ capabilities }) => capabilities) ??
+                authority?.capabilities
+            : undefined);
+        const raw = frontend({
+            capabilities: moduleCapabilities,
+            filename: source.filename,
+            language: source.language,
+            program: {
+                classes: visibleClassesByName,
+                functions: visibleFunctions,
+                isEntry: source.id == input.entryModule,
+                errors: visibleErrorsByName,
+                records: visibleRecordsByName,
+                valueRecords: visibleValueRecordsByName
+            },
+            source: source.source
+        });
+        if (moduleCapabilities)
+            raw.capabilities = /** @type {import("../semantic/types.js").EffectCapabilityDeclaration[]} */ (moduleCapabilities);
+        if ((raw.classes?.length ?? 0) > 0 && !source.facade?.publicDeclarations.some(({ kind }) => kind == "class")) {
+            semanticFailure(source.language, "UNSUPPORTED_SYNTAX", "Task 033 reference classes are not supported by the Task 010 semantic program profile.", raw.classes?.[0]?.location ?? raw.location);
+        }
+        if (source.id == input.entryModule && raw.entryPoint.body.statements.length == 0) {
+            semanticFailure(source.language, "INVALID_ENTRY_MODULE", `Selected entry module '${source.id}' has no executable statements.`, raw.entryPoint.location);
+        }
+        try {
+            validateParsedModule(raw, source.language, {
+                callEffects: visibleCallEffects,
+                errors: visibleErrorsById,
+                functions: visibleFunctions,
+                records: visibleRecordsById,
+                classes: visibleClassesById
+            });
+        }
+        catch (error) {
+            const task037 = source.language == "ruby" && header.imports.some(({ facade }) => facade?.identity.startsWith("semantifold.task037."));
+            if (task037 && error instanceof SemantifoldDiagnostic && error.code == "UNKNOWN_METHOD" &&
+                error.detail.startsWith("Class 'TCPSocket'")) {
+                facadeFailure("ruby", "STDLIB_FACADE_MEMBER_UNSUPPORTED", error.detail, error.location);
+            }
+            throw error;
+        }
+        rekeyDeclarations(raw, source.id);
+        const localCallEffects = moduleUncheckedErrorEffects(raw, { callEffects: visibleCallEffects, functions: visibleFunctions });
+        for (const declaration of raw.functions) {
+            callEffectsByDeclarationId.set(/** @type {string} */ (declaration.id), new Set(localCallEffects.get(declaration.name) ?? []));
+        }
+        annotateParsedModule(raw, source);
+        rebaseParsedModuleProvenance(raw, registeredSources, sourceId);
+        /** @type {Map<string, {declaration: import("../semantic/types.js").FunctionDeclaration | import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").ErrorDeclaration, symbolKind: import("../semantic/types.js").SemanticDeclarationKind}>} */
+        const declarationsByName = new Map();
+        for (const declaration of raw.records ?? [])
+            declarationsByName.set(declaration.name, { declaration, symbolKind: "record" });
+        for (const declaration of raw.classes ?? [])
+            declarationsByName.set(declaration.name, { declaration, symbolKind: "class" });
+        for (const declaration of raw.errors ?? [])
+            declarationsByName.set(declaration.name, { declaration, symbolKind: "error" });
+        for (const declaration of raw.functions)
+            declarationsByName.set(declaration.name, { declaration, symbolKind: "function" });
+        /** @type {import("../semantic/types.js").SemanticExport[]} */
+        const exports = header.exports.map((request) => {
+            const resolved = declarationsByName.get(request.localName);
+            if (!resolved)
+                semanticFailure(source.language, "UNRESOLVED_EXPORT", `Unknown exported declaration '${request.localName}'.`, request.location);
+            if (request.typeOnly && resolved.symbolKind != "record") {
+                semanticFailure(source.language, "EXPORT_KIND_MISMATCH", `Type export '${request.exportedName}' does not name a record.`, request.location);
+            }
+            return {
+                declarationId: /** @type {string} */ (resolved.declaration.id),
+                exportedName: request.exportedName,
+                kind: /** @type {const} */ ("Export"),
+                location: request.location,
+                sourceProvenance: sourceAssociation(request.location, {
+                    declaration: request.declarationLocation ?? request.location,
+                    exportedName: request.exportedNameLocation ?? request.location,
+                    localName: request.localNameLocation ?? request.location
+                }, sourceId),
+                symbolKind: resolved.symbolKind
+            };
+        });
+        const exportedNames = new Set();
+        for (const exported of exports) {
+            if (exportedNames.has(exported.exportedName)) {
+                semanticFailure(source.language, "DUPLICATE_EXPORT", `Duplicate export '${exported.exportedName}'.`, exported.location);
+            }
+            exportedNames.add(exported.exportedName);
+        }
+        const { entryPoint, ...moduleWithoutEntry } = raw;
+        const module = /** @type {import("../semantic/types.js").SemanticProgramModule} */ ({
+            ...moduleWithoutEntry,
+            ...(source.id == input.entryModule ? { entryPoint } : {}),
+            exports,
+            id: source.id,
+            imports,
+            ...(source.facade ? { stdlibFacade: { identity: source.facade.identity, version: source.facade.version } } : {}),
+            sourceFilename: source.filename
+        });
+        if (source.facade)
+            validateParsedFacade(source.facade, module);
+        parsed.set(source.id, module);
+    }
+    return {
+        entryModule: input.entryModule,
+        kind: "Program",
+        modules: orderedIds.map((id) => /** @type {import("../semantic/types.js").SemanticProgramModule} */ (parsed.get(id))),
+        ...(requestedAuthority ? {
+            stdlibContract: {
+                identity: requestedAuthority.id,
+                ...(requestedAuthority.contractVersion !== undefined ? { contractVersion: requestedAuthority.contractVersion } : {})
+            }
+        } : facadeAuthority && "contracts" in facadeAuthority ? { stdlibContracts: facadeAuthority.contracts }
+            : facadeAuthority ? { stdlibContract: facadeAuthority.contract } : {}),
+        ...(facadeRecords.length > 0 ? { stdlibFacades: stdlibFacadeProgramDescriptor(applicationSources[0].language, facadeRecords) } : {}),
+        sources: registeredSources
+    };
+}
+/**
+ * Resolves parser-owned native module and symbol evidence to facade roots.
+ * Mutating the private header requests keeps the proof attached to the exact import node.
+ * @param {ProgramSource[]} sources - Caller-owned sources.
+ * @param {Map<string, ProgramHeader>} headers - Parser-owned source headers.
+ * @returns {import("../stdlib-facades.js").StdlibFacadeRecord[]} Selected facade roots.
+ */
+function resolveFacadeImports(sources, headers) {
+    /** @type {import("../stdlib-facades.js").StdlibFacadeRecord[]} */
+    const roots = [];
+    for (const source of sources) {
+        const header = requiredMapValue(headers, source.id);
+        if (source.language == "ruby")
+            resolveRubyTask037Facades(source, header, roots);
+        if (source.language == "php") {
+            for (const binding of header.bindings ?? []) {
+                const parts = binding.nativeName.split("\\");
+                const symbol = /** @type {string} */ (parts.pop());
+                const nativeModule = parts.join("\\");
+                if (!nativeModule.startsWith("Semantifold\\Task036\\"))
+                    continue;
+                const facade = resolveFacadeAt(source, nativeModule, symbol, binding.location);
+                header.imports.push({
+                    declarationLocation: binding.location,
+                    facade,
+                    importedName: "*",
+                    importedNameLocation: binding.location,
+                    localName: "",
+                    localNameLocation: binding.location,
+                    location: binding.location,
+                    namespace: true,
+                    pathLocation: binding.location,
+                    specifier: nativeModule,
+                    stdlibCandidate: true,
+                    typeOnly: false
+                });
+                roots.push(facade);
+            }
+        }
+        for (const request of header.imports) {
+            const javaCandidate = source.language == "java" && request.specifier.startsWith("semantifold.task036.");
+            if (!request.stdlibCandidate && !javaCandidate)
+                continue;
+            if (request.facade)
+                continue;
+            if (/\.(?:bundle|dll|node|so)$/iu.test(request.specifier)) {
+                facadeFailure(source.language, "STDLIB_FACADE_NATIVE_EXTENSION_UNSUPPORTED", "Native-extension loading cannot participate in a portable stdlib facade.", request.pathLocation);
+            }
+            const supplied = [...headers.entries()].find(([, candidate]) => candidate.nativeName == request.specifier);
+            if (supplied) {
+                facadeFailure(source.language, "STDLIB_FACADE_SHADOWED", `Caller-supplied module '${supplied[0]}' replaces the catalogued native facade identity '${request.specifier}'.`, request.pathLocation);
+            }
+            const facade = request.namespace
+                ? resolveFacadeModuleAt(source, request.specifier, request.pathLocation)
+                : resolveFacadeAt(source, request.specifier, request.importedName, request.importedNameLocation ?? request.location);
+            request.facade = facade;
+            roots.push(facade);
+        }
+    }
+    return roots;
+}
+/**
+ * Resolves exact Task 037 Ruby references under a literal socket activation edge.
+ * @param {ProgramSource} source - Importing Ruby source.
+ * @param {ProgramHeader} header - Parser-owned Ruby header.
+ * @param {import("../stdlib-facades.js").StdlibFacadeRecord[]} roots - Selected facade roots.
+ * @returns {void}
+ */
+function resolveRubyTask037Facades(source, header, roots) {
+    const activationIndex = header.imports.findIndex(({ specifier, stdlibCandidate }) => stdlibCandidate && specifier == "socket");
+    if (activationIndex < 0)
+        return;
+    const activation = /** @type {ProgramImportRequest} */ (header.imports.splice(activationIndex, 1)[0]);
+    const bindings = new Set();
+    for (const reference of header.nativeReferences ?? []) {
+        if (reference.nativeModule != "socket" && reference.nativeModule != "ruby:Kernel")
+            continue;
+        const localName = reference.form == "receiver-call" ? "Kernel.puts" : reference.symbol;
+        if (bindings.has(localName))
+            continue;
+        bindings.add(localName);
+        const facade = resolveFacadeAt(source, reference.nativeModule, reference.symbol, reference.location);
+        header.imports.push({
+            declarationLocation: reference.location,
+            facade,
+            importedName: reference.symbol,
+            importedNameLocation: reference.location,
+            localName,
+            localNameLocation: reference.location,
+            location: reference.location,
+            pathLocation: activation.pathLocation,
+            specifier: reference.nativeModule,
+            stdlibCandidate: true,
+            typeOnly: false
+        });
+        roots.push(facade);
+    }
+}
+/**
+ * Resolves one exact native module and symbol while preserving parser location.
+ * @param {ProgramSource} source - Importing source.
+ * @param {string} nativeModule - Parser-proved native module identity.
+ * @param {string} symbol - Parser-proved native symbol.
+ * @param {import("../semantic/types.js").SourceLocation} location - Identity evidence location.
+ * @returns {import("../stdlib-facades.js").StdlibFacadeRecord} Located exact native facade resolution.
+ */
+function resolveFacadeAt(source, nativeModule, symbol, location) {
+    try {
+        return stdlibFacadeRegistry.resolveFacade(source.language, nativeModule, symbol);
+    }
+    catch (error) {
+        if (error instanceof SemantifoldDiagnostic)
+            facadeFailure(source.language, error.code, error.detail, location);
+        throw error;
+    }
+}
+/**
+ * Resolves one exact namespace-style native module while preserving parser location.
+ * @param {ProgramSource} source - Importing source.
+ * @param {string} nativeModule - Parser-proved native module identity.
+ * @param {import("../semantic/types.js").SourceLocation} location - Identity evidence location.
+ * @returns {import("../stdlib-facades.js").StdlibFacadeRecord} Located exact native facade-module resolution.
+ */
+function resolveFacadeModuleAt(source, nativeModule, location) {
+    try {
+        return stdlibFacadeRegistry.resolveModule(source.language, nativeModule);
+    }
+    catch (error) {
+        if (error instanceof SemantifoldDiagnostic)
+            facadeFailure(source.language, error.code, error.detail, location);
+        throw error;
+    }
+}
+/**
+ * Rejects caller capture of compiler-owned module/source/native names and imported bindings.
+ * @param {ProgramSource[]} applicationSources - Caller-owned sources.
+ * @param {Map<string, ProgramHeader>} headers - Caller parser headers.
+ * @param {ProgramSource[]} facadeSources - Selected compiler-owned facade sources.
+ * @returns {void}
+ */
+function validateFacadeCollisions(applicationSources, headers, facadeSources) {
+    const facadeIds = new Set(facadeSources.map(({ id }) => id));
+    const facadeFilenames = new Set(facadeSources.map(({ filename }) => filename));
+    const facadeNativeNames = new Set(facadeSources.map((source) => inspectSource(source).nativeName).filter(Boolean));
+    for (const source of applicationSources) {
+        const header = requiredMapValue(headers, source.id);
+        if (facadeIds.has(source.id) || facadeFilenames.has(source.filename)) {
+            facadeFailure(source.language, "STDLIB_FACADE_NAME_COLLISION", `Caller module '${source.id}' collides with a compiler-owned facade module or source path.`, moduleLocation(source.filename, source.source));
+        }
+        if (header.nativeName && facadeNativeNames.has(header.nativeName)) {
+            facadeFailure(source.language, "STDLIB_FACADE_REOPENED", `Caller source reopens the compiler-owned facade native identity '${header.nativeName}'.`, moduleLocation(source.filename, source.source));
+        }
+        const importedBindings = new Set(header.imports.filter(({ facade }) => facade && !facade.publicDeclarations.some(({ name }) => name == ""))
+            .flatMap((request) => request.namespace && source.language == "php"
+            ? (header.bindings ?? []).filter(({ nativeName }) => nativeName.startsWith(`${request.specifier}\\`)).map(({ localName }) => localName)
+            : request.namespace ? [] : [request.localName]));
+        const shadowed = header.exports.find(({ localName }) => importedBindings.has(localName));
+        if (shadowed)
+            facadeFailure(source.language, "STDLIB_FACADE_SHADOWED", `Local declaration '${shadowed.localName}' shadows a parser-proved stdlib facade binding.`, shadowed.location);
+    }
+}
+/**
+ * Validates a parsed compiler-owned facade against its registry declaration and canonical-only requirements.
+ * @param {import("../stdlib-facades.js").StdlibFacadeRecord} facade - Selected facade record.
+ * @param {import("../semantic/types.js").SemanticProgramModule} module - Parsed semantic module.
+ * @returns {void}
+ */
+function validateParsedFacade(facade, module) {
+    const exported = new Map(module.exports.map((item) => [item.exportedName, item]));
+    for (const declaration of facade.publicDeclarations) {
+        if (declaration.kind == "class") {
+            validateParsedFacadeClass(facade, module, declaration, exported.get(declaration.name));
+            continue;
+        }
+        const exportedDeclaration = exported.get(declaration.name);
+        const parsed = exportedDeclaration ? module.functions.find(({ id }) => id == exportedDeclaration.declarationId) : undefined;
+        const signatureMatches = parsed && parsed.parameters.length == declaration.parameters.length &&
+            parsed.parameters.every((parameter, index) => parameter.name == declaration.parameters[index].name &&
+                semanticTypeName(parameter.type) == declaration.parameters[index].type) &&
+            semanticTypeName(parsed.returnType) == declaration.returnType;
+        if (!signatureMatches)
+            facadeFailure(facade.language, "STDLIB_FACADE_DECLARATION_MISMATCH", `Facade '${facade.identity}' executable source does not match public declaration '${declaration.name}'.`, parsed?.location ?? module.location);
+    }
+    const dependencyIds = new Set(facade.dependencies.map((dependency) => stdlibFacadeRegistry.resolveIdentity(dependency.identity, facade.language, dependency.range).source.id));
+    if (module.imports.some(({ moduleId }) => !dependencyIds.has(moduleId)) ||
+        [...dependencyIds].some((moduleId) => !module.imports.some((imported) => imported.moduleId == moduleId))) {
+        facadeFailure(facade.language, "STDLIB_FACADE_DECLARATION_MISMATCH", `Facade '${facade.identity}' executable imports do not match its declared dependencies.`, module.location);
+    }
+    const allowedOperations = new Set(facade.requirements.flatMap(({ operations }) => operations));
+    const operationNames = new Map((module.capabilities ?? []).flatMap(({ operations }) => operations.map(({ id, name }) => [id, name])));
+    const usedOperations = collectEffectOperations(module, operationNames);
+    if ([...usedOperations].some((operation) => !allowedOperations.has(operation)) ||
+        [...allowedOperations].some((operation) => !usedOperations.has(operation))) {
+        facadeFailure(facade.language, "STDLIB_FACADE_AUTHORITY_FORGED", `Facade '${facade.identity}' canonical calls do not match its declared requirements.`, module.location);
+    }
+}
+/**
+ * Verifies one executable compiler-owned facade class against its closed descriptor.
+ * @param {import("../stdlib-facades.js").StdlibFacadeRecord} facade - Owning facade.
+ * @param {import("../semantic/types.js").SemanticProgramModule} module - Parsed facade module.
+ * @param {import("../stdlib-facades.js").StdlibFacadeClassDeclaration} descriptor - Registry descriptor.
+ * @param {import("../semantic/types.js").SemanticExport | undefined} exported - Matching export evidence.
+ * @returns {void}
+ */
+function validateParsedFacadeClass(facade, module, descriptor, exported) {
+    const parsed = exported?.symbolKind == "class"
+        ? module.classes?.find(({ id }) => id == exported.declarationId) : undefined;
+    const failureNames = new Map((module.capabilities ?? []).flatMap(({ failures }) => failures.map(({ id, name }) => [id, name])));
+    const constructorFailures = parsed?.constructor.failureIds?.map((id) => failureNames.get(id)) ?? [];
+    const constructorMatches = parsed?.name == descriptor.name && parsed.ownership?.kind == "ownedResource" &&
+        parsed.constructor.effects?.join(",") == descriptor.constructor.effects.join(",") &&
+        constructorFailures.join(",") == descriptor.constructor.failures.join(",") &&
+        parsed.constructor.parameters.length == descriptor.constructor.parameters.length &&
+        parsed.constructor.parameters.every((parameter, index) => parameter.name == descriptor.constructor.parameters[index].name &&
+            semanticTypeName(parameter.type) == descriptor.constructor.parameters[index].type);
+    const methodsMatch = parsed?.methods.length == descriptor.methods.length && descriptor.methods.every((expected, index) => {
+        const method = parsed?.methods[index];
+        const actualFailures = method?.failureIds?.map((id) => failureNames.get(id)) ?? [];
+        const operation = method?.body.statements.flatMap((statement) => {
+            const expression = statement.kind == "ExpressionStatement" || statement.kind == "ReturnStatement"
+                ? statement.expression : statement.kind == "LocalDeclaration" ? statement.initializer : undefined;
+            return expression?.kind == "EffectCallExpression" ? [expression] : [];
+        })[0];
+        const flow = operation?.resolution.resourceFlow;
+        const terminalFailureId = flow?.kind == "borrow" || flow?.kind == "close" ? flow.terminalFailureId : undefined;
+        if (terminalFailureId)
+            actualFailures.push(failureNames.get(terminalFailureId));
+        return method?.name == expected.name && method.effects?.join(",") == expected.effects.join(",") &&
+            actualFailures.join(",") == expected.failures.join(",") && method.parameters.length == expected.parameters.length &&
+            method.parameters.every((parameter, parameterIndex) => parameter.name == expected.parameters[parameterIndex].name &&
+                semanticTypeName(parameter.type) == expected.parameters[parameterIndex].type) &&
+            semanticTypeName(method.returnType) == expected.returnType;
+    });
+    if (!constructorMatches || !methodsMatch) {
+        facadeFailure(facade.language, "STDLIB_FACADE_DECLARATION_MISMATCH", `Facade '${facade.identity}' executable source does not match public class '${descriptor.name}'.`, parsed?.location ?? module.location);
+    }
+}
+/**
+ * Collects canonical operation names reached in one facade module.
+ * @param {import("../semantic/types.js").SemanticProgramModule} module - Parsed facade module.
+ * @param {Map<string, string>} operationNames - Canonical names by operation identity.
+ * @returns {Set<string>} Used operation names.
+ */
+function collectEffectOperations(module, operationNames) {
+    const used = new Set();
+    const seen = new WeakSet();
+    /**
+     * Visits one semantic subtree without following authority or provenance graphs.
+     * @param {unknown} value - Semantic subtree.
+     * @returns {void}
+     */
+    function visit(value) {
+        if (!value || typeof value != "object" || seen.has(value))
+            return;
+        seen.add(value);
+        if (!Array.isArray(value) && Reflect.get(value, "kind") == "EffectCallExpression") {
+            const name = operationNames.get(Reflect.get(value, "operation"));
+            if (name)
+                used.add(name);
+        }
+        for (const [key, child] of Object.entries(value)) {
+            if (key != "capabilities" && key != "location" && key != "provenance" && key != "sourceProvenance")
+                visit(child);
+        }
+    }
+    visit(module);
+    return used;
+}
+/**
+ * Converts one parsed semantic type to the facade declaration vocabulary.
+ * @param {import("../semantic/types.js").SemanticFunctionReturnType} type - Parsed type.
+ * @returns {string} Closed canonical public type name.
+ */
+function semanticTypeName(type) {
+    if (type.kind == "TypeReference")
+        return type.name;
+    return type.kind == "OptionalType" && type.valueType.kind == "TypeReference"
+        ? `optional:${type.valueType.name}` : "unsupported";
+}
+/**
+ * Throws one stable located facade diagnostic.
+ * @param {string} language - Source language.
+ * @param {string} code - Stable diagnostic code.
+ * @param {string} message - Diagnostic detail.
+ * @param {import("../semantic/types.js").SourceLocation | undefined} location - Parser-owned location.
+ * @returns {never} Always throws.
+ */
+function facadeFailure(language, code, message, location) {
+    throw new SemantifoldDiagnostic({ code, language, location, message });
+}
+/**
+ * Rejects source-profile identities whose lookup or reopening would depend on caller order.
+ * @param {ProgramSource[]} sources - Complete validated source set.
+ * @param {Map<string, ProgramHeader>} headers - Parser-owned module headers.
+ * @returns {void}
+ */
+function validateNativeModuleIdentities(sources, headers) {
+    if (!sources.every(({ language }) => language == "java") && !sources.every(({ language }) => language == "ruby"))
+        return;
+    const ordered = [...sources].sort((left, right) => left.filename.localeCompare(right.filename, "en-US") ||
+        left.id.localeCompare(right.id, "en-US"));
+    const owners = new Map();
+    for (const source of ordered) {
+        const nativeName = requiredMapValue(headers, source.id).nativeName;
+        if (!nativeName)
+            continue;
+        const earlier = owners.get(nativeName);
+        if (earlier) {
+            const label = source.language == "java" ? "Java" : "Ruby";
+            semanticFailure(source.language, "DUPLICATE_MODULE", `Duplicate ${label} native module identity '${nativeName}' in '${earlier.filename}' and '${source.filename}'.`, moduleLocation(source.filename, source.source));
+        }
+        owners.set(nativeName, source);
+    }
+}
+/**
+ * Validates and snapshots one caller-supplied program source descriptor.
+ * @param {unknown} candidate - Candidate source descriptor.
+ * @param {number} index - Source index.
+ * @returns {ProgramSource} Validated source descriptor.
+ */
+function validateSource(candidate, index) {
+    if (!isPlainObject(candidate)) {
+        return invalidProgram(`Program source ${index} requires a stable module ID, safe filename, language, and source text.`);
+    }
+    if (!isPlainObject(candidate) || typeof candidate.id != "string" || !moduleIdPattern.test(candidate.id) ||
+        typeof candidate.filename != "string" || !isSafeSourcePath(candidate.filename) ||
+        typeof candidate.source != "string" || typeof candidate.language != "string") {
+        invalidProgram(`Program source ${index} requires a stable module ID, safe filename, language, and source text.`);
+    }
+    languageRegistry.record(candidate.language);
+    if (!programLanguages.has(candidate.language))
+        unsupportedRole(candidate.language, "multi-file frontend");
+    return /** @type {ProgramSource} */ ({
+        filename: candidate.filename,
+        id: candidate.id,
+        language: candidate.language,
+        ownership: "application",
+        source: candidate.source
+    });
+}
+/**
+ * Dispatches parser-owned module header inspection for one cohort source.
+ * @param {{filename: string, language: import("../semantic/types.js").SemanticLanguage, source: string}} source - Validated source.
+ * @returns {ProgramHeader} Parser-owned import/export header.
+ */
+function inspectSource(source) {
+    if (source.language == "javascript" || source.language == "typescript") {
+        return inspectJavaScriptTypeScriptModule(/** @type {{filename: string, language: "javascript" | "typescript", source: string}} */ (source));
+    }
+    if (source.language == "ruby") {
+        return inspectRubyModule(/** @type {{filename: string, language: "ruby", source: string}} */ (source));
+    }
+    if (source.language == "php") {
+        return inspectPhpModule(/** @type {{filename: string, language: "php", source: string}} */ (source));
+    }
+    if (source.language == "java") {
+        return inspectJavaModule(/** @type {{filename: string, language: "java", source: string}} */ (source));
+    }
+    return unsupportedRole(source.language, "multi-file frontend");
+}
+/**
+ * Resolves only an explicit relative ESM specifier against caller-supplied filenames.
+ * @param {{filename: string, language: import("../semantic/types.js").SemanticLanguage}} source - Importing source.
+ * @param {string} specifier - Parser-owned relative specifier.
+ * @param {import("../semantic/types.js").SourceLocation} location - Specifier location.
+ * @param {Map<string, ProgramSource>} sources - Sources by exact filename.
+ * @param {Map<string, ProgramHeader>} headers - Parser-owned module headers.
+ * @returns {string} Resolved module identity.
+ */
+function resolveImportModule(source, specifier, location, sources, headers) {
+    if (source.language == "java") {
+        const matched = [...headers.entries()].find(([, header]) => header.nativeName == specifier);
+        if (!matched)
+            semanticFailure(source.language, "UNRESOLVED_MODULE", `Import '${specifier}' does not identify a supplied source.`, location);
+        return matched[0];
+    }
+    const directory = source.filename.split("/").slice(0, -1);
+    const parts = [...directory];
+    for (const part of specifier.split("/")) {
+        if (part == "" || part == ".")
+            continue;
+        if (part == "..") {
+            if (parts.length == 0)
+                semanticFailure(source.language, "UNSAFE_MODULE_PATH", `Import '${specifier}' escapes the supplied source root.`, location);
+            parts.pop();
+        }
+        else
+            parts.push(part);
+    }
+    let exact = parts.join("/");
+    if (source.language == "ruby" && !exact.endsWith(".rb"))
+        exact += ".rb";
+    const candidates = [exact];
+    if (source.language == "typescript" && exact.endsWith(".js"))
+        candidates.push(`${exact.slice(0, -3)}.ts`);
+    const matched = candidates.flatMap((filename) => sources.has(filename) ? [sources.get(filename)] : [])[0];
+    if (!matched)
+        semanticFailure(source.language, "UNRESOLVED_MODULE", `Import '${specifier}' does not identify a supplied source.`, location);
+    return matched.id;
+}
+/**
+ * Builds the source-profile spelling used to resolve one namespace-qualified import.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Importing source language.
+ * @param {string | undefined} nativeName - Dependency namespace/module name.
+ * @param {import("../semantic/types.js").SemanticExport} exported - Imported export.
+ * @returns {string} Source-profile binding spelling.
+ */
+function qualifiedImportName(language, nativeName, exported) {
+    if (!nativeName)
+        throw new Error("Namespace import dependency has no parser-owned native name.");
+    if (language == "ruby")
+        return `${nativeName}${exported.symbolKind == "function" ? "." : "::"}${exported.exportedName}`;
+    if (language == "java") {
+        const className = nativeName.split(".").at(-1);
+        if (!className)
+            throw new Error("Java import dependency has no class name.");
+        return exported.symbolKind == "function" ? `${className}.${exported.exportedName}` : className;
+    }
+    throw new Error(`Unsupported namespace import profile '${language}'.`);
+}
+/**
+ * Sorts the explicit module graph in stable dependency-first order.
+ * @param {ProgramSource[]} sources - Validated sources.
+ * @param {Map<string, {source: ProgramSource, requests: {moduleId: string, location: import("../semantic/types.js").SourceLocation}[]}>} graph - Resolved graph.
+ * @returns {string[]} Dependency-first module identities.
+ */
+function topologicalOrder(sources, graph) {
+    const complete = new Set();
+    const active = new Set();
+    /** @type {string[]} */
+    const result = [];
+    /**
+     * Visits one module and its dependencies.
+     * @param {string} id - Module identity.
+     */
+    function visit(id) {
+        if (complete.has(id))
+            return;
+        if (active.has(id)) {
+            const edge = requiredMapValue(graph, id).requests[0];
+            semanticFailure(requiredMapValue(graph, id).source.language, "IMPORT_CYCLE", `Import cycle includes module '${id}'.`, edge?.location);
+        }
+        active.add(id);
+        for (const request of requiredMapValue(graph, id).requests)
+            visit(request.moduleId);
+        active.delete(id);
+        complete.add(id);
+        result.push(id);
+    }
+    for (const source of sources)
+        visit(source.id);
+    return result;
+}
+/**
+ * Looks up one already-resolved exported declaration.
+ * @param {import("../semantic/types.js").SemanticProgramModule} module - Exporting module.
+ * @param {import("../semantic/types.js").SemanticExport} exported - Resolved export.
+ * @returns {import("../semantic/types.js").FunctionDeclaration | import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").ErrorDeclaration} Declaration.
+ */
+function declarationFor(module, exported) {
+    const declarations = exported.symbolKind == "function" ? module.functions :
+        exported.symbolKind == "record" ? module.records ?? [] : exported.symbolKind == "class" ? module.classes ?? [] : module.errors ?? [];
+    const declaration = declarations.find(({ id }) => id == exported.declarationId);
+    if (!declaration)
+        throw new Error(`Resolved export '${exported.declarationId}' has no declaration.`);
+    return declaration;
+}
+/**
+ * Prefixes module-owned declaration identities and explicit resolved references to them.
+ * @param {import("../semantic/types.js").SemanticModule} module - Validated module.
+ * @param {string} moduleId - Stable module identity.
+ * @returns {void}
+ */
+function rekeyDeclarations(module, moduleId) {
+    const replacements = new Map();
+    for (const declaration of module.classes ?? []) {
+        replacements.set(declaration.id, `${moduleId}#${declaration.id}`);
+        replacements.set(declaration.constructor.id, `${moduleId}#${declaration.constructor.id}`);
+        for (const field of declaration.fields)
+            replacements.set(field.id, `${moduleId}#${field.id}`);
+        for (const method of declaration.methods)
+            replacements.set(method.id, `${moduleId}#${method.id}`);
+    }
+    for (const declaration of module.records ?? []) {
+        replacements.set(declaration.id, `${moduleId}#${declaration.id}`);
+        for (const parameter of declaration.typeParameters ?? []) {
+            if (parameter.id)
+                replacements.set(parameter.id, `${moduleId}#${parameter.id}`);
+        }
+        for (const field of declaration.fields)
+            replacements.set(field.id, `${moduleId}#${field.id}`);
+    }
+    for (const declaration of module.errors ?? [])
+        replacements.set(declaration.id, `${moduleId}#${declaration.id}`);
+    for (const declaration of module.functions) {
+        replacements.set(declaration.id, `${moduleId}#${declaration.id}`);
+        for (const parameter of declaration.typeParameters ?? []) {
+            if (parameter.id)
+                replacements.set(parameter.id, `${moduleId}#${parameter.id}`);
+        }
+    }
+    for (const declaration of module.records ?? []) {
+        declaration.id = replacements.get(declaration.id);
+        for (const parameter of declaration.typeParameters ?? []) {
+            parameter.id = /** @type {string} */ (replacements.get(/** @type {string} */ (parameter.id)));
+        }
+        for (const field of declaration.fields)
+            field.id = /** @type {string} */ (replacements.get(field.id));
+    }
+    for (const declaration of module.errors ?? [])
+        declaration.id = replacements.get(declaration.id);
+    for (const declaration of module.classes ?? []) {
+        declaration.id = replacements.get(declaration.id);
+        declaration.constructor.id = replacements.get(declaration.constructor.id);
+        for (const field of declaration.fields)
+            field.id = replacements.get(field.id);
+        for (const method of declaration.methods)
+            method.id = replacements.get(method.id);
+        if (declaration.ownership?.kind == "ownedResource") {
+            declaration.ownership.fieldId = /** @type {string} */ (replacements.get(declaration.ownership.fieldId));
+        }
+    }
+    for (const declaration of module.functions) {
+        declaration.id = replacements.get(declaration.id);
+        for (const parameter of declaration.typeParameters ?? []) {
+            parameter.id = /** @type {string} */ (replacements.get(/** @type {string} */ (parameter.id)));
+        }
+    }
+    const seen = new WeakSet();
+    /**
+     * Rewrites only typed identity-bearing fields throughout one semantic subtree.
+     * @param {unknown} value - Semantic subtree.
+     */
+    function visit(value) {
+        if (!value || typeof value != "object" || seen.has(value))
+            return;
+        seen.add(value);
+        const object = /** @type {Record<string, unknown>} */ (value);
+        if ((object.kind == "RecordType" || object.kind == "ReferenceType" || object.kind == "OwnedReferenceType" ||
+            object.kind == "ErrorType" || object.kind == "ResolvedFunctionSignature" ||
+            object.kind == "ResolvedConstructorSignature" || object.kind == "ResolvedMethodSignature") &&
+            typeof object.declarationId == "string" && replacements.has(object.declarationId)) {
+            object.declarationId = replacements.get(object.declarationId);
+        }
+        if ((object.kind == "MemberRead" || object.kind == "PrivateFieldRead" || object.kind == "PrivateFieldWriteStatement") &&
+            typeof object.field == "string" && replacements.has(object.field)) {
+            object.field = replacements.get(object.field);
+        }
+        if (object.kind == "MethodCallExpression" && typeof object.method == "string" && replacements.has(object.method)) {
+            object.method = replacements.get(object.method);
+        }
+        if (object.kind == "ReceiverExpression" && typeof object.classId == "string" && replacements.has(object.classId)) {
+            object.classId = replacements.get(object.classId);
+        }
+        if (object.kind == "TypeVariableReference" && typeof object.parameterId == "string" && replacements.has(object.parameterId)) {
+            object.parameterId = replacements.get(object.parameterId);
+        }
+        for (const child of Object.values(object))
+            if (typeof child == "object")
+                visit(child);
+    }
+    visit(module);
+}
+/**
+ * Creates a source association for a parser-owned module header node.
+ * @param {import("../semantic/types.js").SourceLocation} location - Node origin.
+ * @param {Readonly<Record<string, import("../semantic/types.js").SourceLocation>>} ranges - Exact available header roles.
+ * @param {string} sourceId - Program-wide source identity.
+ * @returns {import("../semantic/types.js").SemanticNodeSourceProvenance} Source association.
+ */
+function sourceAssociation(location, ranges, sourceId) {
+    return {
+        origin: { kind: "source", location, sourceId },
+        ranges,
+        schema: "SemantifoldNodeProvenance",
+        version: 1
+    };
+}
+/**
+ * Rebinds one parser-local provenance registry to the complete program source registry.
+ * @param {import("../semantic/types.js").SemanticModule} module - Newly parsed module.
+ * @param {import("../semantic/types.js").RegisteredSource[]} sources - Program-wide registry.
+ * @param {string} sourceId - Owning source identity.
+ * @returns {void}
+ */
+function rebaseParsedModuleProvenance(module, sources, sourceId) {
+    if (!module.provenance)
+        throw new Error("Parsed program module has no source provenance.");
+    const seen = new WeakSet();
+    /**
+     * Rebinds source-origin identities throughout one semantic subtree.
+     * @param {unknown} value - Semantic subtree.
+     */
+    function visit(value) {
+        if (!value || typeof value != "object" || seen.has(value))
+            return;
+        seen.add(value);
+        const candidate = /** @type {Record<string, unknown>} */ (value);
+        const provenance = candidate.sourceProvenance;
+        const origin = isPlainObject(provenance) ? provenance.origin : undefined;
+        if (isPlainObject(origin) && origin.kind == "source")
+            origin.sourceId = sourceId;
+        for (const child of Object.values(candidate))
+            visit(child);
+    }
+    visit(module);
+    for (const node of module.provenance.nodes) {
+        if (node.origin.kind == "source")
+            node.origin.sourceId = sourceId;
+    }
+    module.provenance.sources = sources;
+}
+/**
+ * Reports whether a candidate is a direct plain object.
+ * @param {unknown} value - Candidate object.
+ * @returns {value is Record<string, unknown>} Whether the value is a plain object.
+ */
+function isPlainObject(value) {
+    return Boolean(value) && typeof value == "object" && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype;
+}
+/**
+ * Reads a value whose map key was validated earlier in program assembly.
+ * @template T
+ * @param {Map<string, T>} map - Map with a previously validated key.
+ * @param {string} key - Required key.
+ * @returns {T} Stored value.
+ */
+function requiredMapValue(map, key) {
+    const value = map.get(key);
+    if (value === undefined)
+        throw new Error(`Missing validated map value '${key}'.`);
+    return value;
+}
+/**
+ * Raises a stable malformed program request diagnostic.
+ * @param {string} message - Stable request failure detail.
+ * @returns {never} Always throws.
+ */
+function invalidProgram(message) {
+    throw new SemantifoldDiagnostic({ code: "INVALID_PROGRAM", language: "program", message });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"program.js","sourceRoot":"","sources":["../../../src/frontends/program.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {isDenseArray} from \"../array.js\"\nimport {isSafeSourcePath} from \"../artifact-path.js\"\nimport {SemantifoldDiagnostic, semanticFailure, unsupportedCapability, unsupportedRole} from \"../diagnostic.js\"\nimport {languageRegistry} from \"../language-registry.js\"\nimport {normalizeCapabilityAuthority} from \"../semantic/capabilities.js\"\nimport {moduleLocation} from \"../semantic/location.js\"\nimport {annotateParsedModule} from \"../semantic/provenance.js\"\nimport {moduleUncheckedErrorEffects, validateParsedModule} from \"../semantic/validate.js\"\nimport {\n  facadeCapabilityAuthority, resolveStdlibFacadeClosure, stdlibFacadeProgramDescriptor, stdlibFacadeRegistry\n} from \"../stdlib-facades.js\"\nimport {inspectJavaScriptTypeScriptModule} from \"./javascript-typescript.js\"\nimport {inspectJavaModule} from \"./java.js\"\nimport {inspectPhpModule} from \"./php.js\"\nimport {inspectRubyModule} from \"./ruby.js\"\n\nconst programLanguages = new Set([\"php\", \"ruby\", \"javascript\", \"typescript\", \"java\"])\nconst moduleIdPattern = /^[a-z][a-z0-9_]*(?:[.-][a-z][a-z0-9_]*)*$/u\n\n/** @typedef {{facade?: import(\"../stdlib-facades.js\").StdlibFacadeRecord, filename: string, id: string, language: import(\"../semantic/types.js\").SemanticLanguage, ownership: \"application\" | \"facade\", source: string}} ProgramSource */\n/** @typedef {{declarationLocation?: import(\"../semantic/types.js\").SourceLocation, facade?: import(\"../stdlib-facades.js\").StdlibFacadeRecord, importedName: string, importedNameLocation?: import(\"../semantic/types.js\").SourceLocation, localName: string, localNameLocation?: import(\"../semantic/types.js\").SourceLocation, location: import(\"../semantic/types.js\").SourceLocation, namespace?: boolean, pathLocation: import(\"../semantic/types.js\").SourceLocation, specifier: string, stdlibCandidate?: true, typeOnly: boolean}} ProgramImportRequest */\n/** @typedef {{importedName: string, localName: string, location: import(\"../semantic/types.js\").SourceLocation, nativeName: string, symbolKind: import(\"../semantic/types.js\").SemanticDeclarationKind, typeOnly: boolean}} ProgramNativeBinding */\n/** @typedef {{imports: ProgramImportRequest[], exports: {declarationLocation?: import(\"../semantic/types.js\").SourceLocation, exportedName: string, exportedNameLocation?: import(\"../semantic/types.js\").SourceLocation, localName: string, localNameLocation?: import(\"../semantic/types.js\").SourceLocation, location: import(\"../semantic/types.js\").SourceLocation, symbolKind?: import(\"../semantic/types.js\").SemanticDeclarationKind, typeOnly: boolean}[], bindings?: ProgramNativeBinding[], nativeName?: string, nativeReferences?: {form: \"constructor-call\" | \"receiver-call\" | \"unqualified-call\", location: import(\"../semantic/types.js\").SourceLocation, nativeModule: string, symbol: string}[]}} ProgramHeader */\n\n/**\n * Parses an explicit caller-supplied multi-source program without filesystem discovery.\n * @param {object} input - Program parse request.\n * @param {string} input.entryModule - Sole entry module identity.\n * @param {{filename: string, id: string, language: import(\"../semantic/types.js\").SemanticLanguage, source: string}[]} input.sources - Complete source set.\n * @param {Readonly<import(\"../semantic/types.js\").CapabilityAuthority> | import(\"../semantic/types.js\").CapabilityAuthorityInput} [input.capabilityAuthority] - Explicit compiler authority.\n * @returns {import(\"../semantic/types.js\").SemanticProgram} Resolved semantic program.\n */\nexport function parseProgramSource(input) {\n  if (!isPlainObject(input) || !isDenseArray(input.sources) || input.sources.length == 0 ||\n    typeof input.entryModule != \"string\") invalidProgram(\"Program parsing requires a non-empty ordered source set and entry module.\")\n\n  const applicationSources = input.sources.map((source, index) => validateSource(source, index))\n  const requestedAuthority = normalizeCapabilityAuthority(input.capabilityAuthority)\n  const sourceLanguages = new Set(applicationSources.map(({language}) => language))\n\n  if (sourceLanguages.size != 1) {\n    semanticFailure(applicationSources[0].language, \"MIXED_SOURCE_LANGUAGES\", \"A semantic program must use one source-language compatibility profile.\", undefined)\n  }\n  if (requestedAuthority && !languageRegistry.record(applicationSources[0].language).features.effectfulCapabilitiesAndResources) {\n    unsupportedCapability(applicationSources[0].language, \"Task 034 effectful capabilities and owned resources\",\n      moduleLocation(applicationSources[0].filename, applicationSources[0].source))\n  }\n  const byId = new Map()\n  const byFilename = new Map()\n\n  for (const source of applicationSources) {\n    if (byId.has(source.id)) semanticFailure(source.language, \"DUPLICATE_MODULE\", `Duplicate module identity '${source.id}'.`, undefined)\n    if (byFilename.has(source.filename)) semanticFailure(source.language, \"DUPLICATE_MODULE\", `Duplicate module filename '${source.filename}'.`, undefined)\n    byId.set(source.id, source)\n    byFilename.set(source.filename, source)\n  }\n  if (!byId.has(input.entryModule)) {\n    semanticFailure(applicationSources[0].language, \"INVALID_ENTRY_MODULE\", `Unknown entry module '${input.entryModule}'.`, undefined)\n  }\n\n  const headers = new Map(applicationSources.map((source) => [source.id, inspectSource(source)]))\n  const facadeRoots = resolveFacadeImports(applicationSources, headers)\n  const facadeRecords = resolveStdlibFacadeClosure(facadeRoots)\n\n  if (facadeRecords.length > 0 && requestedAuthority) {\n    const located = applicationSources.flatMap((source) => requiredMapValue(headers, source.id).imports)\n      .find(({facade}) => facade)?.location\n\n    facadeFailure(applicationSources[0].language, \"STDLIB_FACADE_AUTHORITY_FORGED\",\n      \"Programs resolved through compiler-owned facades cannot supply their own canonical capability authority.\", located)\n  }\n  const facadeAuthority = facadeCapabilityAuthority(facadeRecords)\n  const authority = requestedAuthority ?? (facadeAuthority ? normalizeCapabilityAuthority(facadeAuthority.input) : undefined)\n  const facadeSources = facadeRecords.map((facade) => /** @type {ProgramSource} */ ({\n    facade,\n    filename: facade.source.filename,\n    id: facade.source.id,\n    language: facade.language,\n    ownership: \"facade\",\n    source: facade.source.content\n  }))\n\n  validateFacadeCollisions(applicationSources, headers, facadeSources)\n  const sources = [...applicationSources, ...facadeSources]\n\n  for (const source of facadeSources) {\n    byId.set(source.id, source)\n    byFilename.set(source.filename, source)\n    headers.set(source.id, inspectSource(source))\n  }\n  const registeredSources = sources.map((source, index) => ({\n    content: source.source,\n    filename: source.filename,\n    id: `source:${index}`,\n    language: source.language,\n    ownership: source.ownership\n  }))\n  const sourceIds = new Map(sources.map((source, index) => [source.id, `source:${index}`]))\n\n  validateNativeModuleIdentities(sources, headers)\n  /** @type {Map<string, {source: typeof sources[number], requests: (ReturnType<typeof inspectSource>[\"imports\"][number] & {moduleId: string})[]}>} */\n  const graph = new Map()\n\n  for (const source of sources) {\n    const requests = requiredMapValue(headers, source.id).imports.map((request) => ({\n      ...request,\n      moduleId: request.facade?.source.id ?? resolveImportModule(source, request.specifier, request.pathLocation, byFilename, headers)\n    }))\n\n    graph.set(source.id, {requests, source})\n  }\n  const orderedIds = topologicalOrder(sources, graph)\n  /** @type {Map<string, import(\"../semantic/types.js\").SemanticProgramModule>} */\n  const parsed = new Map()\n  /** @type {Map<string, Set<string>>} */\n  const callEffectsByDeclarationId = new Map()\n\n  for (const moduleId of orderedIds) {\n    const {requests, source} = requiredMapValue(graph, moduleId)\n    const sourceId = /** @type {string} */ (sourceIds.get(source.id))\n    const header = requiredMapValue(headers, moduleId)\n    const localNames = new Set()\n    const visibleFunctions = new Map()\n    const visibleCallEffects = new Map()\n    const visibleRecordsByName = new Map()\n    const visibleValueRecordsByName = new Map()\n    const visibleRecordsById = new Map()\n    const visibleClassesByName = new Map()\n    const visibleClassesById = new Map()\n    const visibleErrorsByName = new Map()\n    const visibleErrorsById = new Map()\n    const consumedBindings = new Set()\n    /** @type {import(\"../semantic/types.js\").SemanticImport[]} */\n    const imports = []\n\n    if (!source.facade && authority) {\n      const failureNames = new Set(header.imports.filter(({facade}) => facade).flatMap(({facade}) =>\n        facade?.publicDeclarations.flatMap((declaration) => declaration.kind == \"function\"\n          ? declaration.failures\n          : [...declaration.constructor.failures, ...declaration.methods.flatMap(({failures}) => failures)]) ?? []))\n\n      for (const failure of authority.capabilities.flatMap(({failures}) => failures)) {\n        if (!failureNames.has(failure.name)) continue\n        const declaration = /** @type {import(\"../semantic/types.js\").ErrorDeclaration} */ (/** @type {unknown} */ (failure))\n\n        visibleErrorsByName.set(failure.name, declaration)\n        visibleErrorsById.set(failure.id, declaration)\n      }\n    }\n\n    for (const request of requests) {\n      const dependency = parsed.get(request.moduleId)\n\n      if (!dependency) {\n        throw new Error(`Dependency '${request.moduleId}' was not parsed before '${source.id}'.`)\n      }\n      const dependencyHeader = requiredMapValue(headers, request.moduleId)\n      const nativeBindingPrefix = request.facade?.nativeModules.find(({identity}) => identity == request.specifier)?.identity ??\n        dependencyHeader.nativeName\n      const nativeBindings = source.language == \"php\" && request.namespace\n        ? (header.bindings ?? []).filter(({nativeName}) => nativeName.startsWith(`${nativeBindingPrefix}\\\\`))\n        : []\n      const selectedExports = request.namespace && source.language == \"php\"\n        ? dependency.exports.filter(({exportedName}) => nativeBindings.some(({importedName}) => importedName == exportedName))\n        : request.namespace\n          ? dependency.exports\n        : dependency.exports.filter(({exportedName}) => exportedName == request.importedName)\n\n      if (selectedExports.length == 0) {\n        semanticFailure(source.language, \"UNRESOLVED_IMPORT\", request.namespace\n          ? `Imported module '${request.moduleId}' has no explicitly bound exports.`\n          : `Module '${request.moduleId}' does not export '${request.importedName}'.`, request.location)\n      }\n      for (const exported of selectedExports) {\n        const nativeBinding = nativeBindings.find(({importedName}) => importedName == exported.exportedName)\n        const localName = nativeBinding?.localName ?? (request.namespace\n          ? qualifiedImportName(source.language, dependencyHeader.nativeName, exported)\n          : request.localName\n        )\n        const importLocation = nativeBinding?.location ?? request.location\n\n        if (localNames.has(localName)) {\n          semanticFailure(source.language, \"DUPLICATE_IMPORT_BINDING\", `Duplicate import binding '${localName}'.`, importLocation)\n        }\n        localNames.add(localName)\n        if (nativeBinding && nativeBinding.symbolKind != exported.symbolKind &&\n          !(nativeBinding.symbolKind == \"record\" && exported.symbolKind == \"error\")) {\n          semanticFailure(source.language, \"IMPORT_KIND_MISMATCH\", `Import '${nativeBinding.importedName}' has the wrong declaration kind.`, importLocation)\n        }\n        if (request.typeOnly && exported.symbolKind != \"record\") {\n          semanticFailure(source.language, \"IMPORT_KIND_MISMATCH\", `Type import '${request.importedName}' does not name a record.`, importLocation)\n        }\n        if (nativeBinding) consumedBindings.add(nativeBinding)\n        const declaration = declarationFor(dependency, exported)\n        const typeOnly = nativeBinding?.typeOnly ?? request.typeOnly\n\n        if (exported.symbolKind == \"function\") {\n          visibleFunctions.set(localName, /** @type {import(\"../semantic/types.js\").FunctionDeclaration} */ (declaration))\n          visibleCallEffects.set(localName, new Set(callEffectsByDeclarationId.get(exported.declarationId) ?? []))\n        }\n        else if (exported.symbolKind == \"record\") {\n          const record = /** @type {import(\"../semantic/types.js\").RecordDeclaration} */ (declaration)\n\n          visibleRecordsByName.set(localName, record)\n          if (!typeOnly) visibleValueRecordsByName.set(localName, record)\n          visibleRecordsById.set(/** @type {string} */ (record.id), record)\n        } else if (exported.symbolKind == \"class\") {\n          const declaration = /** @type {import(\"../semantic/types.js\").ClassDeclaration} */ (declarationFor(dependency, exported))\n\n          visibleClassesByName.set(localName, declaration)\n          visibleClassesById.set(/** @type {string} */ (declaration.id), declaration)\n        } else {\n          const error = /** @type {import(\"../semantic/types.js\").ErrorDeclaration} */ (declaration)\n\n          visibleErrorsByName.set(localName, error)\n          visibleErrorsById.set(/** @type {string} */ (error.id), error)\n        }\n        /** @type {Record<string, import(\"../semantic/types.js\").SourceLocation>} */\n        const ranges = {\n          declaration: request.declarationLocation ?? request.location,\n          path: request.pathLocation\n        }\n\n        if (!request.namespace || nativeBinding || request.facade) {\n          ranges.importedName = nativeBinding?.location ?? request.importedNameLocation ?? importLocation\n          ranges.localName = nativeBinding?.location ?? request.localNameLocation ?? importLocation\n        }\n\n        imports.push({\n          declarationId: exported.declarationId,\n          importedName: exported.exportedName,\n          kind: \"Import\",\n          localName,\n          location: importLocation,\n          moduleId: request.moduleId,\n          ...(request.facade ? {stdlibFacade: {\n            facadeIdentity: request.facade.identity,\n            facadeVersion: request.facade.version,\n            nativeModule: request.specifier,\n            nativeSymbol: exported.exportedName,\n            schema: /** @type {const} */ (\"SemantifoldStdlibFacadeResolution\"),\n            version: /** @type {const} */ (1)\n          }} : {}),\n          sourceProvenance: sourceAssociation(importLocation, ranges, sourceId),\n          symbolKind: exported.symbolKind,\n          typeOnly\n        })\n      }\n    }\n    const unconsumedBinding = (header.bindings ?? []).find((binding) => !consumedBindings.has(binding))\n\n    if (unconsumedBinding) {\n      semanticFailure(source.language, \"UNRESOLVED_IMPORT\", `Native import '${unconsumedBinding.nativeName}' has no matching required module.`, unconsumedBinding.location)\n    }\n\n    const frontend = /** @type {(input: object) => import(\"../semantic/types.js\").SemanticModule} */ (\n      languageRegistry.resolve(source.language, \"frontend\"))\n    const facadeModules = new Set(source.facade?.requirements.map(({module}) => module) ?? [])\n    const moduleCapabilities = requestedAuthority?.capabilities ?? (source.facade?.requirements.length\n      ? authority?.modules?.filter(({identity}) => facadeModules.has(identity)).flatMap(({capabilities}) => capabilities) ??\n        authority?.capabilities\n      : undefined)\n    const raw = frontend({\n      capabilities: moduleCapabilities,\n      filename: source.filename,\n      language: source.language,\n      program: {\n        classes: visibleClassesByName,\n        functions: visibleFunctions,\n        isEntry: source.id == input.entryModule,\n        errors: visibleErrorsByName,\n        records: visibleRecordsByName,\n        valueRecords: visibleValueRecordsByName\n      },\n      source: source.source\n    })\n\n    if (moduleCapabilities) raw.capabilities = /** @type {import(\"../semantic/types.js\").EffectCapabilityDeclaration[]} */ (moduleCapabilities)\n    if ((raw.classes?.length ?? 0) > 0 && !source.facade?.publicDeclarations.some(({kind}) => kind == \"class\")) {\n      semanticFailure(source.language, \"UNSUPPORTED_SYNTAX\",\n        \"Task 033 reference classes are not supported by the Task 010 semantic program profile.\",\n        raw.classes?.[0]?.location ?? raw.location)\n    }\n\n    if (source.id == input.entryModule && raw.entryPoint.body.statements.length == 0) {\n      semanticFailure(source.language, \"INVALID_ENTRY_MODULE\", `Selected entry module '${source.id}' has no executable statements.`, raw.entryPoint.location)\n    }\n    try {\n      validateParsedModule(raw, source.language, {\n        callEffects: visibleCallEffects,\n        errors: visibleErrorsById,\n        functions: visibleFunctions,\n        records: visibleRecordsById,\n        classes: visibleClassesById\n      })\n    } catch (error) {\n      const task037 = source.language == \"ruby\" && header.imports.some(({facade}) => facade?.identity.startsWith(\"semantifold.task037.\"))\n\n      if (task037 && error instanceof SemantifoldDiagnostic && error.code == \"UNKNOWN_METHOD\" &&\n        error.detail.startsWith(\"Class 'TCPSocket'\")) {\n        facadeFailure(\"ruby\", \"STDLIB_FACADE_MEMBER_UNSUPPORTED\", error.detail, error.location)\n      }\n      throw error\n    }\n    rekeyDeclarations(raw, source.id)\n    const localCallEffects = moduleUncheckedErrorEffects(raw, {callEffects: visibleCallEffects, functions: visibleFunctions})\n\n    for (const declaration of raw.functions) {\n      callEffectsByDeclarationId.set(/** @type {string} */ (declaration.id), new Set(localCallEffects.get(declaration.name) ?? []))\n    }\n    annotateParsedModule(raw, source)\n    rebaseParsedModuleProvenance(raw, registeredSources, sourceId)\n\n    /** @type {Map<string, {declaration: import(\"../semantic/types.js\").FunctionDeclaration | import(\"../semantic/types.js\").RecordDeclaration | import(\"../semantic/types.js\").ClassDeclaration | import(\"../semantic/types.js\").ErrorDeclaration, symbolKind: import(\"../semantic/types.js\").SemanticDeclarationKind}>} */\n    const declarationsByName = new Map()\n\n    for (const declaration of raw.records ?? []) declarationsByName.set(declaration.name, {declaration, symbolKind: \"record\"})\n    for (const declaration of raw.classes ?? []) declarationsByName.set(declaration.name, {declaration, symbolKind: \"class\"})\n    for (const declaration of raw.errors ?? []) declarationsByName.set(declaration.name, {declaration, symbolKind: \"error\"})\n    for (const declaration of raw.functions) declarationsByName.set(declaration.name, {declaration, symbolKind: \"function\"})\n    /** @type {import(\"../semantic/types.js\").SemanticExport[]} */\n    const exports = header.exports.map((request) => {\n      const resolved = declarationsByName.get(request.localName)\n\n      if (!resolved) semanticFailure(source.language, \"UNRESOLVED_EXPORT\", `Unknown exported declaration '${request.localName}'.`, request.location)\n      if (request.typeOnly && resolved.symbolKind != \"record\") {\n        semanticFailure(source.language, \"EXPORT_KIND_MISMATCH\", `Type export '${request.exportedName}' does not name a record.`, request.location)\n      }\n\n      return {\n        declarationId: /** @type {string} */ (resolved.declaration.id),\n        exportedName: request.exportedName,\n        kind: /** @type {const} */ (\"Export\"),\n        location: request.location,\n        sourceProvenance: sourceAssociation(request.location, {\n          declaration: request.declarationLocation ?? request.location,\n          exportedName: request.exportedNameLocation ?? request.location,\n          localName: request.localNameLocation ?? request.location\n        }, sourceId),\n        symbolKind: resolved.symbolKind\n      }\n    })\n    const exportedNames = new Set()\n\n    for (const exported of exports) {\n      if (exportedNames.has(exported.exportedName)) {\n        semanticFailure(source.language, \"DUPLICATE_EXPORT\", `Duplicate export '${exported.exportedName}'.`, exported.location)\n      }\n      exportedNames.add(exported.exportedName)\n    }\n\n    const {entryPoint, ...moduleWithoutEntry} = raw\n    const module = /** @type {import(\"../semantic/types.js\").SemanticProgramModule} */ ({\n      ...moduleWithoutEntry,\n      ...(source.id == input.entryModule ? {entryPoint} : {}),\n      exports,\n      id: source.id,\n      imports,\n      ...(source.facade ? {stdlibFacade: {identity: source.facade.identity, version: source.facade.version}} : {}),\n      sourceFilename: source.filename\n    })\n\n    if (source.facade) validateParsedFacade(source.facade, module)\n\n    parsed.set(source.id, module)\n  }\n\n  return {\n    entryModule: input.entryModule,\n    kind: \"Program\",\n    modules: orderedIds.map((id) => /** @type {import(\"../semantic/types.js\").SemanticProgramModule} */ (parsed.get(id))),\n    ...(requestedAuthority ? {\n      stdlibContract: {\n        identity: requestedAuthority.id,\n        ...(requestedAuthority.contractVersion !== undefined ? {contractVersion: requestedAuthority.contractVersion} : {})\n      }\n    } : facadeAuthority && \"contracts\" in facadeAuthority ? {stdlibContracts: facadeAuthority.contracts}\n      : facadeAuthority ? {stdlibContract: facadeAuthority.contract} : {}),\n    ...(facadeRecords.length > 0 ? {stdlibFacades: stdlibFacadeProgramDescriptor(applicationSources[0].language, facadeRecords)} : {}),\n    sources: registeredSources\n  }\n}\n\n/**\n * Resolves parser-owned native module and symbol evidence to facade roots.\n * Mutating the private header requests keeps the proof attached to the exact import node.\n * @param {ProgramSource[]} sources - Caller-owned sources.\n * @param {Map<string, ProgramHeader>} headers - Parser-owned source headers.\n * @returns {import(\"../stdlib-facades.js\").StdlibFacadeRecord[]} Selected facade roots.\n */\nfunction resolveFacadeImports(sources, headers) {\n  /** @type {import(\"../stdlib-facades.js\").StdlibFacadeRecord[]} */\n  const roots = []\n\n  for (const source of sources) {\n    const header = requiredMapValue(headers, source.id)\n\n    if (source.language == \"ruby\") resolveRubyTask037Facades(source, header, roots)\n\n    if (source.language == \"php\") {\n      for (const binding of header.bindings ?? []) {\n        const parts = binding.nativeName.split(\"\\\\\")\n        const symbol = /** @type {string} */ (parts.pop())\n        const nativeModule = parts.join(\"\\\\\")\n\n        if (!nativeModule.startsWith(\"Semantifold\\\\Task036\\\\\")) continue\n        const facade = resolveFacadeAt(source, nativeModule, symbol, binding.location)\n\n        header.imports.push({\n          declarationLocation: binding.location,\n          facade,\n          importedName: \"*\",\n          importedNameLocation: binding.location,\n          localName: \"\",\n          localNameLocation: binding.location,\n          location: binding.location,\n          namespace: true,\n          pathLocation: binding.location,\n          specifier: nativeModule,\n          stdlibCandidate: true,\n          typeOnly: false\n        })\n        roots.push(facade)\n      }\n    }\n\n    for (const request of header.imports) {\n      const javaCandidate = source.language == \"java\" && request.specifier.startsWith(\"semantifold.task036.\")\n\n      if (!request.stdlibCandidate && !javaCandidate) continue\n      if (request.facade) continue\n      if (/\\.(?:bundle|dll|node|so)$/iu.test(request.specifier)) {\n        facadeFailure(source.language, \"STDLIB_FACADE_NATIVE_EXTENSION_UNSUPPORTED\",\n          \"Native-extension loading cannot participate in a portable stdlib facade.\", request.pathLocation)\n      }\n      const supplied = [...headers.entries()].find(([, candidate]) => candidate.nativeName == request.specifier)\n\n      if (supplied) {\n        facadeFailure(source.language, \"STDLIB_FACADE_SHADOWED\",\n          `Caller-supplied module '${supplied[0]}' replaces the catalogued native facade identity '${request.specifier}'.`, request.pathLocation)\n      }\n      const facade = request.namespace\n        ? resolveFacadeModuleAt(source, request.specifier, request.pathLocation)\n        : resolveFacadeAt(source, request.specifier, request.importedName, request.importedNameLocation ?? request.location)\n\n      request.facade = facade\n      roots.push(facade)\n    }\n  }\n\n  return roots\n}\n\n/**\n * Resolves exact Task 037 Ruby references under a literal socket activation edge.\n * @param {ProgramSource} source - Importing Ruby source.\n * @param {ProgramHeader} header - Parser-owned Ruby header.\n * @param {import(\"../stdlib-facades.js\").StdlibFacadeRecord[]} roots - Selected facade roots.\n * @returns {void}\n */\nfunction resolveRubyTask037Facades(source, header, roots) {\n  const activationIndex = header.imports.findIndex(({specifier, stdlibCandidate}) => stdlibCandidate && specifier == \"socket\")\n\n  if (activationIndex < 0) return\n  const activation = /** @type {ProgramImportRequest} */ (header.imports.splice(activationIndex, 1)[0])\n  const bindings = new Set()\n\n  for (const reference of header.nativeReferences ?? []) {\n    if (reference.nativeModule != \"socket\" && reference.nativeModule != \"ruby:Kernel\") continue\n    const localName = reference.form == \"receiver-call\" ? \"Kernel.puts\" : reference.symbol\n\n    if (bindings.has(localName)) continue\n    bindings.add(localName)\n    const facade = resolveFacadeAt(source, reference.nativeModule, reference.symbol, reference.location)\n\n    header.imports.push({\n      declarationLocation: reference.location,\n      facade,\n      importedName: reference.symbol,\n      importedNameLocation: reference.location,\n      localName,\n      localNameLocation: reference.location,\n      location: reference.location,\n      pathLocation: activation.pathLocation,\n      specifier: reference.nativeModule,\n      stdlibCandidate: true,\n      typeOnly: false\n    })\n    roots.push(facade)\n  }\n}\n\n/**\n * Resolves one exact native module and symbol while preserving parser location.\n * @param {ProgramSource} source - Importing source.\n * @param {string} nativeModule - Parser-proved native module identity.\n * @param {string} symbol - Parser-proved native symbol.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Identity evidence location.\n * @returns {import(\"../stdlib-facades.js\").StdlibFacadeRecord} Located exact native facade resolution.\n */\nfunction resolveFacadeAt(source, nativeModule, symbol, location) {\n  try {\n    return stdlibFacadeRegistry.resolveFacade(source.language, nativeModule, symbol)\n  } catch (error) {\n    if (error instanceof SemantifoldDiagnostic) facadeFailure(source.language, error.code, error.detail, location)\n    throw error\n  }\n}\n\n/**\n * Resolves one exact namespace-style native module while preserving parser location.\n * @param {ProgramSource} source - Importing source.\n * @param {string} nativeModule - Parser-proved native module identity.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Identity evidence location.\n * @returns {import(\"../stdlib-facades.js\").StdlibFacadeRecord} Located exact native facade-module resolution.\n */\nfunction resolveFacadeModuleAt(source, nativeModule, location) {\n  try {\n    return stdlibFacadeRegistry.resolveModule(source.language, nativeModule)\n  } catch (error) {\n    if (error instanceof SemantifoldDiagnostic) facadeFailure(source.language, error.code, error.detail, location)\n    throw error\n  }\n}\n\n/**\n * Rejects caller capture of compiler-owned module/source/native names and imported bindings.\n * @param {ProgramSource[]} applicationSources - Caller-owned sources.\n * @param {Map<string, ProgramHeader>} headers - Caller parser headers.\n * @param {ProgramSource[]} facadeSources - Selected compiler-owned facade sources.\n * @returns {void}\n */\nfunction validateFacadeCollisions(applicationSources, headers, facadeSources) {\n  const facadeIds = new Set(facadeSources.map(({id}) => id))\n  const facadeFilenames = new Set(facadeSources.map(({filename}) => filename))\n  const facadeNativeNames = new Set(facadeSources.map((source) => inspectSource(source).nativeName).filter(Boolean))\n\n  for (const source of applicationSources) {\n    const header = requiredMapValue(headers, source.id)\n\n    if (facadeIds.has(source.id) || facadeFilenames.has(source.filename)) {\n      facadeFailure(source.language, \"STDLIB_FACADE_NAME_COLLISION\",\n        `Caller module '${source.id}' collides with a compiler-owned facade module or source path.`, moduleLocation(source.filename, source.source))\n    }\n    if (header.nativeName && facadeNativeNames.has(header.nativeName)) {\n      facadeFailure(source.language, \"STDLIB_FACADE_REOPENED\",\n        `Caller source reopens the compiler-owned facade native identity '${header.nativeName}'.`, moduleLocation(source.filename, source.source))\n    }\n    const importedBindings = new Set(header.imports.filter(({facade}) => facade && !facade.publicDeclarations.some(({name}) => name == \"\"))\n      .flatMap((request) => request.namespace && source.language == \"php\"\n        ? (header.bindings ?? []).filter(({nativeName}) => nativeName.startsWith(`${request.specifier}\\\\`)).map(({localName}) => localName)\n        : request.namespace ? [] : [request.localName]))\n    const shadowed = header.exports.find(({localName}) => importedBindings.has(localName))\n\n    if (shadowed) facadeFailure(source.language, \"STDLIB_FACADE_SHADOWED\",\n      `Local declaration '${shadowed.localName}' shadows a parser-proved stdlib facade binding.`, shadowed.location)\n  }\n}\n\n/**\n * Validates a parsed compiler-owned facade against its registry declaration and canonical-only requirements.\n * @param {import(\"../stdlib-facades.js\").StdlibFacadeRecord} facade - Selected facade record.\n * @param {import(\"../semantic/types.js\").SemanticProgramModule} module - Parsed semantic module.\n * @returns {void}\n */\nfunction validateParsedFacade(facade, module) {\n  const exported = new Map(module.exports.map((item) => [item.exportedName, item]))\n\n  for (const declaration of facade.publicDeclarations) {\n    if (declaration.kind == \"class\") {\n      validateParsedFacadeClass(facade, module, declaration, exported.get(declaration.name))\n      continue\n    }\n    const exportedDeclaration = exported.get(declaration.name)\n    const parsed = exportedDeclaration ? module.functions.find(({id}) => id == exportedDeclaration.declarationId) : undefined\n    const signatureMatches = parsed && parsed.parameters.length == declaration.parameters.length &&\n      parsed.parameters.every((parameter, index) => parameter.name == declaration.parameters[index].name &&\n        semanticTypeName(parameter.type) == declaration.parameters[index].type) &&\n      semanticTypeName(parsed.returnType) == declaration.returnType\n\n    if (!signatureMatches) facadeFailure(facade.language, \"STDLIB_FACADE_DECLARATION_MISMATCH\",\n      `Facade '${facade.identity}' executable source does not match public declaration '${declaration.name}'.`, parsed?.location ?? module.location)\n  }\n  const dependencyIds = new Set(facade.dependencies.map((dependency) =>\n    stdlibFacadeRegistry.resolveIdentity(dependency.identity, facade.language, dependency.range).source.id))\n\n  if (module.imports.some(({moduleId}) => !dependencyIds.has(moduleId)) ||\n    [...dependencyIds].some((moduleId) => !module.imports.some((imported) => imported.moduleId == moduleId))) {\n    facadeFailure(facade.language, \"STDLIB_FACADE_DECLARATION_MISMATCH\",\n      `Facade '${facade.identity}' executable imports do not match its declared dependencies.`, module.location)\n  }\n  const allowedOperations = new Set(facade.requirements.flatMap(({operations}) => operations))\n  const operationNames = new Map((module.capabilities ?? []).flatMap(({operations}) => operations.map(({id, name}) => [id, name])))\n  const usedOperations = collectEffectOperations(module, operationNames)\n\n  if ([...usedOperations].some((operation) => !allowedOperations.has(operation)) ||\n    [...allowedOperations].some((operation) => !usedOperations.has(operation))) {\n    facadeFailure(facade.language, \"STDLIB_FACADE_AUTHORITY_FORGED\",\n      `Facade '${facade.identity}' canonical calls do not match its declared requirements.`, module.location)\n  }\n}\n\n/**\n * Verifies one executable compiler-owned facade class against its closed descriptor.\n * @param {import(\"../stdlib-facades.js\").StdlibFacadeRecord} facade - Owning facade.\n * @param {import(\"../semantic/types.js\").SemanticProgramModule} module - Parsed facade module.\n * @param {import(\"../stdlib-facades.js\").StdlibFacadeClassDeclaration} descriptor - Registry descriptor.\n * @param {import(\"../semantic/types.js\").SemanticExport | undefined} exported - Matching export evidence.\n * @returns {void}\n */\nfunction validateParsedFacadeClass(facade, module, descriptor, exported) {\n  const parsed = exported?.symbolKind == \"class\"\n    ? module.classes?.find(({id}) => id == exported.declarationId) : undefined\n  const failureNames = new Map((module.capabilities ?? []).flatMap(({failures}) => failures.map(({id, name}) => [id, name])))\n  const constructorFailures = parsed?.constructor.failureIds?.map((id) => failureNames.get(id)) ?? []\n  const constructorMatches = parsed?.name == descriptor.name && parsed.ownership?.kind == \"ownedResource\" &&\n    parsed.constructor.effects?.join(\",\") == descriptor.constructor.effects.join(\",\") &&\n    constructorFailures.join(\",\") == descriptor.constructor.failures.join(\",\") &&\n    parsed.constructor.parameters.length == descriptor.constructor.parameters.length &&\n    parsed.constructor.parameters.every((parameter, index) => parameter.name == descriptor.constructor.parameters[index].name &&\n      semanticTypeName(parameter.type) == descriptor.constructor.parameters[index].type)\n  const methodsMatch = parsed?.methods.length == descriptor.methods.length && descriptor.methods.every((expected, index) => {\n    const method = parsed?.methods[index]\n    const actualFailures = method?.failureIds?.map((id) => failureNames.get(id)) ?? []\n    const operation = method?.body.statements.flatMap((statement) => {\n      const expression = statement.kind == \"ExpressionStatement\" || statement.kind == \"ReturnStatement\"\n        ? statement.expression : statement.kind == \"LocalDeclaration\" ? statement.initializer : undefined\n\n      return expression?.kind == \"EffectCallExpression\" ? [expression] : []\n    })[0]\n    const flow = operation?.resolution.resourceFlow\n    const terminalFailureId = flow?.kind == \"borrow\" || flow?.kind == \"close\" ? flow.terminalFailureId : undefined\n\n    if (terminalFailureId) actualFailures.push(failureNames.get(terminalFailureId))\n    return method?.name == expected.name && method.effects?.join(\",\") == expected.effects.join(\",\") &&\n      actualFailures.join(\",\") == expected.failures.join(\",\") && method.parameters.length == expected.parameters.length &&\n      method.parameters.every((parameter, parameterIndex) =>\n        parameter.name == expected.parameters[parameterIndex].name &&\n        semanticTypeName(parameter.type) == expected.parameters[parameterIndex].type) &&\n      semanticTypeName(method.returnType) == expected.returnType\n  })\n\n  if (!constructorMatches || !methodsMatch) {\n    facadeFailure(facade.language, \"STDLIB_FACADE_DECLARATION_MISMATCH\",\n      `Facade '${facade.identity}' executable source does not match public class '${descriptor.name}'.`, parsed?.location ?? module.location)\n  }\n}\n\n/**\n * Collects canonical operation names reached in one facade module.\n * @param {import(\"../semantic/types.js\").SemanticProgramModule} module - Parsed facade module.\n * @param {Map<string, string>} operationNames - Canonical names by operation identity.\n * @returns {Set<string>} Used operation names.\n */\nfunction collectEffectOperations(module, operationNames) {\n  const used = new Set()\n  const seen = new WeakSet()\n\n  /**\n   * Visits one semantic subtree without following authority or provenance graphs.\n   * @param {unknown} value - Semantic subtree.\n   * @returns {void}\n   */\n  function visit(value) {\n    if (!value || typeof value != \"object\" || seen.has(value)) return\n    seen.add(value)\n    if (!Array.isArray(value) && Reflect.get(value, \"kind\") == \"EffectCallExpression\") {\n      const name = operationNames.get(Reflect.get(value, \"operation\"))\n\n      if (name) used.add(name)\n    }\n    for (const [key, child] of Object.entries(value)) {\n      if (key != \"capabilities\" && key != \"location\" && key != \"provenance\" && key != \"sourceProvenance\") visit(child)\n    }\n  }\n  visit(module)\n  return used\n}\n\n/**\n * Converts one parsed semantic type to the facade declaration vocabulary.\n * @param {import(\"../semantic/types.js\").SemanticFunctionReturnType} type - Parsed type.\n * @returns {string} Closed canonical public type name.\n */\nfunction semanticTypeName(type) {\n  if (type.kind == \"TypeReference\") return type.name\n  return type.kind == \"OptionalType\" && type.valueType.kind == \"TypeReference\"\n    ? `optional:${type.valueType.name}` : \"unsupported\"\n}\n\n/**\n * Throws one stable located facade diagnostic.\n * @param {string} language - Source language.\n * @param {string} code - Stable diagnostic code.\n * @param {string} message - Diagnostic detail.\n * @param {import(\"../semantic/types.js\").SourceLocation | undefined} location - Parser-owned location.\n * @returns {never} Always throws.\n */\nfunction facadeFailure(language, code, message, location) {\n  throw new SemantifoldDiagnostic({code, language, location, message})\n}\n\n/**\n * Rejects source-profile identities whose lookup or reopening would depend on caller order.\n * @param {ProgramSource[]} sources - Complete validated source set.\n * @param {Map<string, ProgramHeader>} headers - Parser-owned module headers.\n * @returns {void}\n */\nfunction validateNativeModuleIdentities(sources, headers) {\n  if (!sources.every(({language}) => language == \"java\") && !sources.every(({language}) => language == \"ruby\")) return\n  const ordered = [...sources].sort((left, right) => left.filename.localeCompare(right.filename, \"en-US\") ||\n    left.id.localeCompare(right.id, \"en-US\"))\n  const owners = new Map()\n\n  for (const source of ordered) {\n    const nativeName = requiredMapValue(headers, source.id).nativeName\n\n    if (!nativeName) continue\n    const earlier = owners.get(nativeName)\n\n    if (earlier) {\n      const label = source.language == \"java\" ? \"Java\" : \"Ruby\"\n\n      semanticFailure(source.language, \"DUPLICATE_MODULE\",\n        `Duplicate ${label} native module identity '${nativeName}' in '${earlier.filename}' and '${source.filename}'.`,\n        moduleLocation(source.filename, source.source))\n    }\n    owners.set(nativeName, source)\n  }\n}\n\n/**\n * Validates and snapshots one caller-supplied program source descriptor.\n * @param {unknown} candidate - Candidate source descriptor.\n * @param {number} index - Source index.\n * @returns {ProgramSource} Validated source descriptor.\n */\nfunction validateSource(candidate, index) {\n  if (!isPlainObject(candidate)) {\n    return invalidProgram(`Program source ${index} requires a stable module ID, safe filename, language, and source text.`)\n  }\n  if (!isPlainObject(candidate) || typeof candidate.id != \"string\" || !moduleIdPattern.test(candidate.id) ||\n    typeof candidate.filename != \"string\" || !isSafeSourcePath(candidate.filename) ||\n    typeof candidate.source != \"string\" || typeof candidate.language != \"string\") {\n    invalidProgram(`Program source ${index} requires a stable module ID, safe filename, language, and source text.`)\n  }\n  languageRegistry.record(candidate.language)\n  if (!programLanguages.has(candidate.language)) unsupportedRole(candidate.language, \"multi-file frontend\")\n\n  return /** @type {ProgramSource} */ ({\n    filename: candidate.filename,\n    id: candidate.id,\n    language: candidate.language,\n    ownership: \"application\",\n    source: candidate.source\n  })\n}\n\n/**\n * Dispatches parser-owned module header inspection for one cohort source.\n * @param {{filename: string, language: import(\"../semantic/types.js\").SemanticLanguage, source: string}} source - Validated source.\n * @returns {ProgramHeader} Parser-owned import/export header.\n */\nfunction inspectSource(source) {\n  if (source.language == \"javascript\" || source.language == \"typescript\") {\n    return inspectJavaScriptTypeScriptModule(/** @type {{filename: string, language: \"javascript\" | \"typescript\", source: string}} */ (source))\n  }\n  if (source.language == \"ruby\") {\n    return inspectRubyModule(/** @type {{filename: string, language: \"ruby\", source: string}} */ (source))\n  }\n  if (source.language == \"php\") {\n    return inspectPhpModule(/** @type {{filename: string, language: \"php\", source: string}} */ (source))\n  }\n  if (source.language == \"java\") {\n    return inspectJavaModule(/** @type {{filename: string, language: \"java\", source: string}} */ (source))\n  }\n\n  return unsupportedRole(source.language, \"multi-file frontend\")\n}\n\n/**\n * Resolves only an explicit relative ESM specifier against caller-supplied filenames.\n * @param {{filename: string, language: import(\"../semantic/types.js\").SemanticLanguage}} source - Importing source.\n * @param {string} specifier - Parser-owned relative specifier.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Specifier location.\n * @param {Map<string, ProgramSource>} sources - Sources by exact filename.\n * @param {Map<string, ProgramHeader>} headers - Parser-owned module headers.\n * @returns {string} Resolved module identity.\n */\nfunction resolveImportModule(source, specifier, location, sources, headers) {\n  if (source.language == \"java\") {\n    const matched = [...headers.entries()].find(([, header]) => header.nativeName == specifier)\n\n    if (!matched) semanticFailure(source.language, \"UNRESOLVED_MODULE\", `Import '${specifier}' does not identify a supplied source.`, location)\n\n    return matched[0]\n  }\n  const directory = source.filename.split(\"/\").slice(0, -1)\n  const parts = [...directory]\n\n  for (const part of specifier.split(\"/\")) {\n    if (part == \"\" || part == \".\") continue\n    if (part == \"..\") {\n      if (parts.length == 0) semanticFailure(source.language, \"UNSAFE_MODULE_PATH\", `Import '${specifier}' escapes the supplied source root.`, location)\n      parts.pop()\n    } else parts.push(part)\n  }\n  let exact = parts.join(\"/\")\n\n  if (source.language == \"ruby\" && !exact.endsWith(\".rb\")) exact += \".rb\"\n  const candidates = [exact]\n\n  if (source.language == \"typescript\" && exact.endsWith(\".js\")) candidates.push(`${exact.slice(0, -3)}.ts`)\n  const matched = candidates.flatMap((filename) => sources.has(filename) ? [sources.get(filename)] : [])[0]\n\n  if (!matched) semanticFailure(source.language, \"UNRESOLVED_MODULE\", `Import '${specifier}' does not identify a supplied source.`, location)\n\n  return matched.id\n}\n\n/**\n * Builds the source-profile spelling used to resolve one namespace-qualified import.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Importing source language.\n * @param {string | undefined} nativeName - Dependency namespace/module name.\n * @param {import(\"../semantic/types.js\").SemanticExport} exported - Imported export.\n * @returns {string} Source-profile binding spelling.\n */\nfunction qualifiedImportName(language, nativeName, exported) {\n  if (!nativeName) throw new Error(\"Namespace import dependency has no parser-owned native name.\")\n  if (language == \"ruby\") return `${nativeName}${exported.symbolKind == \"function\" ? \".\" : \"::\"}${exported.exportedName}`\n  if (language == \"java\") {\n    const className = nativeName.split(\".\").at(-1)\n\n    if (!className) throw new Error(\"Java import dependency has no class name.\")\n\n    return exported.symbolKind == \"function\" ? `${className}.${exported.exportedName}` : className\n  }\n\n  throw new Error(`Unsupported namespace import profile '${language}'.`)\n}\n\n/**\n * Sorts the explicit module graph in stable dependency-first order.\n * @param {ProgramSource[]} sources - Validated sources.\n * @param {Map<string, {source: ProgramSource, requests: {moduleId: string, location: import(\"../semantic/types.js\").SourceLocation}[]}>} graph - Resolved graph.\n * @returns {string[]} Dependency-first module identities.\n */\nfunction topologicalOrder(sources, graph) {\n  const complete = new Set()\n  const active = new Set()\n  /** @type {string[]} */\n  const result = []\n\n  /**\n   * Visits one module and its dependencies.\n   * @param {string} id - Module identity.\n   */\n  function visit(id) {\n    if (complete.has(id)) return\n    if (active.has(id)) {\n      const edge = requiredMapValue(graph, id).requests[0]\n\n      semanticFailure(requiredMapValue(graph, id).source.language, \"IMPORT_CYCLE\", `Import cycle includes module '${id}'.`, edge?.location)\n    }\n    active.add(id)\n    for (const request of requiredMapValue(graph, id).requests) visit(request.moduleId)\n    active.delete(id)\n    complete.add(id)\n    result.push(id)\n  }\n\n  for (const source of sources) visit(source.id)\n\n  return result\n}\n\n/**\n * Looks up one already-resolved exported declaration.\n * @param {import(\"../semantic/types.js\").SemanticProgramModule} module - Exporting module.\n * @param {import(\"../semantic/types.js\").SemanticExport} exported - Resolved export.\n * @returns {import(\"../semantic/types.js\").FunctionDeclaration | import(\"../semantic/types.js\").RecordDeclaration | import(\"../semantic/types.js\").ClassDeclaration | import(\"../semantic/types.js\").ErrorDeclaration} Declaration.\n */\nfunction declarationFor(module, exported) {\n  const declarations = exported.symbolKind == \"function\" ? module.functions :\n    exported.symbolKind == \"record\" ? module.records ?? [] : exported.symbolKind == \"class\" ? module.classes ?? [] : module.errors ?? []\n  const declaration = declarations.find(({id}) => id == exported.declarationId)\n\n  if (!declaration) throw new Error(`Resolved export '${exported.declarationId}' has no declaration.`)\n\n  return declaration\n}\n\n/**\n * Prefixes module-owned declaration identities and explicit resolved references to them.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Validated module.\n * @param {string} moduleId - Stable module identity.\n * @returns {void}\n */\nfunction rekeyDeclarations(module, moduleId) {\n  const replacements = new Map()\n\n  for (const declaration of module.classes ?? []) {\n    replacements.set(declaration.id, `${moduleId}#${declaration.id}`)\n    replacements.set(declaration.constructor.id, `${moduleId}#${declaration.constructor.id}`)\n    for (const field of declaration.fields) replacements.set(field.id, `${moduleId}#${field.id}`)\n    for (const method of declaration.methods) replacements.set(method.id, `${moduleId}#${method.id}`)\n  }\n  for (const declaration of module.records ?? []) {\n    replacements.set(declaration.id, `${moduleId}#${declaration.id}`)\n    for (const parameter of declaration.typeParameters ?? []) {\n      if (parameter.id) replacements.set(parameter.id, `${moduleId}#${parameter.id}`)\n    }\n    for (const field of declaration.fields) replacements.set(field.id, `${moduleId}#${field.id}`)\n  }\n  for (const declaration of module.errors ?? []) replacements.set(declaration.id, `${moduleId}#${declaration.id}`)\n  for (const declaration of module.functions) {\n    replacements.set(declaration.id, `${moduleId}#${declaration.id}`)\n    for (const parameter of declaration.typeParameters ?? []) {\n      if (parameter.id) replacements.set(parameter.id, `${moduleId}#${parameter.id}`)\n    }\n  }\n\n  for (const declaration of module.records ?? []) {\n    declaration.id = replacements.get(declaration.id)\n    for (const parameter of declaration.typeParameters ?? []) {\n      parameter.id = /** @type {string} */ (replacements.get(/** @type {string} */ (parameter.id)))\n    }\n    for (const field of declaration.fields) field.id = /** @type {string} */ (replacements.get(field.id))\n  }\n  for (const declaration of module.errors ?? []) declaration.id = replacements.get(declaration.id)\n  for (const declaration of module.classes ?? []) {\n    declaration.id = replacements.get(declaration.id)\n    declaration.constructor.id = replacements.get(declaration.constructor.id)\n    for (const field of declaration.fields) field.id = replacements.get(field.id)\n    for (const method of declaration.methods) method.id = replacements.get(method.id)\n    if (declaration.ownership?.kind == \"ownedResource\") {\n      declaration.ownership.fieldId = /** @type {string} */ (replacements.get(declaration.ownership.fieldId))\n    }\n  }\n  for (const declaration of module.functions) {\n    declaration.id = replacements.get(declaration.id)\n    for (const parameter of declaration.typeParameters ?? []) {\n      parameter.id = /** @type {string} */ (replacements.get(/** @type {string} */ (parameter.id)))\n    }\n  }\n\n  const seen = new WeakSet()\n  /**\n   * Rewrites only typed identity-bearing fields throughout one semantic subtree.\n   * @param {unknown} value - Semantic subtree.\n   */\n  function visit(value) {\n    if (!value || typeof value != \"object\" || seen.has(value)) return\n    seen.add(value)\n    const object = /** @type {Record<string, unknown>} */ (value)\n\n    if ((object.kind == \"RecordType\" || object.kind == \"ReferenceType\" || object.kind == \"OwnedReferenceType\" ||\n      object.kind == \"ErrorType\" || object.kind == \"ResolvedFunctionSignature\" ||\n      object.kind == \"ResolvedConstructorSignature\" || object.kind == \"ResolvedMethodSignature\") &&\n      typeof object.declarationId == \"string\" && replacements.has(object.declarationId)) {\n      object.declarationId = replacements.get(object.declarationId)\n    }\n    if ((object.kind == \"MemberRead\" || object.kind == \"PrivateFieldRead\" || object.kind == \"PrivateFieldWriteStatement\") &&\n      typeof object.field == \"string\" && replacements.has(object.field)) {\n      object.field = replacements.get(object.field)\n    }\n    if (object.kind == \"MethodCallExpression\" && typeof object.method == \"string\" && replacements.has(object.method)) {\n      object.method = replacements.get(object.method)\n    }\n    if (object.kind == \"ReceiverExpression\" && typeof object.classId == \"string\" && replacements.has(object.classId)) {\n      object.classId = replacements.get(object.classId)\n    }\n    if (object.kind == \"TypeVariableReference\" && typeof object.parameterId == \"string\" && replacements.has(object.parameterId)) {\n      object.parameterId = replacements.get(object.parameterId)\n    }\n    for (const child of Object.values(object)) if (typeof child == \"object\") visit(child)\n  }\n  visit(module)\n}\n\n/**\n * Creates a source association for a parser-owned module header node.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Node origin.\n * @param {Readonly<Record<string, import(\"../semantic/types.js\").SourceLocation>>} ranges - Exact available header roles.\n * @param {string} sourceId - Program-wide source identity.\n * @returns {import(\"../semantic/types.js\").SemanticNodeSourceProvenance} Source association.\n */\nfunction sourceAssociation(location, ranges, sourceId) {\n  return {\n    origin: {kind: \"source\", location, sourceId},\n    ranges,\n    schema: \"SemantifoldNodeProvenance\",\n    version: 1\n  }\n}\n\n/**\n * Rebinds one parser-local provenance registry to the complete program source registry.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Newly parsed module.\n * @param {import(\"../semantic/types.js\").RegisteredSource[]} sources - Program-wide registry.\n * @param {string} sourceId - Owning source identity.\n * @returns {void}\n */\nfunction rebaseParsedModuleProvenance(module, sources, sourceId) {\n  if (!module.provenance) throw new Error(\"Parsed program module has no source provenance.\")\n  const seen = new WeakSet()\n\n  /**\n   * Rebinds source-origin identities throughout one semantic subtree.\n   * @param {unknown} value - Semantic subtree.\n   */\n  function visit(value) {\n    if (!value || typeof value != \"object\" || seen.has(value)) return\n    seen.add(value)\n    const candidate = /** @type {Record<string, unknown>} */ (value)\n    const provenance = candidate.sourceProvenance\n    const origin = isPlainObject(provenance) ? provenance.origin : undefined\n\n    if (isPlainObject(origin) && origin.kind == \"source\") origin.sourceId = sourceId\n    for (const child of Object.values(candidate)) visit(child)\n  }\n  visit(module)\n  for (const node of module.provenance.nodes) {\n    if (node.origin.kind == \"source\") node.origin.sourceId = sourceId\n  }\n  module.provenance.sources = sources\n}\n\n/**\n * Reports whether a candidate is a direct plain object.\n * @param {unknown} value - Candidate object.\n * @returns {value is Record<string, unknown>} Whether the value is a plain object.\n */\nfunction isPlainObject(value) {\n  return Boolean(value) && typeof value == \"object\" && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype\n}\n\n/**\n * Reads a value whose map key was validated earlier in program assembly.\n * @template T\n * @param {Map<string, T>} map - Map with a previously validated key.\n * @param {string} key - Required key.\n * @returns {T} Stored value.\n */\nfunction requiredMapValue(map, key) {\n  const value = map.get(key)\n\n  if (value === undefined) throw new Error(`Missing validated map value '${key}'.`)\n\n  return value\n}\n\n/**\n * Raises a stable malformed program request diagnostic.\n * @param {string} message - Stable request failure detail.\n * @returns {never} Always throws.\n */\nfunction invalidProgram(message) {\n  throw new SemantifoldDiagnostic({code: \"INVALID_PROGRAM\", language: \"program\", message})\n}\n"]}