semantifold 0.3.0 → 0.5.0

package/build/src/backends/program.js

@@ -0,0 +1,1309 @@
+// @ts-check
+import { isDenseArray } from "../array.js";
+import { isSafeArtifactPath, isSafeSourcePath } from "../artifact-path.js";
+import { createGeneratedArtifactSet } from "../artifacts.js";
+import { SemantifoldDiagnostic, unsupportedCapability, unsupportedRole } from "../diagnostic.js";
+import { parseProgramSource } from "../frontends/program.js";
+import { languageRegistry } from "../language-registry.js";
+import { finalizeMapping, toSourceMapV3 } from "../mapping.js";
+import { createCoordinateIndex, indexedPointAt, moduleLocation } from "../semantic/location.js";
+import { semanticEntries } from "../semantic/provenance.js";
+import { listStdlibModules, parseStdlibVersionRange } from "../semantic/stdlib.js";
+import { moduleUncheckedErrorEffects } from "../semantic/validate.js";
+import { negotiateStdlibProviders } from "../stdlib-negotiation.js";
+import { stdlibFacadeProgramDescriptor, stdlibFacadeRegistry } from "../stdlib-facades.js";
+import { stdlibProviderRegistry } from "../stdlib-providers.js";
+import { preflightEffectCapabilities } from "./effects.js";
+import { validateTargetBindingIdentifier, validateTargetIdentifier, validateTargetTypeIdentifier } from "./identifiers.js";
+import { generateStdlibProviderContent } from "./stdlib-support.js";
+import { validateBackendModule } from "./shared.js";
+import { programImportName, SourceWriter } from "./writer.js";
+/** @type {Readonly<Set<import("../semantic/types.js").SemanticLanguage>>} */
+const programTargets = new Set(["php", "ruby", "javascript", "typescript", "java"]);
+/** @type {Readonly<Set<import("../semantic/types.js").BackendLanguage>>} */
+const programApplicationTargets = new Set(["android", "ios"]);
+/**
+ * Validates and prepares a complete semantic program for a non-text backend without allocating a writer.
+ * @param {object} input - Backend preflight request.
+ * @param {import("../semantic/types.js").SemanticLanguage} input.backendLanguage - Existing semantic backend profile to enforce.
+ * @param {import("../semantic/types.js").BackendLanguage} input.diagnosticLanguage - Public target identity for capability failures.
+ * @param {import("../semantic/types.js").SemanticProgram} input.program - Complete candidate program.
+ * @param {Readonly<Set<import("../semantic/types.js").SemanticLanguage>>} [input.sourceLanguages] - Accepted source provenance languages.
+ * @returns {{modules: import("../semantic/types.js").SemanticModule[], program: import("../semantic/types.js").SemanticProgram, sources: {content: string, filename: string, language?: import("../semantic/types.js").SemanticLanguage}[]}} Prepared immutable-input views.
+ */
+export function preflightSemanticProgram({ backendLanguage, diagnosticLanguage, program: candidate, sourceLanguages }) {
+    try {
+        const program = validateProgram(candidate, backendLanguage, sourceLanguages);
+        const modules = prepareEmissionModules(program, backendLanguage);
+        validateProgramSourceOwnership(program, backendLanguage);
+        const sources = program.sources.map((source) => {
+            if (source.content === null)
+                invalidProgramGeneration(`Program source '${source.filename}' has no retained content.`);
+            return { content: source.content, filename: source.filename, ...(source.language ? { language: source.language } : {}) };
+        });
+        return { modules, program, sources };
+    }
+    catch (error) {
+        if (error instanceof SemantifoldDiagnostic && error.code == "UNSUPPORTED_CAPABILITY" &&
+            error.language != diagnosticLanguage) {
+            throw new SemantifoldDiagnostic({
+                cause: error,
+                code: error.code,
+                language: diagnosticLanguage,
+                location: error.location,
+                message: error.detail
+            });
+        }
+        throw error;
+    }
+}
+/**
+ * Generates a complete deterministic mapped artifact set for one semantic program.
+ * @param {object} input - Program generation request.
+ * @param {import("../semantic/types.js").BackendLanguage} input.language - Registered program target.
+ * @param {import("../semantic/types.js").SemanticProgram} input.program - Complete semantic program.
+ * @param {"text" | "application"} [input.role] - Explicit artifact role; omitted preserves text generation.
+ * @param {import("../semantic/types.js").IosApplicationConfigurationInput | import("../semantic/types.js").AndroidApplicationConfigurationInput} [input.configuration] - Application configuration.
+ * @param {import("../semantic/types.js").IosApplicationAssetInput[] | import("../semantic/types.js").AndroidApplicationInputFile[]} [input.assets] - Exact caller assets.
+ * @param {import("../semantic/types.js").AndroidApplicationInputFile[]} [input.resources] - Exact Android caller resources.
+ * @returns {import("../semantic/types.js").GeneratedArtifactSet} Transactionally validated artifact set.
+ */
+export function generateProgramArtifacts(input) {
+    if (!isPlainObject(input) || typeof input.language != "string")
+        invalidProgramGeneration("Program generation requires a target language and program.");
+    const role = input.role ?? "text";
+    if (role != "text" && role != "application")
+        invalidProgramGeneration("Program artifact role must be 'text' or 'application'.");
+    languageRegistry.record(input.language);
+    if (role == "application") {
+        if (!programApplicationTargets.has(input.language))
+            unsupportedRole(input.language, "multi-file application backend");
+        const backend = languageRegistry.resolve(input.language, "applicationBackend");
+        return createGeneratedArtifactSet(backend(input));
+    }
+    if (!programTargets.has(/** @type {import("../semantic/types.js").SemanticLanguage} */ (input.language))) {
+        unsupportedRole(input.language, "multi-file text backend");
+    }
+    const language = /** @type {import("../semantic/types.js").SemanticLanguage} */ (input.language);
+    const program = validateProgram(input.program, language);
+    const linking = planStdlibLinking(program, language);
+    const emissionModules = prepareEmissionModules(program, language, linking);
+    validateProgramSourceOwnership(program, language);
+    const paths = planModulePaths(program, language, linking);
+    const sources = program.sources.map((source) => {
+        if (source.content === null)
+            invalidProgramGeneration(`Program source '${source.filename}' has no retained content.`);
+        return { content: source.content, filename: source.filename, ...(source.language ? { language: source.language } : {}) };
+    });
+    const backend = /** @type {typeof import("./javascript.js").generateJavaScript} */ (languageRegistry.resolve(language, "textBackend"));
+    const mediaType = languageRegistry.record(language).mediaType;
+    /** @type {import("../semantic/types.js").GeneratedSetArtifact[]} */
+    const artifacts = language == "javascript" || language == "typescript" ? [{
+            content: "{\n  \"type\": \"module\"\n}\n",
+            contentKind: /** @type {const} */ ("text"),
+            mediaType: "application/json",
+            ownership: /** @type {const} */ ("generated"),
+            path: "package.json",
+            provenance: {
+                kind: /** @type {const} */ ("synthetic"),
+                reason: "Declares the generated JavaScript-family artifact set as canonical ESM.",
+                relatedOrigins: []
+            },
+            role: "manifest"
+        }] : [];
+    if (linking && language != "java") {
+        for (const provider of linking.negotiation.providers) {
+            const record = /** @type {import("../stdlib-providers.js").StdlibProviderRecord} */ (linking.records.get(provider.module));
+            artifacts.push({
+                content: generateStdlibProviderContent(/** @type {"php" | "ruby" | "javascript" | "typescript"} */ (language), [...provider.operations], provider.module),
+                contentKind: /** @type {const} */ ("text"),
+                mediaType: record.artifact.mediaType,
+                ownership: /** @type {const} */ ("generated"),
+                path: record.artifact.path,
+                provenance: {
+                    kind: /** @type {const} */ ("synthetic"),
+                    reason: `semantifold-stdlib-provider:${record.identity}`,
+                    relatedOrigins: []
+                },
+                role: /** @type {const} */ ("support")
+            });
+        }
+    }
+    for (const emissionModule of emissionModules) {
+        const moduleId = /** @type {string} */ (Reflect.get(emissionModule, "id"));
+        const filename = /** @type {string} */ (paths.get(moduleId));
+        const writer = new SourceWriter({
+            filename,
+            language,
+            module: emissionModule,
+            program,
+            programPaths: paths,
+            sources,
+            ...(linking && emissionModule.capabilities !== undefined ? {
+                stdlibProviderEntries: Object.fromEntries((linking.usedOperationsByModule.get(moduleId) ?? []).map(({ module, operation }) => [
+                    qualifiedOperationKey(module, operation),
+                    /** @type {string} */ (linking.records.get(module)?.nativeEntries[operation])
+                ])),
+                stdlibProviderImports: language == "java" || language == "javascript" || language == "typescript" ?
+                    linking.providerImportsByModule.get(moduleId) : undefined,
+                stdlibProviderPaths: linking.providerPathsByModule.get(moduleId),
+                ...(language == "java" ? {
+                    stdlibProviderOwnerModule: /** @type {string} */ (linking.ownerModuleId),
+                    stdlibProviderShims: moduleId == linking.ownerModuleId ? linking.usedOperations.map(({ operation }) => operation) : undefined
+                } : {})
+            } : {})
+        });
+        backend(emissionModule, writer);
+        const mapping = finalizeMapping(writer.finish());
+        artifacts.push({
+            content: mapping.generated.content,
+            contentKind: /** @type {const} */ ("text"),
+            mediaType: /** @type {string} */ (mediaType),
+            ownership: /** @type {const} */ ("generated"),
+            path: filename,
+            provenance: {
+                kind: /** @type {const} */ ("text"),
+                mapping,
+                sourceMap: toSourceMapV3(mapping),
+                sourceMapFilename: `${filename}.map`
+            },
+            role: /** @type {import("../semantic/types.js").GeneratedArtifactRole} */ (moduleId == program.entryModule ? "entry" : Reflect.get(emissionModule, "stdlibFacade") ? "support" : "source")
+        });
+    }
+    return createGeneratedArtifactSet({
+        artifacts,
+        ...(linking || program.stdlibFacades ? { metadata: stdlibLinkMetadata(linking, paths, program.stdlibFacades) } : {}),
+        target: language
+    });
+}
+/**
+ * @typedef StdlibProgramLinking
+ * @property {import("../stdlib-negotiation.js").StdlibNegotiationResult} negotiation - Negotiated provider closure.
+ * @property {Map<string, import("../stdlib-providers.js").StdlibProviderRecord>} records - Materialized provider records by canonical module.
+ * @property {QualifiedStdlibOperation[]} usedOperations - Program-wide used canonical operations in stable order.
+ * @property {Map<string, QualifiedStdlibOperation[]>} usedOperationsByModule - Used canonical operations by program module identity.
+ * @property {Map<string, string[]>} providerImportsByModule - Ordered provider import names by module identity.
+ * @property {Map<string, string[]>} providerPathsByModule - Provider artifact closure by program module identity.
+ * @property {string | null} ownerModuleId - Java target: first operation-using module identity hosting the shared support; null for artifact-materializing targets.
+ */
+/**
+ * @typedef QualifiedStdlibOperation
+ * @property {string} module - Canonical module identity.
+ * @property {string} operation - Canonical operation name.
+ */
+/**
+ * Plans the linked stdlib provider for one program, or reports that no operation is used.
+ * Java resolves the same negotiated provider record but hosts its support in the first
+ * operation-using module instead of a separate provider artifact.
+ * @param {import("../semantic/types.js").SemanticProgram} program - Validated semantic program.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @returns {StdlibProgramLinking | null} Linking plan, or null when nothing is used.
+ */
+function planStdlibLinking(program, language) {
+    const { programWide, usedOperationsByModule } = collectUsedEffectOperations(program);
+    if (programWide.length == 0)
+        return null;
+    const contracts = program.stdlibContracts ?? [/** @type {{identity: string, contractVersion?: string}} */ (program.stdlibContract)];
+    const contractsByIdentity = new Map(contracts.map((contract) => [contract.identity, contract]));
+    const requirementsByModule = new Map();
+    for (const qualified of programWide) {
+        const requirement = requirementsByModule.get(qualified.module) ?? [];
+        requirement.push(qualified.operation);
+        requirementsByModule.set(qualified.module, requirement);
+    }
+    const negotiation = negotiateStdlibProviders({
+        requirements: [...requirementsByModule].map(([module, operations]) => {
+            const contract = contractsByIdentity.get(module);
+            if (!contract)
+                throw new SemantifoldDiagnostic({
+                    code: "STDLIB_LINK_FAILURE",
+                    language,
+                    message: `Reachable canonical operation '${module}.${operations[0]}' has no declared standard-library contract.`
+                });
+            return { module, operations, ...(contract.contractVersion !== undefined ? { range: contract.contractVersion } : {}) };
+        }),
+        target: language
+    });
+    /** @type {Map<string, import("../stdlib-providers.js").StdlibProviderRecord>} */
+    const records = new Map();
+    for (const selected of negotiation.modules) {
+        const candidates = stdlibProviderRegistry.providersFor(language, selected.identity, selected.version);
+        if (candidates.length != 1) {
+            throw new SemantifoldDiagnostic({
+                code: "STDLIB_LINK_FAILURE",
+                language,
+                message: `Expected exactly one registered stdlib provider for '${selected.identity}' on '${language}'.`
+            });
+        }
+        records.set(selected.identity, /** @type {import("../stdlib-providers.js").StdlibProviderRecord} */ (candidates[0]));
+    }
+    const ownerModuleId = language == "java"
+        ? program.modules.map((module) => module.id).find((id) => (usedOperationsByModule.get(id) ?? []).length > 0)
+        : null;
+    if (ownerModuleId === undefined)
+        throw new SemantifoldDiagnostic({
+            code: "STDLIB_LINK_FAILURE",
+            language,
+            message: "Java program linking requires one module using canonical operations."
+        });
+    return {
+        negotiation,
+        ownerModuleId,
+        providerImportsByModule: collectProviderImports(program, negotiation, records, usedOperationsByModule, language, ownerModuleId),
+        providerPathsByModule: collectProviderPaths(negotiation, records, usedOperationsByModule),
+        records,
+        usedOperations: [...programWide],
+        usedOperationsByModule
+    };
+}
+/**
+ * Selects the exact provider/type dependency closure required by each emitting program module.
+ * @param {import("../stdlib-negotiation.js").StdlibNegotiationResult} negotiation - Negotiated program closure.
+ * @param {Map<string, import("../stdlib-providers.js").StdlibProviderRecord>} records - Selected provider records.
+ * @param {Map<string, QualifiedStdlibOperation[]>} usedOperationsByModule - Reachable operations by program module.
+ * @returns {Map<string, string[]>} Ordered provider paths by program module.
+ */
+function collectProviderPaths(negotiation, records, usedOperationsByModule) {
+    const paths = new Map();
+    for (const [moduleId, operations] of usedOperationsByModule) {
+        const selected = new Set(operations.map(({ module }) => module));
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const module of [...selected]) {
+                for (const dependency of records.get(module)?.dependencies ?? []) {
+                    if (!selected.has(dependency.module)) {
+                        selected.add(dependency.module);
+                        changed = true;
+                    }
+                }
+            }
+        }
+        paths.set(moduleId, negotiation.providers.filter(({ module }) => selected.has(module)).map(({ module }) => 
+        /** @type {import("../stdlib-providers.js").StdlibProviderRecord} */ (records.get(module)).artifact.path));
+    }
+    return paths;
+}
+/**
+ * Collects the canonical operations invoked by each program module in stable order.
+ * @param {import("../semantic/types.js").SemanticProgram} program - Validated semantic program.
+ * @returns {{programWide: QualifiedStdlibOperation[], usedOperationsByModule: Map<string, QualifiedStdlibOperation[]>}} Used operations.
+ */
+function collectUsedEffectOperations(program) {
+    /** @type {Map<string, QualifiedStdlibOperation[]>} */
+    const usedOperationsByModule = new Map();
+    /** @type {Map<string, QualifiedStdlibOperation>} */
+    const programWide = new Map();
+    /** @type {Map<string, {body: unknown, module: import("../semantic/types.js").SemanticProgramModule}>} */
+    const bodies = new Map();
+    for (const module of program.modules) {
+        for (const declaration of module.functions)
+            bodies.set(/** @type {string} */ (declaration.id), { body: declaration.body, module });
+        for (const declaration of module.classes ?? []) {
+            bodies.set(/** @type {string} */ (declaration.constructor.id), { body: declaration.constructor.body, module });
+            for (const method of declaration.methods)
+                bodies.set(/** @type {string} */ (method.id), { body: method.body, module });
+        }
+        usedOperationsByModule.set(module.id, []);
+    }
+    const entryModule = /** @type {import("../semantic/types.js").SemanticProgramModule} */ (program.modules.find(({ id }) => id == program.entryModule));
+    /** @type {{body: unknown, module: import("../semantic/types.js").SemanticProgramModule}[]} */
+    const pending = [{ body: entryModule.entryPoint?.body, module: entryModule }];
+    const reachedDeclarations = new Set();
+    while (pending.length > 0) {
+        const current = /** @type {{body: unknown, module: import("../semantic/types.js").SemanticProgramModule}} */ (pending.shift());
+        const operationNames = new Map(current.module.capabilities?.flatMap((capability) => capability.operations.map((operation) => [operation.id, { module: capability.authorityId, operation: operation.name }])) ?? []);
+        const seen = new Set();
+        /**
+         * Visits one reachable semantic subtree.
+         * @param {unknown} value - Candidate semantic subtree.
+         */
+        const visit = (value) => {
+            if (!value || typeof value != "object" || seen.has(value))
+                return;
+            seen.add(value);
+            if (!Array.isArray(value)) {
+                const kind = Reflect.get(value, "kind");
+                if (kind == "EffectCallExpression") {
+                    const operation = Reflect.get(value, "operation");
+                    if (typeof operation == "string") {
+                        const qualified = operationNames.get(operation);
+                        if (qualified !== undefined) {
+                            const key = qualifiedOperationKey(qualified.module, qualified.operation);
+                            const moduleOperations = /** @type {QualifiedStdlibOperation[]} */ (usedOperationsByModule.get(current.module.id));
+                            if (!moduleOperations.some((item) => qualifiedOperationKey(item.module, item.operation) == key))
+                                moduleOperations.push(qualified);
+                            programWide.set(key, qualified);
+                        }
+                    }
+                }
+                const declarationId = isPlainObject(Reflect.get(value, "resolution"))
+                    ? Reflect.get(Reflect.get(value, "resolution"), "declarationId") : undefined;
+                if (typeof declarationId == "string" && !reachedDeclarations.has(declarationId)) {
+                    const declaration = bodies.get(declarationId);
+                    if (declaration) {
+                        reachedDeclarations.add(declarationId);
+                        pending.push(declaration);
+                    }
+                }
+                for (const [key, child] of Object.entries(value)) {
+                    if (["capabilities", "location", "provenance", "resolution", "sourceProvenance"].includes(key))
+                        continue;
+                    visit(child);
+                }
+            }
+            else
+                for (const child of value)
+                    visit(child);
+        };
+        visit(current.body);
+    }
+    for (const operations of usedOperationsByModule.values()) {
+        operations.sort((left, right) => qualifiedOperationKey(left.module, left.operation)
+            .localeCompare(qualifiedOperationKey(right.module, right.operation), "en"));
+    }
+    return { programWide: [...programWide.values()].sort((left, right) => qualifiedOperationKey(left.module, left.operation)
+            .localeCompare(qualifiedOperationKey(right.module, right.operation), "en")), usedOperationsByModule };
+}
+/**
+ * Builds an unambiguous internal key for one canonical operation authority.
+ * @param {string} module - Canonical module identity.
+ * @param {string} operation - Canonical operation name.
+ * @returns {string} Qualified internal key.
+ */
+function qualifiedOperationKey(module, operation) {
+    return `${module}\u0000${operation}`;
+}
+/**
+ * Collects the ordered provider import names each module must pull from the linked provider.
+ * Java modules list referenced capability type names only; the owner lists none.
+ * @param {import("../semantic/types.js").SemanticProgram} program - Validated semantic program.
+ * @param {import("../stdlib-negotiation.js").StdlibNegotiationResult} negotiation - Negotiated closure.
+ * @param {Map<string, import("../stdlib-providers.js").StdlibProviderRecord>} records - Provider records by canonical module.
+ * @param {Map<string, QualifiedStdlibOperation[]>} usedOperationsByModule - Used canonical operations by module identity.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @param {string | null} [ownerModuleId] - Java owner module identity.
+ * @returns {Map<string, string[]>} Ordered provider import names by module identity.
+ */
+function collectProviderImports(program, negotiation, records, usedOperationsByModule, language, ownerModuleId = null) {
+    /** @type {Map<string, string[]>} */
+    const providerImportsByModule = new Map();
+    for (const module of program.modules) {
+        if (module.capabilities === undefined)
+            continue;
+        const used = new Set((usedOperationsByModule.get(module.id) ?? []).map(({ module: owner, operation }) => qualifiedOperationKey(owner, operation)));
+        /** @type {Set<string>} */
+        const surface = new Set();
+        /** @type {Map<string, string>} */
+        const resourceNameById = new Map();
+        /** @type {Map<string, string>} */
+        const declarationNames = new Map((module.records ?? []).map((declaration) => [/** @type {string} */ (declaration.id), declaration.name]));
+        for (const declaration of module.errors ?? []) {
+            declarationNames.set(/** @type {string} */ (declaration.id), declaration.name);
+        }
+        for (const capability of module.capabilities) {
+            for (const resource of capability.resources) {
+                surface.add(resource.name);
+                resourceNameById.set(resource.id, resource.name);
+            }
+            for (const failure of capability.failures) {
+                surface.add(failure.name);
+                declarationNames.set(failure.id, failure.name);
+            }
+        }
+        const referenced = new Set();
+        const seen = new Set();
+        /**
+         * Visits one semantic value.
+         * @param {unknown} value - Candidate semantic subtree.
+         * @returns {void}
+         */
+        const visit = (value) => {
+            if (!value || typeof value != "object" || seen.has(value))
+                return;
+            seen.add(value);
+            if (!Array.isArray(value)) {
+                const kind = Reflect.get(value, "kind");
+                if (kind == "OwnedResourceType") {
+                    const resourceId = Reflect.get(value, "resourceId");
+                    if (typeof resourceId == "string") {
+                        const name = resourceNameById.get(resourceId);
+                        if (name !== undefined)
+                            referenced.add(name);
+                    }
+                }
+                else if (kind == "ReferenceType" || kind == "OwnedReferenceType" || kind == "ErrorType") {
+                    const declarationId = Reflect.get(value, "declarationId");
+                    if (typeof declarationId == "string") {
+                        const name = declarationNames.get(declarationId);
+                        if (name !== undefined && surface.has(name))
+                            referenced.add(name);
+                    }
+                }
+                for (const [key, child] of Object.entries(value)) {
+                    if (key == "capabilities" || key == "location" || key == "sourceProvenance")
+                        continue;
+                    visit(child);
+                }
+            }
+            else
+                for (const child of value)
+                    visit(child);
+        };
+        visit(module);
+        const names = [];
+        if (language != "java" || module.id != ownerModuleId) {
+            for (const capability of module.capabilities) {
+                for (const resource of capability.resources)
+                    if (referenced.has(resource.name))
+                        names.push(resource.name);
+                for (const failure of capability.failures)
+                    if (referenced.has(failure.name))
+                        names.push(failure.name);
+            }
+        }
+        if (language != "java") {
+            for (const provider of negotiation.providers) {
+                const record = records.get(provider.module);
+                for (const operation of provider.operations) {
+                    if (used.has(qualifiedOperationKey(provider.module, operation))) {
+                        names.push(/** @type {string} */ (record?.nativeEntries[operation]));
+                    }
+                }
+            }
+        }
+        providerImportsByModule.set(module.id, names);
+    }
+    return providerImportsByModule;
+}
+/**
+ * Builds the truthful generated stdlib link metadata for one negotiated closure.
+ * Java reports the owner module file as the provider carrier instead of a separate artifact.
+ * @param {StdlibProgramLinking | null} linking - Linking plan.
+ * @param {Map<string, string>} paths - Planned artifact path by module identity.
+ * @param {import("../semantic/types.js").StdlibFacadeProgramDescriptor | undefined} facades - Selected source facade closure.
+ * @returns {Record<string, unknown>} Plain JSON metadata.
+ */
+function stdlibLinkMetadata(linking, paths, facades) {
+    return {
+        ...(facades ? { facades } : {}),
+        modules: (linking?.negotiation.modules ?? []).map((item) => ({
+            identity: item.identity,
+            operations: [...item.operations],
+            version: item.version
+        })),
+        providers: (linking?.negotiation.providers ?? []).map((item) => {
+            const record = linking?.records.get(item.module);
+            const artifactPath = linking?.ownerModuleId !== null && linking?.ownerModuleId !== undefined
+                ? /** @type {string} */ (paths.get(linking.ownerModuleId))
+                : record?.artifact.path;
+            return {
+                artifact: { mediaType: record?.artifact.mediaType, path: artifactPath },
+                dependencies: (record?.dependencies ?? []).map((dependency) => ({ module: dependency.module, range: dependency.range })),
+                identity: item.identity,
+                module: item.module,
+                nativeEntries: { ...item.nativeEntries },
+                operations: [...item.operations],
+                target: item.target,
+                version: item.version
+            };
+        }),
+        schema: "SemantifoldStdlibLink",
+        version: 1
+    };
+}
+/**
+ * Validates every mandatory semantic location against its owning module source before writer allocation.
+ * @param {import("../semantic/types.js").SemanticProgram} program - Structurally and semantically validated program.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @returns {void}
+ */
+function validateProgramSourceOwnership(program, language) {
+    const sources = new Map(program.sources.map((source) => [source.filename, {
+            ...source,
+            coordinates: createCoordinateIndex(/** @type {string} */ (source.content))
+        }]));
+    for (const module of program.modules) {
+        const source = sources.get(module.sourceFilename);
+        if (!source)
+            unsupportedCapability(language, "semantic program module source ownership", undefined);
+        const fallback = moduleLocation(source.filename, /** @type {string} */ (source.content));
+        for (const entry of semanticEntries(module)) {
+            const subject = entry.node.kind == "Module" ? "module" : entry.node.kind == "Import" ? "import" :
+                entry.node.kind == "Export" ? "export" : "semantic node";
+            if (!("location" in entry.node)) {
+                if (subject != "semantic node")
+                    unsupportedCapability(language, `semantic program ${subject} location`, fallback);
+                continue;
+            }
+            const location = entry.node.location;
+            if (sourceOwnsLocation(source, location))
+                continue;
+            unsupportedCapability(language, `semantic program ${subject} location source ownership`, fallback);
+        }
+    }
+}
+/**
+ * Checks a normalized UTF-16 location against one exact registered source without throwing.
+ * @param {{filename: string, content: string | null, coordinates: ReturnType<typeof createCoordinateIndex>}} source - Owning source.
+ * @param {unknown} candidate - Candidate location.
+ * @returns {boolean} Whether the source owns the location.
+ */
+function sourceOwnsLocation(source, candidate) {
+    if (!isPlainObject(candidate) || candidate.filename != source.filename || !isPlainObject(candidate.start) ||
+        !isPlainObject(candidate.end) || !Number.isInteger(candidate.start.offset) || !Number.isInteger(candidate.end.offset) ||
+        !Number.isInteger(candidate.start.line) || !Number.isInteger(candidate.start.column) ||
+        !Number.isInteger(candidate.end.line) || !Number.isInteger(candidate.end.column))
+        return false;
+    const startOffset = /** @type {number} */ (candidate.start.offset);
+    const endOffset = /** @type {number} */ (candidate.end.offset);
+    if (startOffset < 0 || endOffset < startOffset || endOffset > source.coordinates.source.length)
+        return false;
+    const expectedStart = indexedPointAt(source.coordinates, startOffset);
+    const expectedEnd = indexedPointAt(source.coordinates, endOffset);
+    return samePoint(candidate.start, expectedStart) && samePoint(candidate.end, expectedEnd);
+}
+/**
+ * Compares an untrusted point with one canonical indexed point.
+ * @param {Record<string, unknown>} candidate - Candidate point.
+ * @param {import("../semantic/types.js").SourcePoint} expected - Canonical point.
+ * @returns {boolean} Whether every coordinate agrees.
+ */
+function samePoint(candidate, expected) {
+    return candidate.offset == expected.offset && candidate.line == expected.line && candidate.column == expected.column;
+}
+/**
+ * Collects nominal failure identities referenced by executable/type nodes outside the module's authority declarations.
+ * @param {import("../semantic/types.js").SemanticProgramModule} module - Program module.
+ * @returns {Set<string>} Referenced failure declaration identities.
+ */
+function collectReferencedFailureIds(module) {
+    /** @type {Set<string>} */
+    const ids = new Set();
+    const seen = new Set();
+    /**
+     * Visits one semantic subtree for referenced failures.
+     * @param {unknown} value - Candidate semantic subtree.
+     */
+    const visit = (value) => {
+        if (!value || typeof value != "object" || seen.has(value))
+            return;
+        seen.add(value);
+        if (!Array.isArray(value)) {
+            if (Reflect.get(value, "kind") == "ErrorType" && typeof Reflect.get(value, "declarationId") == "string") {
+                ids.add(Reflect.get(value, "declarationId"));
+            }
+            const failureIds = Reflect.get(value, "failureIds");
+            if (Array.isArray(failureIds))
+                for (const id of failureIds)
+                    if (typeof id == "string")
+                        ids.add(id);
+            for (const [key, child] of Object.entries(value)) {
+                if (["capabilities", "location", "provenance", "sourceProvenance"].includes(key))
+                    continue;
+                visit(child);
+            }
+        }
+        else
+            for (const child of value)
+                visit(child);
+    };
+    visit({ classes: module.classes, entryPoint: module.entryPoint, functions: module.functions });
+    return ids;
+}
+/**
+ * Creates and validates every backend-shaped module before any writer is allocated.
+ * @param {import("../semantic/types.js").SemanticProgram} program - Validated semantic program.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @param {StdlibProgramLinking | null} [linking] - Planned stdlib provider link.
+ * @returns {import("../semantic/types.js").SemanticModule[]} Emission views in dependency order.
+ */
+function prepareEmissionModules(program, language, linking = null) {
+    /** @type {Map<string, import("../semantic/types.js").FunctionDeclaration | import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").ErrorDeclaration>} */
+    const declarations = new Map();
+    for (const module of program.modules) {
+        for (const declaration of module.records ?? [])
+            declarations.set(/** @type {string} */ (declaration.id), declaration);
+        for (const declaration of module.classes ?? [])
+            declarations.set(/** @type {string} */ (declaration.id), declaration);
+        for (const declaration of module.errors ?? [])
+            declarations.set(/** @type {string} */ (declaration.id), declaration);
+        for (const declaration of module.functions)
+            declarations.set(/** @type {string} */ (declaration.id), declaration);
+    }
+    const modules = program.modules.map((module) => /** @type {import("../semantic/types.js").SemanticModule} */ ({
+        ...module,
+        entryPoint: module.entryPoint ?? {
+            body: { kind: /** @type {const} */ ("Block"), location: module.location, statements: [] },
+            kind: /** @type {const} */ ("EntryPoint"),
+            location: module.location
+        }
+    }));
+    /** @type {Map<string, Set<string>>} */
+    const callEffectsByDeclarationId = new Map();
+    for (const module of modules) {
+        const programModule = /** @type {import("../semantic/types.js").SemanticProgramModule} */ ( /** @type {unknown} */(module));
+        const visibleFunctions = new Map();
+        const visibleCallEffects = new Map();
+        const visibleRecords = new Map();
+        const visibleClasses = new Map();
+        const visibleErrors = new Map();
+        const externalDeclarationIds = new Set();
+        const neededFailureIds = collectReferencedFailureIds(programModule);
+        const localFailureIds = new Set(programModule.capabilities?.flatMap(({ failures }) => failures.map(({ id }) => id)) ?? []);
+        for (const owner of program.modules) {
+            if (owner.id == programModule.id)
+                continue;
+            for (const capability of owner.capabilities ?? []) {
+                for (const failure of capability.failures) {
+                    if (!localFailureIds.has(failure.id) && neededFailureIds.has(failure.id))
+                        visibleErrors.set(failure.id, failure);
+                }
+            }
+        }
+        for (const imported of programModule.imports) {
+            const declaration = declarations.get(imported.declarationId);
+            if (!declaration)
+                unsupportedCapability(language, "program import without a declaration", imported.location);
+            externalDeclarationIds.add(imported.declarationId);
+            if (imported.symbolKind == "function") {
+                visibleFunctions.set(imported.localName, /** @type {import("../semantic/types.js").FunctionDeclaration} */ (declaration));
+                visibleCallEffects.set(imported.localName, new Set(callEffectsByDeclarationId.get(imported.declarationId) ?? []));
+            }
+            else if (imported.symbolKind == "record") {
+                visibleRecords.set(imported.declarationId, /** @type {import("../semantic/types.js").RecordDeclaration} */ (declaration));
+            }
+            else if (imported.symbolKind == "class") {
+                visibleClasses.set(imported.declarationId, /** @type {import("../semantic/types.js").ClassDeclaration} */ (declaration));
+            }
+            else {
+                visibleErrors.set(imported.declarationId, /** @type {import("../semantic/types.js").ErrorDeclaration} */ (declaration));
+            }
+        }
+        if (module.capabilities !== undefined || !linking) {
+            preflightEffectCapabilities(module, language, linking ? { usedOperations: (linking.usedOperationsByModule.get(programModule.id) ?? [])
+                    .map(({ operation }) => operation) } : {});
+        }
+        validateBackendModule(module, language, {
+            externalDeclarationIds,
+            program: true,
+            visibleCallEffects,
+            visibleClasses,
+            visibleErrors,
+            visibleFunctions,
+            visibleRecords
+        });
+        const localCallEffects = moduleUncheckedErrorEffects(module, { callEffects: visibleCallEffects, functions: visibleFunctions });
+        for (const declaration of module.functions) {
+            callEffectsByDeclarationId.set(/** @type {string} */ (declaration.id), new Set(localCallEffects.get(declaration.name) ?? []));
+        }
+    }
+    return modules;
+}
+/**
+ * Validates the closed parser-neutral program graph before any target emission.
+ * @param {unknown} candidate - Candidate semantic program.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @param {Readonly<Set<import("../semantic/types.js").SemanticLanguage>>} [sourceLanguages] - Accepted source languages.
+ * @returns {import("../semantic/types.js").SemanticProgram} Validated program.
+ */
+function validateProgram(candidate, language, sourceLanguages = programTargets) {
+    if (!isPlainObject(candidate) || candidate.kind != "Program" || typeof candidate.entryModule != "string" ||
+        !isDenseArray(candidate.modules) || candidate.modules.length == 0 || !isDenseArray(candidate.sources) || candidate.sources.length == 0) {
+        invalidProgramGeneration("Malformed semantic program.");
+    }
+    const program = /** @type {import("../semantic/types.js").SemanticProgram} */ (candidate);
+    const modules = new Map();
+    /** @type {Map<string, {declaration: import("../semantic/types.js").FunctionDeclaration | import("../semantic/types.js").RecordDeclaration | import("../semantic/types.js").ClassDeclaration | import("../semantic/types.js").ErrorDeclaration, module: import("../semantic/types.js").SemanticProgramModule}>} */
+    const declarations = new Map();
+    /** @type {import("../semantic/types.js").SemanticProgramModule[]} */
+    const capabilityModules = [];
+    let entryCount = 0;
+    const sourceIds = new Set();
+    const sourceFilenames = new Set();
+    for (const source of program.sources) {
+        if (!isPlainObject(source) || typeof source.id != "string" || sourceIds.has(source.id) ||
+            typeof source.filename != "string" || !isSafeSourcePath(source.filename) || sourceFilenames.has(source.filename) ||
+            typeof source.content != "string" || typeof source.language != "string" || !sourceLanguages.has(source.language)) {
+            invalidProgramGeneration("Malformed or duplicate semantic program source registry.");
+        }
+        sourceIds.add(source.id);
+        sourceFilenames.add(source.filename);
+    }
+    for (const module of program.modules) {
+        if (!isPlainObject(module) || module.kind != "Module" || typeof module.id != "string" ||
+            !/^[a-z][a-z0-9_]*(?:[.-][a-z][a-z0-9_]*)*$/u.test(module.id) || modules.has(module.id) ||
+            !isDenseArray(module.functions) || module.records !== undefined && !isDenseArray(module.records) ||
+            module.errors !== undefined && !isDenseArray(module.errors) ||
+            !isDenseArray(module.imports) || !isDenseArray(module.exports)) {
+            unsupportedCapability(language, "malformed or duplicate semantic program module", module?.location);
+        }
+        if (Reflect.get(module, "classes") !== undefined && (!isDenseArray(module.classes) ||
+            Reflect.get(module, "stdlibFacade") === undefined)) {
+            unsupportedCapability(language, "Task 033 reference classes are not supported by semantic program generation", Reflect.get(module, "classes")?.[0]?.location ?? module.location);
+        }
+        if (Reflect.get(module, "capabilities") !== undefined) {
+            if (!isDenseArray(module.capabilities) || module.capabilities.length == 0) {
+                unsupportedCapability(language, "malformed or empty Task 034 capability graph", module.location);
+            }
+            capabilityModules.push(module);
+        }
+        if (typeof module.sourceFilename != "string" || !sourceFilenames.has(module.sourceFilename)) {
+            unsupportedCapability(language, "semantic program module source identity", module.location);
+        }
+        if (module.entryPoint) {
+            entryCount++;
+            if (module.id != program.entryModule)
+                unsupportedCapability(language, "entry point on an unselected module", module.entryPoint.location);
+        }
+        for (const declaration of [...module.records ?? [], ...module.classes ?? [], ...module.errors ?? [], ...module.functions]) {
+            if (!isPlainObject(declaration) || typeof declaration.id != "string" ||
+                !declaration.id.startsWith(`${module.id}#`) || declarations.has(declaration.id)) {
+                unsupportedCapability(language, "duplicate or unstable program declaration identity", declaration?.location ?? module.location);
+            }
+            declarations.set(declaration.id, { declaration, module });
+        }
+        for (const imported of module.imports) {
+            if (!isPlainObject(imported) || imported.kind != "Import" || typeof imported.moduleId != "string" ||
+                typeof imported.importedName != "string" || typeof imported.localName != "string" ||
+                typeof imported.declarationId != "string" || !["function", "record", "class", "error"].includes(imported.symbolKind) ||
+                typeof imported.typeOnly != "boolean") {
+                unsupportedCapability(language, "malformed semantic program import", imported?.location ?? module.location);
+            }
+        }
+        for (const exported of module.exports) {
+            if (!isPlainObject(exported) || exported.kind != "Export" || typeof exported.exportedName != "string" ||
+                typeof exported.declarationId != "string" || !["function", "record", "class", "error"].includes(exported.symbolKind)) {
+                unsupportedCapability(language, "malformed semantic program export", exported?.location ?? module.location);
+            }
+        }
+        modules.set(module.id, module);
+    }
+    if (entryCount != 1 || !modules.get(program.entryModule)?.entryPoint) {
+        unsupportedCapability(language, "program without exactly one selected entry point", modules.get(program.entryModule)?.location);
+    }
+    const selectedModule = /** @type {import("../semantic/types.js").SemanticProgramModule} */ (modules.get(program.entryModule));
+    const selectedEntry = selectedModule.entryPoint;
+    if (!isPlainObject(selectedEntry?.body) || !isDenseArray(selectedEntry.body.statements) || selectedEntry.body.statements.length == 0) {
+        unsupportedCapability(language, "program without a dense non-empty selected entry point block", selectedEntry?.location ?? selectedModule.location);
+    }
+    const earlier = new Set();
+    for (const module of program.modules) {
+        const localTargetNames = new Set([...module.records ?? [], ...module.classes ?? [], ...module.errors ?? [], ...module.functions]
+            .map(({ name }) => targetName(language, name)));
+        const importedTargetNames = new Set();
+        const localJavaClass = module.records?.[0]?.name ?? module.classes?.[0]?.name ?? module.errors?.[0]?.name ??
+            (module.id == program.entryModule ? "Main" : moduleClassName(module.id));
+        const javaImportClasses = new Map(language == "java" ? [[localJavaClass, module.id]] : []);
+        for (const imported of module.imports) {
+            const resolved = declarations.get(imported.declarationId);
+            const remoteExport = resolved?.module.exports.find((item) => item.declarationId == imported.declarationId && item.exportedName == imported.importedName);
+            if (!resolved || resolved.module.id != imported.moduleId || !earlier.has(imported.moduleId) ||
+                !remoteExport) {
+                unsupportedCapability(language, "unresolved, private, cyclic, or out-of-order program import", imported.location ?? module.location);
+            }
+            const declarationKind = resolved.declaration.kind == "FunctionDeclaration" ? "function" :
+                resolved.declaration.kind == "RecordDeclaration" ? "record" :
+                    resolved.declaration.kind == "ClassDeclaration" ? "class" : "error";
+            if (imported.symbolKind != remoteExport.symbolKind || imported.symbolKind != declarationKind ||
+                imported.typeOnly && declarationKind != "record" && declarationKind != "class") {
+                unsupportedCapability(language, "program import declaration kind mismatch", imported.location ?? module.location);
+            }
+            const importName = programImportName(program, module, imported);
+            if (language != "ruby" && language != "java") {
+                if (imported.symbolKind != "function")
+                    validateTargetTypeIdentifier(language, importName, imported.location);
+                else
+                    validateTargetBindingIdentifier(language, importName, "import", imported.location);
+            }
+            const name = targetName(language, importName);
+            if (language != "ruby" && language != "java" && (localTargetNames.has(name) || importedTargetNames.has(name))) {
+                unsupportedCapability(language, `target import-name collision '${importName}'`, imported.location);
+            }
+            if (language == "java") {
+                const importedClass = imported.symbolKind == "function" ? moduleClassName(resolved.module.id) : resolved.declaration.name;
+                const existingOwner = javaImportClasses.get(importedClass);
+                if (existingOwner && existingOwner != resolved.module.id) {
+                    unsupportedCapability(language, `target import-class collision '${importedClass}'`, imported.location);
+                }
+                javaImportClasses.set(importedClass, resolved.module.id);
+            }
+            if (language == "ruby") {
+                const importedModule = moduleClassName(resolved.module.id);
+                if (localTargetNames.has(importedModule)) {
+                    unsupportedCapability(language, `target import-module collision '${importedModule}'`, imported.location);
+                }
+            }
+            importedTargetNames.add(name);
+        }
+        const valueDeclarationIds = new Set(module.imports.filter(({ typeOnly }) => !typeOnly).map(({ declarationId }) => declarationId));
+        const typeOnlyDeclarationIds = new Set(module.imports
+            .filter(({ declarationId, typeOnly }) => typeOnly && !valueDeclarationIds.has(declarationId))
+            .map(({ declarationId }) => declarationId));
+        const valueConstruction = findTypeOnlyValueConstruction(module, typeOnlyDeclarationIds);
+        if (valueConstruction) {
+            unsupportedCapability(language, "type-only program import used as a value", valueConstruction.location ?? module.location);
+        }
+        const exportNames = new Set();
+        for (const exported of module.exports) {
+            const resolved = declarations.get(exported.declarationId);
+            const name = targetName(language, exported.exportedName);
+            if (language == "javascript" || language == "typescript") {
+                validateTargetIdentifier(language, exported.exportedName, "export", exported.location ?? module.location);
+            }
+            if (!resolved || resolved.module.id != module.id || exportNames.has(name)) {
+                unsupportedCapability(language, `unresolved or colliding target export '${exported.exportedName}'`, exported.location ?? module.location);
+            }
+            const declarationKind = resolved.declaration.kind == "FunctionDeclaration" ? "function" :
+                resolved.declaration.kind == "RecordDeclaration" ? "record" :
+                    resolved.declaration.kind == "ClassDeclaration" ? "class" : "error";
+            if (exported.symbolKind != declarationKind) {
+                unsupportedCapability(language, "program export declaration kind mismatch", exported.location ?? module.location);
+            }
+            if (language != "javascript" && language != "typescript" && exported.exportedName != resolved.declaration.name) {
+                unsupportedCapability(language, `export alias '${exported.exportedName}' without an equivalent target binding`, exported.location ?? resolved.declaration.location);
+            }
+            exportNames.add(name);
+        }
+        if (language == "php") {
+            const exportedDeclarationIds = new Set(module.exports.map(({ declarationId }) => declarationId));
+            const privateDeclaration = [...module.records ?? [], ...module.classes ?? [], ...module.errors ?? [], ...module.functions].find(({ id }) => typeof id == "string" && !exportedDeclarationIds.has(id));
+            if (privateDeclaration) {
+                unsupportedCapability(language, `non-exported declaration '${privateDeclaration.name}' without target-private module visibility`, privateDeclaration.location);
+            }
+        }
+        earlier.add(module.id);
+    }
+    validateProgramStdlibContract(program, language, capabilityModules);
+    validateProgramStdlibFacades(program, language);
+    return program;
+}
+/**
+ * Validates compiler-selected facade descriptors, executable sources, module markers, and native identity evidence.
+ * @param {import("../semantic/types.js").SemanticProgram} program - Candidate program.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Target language for diagnostics.
+ * @returns {void}
+ */
+function validateProgramStdlibFacades(program, language) {
+    const descriptor = Reflect.get(program, "stdlibFacades");
+    const markedModules = program.modules.filter((module) => Reflect.get(module, "stdlibFacade") !== undefined);
+    const facadeSources = program.sources.filter((source) => Reflect.get(source, "ownership") == "facade");
+    const evidencedImports = program.modules.flatMap((module) => module.imports.filter((item) => Reflect.get(item, "stdlibFacade") !== undefined));
+    if (descriptor === undefined) {
+        if (markedModules.length > 0 || facadeSources.length > 0 || evidencedImports.length > 0) {
+            invalidFacadeDescriptor(language, "Facade modules, sources, or import evidence require a complete program facade descriptor.");
+        }
+        return;
+    }
+    if (!isPlainObject(descriptor) || descriptor.schema != "SemantifoldStdlibFacades" || descriptor.version != 1 ||
+        typeof descriptor.language != "string" || !programTargets.has(descriptor.language) || !isDenseArray(descriptor.modules) ||
+        descriptor.modules.length == 0) {
+        invalidFacadeDescriptor(language, "The program facade descriptor is malformed.");
+    }
+    const facadeLanguage = /** @type {import("../semantic/types.js").SemanticLanguage} */ (descriptor.language);
+    const records = descriptor.modules.map((item) => {
+        if (!isPlainObject(item) || typeof item.identity != "string" || typeof item.version != "string") {
+            invalidFacadeDescriptor(language, "The program facade module descriptor is malformed.");
+        }
+        return stdlibFacadeRegistry.resolveIdentity(item.identity, facadeLanguage, item.version);
+    });
+    const expected = stdlibFacadeProgramDescriptor(facadeLanguage, records);
+    if (!equalPlainData(descriptor, expected)) {
+        invalidFacadeDescriptor(language, "The program facade descriptor does not match the registered versioned facade closure.");
+    }
+    const selectedRecords = new Map();
+    for (const record of records) {
+        if (selectedRecords.has(record.identity)) {
+            invalidFacadeDescriptor(language, `Facade '${record.identity}' is selected more than once.`);
+        }
+        for (const dependency of record.dependencies) {
+            const resolved = stdlibFacadeRegistry.resolveIdentity(dependency.identity, facadeLanguage, dependency.range);
+            const selected = selectedRecords.get(resolved.identity);
+            if (!selected || selected.version != resolved.version) {
+                invalidFacadeDescriptor(language, `Facade '${record.identity}' dependency '${resolved.identity}@${resolved.version}' is missing or out of order.`);
+            }
+        }
+        selectedRecords.set(record.identity, record);
+    }
+    if (markedModules.length != records.length) {
+        invalidFacadeDescriptor(language, "The program facade descriptor does not match its executable semantic modules.");
+    }
+    if (program.sources.some((source) => source.language != facadeLanguage ||
+        !["application", "facade"].includes(String(Reflect.get(source, "ownership"))))) {
+        invalidFacadeDescriptor(language, "Facade programs require one source language and explicit application/facade ownership.");
+    }
+    const selectedIdentities = new Set(records.map(({ identity }) => identity));
+    const registeredModules = reparseRegisteredFacadeModules(program, facadeLanguage, language);
+    for (let index = 0; index < records.length; index += 1) {
+        const record = records[index];
+        const module = markedModules[index];
+        const marker = Reflect.get(module, "stdlibFacade");
+        if (!isPlainObject(marker) || Object.keys(marker).sort().join(",") != "identity,version" ||
+            marker.identity != record.identity || marker.version != record.version || module.id != record.source.id ||
+            module.sourceFilename != record.source.filename) {
+            invalidFacadeDescriptor(language, `Facade '${record.identity}' semantic module identity is not canonical.`);
+        }
+        const source = program.sources.find(({ filename }) => filename == record.source.filename);
+        if (!source || source.content != record.source.content || Reflect.get(source, "ownership") != "facade") {
+            invalidFacadeDescriptor(language, `Facade '${record.identity}' executable source does not match its registered definition.`);
+        }
+        const registeredModule = registeredModules.get(record.identity);
+        if (!registeredModule || !equalPlainData(module, registeredModule)) {
+            invalidFacadeAuthority(language, `Facade '${record.identity}' semantic module does not match its registered executable source.`, module.location);
+        }
+        const allowedOperations = new Set(record.requirements.flatMap(({ operations }) => operations));
+        const usedOperations = collectDeclaredEffectOperations(module);
+        if (allowedOperations.size != usedOperations.size || [...allowedOperations].some((operation) => !usedOperations.has(operation))) {
+            invalidFacadeAuthority(language, `Facade '${record.identity}' semantic body does not match its declared canonical requirements.`, module.location);
+        }
+    }
+    if (facadeSources.length != records.length) {
+        invalidFacadeDescriptor(language, "The program contains an unselected compiler-owned facade source.");
+    }
+    if (evidencedImports.length == 0) {
+        invalidFacadeDescriptor(language, "The selected facade closure has no parser-proved native import evidence.");
+    }
+    for (const imported of evidencedImports) {
+        const evidence = Reflect.get(imported, "stdlibFacade");
+        if (!isPlainObject(evidence) || Object.keys(evidence).sort().join(",") !=
+            "facadeIdentity,facadeVersion,nativeModule,nativeSymbol,schema,version" ||
+            evidence.schema != "SemantifoldStdlibFacadeResolution" || evidence.version != 1 ||
+            typeof evidence.facadeIdentity != "string" || typeof evidence.facadeVersion != "string" ||
+            typeof evidence.nativeModule != "string" || typeof evidence.nativeSymbol != "string") {
+            invalidFacadeDescriptor(language, "A facade import has malformed native identity evidence.");
+        }
+        const record = stdlibFacadeRegistry.resolveFacade(facadeLanguage, evidence.nativeModule, evidence.nativeSymbol, evidence.facadeVersion);
+        if (record.identity != evidence.facadeIdentity || !selectedIdentities.has(record.identity) || imported.moduleId != record.source.id ||
+            imported.importedName != evidence.nativeSymbol) {
+            invalidFacadeDescriptor(language, "A facade import does not match its registered native module and symbol identity.");
+        }
+    }
+}
+/**
+ * Collects every canonical operation present in one validated facade implementation.
+ * This checks the facade's complete declared authority independently from program reachability.
+ * @param {import("../semantic/types.js").SemanticProgramModule} module - Facade module.
+ * @returns {Set<string>} Used operation names.
+ */
+function collectDeclaredEffectOperations(module) {
+    const operationNames = new Map(module.capabilities?.flatMap(({ operations }) => operations.map((operation) => [operation.id, operation.name])) ?? []);
+    const used = new Set();
+    const seen = new Set();
+    /**
+     * Visits one facade semantic subtree.
+     * @param {unknown} value - Candidate semantic subtree.
+     */
+    const visit = (value) => {
+        if (!value || typeof value != "object" || seen.has(value))
+            return;
+        seen.add(value);
+        if (!Array.isArray(value)) {
+            const operation = Reflect.get(value, "kind") == "EffectCallExpression" ? Reflect.get(value, "operation") : undefined;
+            if (typeof operation == "string" && operationNames.has(operation))
+                used.add(/** @type {string} */ (operationNames.get(operation)));
+            for (const [key, child] of Object.entries(value)) {
+                if (["capabilities", "location", "provenance", "resolution", "sourceProvenance"].includes(key))
+                    continue;
+                visit(child);
+            }
+        }
+        else
+            for (const child of value)
+                visit(child);
+    };
+    visit({ classes: module.classes, entryPoint: module.entryPoint, functions: module.functions });
+    return used;
+}
+/**
+ * Recompiles the registry-selected facade closure from retained caller inputs and registered facade source.
+ * This parser-backed reference graph is created during validation, before provider planning or writer allocation.
+ * @param {import("../semantic/types.js").SemanticProgram} program - Untrusted mutable semantic program.
+ * @param {import("../semantic/types.js").SemanticLanguage} facadeLanguage - Selected source-language facade profile.
+ * @param {import("../semantic/types.js").SemanticLanguage} diagnosticLanguage - Target language for boundary diagnostics.
+ * @returns {Map<string, import("../semantic/types.js").SemanticProgramModule>} Canonical semantic modules by facade identity.
+ */
+function reparseRegisteredFacadeModules(program, facadeLanguage, diagnosticLanguage) {
+    const applicationModules = program.modules.filter((module) => Reflect.get(module, "stdlibFacade") === undefined);
+    const modulesByFilename = new Map(applicationModules.map((module) => [module.sourceFilename, module]));
+    const applicationSources = program.sources.filter((source) => Reflect.get(source, "ownership") == "application").map((source) => {
+        const module = modulesByFilename.get(source.filename);
+        if (!module)
+            invalidFacadeDescriptor(diagnosticLanguage, `Application source '${source.filename}' has no matching semantic module for facade verification.`);
+        return {
+            filename: source.filename,
+            id: /** @type {import("../semantic/types.js").SemanticProgramModule} */ (module).id,
+            language: facadeLanguage,
+            source: /** @type {string} */ (source.content)
+        };
+    });
+    if (applicationSources.length != applicationModules.length) {
+        invalidFacadeDescriptor(diagnosticLanguage, "Facade verification requires one retained application source per semantic module.");
+    }
+    const reparsed = parseProgramSource({ entryModule: program.entryModule, sources: applicationSources });
+    const modules = new Map();
+    for (const module of reparsed.modules) {
+        if (!module.stdlibFacade)
+            continue;
+        if (modules.has(module.stdlibFacade.identity)) {
+            invalidFacadeDescriptor(diagnosticLanguage, `Registered facade '${module.stdlibFacade.identity}' reparsed more than once.`);
+        }
+        modules.set(module.stdlibFacade.identity, module);
+    }
+    return modules;
+}
+/**
+ * Compares closed plain JSON-shaped data without coercion or key-order assumptions.
+ * @param {unknown} left - Candidate value.
+ * @param {unknown} right - Expected value.
+ * @returns {boolean} Exact recursive equivalence.
+ */
+function equalPlainData(left, right) {
+    if (left === right)
+        return true;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        return Array.isArray(left) && Array.isArray(right) && isDenseArray(left) && isDenseArray(right) &&
+            left.length == right.length && left.every((value, index) => equalPlainData(value, right[index]));
+    }
+    if (!isPlainObject(left) || !isPlainObject(right))
+        return false;
+    const leftKeys = Object.keys(left).sort();
+    const rightKeys = Object.keys(right).sort();
+    return leftKeys.length == rightKeys.length && leftKeys.every((key, index) => key == rightKeys[index] && equalPlainData(left[key], right[key]));
+}
+/**
+ * Throws one stable facade artifact-boundary diagnostic.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @param {string} message - Diagnostic detail.
+ * @returns {never} Always throws.
+ */
+function invalidFacadeDescriptor(language, message) {
+    throw new SemantifoldDiagnostic({ code: "STDLIB_FACADE_DESCRIPTOR_INVALID", language, message });
+}
+/**
+ * Throws when a facade semantic body exceeds or omits its registry-declared authority.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @param {string} message - Diagnostic detail.
+ * @param {import("../semantic/types.js").SourceLocation} location - Facade source location.
+ * @returns {never} Always throws.
+ */
+function invalidFacadeAuthority(language, message, location) {
+    throw new SemantifoldDiagnostic({ code: "STDLIB_FACADE_AUTHORITY_FORGED", language, location, message });
+}
+/**
+ * Validates the program stdlib link descriptor against its capability modules.
+ * @param {import("../semantic/types.js").SemanticProgram} program - Candidate program.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @param {import("../semantic/types.js").SemanticProgramModule[]} capabilityModules - Modules carrying capabilities.
+ * @returns {void}
+ */
+function validateProgramStdlibContract(program, language, capabilityModules) {
+    const contract = Reflect.get(program, "stdlibContract");
+    const contracts = Reflect.get(program, "stdlibContracts");
+    if (capabilityModules.length == 0) {
+        if (contract !== undefined || contracts !== undefined) {
+            throw new SemantifoldDiagnostic({
+                code: "STDLIB_LINK_FAILURE",
+                language,
+                message: "A declared standard-library contract requires capability modules."
+            });
+        }
+        return;
+    }
+    if (contract !== undefined && contracts !== undefined) {
+        throw new SemantifoldDiagnostic({
+            code: "STDLIB_LINK_FAILURE",
+            language,
+            message: "A program cannot declare both singular and plural standard-library contract descriptors."
+        });
+    }
+    if (contract === undefined && contracts === undefined) {
+        unsupportedCapability(language, "program modules with capabilities require a declared standard-library contract", capabilityModules[0].location);
+    }
+    const declared = contracts === undefined ? [contract] : contracts;
+    if (!isDenseArray(declared) || declared.length == 0) {
+        throw new SemantifoldDiagnostic({
+            code: "STDLIB_LINK_FAILURE",
+            language,
+            message: "The declared standard-library contract descriptor list is malformed or empty."
+        });
+    }
+    const identities = new Set();
+    for (const descriptor of declared) {
+        if (!isPlainObject(descriptor) || Object.keys(descriptor).some((key) => key != "identity" && key != "contractVersion")) {
+            throw new SemantifoldDiagnostic({
+                code: "STDLIB_LINK_FAILURE",
+                language,
+                message: "The declared standard-library contract descriptor is malformed."
+            });
+        }
+        const identity = descriptor.identity;
+        if (typeof identity != "string" || identity.length == 0 || identities.has(identity) ||
+            !listStdlibModules().some(({ identity: registered }) => registered == identity)) {
+            throw new SemantifoldDiagnostic({
+                code: "STDLIB_LINK_FAILURE",
+                language,
+                message: `Declared standard-library contract '${String(identity)}' is duplicate or not a registered canonical module.`
+            });
+        }
+        if (descriptor.contractVersion !== undefined && parseStdlibVersionRange(descriptor.contractVersion) === null) {
+            throw new SemantifoldDiagnostic({
+                code: "STDLIB_LINK_FAILURE",
+                language,
+                message: `Declared standard-library contract version '${String(descriptor.contractVersion)}' is not canonical.`
+            });
+        }
+        identities.add(identity);
+    }
+    for (const module of capabilityModules) {
+        for (const capability of module.capabilities ?? []) {
+            if (!isPlainObject(capability) || typeof capability.authorityId != "string" || !identities.has(capability.authorityId)) {
+                throw new SemantifoldDiagnostic({
+                    code: "STDLIB_LINK_FAILURE",
+                    language,
+                    message: `Capability authority '${String(Reflect.get(capability, "authorityId"))}' does not match a declared standard-library contract.`
+                });
+            }
+        }
+    }
+}
+/**
+ * Finds a record construction that crosses a type-only import edge.
+ * @param {import("../semantic/types.js").SemanticProgramModule} module - Importing semantic module.
+ * @param {Set<string>} typeOnlyDeclarationIds - Imported identities unavailable in value positions.
+ * @returns {import("../semantic/types.js").RecordConstruction | undefined} Invalid construction when present.
+ */
+function findTypeOnlyValueConstruction(module, typeOnlyDeclarationIds) {
+    if (typeOnlyDeclarationIds.size == 0)
+        return undefined;
+    const seen = new WeakSet();
+    /**
+     * Visits one semantic value.
+     * @param {unknown} value - Candidate semantic subtree.
+     * @returns {import("../semantic/types.js").RecordConstruction | undefined} Invalid construction when present.
+     */
+    function visit(value) {
+        if (!value || typeof value != "object" || seen.has(value))
+            return undefined;
+        seen.add(value);
+        const object = /** @type {Record<string, unknown>} */ (value);
+        if (object.kind == "RecordConstruction" && isPlainObject(object.record) &&
+            typeof object.record.declarationId == "string" && typeOnlyDeclarationIds.has(object.record.declarationId)) {
+            return /** @type {import("../semantic/types.js").RecordConstruction} */ (value);
+        }
+        for (const child of Object.values(object)) {
+            const found = visit(child);
+            if (found)
+                return found;
+        }
+        return undefined;
+    }
+    return visit({ entryPoint: module.entryPoint, functions: module.functions });
+}
+/**
+ * Plans all paths before emission and rejects exact/case/file-directory collisions.
+ * @param {import("../semantic/types.js").SemanticProgram} program - Validated program.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Target language.
+ * @param {StdlibProgramLinking | null} [linking] - Planned stdlib provider link.
+ * @returns {Map<string, string>} Path by module identity.
+ */
+function planModulePaths(program, language, linking = null) {
+    const extension = language == "javascript" ? ".js" : language == "typescript" ? ".ts" : language == "ruby" ? ".rb" :
+        language == "php" ? ".php" : ".java";
+    const paths = new Map();
+    const folded = new Set();
+    const targetModuleNames = new Set();
+    const providerPaths = linking ? linking.negotiation.providers.map(({ module }) => 
+    /** @type {import("../stdlib-providers.js").StdlibProviderRecord} */ (linking.records.get(module)).artifact.path) : [];
+    const foldedProviders = new Map();
+    for (const providerPath of providerPaths) {
+        const key = providerPath.toLocaleLowerCase("en-US");
+        if (!isSafeArtifactPath(providerPath) || folded.has(key)) {
+            throw new SemantifoldDiagnostic({ code: "STDLIB_NAME_COLLISION", language,
+                message: `Stdlib provider artifact path '${providerPath}' is unsafe or colliding.` });
+        }
+        folded.add(key);
+        foldedProviders.set(providerPath.toLocaleLowerCase("en-US").replaceAll(".", "/"), providerPath);
+    }
+    for (const module of program.modules) {
+        let path = `${module.id.replaceAll(".", "/")}${extension}`;
+        const providerPath = foldedProviders.get(path.toLocaleLowerCase("en-US").replaceAll(".", "/"));
+        if (providerPath !== undefined) {
+            throw new SemantifoldDiagnostic({
+                code: "STDLIB_NAME_COLLISION",
+                language,
+                message: `Module path '${path}' collides with the stdlib provider artifact '${providerPath}'.`
+            });
+        }
+        const targetModuleName = moduleClassName(module.id);
+        if (language == "php" || language == "ruby") {
+            const key = language == "php" ? targetModuleName.toLocaleLowerCase("en-US") : targetModuleName;
+            if (targetModuleNames.has(key)) {
+                unsupportedCapability(language, `target module-name collision '${targetModuleName}'`, module.location);
+            }
+            targetModuleNames.add(key);
+        }
+        if (language == "php") {
+            validateTargetIdentifier(language, targetModuleName, "module", module.location);
+            validateTargetTypeIdentifier(language, targetModuleName, module.location);
+        }
+        if (language == "ruby")
+            validateTargetTypeIdentifier(language, targetModuleName, module.location);
+        if (language == "java") {
+            for (const segment of module.id.split("."))
+                validateTargetIdentifier(language, segment, "module", module.location);
+            const nominalCount = (module.records?.length ?? 0) + (module.classes?.length ?? 0) + (module.errors?.length ?? 0);
+            if (module.id.includes("-") || nominalCount > 1 ||
+                nominalCount > 0 && (module.functions.length > 0 || module.entryPoint)) {
+                unsupportedCapability(language, "Java module layout requiring multiple public declarations in one semantic module", module.location);
+            }
+            const className = module.records?.[0]?.name ?? module.classes?.[0]?.name ?? module.errors?.[0]?.name ??
+                (module.id == program.entryModule ? "Main" : targetModuleName);
+            if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(className)) {
+                unsupportedCapability(language, `invalid Java public class name '${className}'`, module.location);
+            }
+            if (module.id != program.entryModule)
+                validateTargetTypeIdentifier(language, className, module.location);
+            path = `semantifold/generated/${module.id.replaceAll(".", "/")}/${className}.java`;
+        }
+        const key = path.toLocaleLowerCase("en-US");
+        if (!isSafeArtifactPath(path) || folded.has(key))
+            unsupportedCapability(language, `unsafe or colliding target path '${path}'`, module.location);
+        folded.add(key);
+        paths.set(module.id, path);
+    }
+    return paths;
+}
+/**
+ * Converts a logical module identity to its canonical target type segment.
+ * @param {string} id - Logical module identity.
+ * @returns {string} Target class name.
+ */
+function moduleClassName(id) {
+    return id.split(/[._-]+/u).map((part) => `${part[0].toUpperCase()}${part.slice(1)}`).join("");
+}
+/**
+ * Normalizes a declaration or binding name for target collision checks.
+ * @param {import("../semantic/types.js").SemanticLanguage} language - Target.
+ * @param {string} name - Name.
+ * @returns {string} Collision key.
+ */
+function targetName(language, name) {
+    return language == "php" ? name.toLocaleLowerCase("en-US") : name;
+}
+/**
+ * Reports whether a candidate is a direct plain object.
+ * @param {unknown} value - Candidate.
+ * @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;
+}
+/**
+ * Raises a stable malformed program-generation request diagnostic.
+ * @param {string} message - Stable failure.
+ * @returns {never} Always throws.
+ */
+function invalidProgramGeneration(message) {
+    throw new SemantifoldDiagnostic({ code: "INVALID_PROGRAM", language: "program", message });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"program.js","sourceRoot":"","sources":["../../../src/backends/program.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {isDenseArray} from \"../array.js\"\nimport {isSafeArtifactPath, isSafeSourcePath} from \"../artifact-path.js\"\nimport {createGeneratedArtifactSet} from \"../artifacts.js\"\nimport {SemantifoldDiagnostic, unsupportedCapability, unsupportedRole} from \"../diagnostic.js\"\nimport {parseProgramSource} from \"../frontends/program.js\"\nimport {languageRegistry} from \"../language-registry.js\"\nimport {finalizeMapping, toSourceMapV3} from \"../mapping.js\"\nimport {createCoordinateIndex, indexedPointAt, moduleLocation} from \"../semantic/location.js\"\nimport {semanticEntries} from \"../semantic/provenance.js\"\nimport {listStdlibModules, parseStdlibVersionRange} from \"../semantic/stdlib.js\"\nimport {moduleUncheckedErrorEffects} from \"../semantic/validate.js\"\nimport {negotiateStdlibProviders} from \"../stdlib-negotiation.js\"\nimport {stdlibFacadeProgramDescriptor, stdlibFacadeRegistry} from \"../stdlib-facades.js\"\nimport {stdlibProviderRegistry} from \"../stdlib-providers.js\"\nimport {preflightEffectCapabilities} from \"./effects.js\"\nimport {validateTargetBindingIdentifier, validateTargetIdentifier, validateTargetTypeIdentifier} from \"./identifiers.js\"\nimport {generateStdlibProviderContent} from \"./stdlib-support.js\"\nimport {validateBackendModule} from \"./shared.js\"\nimport {programImportName, SourceWriter} from \"./writer.js\"\n\n/** @type {Readonly<Set<import(\"../semantic/types.js\").SemanticLanguage>>} */\nconst programTargets = new Set([\"php\", \"ruby\", \"javascript\", \"typescript\", \"java\"])\n/** @type {Readonly<Set<import(\"../semantic/types.js\").BackendLanguage>>} */\nconst programApplicationTargets = new Set([\"android\", \"ios\"])\n\n/**\n * Validates and prepares a complete semantic program for a non-text backend without allocating a writer.\n * @param {object} input - Backend preflight request.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} input.backendLanguage - Existing semantic backend profile to enforce.\n * @param {import(\"../semantic/types.js\").BackendLanguage} input.diagnosticLanguage - Public target identity for capability failures.\n * @param {import(\"../semantic/types.js\").SemanticProgram} input.program - Complete candidate program.\n * @param {Readonly<Set<import(\"../semantic/types.js\").SemanticLanguage>>} [input.sourceLanguages] - Accepted source provenance languages.\n * @returns {{modules: import(\"../semantic/types.js\").SemanticModule[], program: import(\"../semantic/types.js\").SemanticProgram, sources: {content: string, filename: string, language?: import(\"../semantic/types.js\").SemanticLanguage}[]}} Prepared immutable-input views.\n */\nexport function preflightSemanticProgram({backendLanguage, diagnosticLanguage, program: candidate, sourceLanguages}) {\n  try {\n    const program = validateProgram(candidate, backendLanguage, sourceLanguages)\n    const modules = prepareEmissionModules(program, backendLanguage)\n\n    validateProgramSourceOwnership(program, backendLanguage)\n    const sources = program.sources.map((source) => {\n      if (source.content === null) invalidProgramGeneration(`Program source '${source.filename}' has no retained content.`)\n\n      return {content: source.content, filename: source.filename, ...(source.language ? {language: source.language} : {})}\n    })\n\n    return {modules, program, sources}\n  } catch (error) {\n    if (error instanceof SemantifoldDiagnostic && error.code == \"UNSUPPORTED_CAPABILITY\" &&\n      error.language != diagnosticLanguage) {\n      throw new SemantifoldDiagnostic({\n        cause: error,\n        code: error.code,\n        language: diagnosticLanguage,\n        location: error.location,\n        message: error.detail\n      })\n    }\n    throw error\n  }\n}\n\n/**\n * Generates a complete deterministic mapped artifact set for one semantic program.\n * @param {object} input - Program generation request.\n * @param {import(\"../semantic/types.js\").BackendLanguage} input.language - Registered program target.\n * @param {import(\"../semantic/types.js\").SemanticProgram} input.program - Complete semantic program.\n * @param {\"text\" | \"application\"} [input.role] - Explicit artifact role; omitted preserves text generation.\n * @param {import(\"../semantic/types.js\").IosApplicationConfigurationInput | import(\"../semantic/types.js\").AndroidApplicationConfigurationInput} [input.configuration] - Application configuration.\n * @param {import(\"../semantic/types.js\").IosApplicationAssetInput[] | import(\"../semantic/types.js\").AndroidApplicationInputFile[]} [input.assets] - Exact caller assets.\n * @param {import(\"../semantic/types.js\").AndroidApplicationInputFile[]} [input.resources] - Exact Android caller resources.\n * @returns {import(\"../semantic/types.js\").GeneratedArtifactSet} Transactionally validated artifact set.\n */\nexport function generateProgramArtifacts(input) {\n  if (!isPlainObject(input) || typeof input.language != \"string\") invalidProgramGeneration(\"Program generation requires a target language and program.\")\n  const role = input.role ?? \"text\"\n\n  if (role != \"text\" && role != \"application\") invalidProgramGeneration(\"Program artifact role must be 'text' or 'application'.\")\n  languageRegistry.record(input.language)\n  if (role == \"application\") {\n    if (!programApplicationTargets.has(input.language)) unsupportedRole(input.language, \"multi-file application backend\")\n    const backend = languageRegistry.resolve(input.language, \"applicationBackend\")\n\n    return createGeneratedArtifactSet(backend(input))\n  }\n  if (!programTargets.has(/** @type {import(\"../semantic/types.js\").SemanticLanguage} */ (input.language))) {\n    unsupportedRole(input.language, \"multi-file text backend\")\n  }\n  const language = /** @type {import(\"../semantic/types.js\").SemanticLanguage} */ (input.language)\n  const program = validateProgram(input.program, language)\n  const linking = planStdlibLinking(program, language)\n  const emissionModules = prepareEmissionModules(program, language, linking)\n  validateProgramSourceOwnership(program, language)\n  const paths = planModulePaths(program, language, linking)\n  const sources = program.sources.map((source) => {\n    if (source.content === null) invalidProgramGeneration(`Program source '${source.filename}' has no retained content.`)\n\n    return {content: source.content, filename: source.filename, ...(source.language ? {language: source.language} : {})}\n  })\n  const backend = /** @type {typeof import(\"./javascript.js\").generateJavaScript} */ (\n    languageRegistry.resolve(language, \"textBackend\"))\n  const mediaType = languageRegistry.record(language).mediaType\n  /** @type {import(\"../semantic/types.js\").GeneratedSetArtifact[]} */\n  const artifacts = language == \"javascript\" || language == \"typescript\" ? [{\n    content: \"{\\n  \\\"type\\\": \\\"module\\\"\\n}\\n\",\n    contentKind: /** @type {const} */ (\"text\"),\n    mediaType: \"application/json\",\n    ownership: /** @type {const} */ (\"generated\"),\n    path: \"package.json\",\n    provenance: {\n      kind: /** @type {const} */ (\"synthetic\"),\n      reason: \"Declares the generated JavaScript-family artifact set as canonical ESM.\",\n      relatedOrigins: []\n    },\n    role: \"manifest\"\n  }] : []\n\n  if (linking && language != \"java\") {\n    for (const provider of linking.negotiation.providers) {\n      const record = /** @type {import(\"../stdlib-providers.js\").StdlibProviderRecord} */ (linking.records.get(provider.module))\n\n      artifacts.push({\n        content: generateStdlibProviderContent(/** @type {\"php\" | \"ruby\" | \"javascript\" | \"typescript\"} */ (language),\n          [...provider.operations], provider.module),\n        contentKind: /** @type {const} */ (\"text\"),\n        mediaType: record.artifact.mediaType,\n        ownership: /** @type {const} */ (\"generated\"),\n        path: record.artifact.path,\n        provenance: {\n          kind: /** @type {const} */ (\"synthetic\"),\n          reason: `semantifold-stdlib-provider:${record.identity}`,\n          relatedOrigins: []\n        },\n        role: /** @type {const} */ (\"support\")\n      })\n    }\n  }\n\n  for (const emissionModule of emissionModules) {\n    const moduleId = /** @type {string} */ (Reflect.get(emissionModule, \"id\"))\n    const filename = /** @type {string} */ (paths.get(moduleId))\n    const writer = new SourceWriter({\n      filename,\n      language,\n      module: emissionModule,\n      program,\n      programPaths: paths,\n      sources,\n      ...(linking && emissionModule.capabilities !== undefined ? {\n        stdlibProviderEntries: Object.fromEntries((linking.usedOperationsByModule.get(moduleId) ?? []).map(({module, operation}) => [\n          qualifiedOperationKey(module, operation),\n          /** @type {string} */ (linking.records.get(module)?.nativeEntries[operation])\n        ])),\n        stdlibProviderImports: language == \"java\" || language == \"javascript\" || language == \"typescript\" ?\n          linking.providerImportsByModule.get(moduleId) : undefined,\n        stdlibProviderPaths: linking.providerPathsByModule.get(moduleId),\n        ...(language == \"java\" ? {\n          stdlibProviderOwnerModule: /** @type {string} */ (linking.ownerModuleId),\n          stdlibProviderShims: moduleId == linking.ownerModuleId ? linking.usedOperations.map(({operation}) => operation) : undefined\n        } : {})\n      } : {})\n    })\n\n    backend(emissionModule, writer)\n    const mapping = finalizeMapping(writer.finish())\n\n    artifacts.push({\n      content: mapping.generated.content,\n      contentKind: /** @type {const} */ (\"text\"),\n      mediaType: /** @type {string} */ (mediaType),\n      ownership: /** @type {const} */ (\"generated\"),\n      path: filename,\n      provenance: {\n        kind: /** @type {const} */ (\"text\"),\n        mapping,\n        sourceMap: toSourceMapV3(mapping),\n        sourceMapFilename: `${filename}.map`\n      },\n      role: /** @type {import(\"../semantic/types.js\").GeneratedArtifactRole} */ (\n        moduleId == program.entryModule ? \"entry\" : Reflect.get(emissionModule, \"stdlibFacade\") ? \"support\" : \"source\")\n    })\n  }\n\n  return createGeneratedArtifactSet({\n    artifacts,\n    ...(linking || program.stdlibFacades ? {metadata: stdlibLinkMetadata(linking, paths, program.stdlibFacades)} : {}),\n    target: language\n  })\n}\n\n/**\n * @typedef StdlibProgramLinking\n * @property {import(\"../stdlib-negotiation.js\").StdlibNegotiationResult} negotiation - Negotiated provider closure.\n * @property {Map<string, import(\"../stdlib-providers.js\").StdlibProviderRecord>} records - Materialized provider records by canonical module.\n * @property {QualifiedStdlibOperation[]} usedOperations - Program-wide used canonical operations in stable order.\n * @property {Map<string, QualifiedStdlibOperation[]>} usedOperationsByModule - Used canonical operations by program module identity.\n * @property {Map<string, string[]>} providerImportsByModule - Ordered provider import names by module identity.\n * @property {Map<string, string[]>} providerPathsByModule - Provider artifact closure by program module identity.\n * @property {string | null} ownerModuleId - Java target: first operation-using module identity hosting the shared support; null for artifact-materializing targets.\n */\n\n/**\n * @typedef QualifiedStdlibOperation\n * @property {string} module - Canonical module identity.\n * @property {string} operation - Canonical operation name.\n */\n\n/**\n * Plans the linked stdlib provider for one program, or reports that no operation is used.\n * Java resolves the same negotiated provider record but hosts its support in the first\n * operation-using module instead of a separate provider artifact.\n * @param {import(\"../semantic/types.js\").SemanticProgram} program - Validated semantic program.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @returns {StdlibProgramLinking | null} Linking plan, or null when nothing is used.\n */\nfunction planStdlibLinking(program, language) {\n  const {programWide, usedOperationsByModule} = collectUsedEffectOperations(program)\n\n  if (programWide.length == 0) return null\n  const contracts = program.stdlibContracts ?? [/** @type {{identity: string, contractVersion?: string}} */ (program.stdlibContract)]\n  const contractsByIdentity = new Map(contracts.map((contract) => [contract.identity, contract]))\n  const requirementsByModule = new Map()\n\n  for (const qualified of programWide) {\n    const requirement = requirementsByModule.get(qualified.module) ?? []\n\n    requirement.push(qualified.operation)\n    requirementsByModule.set(qualified.module, requirement)\n  }\n  const negotiation = negotiateStdlibProviders({\n    requirements: [...requirementsByModule].map(([module, operations]) => {\n      const contract = contractsByIdentity.get(module)\n\n      if (!contract) throw new SemantifoldDiagnostic({\n        code: \"STDLIB_LINK_FAILURE\",\n        language,\n        message: `Reachable canonical operation '${module}.${operations[0]}' has no declared standard-library contract.`\n      })\n      return {module, operations, ...(contract.contractVersion !== undefined ? {range: contract.contractVersion} : {})}\n    }),\n    target: language\n  })\n  /** @type {Map<string, import(\"../stdlib-providers.js\").StdlibProviderRecord>} */\n  const records = new Map()\n\n  for (const selected of negotiation.modules) {\n    const candidates = stdlibProviderRegistry.providersFor(language, selected.identity, selected.version)\n\n    if (candidates.length != 1) {\n      throw new SemantifoldDiagnostic({\n        code: \"STDLIB_LINK_FAILURE\",\n        language,\n        message: `Expected exactly one registered stdlib provider for '${selected.identity}' on '${language}'.`\n      })\n    }\n    records.set(selected.identity, /** @type {import(\"../stdlib-providers.js\").StdlibProviderRecord} */ (candidates[0]))\n  }\n  const ownerModuleId = language == \"java\"\n    ? program.modules.map((module) => module.id).find((id) => (usedOperationsByModule.get(id) ?? []).length > 0)\n    : null\n\n  if (ownerModuleId === undefined) throw new SemantifoldDiagnostic({\n    code: \"STDLIB_LINK_FAILURE\",\n    language,\n    message: \"Java program linking requires one module using canonical operations.\"\n  })\n\n  return {\n    negotiation,\n    ownerModuleId,\n    providerImportsByModule: collectProviderImports(program, negotiation, records, usedOperationsByModule, language, ownerModuleId),\n    providerPathsByModule: collectProviderPaths(negotiation, records, usedOperationsByModule),\n    records,\n    usedOperations: [...programWide],\n    usedOperationsByModule\n  }\n}\n\n/**\n * Selects the exact provider/type dependency closure required by each emitting program module.\n * @param {import(\"../stdlib-negotiation.js\").StdlibNegotiationResult} negotiation - Negotiated program closure.\n * @param {Map<string, import(\"../stdlib-providers.js\").StdlibProviderRecord>} records - Selected provider records.\n * @param {Map<string, QualifiedStdlibOperation[]>} usedOperationsByModule - Reachable operations by program module.\n * @returns {Map<string, string[]>} Ordered provider paths by program module.\n */\nfunction collectProviderPaths(negotiation, records, usedOperationsByModule) {\n  const paths = new Map()\n\n  for (const [moduleId, operations] of usedOperationsByModule) {\n    const selected = new Set(operations.map(({module}) => module))\n    let changed = true\n\n    while (changed) {\n      changed = false\n      for (const module of [...selected]) {\n        for (const dependency of records.get(module)?.dependencies ?? []) {\n          if (!selected.has(dependency.module)) {\n            selected.add(dependency.module)\n            changed = true\n          }\n        }\n      }\n    }\n    paths.set(moduleId, negotiation.providers.filter(({module}) => selected.has(module)).map(({module}) =>\n      /** @type {import(\"../stdlib-providers.js\").StdlibProviderRecord} */ (records.get(module)).artifact.path))\n  }\n  return paths\n}\n\n/**\n * Collects the canonical operations invoked by each program module in stable order.\n * @param {import(\"../semantic/types.js\").SemanticProgram} program - Validated semantic program.\n * @returns {{programWide: QualifiedStdlibOperation[], usedOperationsByModule: Map<string, QualifiedStdlibOperation[]>}} Used operations.\n */\nfunction collectUsedEffectOperations(program) {\n  /** @type {Map<string, QualifiedStdlibOperation[]>} */\n  const usedOperationsByModule = new Map()\n  /** @type {Map<string, QualifiedStdlibOperation>} */\n  const programWide = new Map()\n  /** @type {Map<string, {body: unknown, module: import(\"../semantic/types.js\").SemanticProgramModule}>} */\n  const bodies = new Map()\n\n  for (const module of program.modules) {\n    for (const declaration of module.functions) bodies.set(/** @type {string} */ (declaration.id), {body: declaration.body, module})\n    for (const declaration of module.classes ?? []) {\n      bodies.set(/** @type {string} */ (declaration.constructor.id), {body: declaration.constructor.body, module})\n      for (const method of declaration.methods) bodies.set(/** @type {string} */ (method.id), {body: method.body, module})\n    }\n    usedOperationsByModule.set(module.id, [])\n  }\n  const entryModule = /** @type {import(\"../semantic/types.js\").SemanticProgramModule} */ (\n    program.modules.find(({id}) => id == program.entryModule))\n  /** @type {{body: unknown, module: import(\"../semantic/types.js\").SemanticProgramModule}[]} */\n  const pending = [{body: entryModule.entryPoint?.body, module: entryModule}]\n  const reachedDeclarations = new Set()\n\n  while (pending.length > 0) {\n    const current = /** @type {{body: unknown, module: import(\"../semantic/types.js\").SemanticProgramModule}} */ (pending.shift())\n    const operationNames = new Map(current.module.capabilities?.flatMap((capability) =>\n      capability.operations.map((operation) => [operation.id, {module: capability.authorityId, operation: operation.name}])) ?? [])\n    const seen = new Set()\n\n    /**\n     * Visits one reachable semantic subtree.\n     * @param {unknown} value - Candidate semantic subtree.\n     */\n    const visit = (value) => {\n      if (!value || typeof value != \"object\" || seen.has(value)) return\n      seen.add(value)\n\n      if (!Array.isArray(value)) {\n        const kind = Reflect.get(value, \"kind\")\n\n        if (kind == \"EffectCallExpression\") {\n          const operation = Reflect.get(value, \"operation\")\n\n          if (typeof operation == \"string\") {\n            const qualified = operationNames.get(operation)\n\n            if (qualified !== undefined) {\n              const key = qualifiedOperationKey(qualified.module, qualified.operation)\n              const moduleOperations = /** @type {QualifiedStdlibOperation[]} */ (usedOperationsByModule.get(current.module.id))\n\n              if (!moduleOperations.some((item) => qualifiedOperationKey(item.module, item.operation) == key)) moduleOperations.push(qualified)\n              programWide.set(key, qualified)\n            }\n          }\n        }\n        const declarationId = isPlainObject(Reflect.get(value, \"resolution\"))\n          ? Reflect.get(Reflect.get(value, \"resolution\"), \"declarationId\") : undefined\n\n        if (typeof declarationId == \"string\" && !reachedDeclarations.has(declarationId)) {\n          const declaration = bodies.get(declarationId)\n\n          if (declaration) {\n            reachedDeclarations.add(declarationId)\n            pending.push(declaration)\n          }\n        }\n        for (const [key, child] of Object.entries(value)) {\n          if ([\"capabilities\", \"location\", \"provenance\", \"resolution\", \"sourceProvenance\"].includes(key)) continue\n          visit(child)\n        }\n      } else for (const child of value) visit(child)\n    }\n\n    visit(current.body)\n  }\n  for (const operations of usedOperationsByModule.values()) {\n    operations.sort((left, right) => qualifiedOperationKey(left.module, left.operation)\n      .localeCompare(qualifiedOperationKey(right.module, right.operation), \"en\"))\n  }\n  return {programWide: [...programWide.values()].sort((left, right) => qualifiedOperationKey(left.module, left.operation)\n    .localeCompare(qualifiedOperationKey(right.module, right.operation), \"en\")), usedOperationsByModule}\n}\n\n/**\n * Builds an unambiguous internal key for one canonical operation authority.\n * @param {string} module - Canonical module identity.\n * @param {string} operation - Canonical operation name.\n * @returns {string} Qualified internal key.\n */\nfunction qualifiedOperationKey(module, operation) {\n  return `${module}\\u0000${operation}`\n}\n\n/**\n * Collects the ordered provider import names each module must pull from the linked provider.\n * Java modules list referenced capability type names only; the owner lists none.\n * @param {import(\"../semantic/types.js\").SemanticProgram} program - Validated semantic program.\n * @param {import(\"../stdlib-negotiation.js\").StdlibNegotiationResult} negotiation - Negotiated closure.\n * @param {Map<string, import(\"../stdlib-providers.js\").StdlibProviderRecord>} records - Provider records by canonical module.\n * @param {Map<string, QualifiedStdlibOperation[]>} usedOperationsByModule - Used canonical operations by module identity.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @param {string | null} [ownerModuleId] - Java owner module identity.\n * @returns {Map<string, string[]>} Ordered provider import names by module identity.\n */\nfunction collectProviderImports(program, negotiation, records, usedOperationsByModule, language, ownerModuleId = null) {\n  /** @type {Map<string, string[]>} */\n  const providerImportsByModule = new Map()\n\n  for (const module of program.modules) {\n    if (module.capabilities === undefined) continue\n    const used = new Set((usedOperationsByModule.get(module.id) ?? []).map(({module: owner, operation}) =>\n      qualifiedOperationKey(owner, operation)))\n    /** @type {Set<string>} */\n    const surface = new Set()\n    /** @type {Map<string, string>} */\n    const resourceNameById = new Map()\n\n    /** @type {Map<string, string>} */\n    const declarationNames = new Map((module.records ?? []).map((declaration) => [/** @type {string} */ (declaration.id), declaration.name]))\n\n    for (const declaration of module.errors ?? []) {\n      declarationNames.set(/** @type {string} */ (declaration.id), declaration.name)\n    }\n\n    for (const capability of module.capabilities) {\n      for (const resource of capability.resources) {\n        surface.add(resource.name)\n        resourceNameById.set(resource.id, resource.name)\n      }\n      for (const failure of capability.failures) {\n        surface.add(failure.name)\n        declarationNames.set(failure.id, failure.name)\n      }\n    }\n    const referenced = new Set()\n    const seen = new Set()\n\n    /**\n     * Visits one semantic value.\n     * @param {unknown} value - Candidate semantic subtree.\n     * @returns {void}\n     */\n    const visit = (value) => {\n      if (!value || typeof value != \"object\" || seen.has(value)) return\n      seen.add(value)\n\n      if (!Array.isArray(value)) {\n        const kind = Reflect.get(value, \"kind\")\n\n        if (kind == \"OwnedResourceType\") {\n          const resourceId = Reflect.get(value, \"resourceId\")\n\n          if (typeof resourceId == \"string\") {\n            const name = resourceNameById.get(resourceId)\n\n            if (name !== undefined) referenced.add(name)\n          }\n        } else if (kind == \"ReferenceType\" || kind == \"OwnedReferenceType\" || kind == \"ErrorType\") {\n          const declarationId = Reflect.get(value, \"declarationId\")\n\n          if (typeof declarationId == \"string\") {\n            const name = declarationNames.get(declarationId)\n\n            if (name !== undefined && surface.has(name)) referenced.add(name)\n          }\n        }\n        for (const [key, child] of Object.entries(value)) {\n          if (key == \"capabilities\" || key == \"location\" || key == \"sourceProvenance\") continue\n          visit(child)\n        }\n      } else for (const child of value) visit(child)\n    }\n\n    visit(module)\n    const names = []\n\n    if (language != \"java\" || module.id != ownerModuleId) {\n      for (const capability of module.capabilities) {\n        for (const resource of capability.resources) if (referenced.has(resource.name)) names.push(resource.name)\n        for (const failure of capability.failures) if (referenced.has(failure.name)) names.push(failure.name)\n      }\n    }\n    if (language != \"java\") {\n      for (const provider of negotiation.providers) {\n        const record = records.get(provider.module)\n\n        for (const operation of provider.operations) {\n          if (used.has(qualifiedOperationKey(provider.module, operation))) {\n            names.push(/** @type {string} */ (record?.nativeEntries[operation]))\n          }\n        }\n      }\n    }\n\n    providerImportsByModule.set(module.id, names)\n  }\n  return providerImportsByModule\n}\n\n/**\n * Builds the truthful generated stdlib link metadata for one negotiated closure.\n * Java reports the owner module file as the provider carrier instead of a separate artifact.\n * @param {StdlibProgramLinking | null} linking - Linking plan.\n * @param {Map<string, string>} paths - Planned artifact path by module identity.\n * @param {import(\"../semantic/types.js\").StdlibFacadeProgramDescriptor | undefined} facades - Selected source facade closure.\n * @returns {Record<string, unknown>} Plain JSON metadata.\n */\nfunction stdlibLinkMetadata(linking, paths, facades) {\n  return {\n    ...(facades ? {facades} : {}),\n    modules: (linking?.negotiation.modules ?? []).map((item) => ({\n      identity: item.identity,\n      operations: [...item.operations],\n      version: item.version\n    })),\n    providers: (linking?.negotiation.providers ?? []).map((item) => {\n      const record = linking?.records.get(item.module)\n      const artifactPath = linking?.ownerModuleId !== null && linking?.ownerModuleId !== undefined\n        ? /** @type {string} */ (paths.get(linking.ownerModuleId))\n        : record?.artifact.path\n\n      return {\n        artifact: {mediaType: record?.artifact.mediaType, path: artifactPath},\n        dependencies: (record?.dependencies ?? []).map((dependency) => ({module: dependency.module, range: dependency.range})),\n        identity: item.identity,\n        module: item.module,\n        nativeEntries: {...item.nativeEntries},\n        operations: [...item.operations],\n        target: item.target,\n        version: item.version\n      }\n    }),\n    schema: \"SemantifoldStdlibLink\",\n    version: 1\n  }\n}\n\n/**\n * Validates every mandatory semantic location against its owning module source before writer allocation.\n * @param {import(\"../semantic/types.js\").SemanticProgram} program - Structurally and semantically validated program.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @returns {void}\n */\nfunction validateProgramSourceOwnership(program, language) {\n  const sources = new Map(program.sources.map((source) => [source.filename, {\n    ...source,\n    coordinates: createCoordinateIndex(/** @type {string} */ (source.content))\n  }]))\n\n  for (const module of program.modules) {\n    const source = sources.get(module.sourceFilename)\n\n    if (!source) unsupportedCapability(language, \"semantic program module source ownership\", undefined)\n    const fallback = moduleLocation(source.filename, /** @type {string} */ (source.content))\n\n    for (const entry of semanticEntries(module)) {\n      const subject = entry.node.kind == \"Module\" ? \"module\" : entry.node.kind == \"Import\" ? \"import\" :\n        entry.node.kind == \"Export\" ? \"export\" : \"semantic node\"\n\n      if (!(\"location\" in entry.node)) {\n        if (subject != \"semantic node\") unsupportedCapability(language, `semantic program ${subject} location`, fallback)\n        continue\n      }\n      const location = entry.node.location\n\n      if (sourceOwnsLocation(source, location)) continue\n\n      unsupportedCapability(language, `semantic program ${subject} location source ownership`, fallback)\n    }\n  }\n}\n\n/**\n * Checks a normalized UTF-16 location against one exact registered source without throwing.\n * @param {{filename: string, content: string | null, coordinates: ReturnType<typeof createCoordinateIndex>}} source - Owning source.\n * @param {unknown} candidate - Candidate location.\n * @returns {boolean} Whether the source owns the location.\n */\nfunction sourceOwnsLocation(source, candidate) {\n  if (!isPlainObject(candidate) || candidate.filename != source.filename || !isPlainObject(candidate.start) ||\n    !isPlainObject(candidate.end) || !Number.isInteger(candidate.start.offset) || !Number.isInteger(candidate.end.offset) ||\n    !Number.isInteger(candidate.start.line) || !Number.isInteger(candidate.start.column) ||\n    !Number.isInteger(candidate.end.line) || !Number.isInteger(candidate.end.column)) return false\n  const startOffset = /** @type {number} */ (candidate.start.offset)\n  const endOffset = /** @type {number} */ (candidate.end.offset)\n\n  if (startOffset < 0 || endOffset < startOffset || endOffset > source.coordinates.source.length) return false\n  const expectedStart = indexedPointAt(source.coordinates, startOffset)\n  const expectedEnd = indexedPointAt(source.coordinates, endOffset)\n\n  return samePoint(candidate.start, expectedStart) && samePoint(candidate.end, expectedEnd)\n}\n\n/**\n * Compares an untrusted point with one canonical indexed point.\n * @param {Record<string, unknown>} candidate - Candidate point.\n * @param {import(\"../semantic/types.js\").SourcePoint} expected - Canonical point.\n * @returns {boolean} Whether every coordinate agrees.\n */\nfunction samePoint(candidate, expected) {\n  return candidate.offset == expected.offset && candidate.line == expected.line && candidate.column == expected.column\n}\n\n/**\n * Collects nominal failure identities referenced by executable/type nodes outside the module's authority declarations.\n * @param {import(\"../semantic/types.js\").SemanticProgramModule} module - Program module.\n * @returns {Set<string>} Referenced failure declaration identities.\n */\nfunction collectReferencedFailureIds(module) {\n  /** @type {Set<string>} */\n  const ids = new Set()\n  const seen = new Set()\n  /**\n   * Visits one semantic subtree for referenced failures.\n   * @param {unknown} value - Candidate semantic subtree.\n   */\n  const visit = (value) => {\n    if (!value || typeof value != \"object\" || seen.has(value)) return\n    seen.add(value)\n    if (!Array.isArray(value)) {\n      if (Reflect.get(value, \"kind\") == \"ErrorType\" && typeof Reflect.get(value, \"declarationId\") == \"string\") {\n        ids.add(Reflect.get(value, \"declarationId\"))\n      }\n      const failureIds = Reflect.get(value, \"failureIds\")\n\n      if (Array.isArray(failureIds)) for (const id of failureIds) if (typeof id == \"string\") ids.add(id)\n      for (const [key, child] of Object.entries(value)) {\n        if ([\"capabilities\", \"location\", \"provenance\", \"sourceProvenance\"].includes(key)) continue\n        visit(child)\n      }\n    } else for (const child of value) visit(child)\n  }\n\n  visit({classes: module.classes, entryPoint: module.entryPoint, functions: module.functions})\n  return ids\n}\n\n/**\n * Creates and validates every backend-shaped module before any writer is allocated.\n * @param {import(\"../semantic/types.js\").SemanticProgram} program - Validated semantic program.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @param {StdlibProgramLinking | null} [linking] - Planned stdlib provider link.\n * @returns {import(\"../semantic/types.js\").SemanticModule[]} Emission views in dependency order.\n */\nfunction prepareEmissionModules(program, language, linking = null) {\n  /** @type {Map<string, import(\"../semantic/types.js\").FunctionDeclaration | import(\"../semantic/types.js\").RecordDeclaration | import(\"../semantic/types.js\").ClassDeclaration | import(\"../semantic/types.js\").ErrorDeclaration>} */\n  const declarations = new Map()\n\n  for (const module of program.modules) {\n    for (const declaration of module.records ?? []) declarations.set(/** @type {string} */ (declaration.id), declaration)\n    for (const declaration of module.classes ?? []) declarations.set(/** @type {string} */ (declaration.id), declaration)\n    for (const declaration of module.errors ?? []) declarations.set(/** @type {string} */ (declaration.id), declaration)\n    for (const declaration of module.functions) declarations.set(/** @type {string} */ (declaration.id), declaration)\n  }\n  const modules = program.modules.map((module) => /** @type {import(\"../semantic/types.js\").SemanticModule} */ ({\n    ...module,\n    entryPoint: module.entryPoint ?? {\n      body: {kind: /** @type {const} */ (\"Block\"), location: module.location, statements: []},\n      kind: /** @type {const} */ (\"EntryPoint\"),\n      location: module.location\n    }\n  }))\n  /** @type {Map<string, Set<string>>} */\n  const callEffectsByDeclarationId = new Map()\n\n  for (const module of modules) {\n    const programModule = /** @type {import(\"../semantic/types.js\").SemanticProgramModule} */ (/** @type {unknown} */ (module))\n    const visibleFunctions = new Map()\n    const visibleCallEffects = new Map()\n    const visibleRecords = new Map()\n    const visibleClasses = new Map()\n    const visibleErrors = new Map()\n    const externalDeclarationIds = new Set()\n\n    const neededFailureIds = collectReferencedFailureIds(programModule)\n    const localFailureIds = new Set(programModule.capabilities?.flatMap(({failures}) => failures.map(({id}) => id)) ?? [])\n\n    for (const owner of program.modules) {\n      if (owner.id == programModule.id) continue\n      for (const capability of owner.capabilities ?? []) {\n        for (const failure of capability.failures) {\n          if (!localFailureIds.has(failure.id) && neededFailureIds.has(failure.id)) visibleErrors.set(failure.id, failure)\n        }\n      }\n    }\n\n    for (const imported of programModule.imports) {\n      const declaration = declarations.get(imported.declarationId)\n\n      if (!declaration) unsupportedCapability(language, \"program import without a declaration\", imported.location)\n      externalDeclarationIds.add(imported.declarationId)\n      if (imported.symbolKind == \"function\") {\n        visibleFunctions.set(imported.localName, /** @type {import(\"../semantic/types.js\").FunctionDeclaration} */ (declaration))\n        visibleCallEffects.set(imported.localName, new Set(callEffectsByDeclarationId.get(imported.declarationId) ?? []))\n      } else if (imported.symbolKind == \"record\") {\n        visibleRecords.set(imported.declarationId, /** @type {import(\"../semantic/types.js\").RecordDeclaration} */ (declaration))\n      } else if (imported.symbolKind == \"class\") {\n        visibleClasses.set(imported.declarationId, /** @type {import(\"../semantic/types.js\").ClassDeclaration} */ (declaration))\n      } else {\n        visibleErrors.set(imported.declarationId, /** @type {import(\"../semantic/types.js\").ErrorDeclaration} */ (declaration))\n      }\n    }\n    if (module.capabilities !== undefined || !linking) {\n      preflightEffectCapabilities(module, language, linking ? {usedOperations: (linking.usedOperationsByModule.get(programModule.id) ?? [])\n        .map(({operation}) => operation)} : {})\n    }\n    validateBackendModule(module, language, {\n      externalDeclarationIds,\n      program: true,\n      visibleCallEffects,\n      visibleClasses,\n      visibleErrors,\n      visibleFunctions,\n      visibleRecords\n    })\n    const localCallEffects = moduleUncheckedErrorEffects(module, {callEffects: visibleCallEffects, functions: visibleFunctions})\n\n    for (const declaration of module.functions) {\n      callEffectsByDeclarationId.set(/** @type {string} */ (declaration.id), new Set(localCallEffects.get(declaration.name) ?? []))\n    }\n  }\n\n  return modules\n}\n\n/**\n * Validates the closed parser-neutral program graph before any target emission.\n * @param {unknown} candidate - Candidate semantic program.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @param {Readonly<Set<import(\"../semantic/types.js\").SemanticLanguage>>} [sourceLanguages] - Accepted source languages.\n * @returns {import(\"../semantic/types.js\").SemanticProgram} Validated program.\n */\nfunction validateProgram(candidate, language, sourceLanguages = programTargets) {\n  if (!isPlainObject(candidate) || candidate.kind != \"Program\" || typeof candidate.entryModule != \"string\" ||\n    !isDenseArray(candidate.modules) || candidate.modules.length == 0 || !isDenseArray(candidate.sources) || candidate.sources.length == 0) {\n    invalidProgramGeneration(\"Malformed semantic program.\")\n  }\n  const program = /** @type {import(\"../semantic/types.js\").SemanticProgram} */ (candidate)\n  const modules = new Map()\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, module: import(\"../semantic/types.js\").SemanticProgramModule}>} */\n  const declarations = new Map()\n  /** @type {import(\"../semantic/types.js\").SemanticProgramModule[]} */\n  const capabilityModules = []\n  let entryCount = 0\n  const sourceIds = new Set()\n  const sourceFilenames = new Set()\n\n  for (const source of program.sources) {\n    if (!isPlainObject(source) || typeof source.id != \"string\" || sourceIds.has(source.id) ||\n      typeof source.filename != \"string\" || !isSafeSourcePath(source.filename) || sourceFilenames.has(source.filename) ||\n      typeof source.content != \"string\" || typeof source.language != \"string\" || !sourceLanguages.has(source.language)) {\n      invalidProgramGeneration(\"Malformed or duplicate semantic program source registry.\")\n    }\n    sourceIds.add(source.id)\n    sourceFilenames.add(source.filename)\n  }\n\n  for (const module of program.modules) {\n    if (!isPlainObject(module) || module.kind != \"Module\" || typeof module.id != \"string\" ||\n      !/^[a-z][a-z0-9_]*(?:[.-][a-z][a-z0-9_]*)*$/u.test(module.id) || modules.has(module.id) ||\n      !isDenseArray(module.functions) || module.records !== undefined && !isDenseArray(module.records) ||\n      module.errors !== undefined && !isDenseArray(module.errors) ||\n      !isDenseArray(module.imports) || !isDenseArray(module.exports)) {\n      unsupportedCapability(language, \"malformed or duplicate semantic program module\", module?.location)\n    }\n    if (Reflect.get(module, \"classes\") !== undefined && (!isDenseArray(module.classes) ||\n      Reflect.get(module, \"stdlibFacade\") === undefined)) {\n      unsupportedCapability(language, \"Task 033 reference classes are not supported by semantic program generation\",\n        Reflect.get(module, \"classes\")?.[0]?.location ?? module.location)\n    }\n    if (Reflect.get(module, \"capabilities\") !== undefined) {\n      if (!isDenseArray(module.capabilities) || module.capabilities.length == 0) {\n        unsupportedCapability(language, \"malformed or empty Task 034 capability graph\", module.location)\n      }\n      capabilityModules.push(module)\n    }\n    if (typeof module.sourceFilename != \"string\" || !sourceFilenames.has(module.sourceFilename)) {\n      unsupportedCapability(language, \"semantic program module source identity\", module.location)\n    }\n    if (module.entryPoint) {\n      entryCount++\n      if (module.id != program.entryModule) unsupportedCapability(language, \"entry point on an unselected module\", module.entryPoint.location)\n    }\n    for (const declaration of [...module.records ?? [], ...module.classes ?? [], ...module.errors ?? [], ...module.functions]) {\n      if (!isPlainObject(declaration) || typeof declaration.id != \"string\" ||\n        !declaration.id.startsWith(`${module.id}#`) || declarations.has(declaration.id)) {\n        unsupportedCapability(language, \"duplicate or unstable program declaration identity\", declaration?.location ?? module.location)\n      }\n      declarations.set(declaration.id, {declaration, module})\n    }\n    for (const imported of module.imports) {\n      if (!isPlainObject(imported) || imported.kind != \"Import\" || typeof imported.moduleId != \"string\" ||\n        typeof imported.importedName != \"string\" || typeof imported.localName != \"string\" ||\n        typeof imported.declarationId != \"string\" || ![\"function\", \"record\", \"class\", \"error\"].includes(imported.symbolKind) ||\n        typeof imported.typeOnly != \"boolean\") {\n        unsupportedCapability(language, \"malformed semantic program import\", imported?.location ?? module.location)\n      }\n    }\n    for (const exported of module.exports) {\n      if (!isPlainObject(exported) || exported.kind != \"Export\" || typeof exported.exportedName != \"string\" ||\n        typeof exported.declarationId != \"string\" || ![\"function\", \"record\", \"class\", \"error\"].includes(exported.symbolKind)) {\n        unsupportedCapability(language, \"malformed semantic program export\", exported?.location ?? module.location)\n      }\n    }\n    modules.set(module.id, module)\n  }\n  if (entryCount != 1 || !modules.get(program.entryModule)?.entryPoint) {\n    unsupportedCapability(language, \"program without exactly one selected entry point\", modules.get(program.entryModule)?.location)\n  }\n  const selectedModule = /** @type {import(\"../semantic/types.js\").SemanticProgramModule} */ (modules.get(program.entryModule))\n  const selectedEntry = selectedModule.entryPoint\n\n  if (!isPlainObject(selectedEntry?.body) || !isDenseArray(selectedEntry.body.statements) || selectedEntry.body.statements.length == 0) {\n    unsupportedCapability(language, \"program without a dense non-empty selected entry point block\",\n      selectedEntry?.location ?? selectedModule.location)\n  }\n  const earlier = new Set()\n\n  for (const module of program.modules) {\n    const localTargetNames = new Set([...module.records ?? [], ...module.classes ?? [], ...module.errors ?? [], ...module.functions]\n      .map(({name}) => targetName(language, name)))\n    const importedTargetNames = new Set()\n    const localJavaClass = module.records?.[0]?.name ?? module.classes?.[0]?.name ?? module.errors?.[0]?.name ??\n      (module.id == program.entryModule ? \"Main\" : moduleClassName(module.id))\n    const javaImportClasses = new Map(language == \"java\" ? [[localJavaClass, module.id]] : [])\n\n    for (const imported of module.imports) {\n      const resolved = declarations.get(imported.declarationId)\n      const remoteExport = resolved?.module.exports.find((item) =>\n        item.declarationId == imported.declarationId && item.exportedName == imported.importedName)\n\n      if (!resolved || resolved.module.id != imported.moduleId || !earlier.has(imported.moduleId) ||\n        !remoteExport) {\n        unsupportedCapability(language, \"unresolved, private, cyclic, or out-of-order program import\", imported.location ?? module.location)\n      }\n      const declarationKind = resolved.declaration.kind == \"FunctionDeclaration\" ? \"function\" :\n        resolved.declaration.kind == \"RecordDeclaration\" ? \"record\" :\n          resolved.declaration.kind == \"ClassDeclaration\" ? \"class\" : \"error\"\n\n      if (imported.symbolKind != remoteExport.symbolKind || imported.symbolKind != declarationKind ||\n        imported.typeOnly && declarationKind != \"record\" && declarationKind != \"class\") {\n        unsupportedCapability(language, \"program import declaration kind mismatch\", imported.location ?? module.location)\n      }\n      const importName = programImportName(program, module, imported)\n\n      if (language != \"ruby\" && language != \"java\") {\n        if (imported.symbolKind != \"function\") validateTargetTypeIdentifier(language, importName, imported.location)\n        else validateTargetBindingIdentifier(language, importName, \"import\", imported.location)\n      }\n      const name = targetName(language, importName)\n\n      if (language != \"ruby\" && language != \"java\" && (localTargetNames.has(name) || importedTargetNames.has(name))) {\n        unsupportedCapability(language, `target import-name collision '${importName}'`, imported.location)\n      }\n      if (language == \"java\") {\n        const importedClass = imported.symbolKind == \"function\" ? moduleClassName(resolved.module.id) : resolved.declaration.name\n        const existingOwner = javaImportClasses.get(importedClass)\n\n        if (existingOwner && existingOwner != resolved.module.id) {\n          unsupportedCapability(language, `target import-class collision '${importedClass}'`, imported.location)\n        }\n        javaImportClasses.set(importedClass, resolved.module.id)\n      }\n      if (language == \"ruby\") {\n        const importedModule = moduleClassName(resolved.module.id)\n\n        if (localTargetNames.has(importedModule)) {\n          unsupportedCapability(language, `target import-module collision '${importedModule}'`, imported.location)\n        }\n      }\n      importedTargetNames.add(name)\n    }\n    const valueDeclarationIds = new Set(module.imports.filter(({typeOnly}) => !typeOnly).map(({declarationId}) => declarationId))\n    const typeOnlyDeclarationIds = new Set(module.imports\n      .filter(({declarationId, typeOnly}) => typeOnly && !valueDeclarationIds.has(declarationId))\n      .map(({declarationId}) => declarationId))\n    const valueConstruction = findTypeOnlyValueConstruction(module, typeOnlyDeclarationIds)\n\n    if (valueConstruction) {\n      unsupportedCapability(language, \"type-only program import used as a value\", valueConstruction.location ?? module.location)\n    }\n    const exportNames = new Set()\n\n    for (const exported of module.exports) {\n      const resolved = declarations.get(exported.declarationId)\n      const name = targetName(language, exported.exportedName)\n\n      if (language == \"javascript\" || language == \"typescript\") {\n        validateTargetIdentifier(language, exported.exportedName, \"export\", exported.location ?? module.location)\n      }\n\n      if (!resolved || resolved.module.id != module.id || exportNames.has(name)) {\n        unsupportedCapability(language, `unresolved or colliding target export '${exported.exportedName}'`, exported.location ?? module.location)\n      }\n      const declarationKind = resolved.declaration.kind == \"FunctionDeclaration\" ? \"function\" :\n        resolved.declaration.kind == \"RecordDeclaration\" ? \"record\" :\n          resolved.declaration.kind == \"ClassDeclaration\" ? \"class\" : \"error\"\n\n      if (exported.symbolKind != declarationKind) {\n        unsupportedCapability(language, \"program export declaration kind mismatch\", exported.location ?? module.location)\n      }\n      if (language != \"javascript\" && language != \"typescript\" && exported.exportedName != resolved.declaration.name) {\n        unsupportedCapability(language, `export alias '${exported.exportedName}' without an equivalent target binding`,\n          exported.location ?? resolved.declaration.location)\n      }\n      exportNames.add(name)\n    }\n    if (language == \"php\") {\n      const exportedDeclarationIds = new Set(module.exports.map(({declarationId}) => declarationId))\n      const privateDeclaration = [...module.records ?? [], ...module.classes ?? [], ...module.errors ?? [], ...module.functions].find(({id}) =>\n        typeof id == \"string\" && !exportedDeclarationIds.has(id))\n\n      if (privateDeclaration) {\n        unsupportedCapability(language, `non-exported declaration '${privateDeclaration.name}' without target-private module visibility`,\n          privateDeclaration.location)\n      }\n    }\n    earlier.add(module.id)\n  }\n\n  validateProgramStdlibContract(program, language, capabilityModules)\n  validateProgramStdlibFacades(program, language)\n\n  return program\n}\n\n/**\n * Validates compiler-selected facade descriptors, executable sources, module markers, and native identity evidence.\n * @param {import(\"../semantic/types.js\").SemanticProgram} program - Candidate program.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language for diagnostics.\n * @returns {void}\n */\nfunction validateProgramStdlibFacades(program, language) {\n  const descriptor = Reflect.get(program, \"stdlibFacades\")\n  const markedModules = program.modules.filter((module) => Reflect.get(module, \"stdlibFacade\") !== undefined)\n  const facadeSources = program.sources.filter((source) => Reflect.get(source, \"ownership\") == \"facade\")\n  const evidencedImports = program.modules.flatMap((module) => module.imports.filter((item) => Reflect.get(item, \"stdlibFacade\") !== undefined))\n\n  if (descriptor === undefined) {\n    if (markedModules.length > 0 || facadeSources.length > 0 || evidencedImports.length > 0) {\n      invalidFacadeDescriptor(language, \"Facade modules, sources, or import evidence require a complete program facade descriptor.\")\n    }\n    return\n  }\n  if (!isPlainObject(descriptor) || descriptor.schema != \"SemantifoldStdlibFacades\" || descriptor.version != 1 ||\n    typeof descriptor.language != \"string\" || !programTargets.has(descriptor.language) || !isDenseArray(descriptor.modules) ||\n    descriptor.modules.length == 0) {\n    invalidFacadeDescriptor(language, \"The program facade descriptor is malformed.\")\n  }\n  const facadeLanguage = /** @type {import(\"../semantic/types.js\").SemanticLanguage} */ (descriptor.language)\n  const records = descriptor.modules.map((item) => {\n    if (!isPlainObject(item) || typeof item.identity != \"string\" || typeof item.version != \"string\") {\n      invalidFacadeDescriptor(language, \"The program facade module descriptor is malformed.\")\n    }\n    return stdlibFacadeRegistry.resolveIdentity(item.identity, facadeLanguage, item.version)\n  })\n  const expected = stdlibFacadeProgramDescriptor(facadeLanguage, records)\n\n  if (!equalPlainData(descriptor, expected)) {\n    invalidFacadeDescriptor(language, \"The program facade descriptor does not match the registered versioned facade closure.\")\n  }\n  const selectedRecords = new Map()\n\n  for (const record of records) {\n    if (selectedRecords.has(record.identity)) {\n      invalidFacadeDescriptor(language, `Facade '${record.identity}' is selected more than once.`)\n    }\n    for (const dependency of record.dependencies) {\n      const resolved = stdlibFacadeRegistry.resolveIdentity(dependency.identity, facadeLanguage, dependency.range)\n      const selected = selectedRecords.get(resolved.identity)\n\n      if (!selected || selected.version != resolved.version) {\n        invalidFacadeDescriptor(language, `Facade '${record.identity}' dependency '${resolved.identity}@${resolved.version}' is missing or out of order.`)\n      }\n    }\n    selectedRecords.set(record.identity, record)\n  }\n  if (markedModules.length != records.length) {\n    invalidFacadeDescriptor(language, \"The program facade descriptor does not match its executable semantic modules.\")\n  }\n  if (program.sources.some((source) => source.language != facadeLanguage ||\n    ![\"application\", \"facade\"].includes(String(Reflect.get(source, \"ownership\"))))) {\n    invalidFacadeDescriptor(language, \"Facade programs require one source language and explicit application/facade ownership.\")\n  }\n  const selectedIdentities = new Set(records.map(({identity}) => identity))\n  const registeredModules = reparseRegisteredFacadeModules(program, facadeLanguage, language)\n\n  for (let index = 0; index < records.length; index += 1) {\n    const record = records[index]\n    const module = markedModules[index]\n    const marker = Reflect.get(module, \"stdlibFacade\")\n\n    if (!isPlainObject(marker) || Object.keys(marker).sort().join(\",\") != \"identity,version\" ||\n      marker.identity != record.identity || marker.version != record.version || module.id != record.source.id ||\n      module.sourceFilename != record.source.filename) {\n      invalidFacadeDescriptor(language, `Facade '${record.identity}' semantic module identity is not canonical.`)\n    }\n    const source = program.sources.find(({filename}) => filename == record.source.filename)\n\n    if (!source || source.content != record.source.content || Reflect.get(source, \"ownership\") != \"facade\") {\n      invalidFacadeDescriptor(language, `Facade '${record.identity}' executable source does not match its registered definition.`)\n    }\n    const registeredModule = registeredModules.get(record.identity)\n\n    if (!registeredModule || !equalPlainData(module, registeredModule)) {\n      invalidFacadeAuthority(language,\n        `Facade '${record.identity}' semantic module does not match its registered executable source.`, module.location)\n    }\n    const allowedOperations = new Set(record.requirements.flatMap(({operations}) => operations))\n    const usedOperations = collectDeclaredEffectOperations(module)\n\n    if (allowedOperations.size != usedOperations.size || [...allowedOperations].some((operation) => !usedOperations.has(operation))) {\n      invalidFacadeAuthority(language, `Facade '${record.identity}' semantic body does not match its declared canonical requirements.`, module.location)\n    }\n  }\n  if (facadeSources.length != records.length) {\n    invalidFacadeDescriptor(language, \"The program contains an unselected compiler-owned facade source.\")\n  }\n  if (evidencedImports.length == 0) {\n    invalidFacadeDescriptor(language, \"The selected facade closure has no parser-proved native import evidence.\")\n  }\n  for (const imported of evidencedImports) {\n    const evidence = Reflect.get(imported, \"stdlibFacade\")\n\n    if (!isPlainObject(evidence) || Object.keys(evidence).sort().join(\",\") !=\n      \"facadeIdentity,facadeVersion,nativeModule,nativeSymbol,schema,version\" ||\n      evidence.schema != \"SemantifoldStdlibFacadeResolution\" || evidence.version != 1 ||\n      typeof evidence.facadeIdentity != \"string\" || typeof evidence.facadeVersion != \"string\" ||\n      typeof evidence.nativeModule != \"string\" || typeof evidence.nativeSymbol != \"string\") {\n      invalidFacadeDescriptor(language, \"A facade import has malformed native identity evidence.\")\n    }\n    const record = stdlibFacadeRegistry.resolveFacade(facadeLanguage, evidence.nativeModule, evidence.nativeSymbol,\n      evidence.facadeVersion)\n\n    if (record.identity != evidence.facadeIdentity || !selectedIdentities.has(record.identity) || imported.moduleId != record.source.id ||\n      imported.importedName != evidence.nativeSymbol) {\n      invalidFacadeDescriptor(language, \"A facade import does not match its registered native module and symbol identity.\")\n    }\n  }\n}\n\n/**\n * Collects every canonical operation present in one validated facade implementation.\n * This checks the facade's complete declared authority independently from program reachability.\n * @param {import(\"../semantic/types.js\").SemanticProgramModule} module - Facade module.\n * @returns {Set<string>} Used operation names.\n */\nfunction collectDeclaredEffectOperations(module) {\n  const operationNames = new Map(module.capabilities?.flatMap(({operations}) =>\n    operations.map((operation) => [operation.id, operation.name])) ?? [])\n  const used = new Set()\n  const seen = new Set()\n  /**\n   * Visits one facade semantic subtree.\n   * @param {unknown} value - Candidate semantic subtree.\n   */\n  const visit = (value) => {\n    if (!value || typeof value != \"object\" || seen.has(value)) return\n    seen.add(value)\n    if (!Array.isArray(value)) {\n      const operation = Reflect.get(value, \"kind\") == \"EffectCallExpression\" ? Reflect.get(value, \"operation\") : undefined\n\n      if (typeof operation == \"string\" && operationNames.has(operation)) used.add(/** @type {string} */ (operationNames.get(operation)))\n      for (const [key, child] of Object.entries(value)) {\n        if ([\"capabilities\", \"location\", \"provenance\", \"resolution\", \"sourceProvenance\"].includes(key)) continue\n        visit(child)\n      }\n    } else for (const child of value) visit(child)\n  }\n\n  visit({classes: module.classes, entryPoint: module.entryPoint, functions: module.functions})\n  return used\n}\n\n/**\n * Recompiles the registry-selected facade closure from retained caller inputs and registered facade source.\n * This parser-backed reference graph is created during validation, before provider planning or writer allocation.\n * @param {import(\"../semantic/types.js\").SemanticProgram} program - Untrusted mutable semantic program.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} facadeLanguage - Selected source-language facade profile.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} diagnosticLanguage - Target language for boundary diagnostics.\n * @returns {Map<string, import(\"../semantic/types.js\").SemanticProgramModule>} Canonical semantic modules by facade identity.\n */\nfunction reparseRegisteredFacadeModules(program, facadeLanguage, diagnosticLanguage) {\n  const applicationModules = program.modules.filter((module) => Reflect.get(module, \"stdlibFacade\") === undefined)\n  const modulesByFilename = new Map(applicationModules.map((module) => [module.sourceFilename, module]))\n  const applicationSources = program.sources.filter((source) => Reflect.get(source, \"ownership\") == \"application\").map((source) => {\n    const module = modulesByFilename.get(source.filename)\n\n    if (!module) invalidFacadeDescriptor(diagnosticLanguage,\n      `Application source '${source.filename}' has no matching semantic module for facade verification.`)\n    return {\n      filename: source.filename,\n      id: /** @type {import(\"../semantic/types.js\").SemanticProgramModule} */ (module).id,\n      language: facadeLanguage,\n      source: /** @type {string} */ (source.content)\n    }\n  })\n\n  if (applicationSources.length != applicationModules.length) {\n    invalidFacadeDescriptor(diagnosticLanguage, \"Facade verification requires one retained application source per semantic module.\")\n  }\n  const reparsed = parseProgramSource({entryModule: program.entryModule, sources: applicationSources})\n  const modules = new Map()\n\n  for (const module of reparsed.modules) {\n    if (!module.stdlibFacade) continue\n    if (modules.has(module.stdlibFacade.identity)) {\n      invalidFacadeDescriptor(diagnosticLanguage, `Registered facade '${module.stdlibFacade.identity}' reparsed more than once.`)\n    }\n    modules.set(module.stdlibFacade.identity, module)\n  }\n  return modules\n}\n\n/**\n * Compares closed plain JSON-shaped data without coercion or key-order assumptions.\n * @param {unknown} left - Candidate value.\n * @param {unknown} right - Expected value.\n * @returns {boolean} Exact recursive equivalence.\n */\nfunction equalPlainData(left, right) {\n  if (left === right) return true\n  if (Array.isArray(left) || Array.isArray(right)) {\n    return Array.isArray(left) && Array.isArray(right) && isDenseArray(left) && isDenseArray(right) &&\n      left.length == right.length && left.every((value, index) => equalPlainData(value, right[index]))\n  }\n  if (!isPlainObject(left) || !isPlainObject(right)) return false\n  const leftKeys = Object.keys(left).sort()\n  const rightKeys = Object.keys(right).sort()\n\n  return leftKeys.length == rightKeys.length && leftKeys.every((key, index) =>\n    key == rightKeys[index] && equalPlainData(left[key], right[key]))\n}\n\n/**\n * Throws one stable facade artifact-boundary diagnostic.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @param {string} message - Diagnostic detail.\n * @returns {never} Always throws.\n */\nfunction invalidFacadeDescriptor(language, message) {\n  throw new SemantifoldDiagnostic({code: \"STDLIB_FACADE_DESCRIPTOR_INVALID\", language, message})\n}\n\n/**\n * Throws when a facade semantic body exceeds or omits its registry-declared authority.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @param {string} message - Diagnostic detail.\n * @param {import(\"../semantic/types.js\").SourceLocation} location - Facade source location.\n * @returns {never} Always throws.\n */\nfunction invalidFacadeAuthority(language, message, location) {\n  throw new SemantifoldDiagnostic({code: \"STDLIB_FACADE_AUTHORITY_FORGED\", language, location, message})\n}\n\n/**\n * Validates the program stdlib link descriptor against its capability modules.\n * @param {import(\"../semantic/types.js\").SemanticProgram} program - Candidate program.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @param {import(\"../semantic/types.js\").SemanticProgramModule[]} capabilityModules - Modules carrying capabilities.\n * @returns {void}\n */\nfunction validateProgramStdlibContract(program, language, capabilityModules) {\n  const contract = Reflect.get(program, \"stdlibContract\")\n  const contracts = Reflect.get(program, \"stdlibContracts\")\n\n  if (capabilityModules.length == 0) {\n    if (contract !== undefined || contracts !== undefined) {\n      throw new SemantifoldDiagnostic({\n        code: \"STDLIB_LINK_FAILURE\",\n        language,\n        message: \"A declared standard-library contract requires capability modules.\"\n      })\n    }\n    return\n  }\n  if (contract !== undefined && contracts !== undefined) {\n    throw new SemantifoldDiagnostic({\n      code: \"STDLIB_LINK_FAILURE\",\n      language,\n      message: \"A program cannot declare both singular and plural standard-library contract descriptors.\"\n    })\n  }\n  if (contract === undefined && contracts === undefined) {\n    unsupportedCapability(language, \"program modules with capabilities require a declared standard-library contract\",\n      capabilityModules[0].location)\n  }\n  const declared = contracts === undefined ? [contract] : contracts\n\n  if (!isDenseArray(declared) || declared.length == 0) {\n    throw new SemantifoldDiagnostic({\n      code: \"STDLIB_LINK_FAILURE\",\n      language,\n      message: \"The declared standard-library contract descriptor list is malformed or empty.\"\n    })\n  }\n  const identities = new Set()\n\n  for (const descriptor of declared) {\n    if (!isPlainObject(descriptor) || Object.keys(descriptor).some((key) => key != \"identity\" && key != \"contractVersion\")) {\n      throw new SemantifoldDiagnostic({\n        code: \"STDLIB_LINK_FAILURE\",\n        language,\n        message: \"The declared standard-library contract descriptor is malformed.\"\n      })\n    }\n    const identity = descriptor.identity\n\n    if (typeof identity != \"string\" || identity.length == 0 || identities.has(identity) ||\n      !listStdlibModules().some(({identity: registered}) => registered == identity)) {\n      throw new SemantifoldDiagnostic({\n        code: \"STDLIB_LINK_FAILURE\",\n        language,\n        message: `Declared standard-library contract '${String(identity)}' is duplicate or not a registered canonical module.`\n      })\n    }\n    if (descriptor.contractVersion !== undefined && parseStdlibVersionRange(descriptor.contractVersion) === null) {\n      throw new SemantifoldDiagnostic({\n        code: \"STDLIB_LINK_FAILURE\",\n        language,\n        message: `Declared standard-library contract version '${String(descriptor.contractVersion)}' is not canonical.`\n      })\n    }\n    identities.add(identity)\n  }\n  for (const module of capabilityModules) {\n    for (const capability of module.capabilities ?? []) {\n      if (!isPlainObject(capability) || typeof capability.authorityId != \"string\" || !identities.has(capability.authorityId)) {\n        throw new SemantifoldDiagnostic({\n          code: \"STDLIB_LINK_FAILURE\",\n          language,\n          message: `Capability authority '${String(Reflect.get(capability, \"authorityId\"))}' does not match a declared standard-library contract.`\n        })\n      }\n    }\n  }\n}\n\n/**\n * Finds a record construction that crosses a type-only import edge.\n * @param {import(\"../semantic/types.js\").SemanticProgramModule} module - Importing semantic module.\n * @param {Set<string>} typeOnlyDeclarationIds - Imported identities unavailable in value positions.\n * @returns {import(\"../semantic/types.js\").RecordConstruction | undefined} Invalid construction when present.\n */\nfunction findTypeOnlyValueConstruction(module, typeOnlyDeclarationIds) {\n  if (typeOnlyDeclarationIds.size == 0) return undefined\n  const seen = new WeakSet()\n\n  /**\n   * Visits one semantic value.\n   * @param {unknown} value - Candidate semantic subtree.\n   * @returns {import(\"../semantic/types.js\").RecordConstruction | undefined} Invalid construction when present.\n   */\n  function visit(value) {\n    if (!value || typeof value != \"object\" || seen.has(value)) return undefined\n    seen.add(value)\n    const object = /** @type {Record<string, unknown>} */ (value)\n\n    if (object.kind == \"RecordConstruction\" && isPlainObject(object.record) &&\n      typeof object.record.declarationId == \"string\" && typeOnlyDeclarationIds.has(object.record.declarationId)) {\n      return /** @type {import(\"../semantic/types.js\").RecordConstruction} */ (value)\n    }\n    for (const child of Object.values(object)) {\n      const found = visit(child)\n\n      if (found) return found\n    }\n\n    return undefined\n  }\n\n  return visit({entryPoint: module.entryPoint, functions: module.functions})\n}\n\n/**\n * Plans all paths before emission and rejects exact/case/file-directory collisions.\n * @param {import(\"../semantic/types.js\").SemanticProgram} program - Validated program.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target language.\n * @param {StdlibProgramLinking | null} [linking] - Planned stdlib provider link.\n * @returns {Map<string, string>} Path by module identity.\n */\nfunction planModulePaths(program, language, linking = null) {\n  const extension = language == \"javascript\" ? \".js\" : language == \"typescript\" ? \".ts\" : language == \"ruby\" ? \".rb\" :\n    language == \"php\" ? \".php\" : \".java\"\n  const paths = new Map()\n  const folded = new Set()\n  const targetModuleNames = new Set()\n  const providerPaths = linking ? linking.negotiation.providers.map(({module}) =>\n    /** @type {import(\"../stdlib-providers.js\").StdlibProviderRecord} */ (linking.records.get(module)).artifact.path) : []\n  const foldedProviders = new Map()\n\n  for (const providerPath of providerPaths) {\n    const key = providerPath.toLocaleLowerCase(\"en-US\")\n\n    if (!isSafeArtifactPath(providerPath) || folded.has(key)) {\n      throw new SemantifoldDiagnostic({code: \"STDLIB_NAME_COLLISION\", language,\n        message: `Stdlib provider artifact path '${providerPath}' is unsafe or colliding.`})\n    }\n    folded.add(key)\n    foldedProviders.set(providerPath.toLocaleLowerCase(\"en-US\").replaceAll(\".\", \"/\"), providerPath)\n  }\n\n  for (const module of program.modules) {\n    let path = `${module.id.replaceAll(\".\", \"/\")}${extension}`\n    const providerPath = foldedProviders.get(path.toLocaleLowerCase(\"en-US\").replaceAll(\".\", \"/\"))\n\n    if (providerPath !== undefined) {\n      throw new SemantifoldDiagnostic({\n        code: \"STDLIB_NAME_COLLISION\",\n        language,\n        message: `Module path '${path}' collides with the stdlib provider artifact '${providerPath}'.`\n      })\n    }\n    const targetModuleName = moduleClassName(module.id)\n\n    if (language == \"php\" || language == \"ruby\") {\n      const key = language == \"php\" ? targetModuleName.toLocaleLowerCase(\"en-US\") : targetModuleName\n\n      if (targetModuleNames.has(key)) {\n        unsupportedCapability(language, `target module-name collision '${targetModuleName}'`, module.location)\n      }\n      targetModuleNames.add(key)\n    }\n\n    if (language == \"php\") {\n      validateTargetIdentifier(language, targetModuleName, \"module\", module.location)\n      validateTargetTypeIdentifier(language, targetModuleName, module.location)\n    }\n    if (language == \"ruby\") validateTargetTypeIdentifier(language, targetModuleName, module.location)\n\n    if (language == \"java\") {\n      for (const segment of module.id.split(\".\")) validateTargetIdentifier(language, segment, \"module\", module.location)\n      const nominalCount = (module.records?.length ?? 0) + (module.classes?.length ?? 0) + (module.errors?.length ?? 0)\n\n      if (module.id.includes(\"-\") || nominalCount > 1 ||\n        nominalCount > 0 && (module.functions.length > 0 || module.entryPoint)) {\n        unsupportedCapability(language, \"Java module layout requiring multiple public declarations in one semantic module\", module.location)\n      }\n      const className = module.records?.[0]?.name ?? module.classes?.[0]?.name ?? module.errors?.[0]?.name ??\n        (module.id == program.entryModule ? \"Main\" : targetModuleName)\n\n      if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/u.test(className)) {\n        unsupportedCapability(language, `invalid Java public class name '${className}'`, module.location)\n      }\n      if (module.id != program.entryModule) validateTargetTypeIdentifier(language, className, module.location)\n      path = `semantifold/generated/${module.id.replaceAll(\".\", \"/\")}/${className}.java`\n    }\n    const key = path.toLocaleLowerCase(\"en-US\")\n\n    if (!isSafeArtifactPath(path) || folded.has(key)) unsupportedCapability(language, `unsafe or colliding target path '${path}'`, module.location)\n    folded.add(key)\n    paths.set(module.id, path)\n  }\n\n  return paths\n}\n\n/**\n * Converts a logical module identity to its canonical target type segment.\n * @param {string} id - Logical module identity.\n * @returns {string} Target class name.\n */\nfunction moduleClassName(id) {\n  return id.split(/[._-]+/u).map((part) => `${part[0].toUpperCase()}${part.slice(1)}`).join(\"\")\n}\n\n/**\n * Normalizes a declaration or binding name for target collision checks.\n * @param {import(\"../semantic/types.js\").SemanticLanguage} language - Target.\n * @param {string} name - Name.\n * @returns {string} Collision key.\n */\nfunction targetName(language, name) {\n  return language == \"php\" ? name.toLocaleLowerCase(\"en-US\") : name\n}\n\n/**\n * Reports whether a candidate is a direct plain object.\n * @param {unknown} value - Candidate.\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 * Raises a stable malformed program-generation request diagnostic.\n * @param {string} message - Stable failure.\n * @returns {never} Always throws.\n */\nfunction invalidProgramGeneration(message) {\n  throw new SemantifoldDiagnostic({code: \"INVALID_PROGRAM\", language: \"program\", message})\n}\n"]}