semantifold 0.3.0 → 0.5.0

package/build/src/backends/writer.js

@@ -1,20 +1,127 @@
 // @ts-check
 import { createGenerationIndex } from "../semantic/provenance.js";
+/**
+ * Collects every caller-controlled binding spelling before synthetic names are chosen.
+ * @param {unknown} root - Semantic graph.
+ * @returns {Set<string>} Used source names.
+ */
+function collectBindingNames(root) {
+    const names = new Set();
+    const pending = [root];
+    const seen = new Set();
+    while (pending.length > 0) {
+        const value = pending.pop();
+        if (!value || typeof value != "object" || seen.has(value))
+            continue;
+        seen.add(value);
+        if (!Array.isArray(value) && typeof Reflect.get(value, "name") == "string")
+            names.add(Reflect.get(value, "name"));
+        for (const child of Array.isArray(value) ? value : Object.values(value)) {
+            if (child && typeof child == "object")
+                pending.push(child);
+        }
+    }
+    return names;
+}
+/**
+ * Converts a logical module identity to its canonical target type segment.
+ * @param {string} id - Logical module identity.
+ * @returns {string} Portable target class/module name.
+ */
+function moduleClassName(id) {
+    return id.split(/[._-]+/u).map((part) => `${part[0].toUpperCase()}${part.slice(1)}`).join("");
+}
+/**
+ * Looks up one declaration name in its owning program module.
+ * @param {Partial<import("../semantic/types.js").SemanticProgramModule>} module - Owning module.
+ * @param {string} declarationId - Stable declaration identity.
+ * @returns {string} Declaration name.
+ */
+function declarationName(module, declarationId) {
+    const declaration = [...module.functions ?? [], ...module.records ?? [], ...module.classes ?? [], ...module.errors ?? []]
+        .find(({ id }) => id == declarationId);
+    if (!declaration)
+        throw new RangeError(`Unknown program declaration '${declarationId}'.`);
+    return declaration.name;
+}
+/**
+ * Chooses an unqualified target binding without treating a source-profile qualifier as semantic identity.
+ * @param {import("../semantic/types.js").SemanticProgram} program - Owning program.
+ * @param {import("../semantic/types.js").SemanticProgramModule} module - Importing module.
+ * @param {import("../semantic/types.js").SemanticImport} imported - Resolved import.
+ * @returns {string} Target-local binding spelling.
+ */
+export function programImportName(program, module, imported) {
+    const source = program.sources.find(({ filename }) => filename == module.sourceFilename);
+    if (!source)
+        throw new RangeError(`Program module '${module.id}' has no registered source.`);
+    return source.language == "ruby" || source.language == "java" ? imported.importedName : imported.localName;
+}
 /** Source-aware deterministic generated-output builder. */
 export class SourceWriter {
     /**
      * Creates a source-aware writer.
      * @param {object} options - Writer options.
      * @param {string} options.filename - Output filename.
-     * @param {import("../semantic/types.js").SemanticLanguage} options.language - Output language.
+     * @param {import("../semantic/types.js").GeneratedTextLanguage} options.language - Output text language.
      * @param {import("../semantic/types.js").SemanticModule} options.module - Semantic module.
+     * @param {import("../semantic/types.js").SemanticProgram} [options.program] - Owning multi-file program.
+     * @param {Map<string, string>} [options.programPaths] - Planned artifact path by module identity.
      * @param {{filename: string, content: string, language?: import("../semantic/types.js").SemanticLanguage}[]} [options.sources] - Caller-provided sources.
+     * @param {Record<string, string>} [options.stdlibProviderEntries] - Used operation to protected native entry for a linked stdlib provider.
+     * @param {string} [options.stdlibProviderPath] - Planned stdlib provider artifact path.
+     * @param {string[]} [options.stdlibProviderPaths] - Planned stdlib provider artifact paths.
+     * @param {string[]} [options.stdlibProviderImports] - Ordered provider names this module must import.
+     * @param {string} [options.stdlibProviderOwnerModule] - Java owner module identity hosting the shared support block and shims.
+     * @param {string[]} [options.stdlibProviderShims] - Java owner program-wide used operations exposed as public static shims.
+     * @param {(expression: import("../semantic/types.js").CallExpression) => string} [options.callNameResolver] - Target-container call spelling override.
+     * @param {string} [options.callArgumentSuffix] - Synthetic trailing argument for every semantic function call.
+     * @param {boolean} [options.methodStringEquality] - Emit string equality through the platform String method.
      */
-    constructor({ filename, language, module, sources }) {
+    constructor({ callArgumentSuffix, callNameResolver, filename, language, methodStringEquality, module, program, programPaths, sources, stdlibProviderEntries, stdlibProviderPath, stdlibProviderPaths, stdlibProviderImports, stdlibProviderOwnerModule, stdlibProviderShims }) {
         const index = createGenerationIndex(module, sources);
         this.filename = filename;
         this.language = language;
+        this.module = module;
+        this.program = program;
+        this.programPaths = programPaths;
+        this.callArgumentSuffix = callArgumentSuffix;
+        this.callNameResolver = callNameResolver;
+        this.methodStringEquality = methodStringEquality ?? false;
         this.index = index;
+        this.stdlibProviderEntries = stdlibProviderEntries;
+        this.stdlibProviderPath = stdlibProviderPath;
+        this.stdlibProviderPaths = stdlibProviderPaths ?? (stdlibProviderPath ? [stdlibProviderPath] : undefined);
+        this.stdlibProviderImports = stdlibProviderImports;
+        this.stdlibProviderOwnerModule = stdlibProviderOwnerModule;
+        this.stdlibProviderShims = stdlibProviderShims;
+        const programRecords = program?.modules.flatMap((programModule) => programModule.records ?? []) ?? module.records ?? [];
+        const programClasses = program?.modules.flatMap((programModule) => programModule.classes ?? []) ?? module.classes ?? [];
+        const capabilityFailures = module.capabilities?.flatMap(({ failures }) => failures) ?? [];
+        const programErrors = program?.modules.flatMap((programModule) => [
+            ...(programModule.errors ?? []),
+            ...(programModule.capabilities?.flatMap(({ failures }) => failures) ?? [])
+        ]) ?? [...module.errors ?? [], ...capabilityFailures];
+        const programFunctions = program?.modules.flatMap((programModule) => programModule.functions) ?? module.functions;
+        this.records = new Map(programRecords.map((record) => [record.id, record]));
+        this.classes = new Map(programClasses.map((declaration) => [declaration.id, declaration]));
+        this.errors = new Map(programErrors.map((error) => [error.id, error]));
+        this.resources = new Map((module.capabilities?.flatMap(({ resources }) => resources) ?? []).map((resource) => [resource.id, resource]));
+        this.effectOperations = new Map((module.capabilities?.flatMap(({ operations }) => operations) ?? []).map((operation) => [operation.id, operation]));
+        this.effectOperationModules = new Map((module.capabilities?.flatMap((capability) => capability.operations.map((operation) => [operation.id, capability.authorityId])) ?? []));
+        this.fields = new Map(programRecords.flatMap((record) => record.fields.map((field) => [field.id, field])));
+        this.fieldRecords = new Map(programRecords.flatMap((record) => record.fields.map((field) => [field.id, record])));
+        this.privateFields = new Map(programClasses.flatMap((declaration) => declaration.fields.map((field) => [field.id, field])));
+        this.methods = new Map(programClasses.flatMap((declaration) => declaration.methods.map((method) => [method.id, method])));
+        this.typeParameters = new Map([...programRecords, ...programFunctions].flatMap((declaration) => (declaration.typeParameters ?? []).map((parameter) => [parameter.id, parameter])));
+        this.referenceClassEmissionDepth = 0;
+        /** @type {Map<string, import("../semantic/types.js").SemanticProgramModule>} */
+        this.declarationModules = new Map(program?.modules.flatMap((programModule) => [
+            ...(programModule.records ?? []).map((declaration) => /** @type {const} */ ([/** @type {string} */ (declaration.id), programModule])),
+            ...(programModule.classes ?? []).map((declaration) => /** @type {const} */ ([/** @type {string} */ (declaration.id), programModule])),
+            ...(programModule.errors ?? []).map((declaration) => /** @type {const} */ ([/** @type {string} */ (declaration.id), programModule])),
+            ...programModule.functions.map((declaration) => /** @type {const} */ ([/** @type {string} */ (declaration.id), programModule]))
+        ]) ?? []);
         /** @type {string[]} */
         this.parts = [];
         /** @type {import("../semantic/types.js").SemantifoldMappingSpan[]} */
@@ -22,6 +129,63 @@ export class SourceWriter {
         this.offset = 0;
         this.line = 1;
         this.column = 1;
+        /** @type {Map<import("../semantic/types.js").Expression, string>} */
+        this.effectTemporaryNames = new Map();
+        /** @type {Map<import("../semantic/types.js").Expression, string>} */
+        this.effectReplacementNames = new Map();
+        /** @type {import("../semantic/types.js").Expression | undefined} */
+        this.effectDefinition = undefined;
+        this.usedBindingNames = collectBindingNames(module);
+    }
+    /**
+     * Installs the effect expressions lowered immediately before the current statement.
+     * @param {import("../semantic/types.js").Expression[]} expressions - Ordered expressions.
+     * @returns {void}
+     */
+    planEffectReplacements(expressions) {
+        this.effectReplacementNames = new Map(expressions.map((expression) => [expression, this.effectTemporaryName(expression)]));
+    }
+    /**
+     * Allocates a collision-safe name for one deterministic effect site.
+     * @param {import("../semantic/types.js").Expression} expression - Effectful expression.
+     * @returns {string} Stable temporary name.
+     */
+    effectTemporaryName(expression) {
+        const known = this.effectTemporaryNames.get(expression);
+        if (known)
+            return known;
+        const site = typeof Reflect.get(expression, "effectSiteId") == "string"
+            ? Reflect.get(expression, "effectSiteId").slice("effect:".length) : String(this.effectTemporaryNames.size);
+        let name = `__semantifold_effect_${site}`;
+        while (this.usedBindingNames.has(name))
+            name = `${name}_`;
+        this.usedBindingNames.add(name);
+        this.effectTemporaryNames.set(expression, name);
+        return name;
+    }
+    /**
+     * Returns the planned temporary replacement outside its own definition.
+     * @param {import("../semantic/types.js").Expression} expression - Candidate expression.
+     * @returns {string | undefined} Temporary name.
+     */
+    effectReplacementName(expression) {
+        return this.effectDefinition === expression ? undefined : this.effectReplacementNames.get(expression);
+    }
+    /**
+     * Emits one effect definition without recursively replacing itself.
+     * @param {import("../semantic/types.js").Expression} expression - Defined expression.
+     * @param {() => void} emit - Target expression emitter.
+     * @returns {void}
+     */
+    emitEffectDefinition(expression, emit) {
+        const previous = this.effectDefinition;
+        this.effectDefinition = expression;
+        try {
+            emit();
+        }
+        finally {
+            this.effectDefinition = previous;
+        }
     }
     /**
      * Returns generated content so far.
@@ -38,6 +202,330 @@ export class SourceWriter {
     occurrencePath(node) {
         return this.index.recordFor(node).path;
     }
+    /**
+     * Resolves a validated nominal declaration identity for target emission.
+     * @param {string} declarationId - Semantic record identity.
+     * @returns {import("../semantic/types.js").RecordDeclaration} Record declaration.
+     */
+    recordForId(declarationId) {
+        const record = this.records.get(declarationId);
+        if (!record)
+            throw new RangeError(`Unknown validated record identity '${declarationId}'.`);
+        return record;
+    }
+    /**
+     * Returns the target spelling for a nominal record identity.
+     * @param {string} declarationId - Stable record declaration identity.
+     * @param {boolean} [valuePosition] - Whether the binding must exist at runtime.
+     * @returns {string} Target record spelling.
+     */
+    recordNameForId(declarationId, valuePosition = false) {
+        const record = this.recordForId(declarationId);
+        const owner = this.declarationModules.get(declarationId);
+        const imported = this.#programModule()?.imports.find((item) => item.declarationId == declarationId && (!valuePosition || !item.typeOnly));
+        if (this.program && owner && owner.id != Reflect.get(this.module, "id") && this.language == "ruby") {
+            return `${moduleClassName(owner.id)}::${record.name}`;
+        }
+        if (imported && (this.language == "javascript" || this.language == "typescript" || this.language == "php")) {
+            return this.importNameFor(imported);
+        }
+        return record.name;
+    }
+    /**
+     * Resolves one validated reference class.
+     * @param {string} declarationId - Stable class identity.
+     * @returns {import("../semantic/types.js").ClassDeclaration} Class declaration.
+     */
+    classForId(declarationId) {
+        const declaration = this.classes.get(declarationId);
+        if (!declaration)
+            throw new RangeError(`Unknown validated reference class identity '${declarationId}'.`);
+        return declaration;
+    }
+    /**
+     * Returns the target spelling of one reference class.
+     * @param {string} declarationId - Stable class identity.
+     * @returns {string} Target spelling.
+     */
+    classNameForId(declarationId) {
+        const declaration = this.classForId(declarationId);
+        const imported = this.#programModule()?.imports.find((item) => item.declarationId == declarationId);
+        if (imported && (this.language == "javascript" || this.language == "typescript" || this.language == "php")) {
+            return this.importNameFor(imported);
+        }
+        return declaration.name;
+    }
+    /**
+     * Resolves one validated owned-resource declaration.
+     * @param {string} resourceId - Stable resource identity.
+     * @returns {import("../semantic/types.js").EffectResourceDeclaration} Resource declaration.
+     */
+    resourceForId(resourceId) {
+        const resource = this.resources.get(resourceId);
+        if (!resource)
+            throw new RangeError(`Unknown validated resource identity '${resourceId}'.`);
+        return resource;
+    }
+    /**
+     * Resolves one validated capability operation declaration.
+     * @param {string} operationId - Stable operation identity.
+     * @returns {import("../semantic/types.js").EffectOperationDeclaration} Operation declaration.
+     */
+    effectOperationForId(operationId) {
+        const operation = this.effectOperations.get(operationId);
+        if (!operation)
+            throw new RangeError(`Unknown validated effect operation identity '${operationId}'.`);
+        return operation;
+    }
+    /**
+     * Resolves one validated private field.
+     * @param {string} fieldId - Stable private-field identity.
+     * @returns {import("../semantic/types.js").PrivateField} Field declaration.
+     */
+    privateFieldForId(fieldId) {
+        const field = this.privateFields.get(fieldId);
+        if (!field)
+            throw new RangeError(`Unknown validated private field identity '${fieldId}'.`);
+        return field;
+    }
+    /**
+     * Resolves one validated receiver method.
+     * @param {string} methodId - Stable method identity.
+     * @returns {import("../semantic/types.js").MethodDeclaration} Method declaration.
+     */
+    methodForId(methodId) {
+        const method = this.methods.get(methodId);
+        if (!method)
+            throw new RangeError(`Unknown validated method identity '${methodId}'.`);
+        return method;
+    }
+    /**
+     * Resolves one validated declaration-scoped type parameter.
+     * @param {string} parameterId - Stable type-parameter identity.
+     * @returns {import("../semantic/types.js").TypeParameter} Type parameter.
+     */
+    typeParameterForId(parameterId) {
+        const parameter = this.typeParameters.get(parameterId);
+        if (!parameter)
+            throw new RangeError(`Unknown validated type parameter identity '${parameterId}'.`);
+        return parameter;
+    }
+    /**
+     * Returns the validated nominal error declaration for an identity.
+     * @param {string} declarationId - Stable error identity.
+     * @returns {import("../semantic/types.js").ErrorDeclaration | import("../semantic/types.js").EffectFailureDeclaration} Error declaration.
+     */
+    errorForId(declarationId) {
+        const error = this.errors.get(declarationId);
+        if (!error)
+            throw new RangeError(`Unknown validated error identity '${declarationId}'.`);
+        return error;
+    }
+    /**
+     * Returns the target-visible spelling for one nominal error identity.
+     * @param {string} declarationId - Stable error identity.
+     * @returns {string} Target-visible name.
+     */
+    errorNameForId(declarationId) {
+        const error = this.errorForId(declarationId);
+        const owner = this.declarationModules.get(declarationId);
+        const imported = this.#programModule()?.imports.find((item) => item.declarationId == declarationId);
+        if (this.program && owner && owner.id != Reflect.get(this.module, "id") && this.language == "ruby") {
+            return `${moduleClassName(owner.id)}::${error.name}`;
+        }
+        if (imported && (this.language == "javascript" || this.language == "typescript" || this.language == "php")) {
+            return this.importNameFor(imported);
+        }
+        return owner ? error.name : this.capabilityNominalName(error.name);
+    }
+    /**
+     * Returns the target spelling for a nominal name owned by a compiler-authorized capability.
+     * PHP program entries live in a generated namespace while stdlib provider classes remain
+     * global, so PHP program mode fully qualifies capability names.
+     * @param {string} name - Declared nominal name.
+     * @returns {string} Target spelling.
+     */
+    capabilityNominalName(name) {
+        return this.program && this.language == "php" ? `\\${name}` : name;
+    }
+    /**
+     * Returns the target spelling for a resolved function call.
+     * @param {import("../semantic/types.js").CallExpression} expression - Resolved call.
+     * @returns {string} Target call name.
+     */
+    callNameFor(expression) {
+        if (this.callNameResolver)
+            return this.callNameResolver(expression);
+        const declarationId = expression.resolution?.declarationId;
+        const owner = declarationId ? this.declarationModules.get(declarationId) : undefined;
+        const imported = declarationId ? this.#programModule()?.imports.find((item) => item.declarationId == declarationId) : undefined;
+        if (this.language == "java" && !this.program && this.referenceClassEmissionDepth > 0)
+            return `Main.${expression.callee}`;
+        if (!declarationId || !this.program || !owner || owner.id == Reflect.get(this.module, "id"))
+            return expression.callee;
+        if (this.language == "ruby" || this.language == "java")
+            return `${moduleClassName(owner.id)}.${declarationName(owner, declarationId)}`;
+        if (imported)
+            return this.importNameFor(imported);
+        return declarationName(owner, declarationId);
+    }
+    /**
+     * Returns a target-container trailing argument for a semantic call.
+     * @param {import("../semantic/types.js").CallExpression} _expression - Resolved semantic call.
+     * @returns {string | undefined} Synthetic argument spelling, when configured.
+     */
+    callArgumentSuffixFor(_expression) {
+        return this.callArgumentSuffix;
+    }
+    /**
+     * Reports whether string equality must avoid a target runtime helper.
+     * @returns {boolean} Whether to emit the platform String method.
+     */
+    usesMethodStringEquality() {
+        return this.methodStringEquality;
+    }
+    /** Marks emission as occurring inside one top-level reference class. */
+    beginReferenceClassEmission() {
+        this.referenceClassEmissionDepth += 1;
+    }
+    /** Ends one balanced top-level reference-class emission scope. */
+    endReferenceClassEmission() {
+        if (this.referenceClassEmissionDepth == 0)
+            throw new RangeError("Reference-class emission scope is not active.");
+        this.referenceClassEmissionDepth -= 1;
+    }
+    /**
+     * Returns the target-local binding for one resolved import.
+     * @param {import("../semantic/types.js").SemanticImport} imported - Resolved import.
+     * @returns {string} Emitted import name.
+     */
+    importNameFor(imported) {
+        const module = this.#programModule();
+        if (!this.program || !module)
+            throw new RangeError("Import names require a validated semantic program.");
+        return programImportName(this.program, module, imported);
+    }
+    /**
+     * Reports whether one local declaration is exported by the current program module.
+     * @param {string | undefined} declarationId - Declaration identity.
+     * @returns {boolean} Whether it has a same-name program export.
+     */
+    isDirectlyExported(declarationId) {
+        const module = /** @type {Partial<import("../semantic/types.js").SemanticProgramModule>} */ (this.module);
+        return typeof declarationId == "string" && Boolean(module.exports?.some((item) => item.declarationId == declarationId && item.exportedName == declarationName(module, declarationId)));
+    }
+    /**
+     * Reports whether one export edge uses its declaration's emitted name.
+     * @param {import("../semantic/types.js").SemanticExport} exported - Current export edge.
+     * @returns {boolean} Whether this edge is represented by the declaration prefix.
+     */
+    isDirectExport(exported) {
+        return exported.exportedName == declarationName(this.module, exported.declarationId);
+    }
+    /**
+     * Reports whether one local declaration has any public program export.
+     * @param {string | undefined} declarationId - Declaration identity.
+     * @returns {boolean} Whether the declaration is exported.
+     */
+    isExported(declarationId) {
+        const module = /** @type {Partial<import("../semantic/types.js").SemanticProgramModule>} */ (this.module);
+        return typeof declarationId == "string" && Boolean(module.exports?.some((item) => item.declarationId == declarationId));
+    }
+    /**
+     * Returns whether this is the selected program entry module.
+     * @returns {boolean} Whether this writer owns the selected entry.
+     */
+    isProgramEntry() {
+        return this.program?.entryModule == Reflect.get(this.module, "id");
+    }
+    /**
+     * Returns the canonical class/module segment for a logical module identity.
+     * @param {string} moduleId - Logical module identity.
+     * @returns {string} Target class/module name.
+     */
+    programModuleName(moduleId) {
+        if (!this.program?.modules.some(({ id }) => id == moduleId))
+            throw new RangeError(`Unknown program module '${moduleId}'.`);
+        return moduleClassName(moduleId);
+    }
+    /**
+     * Finds the current module in the complete program.
+     * @returns {import("../semantic/types.js").SemanticProgramModule | undefined} Current program module.
+     */
+    #programModule() {
+        if (!this.program)
+            return undefined;
+        return this.program.modules.find(({ id }) => id == Reflect.get(this.module, "id"));
+    }
+    /**
+     * Returns a relative ESM/require specifier for a planned dependency artifact.
+     * @param {string} moduleId - Dependency module identity.
+     * @param {string} [extension] - Optional replacement extension.
+     * @returns {string} Relative POSIX specifier.
+     */
+    relativeModuleSpecifier(moduleId, extension) {
+        const targetPath = this.programPaths?.get(moduleId);
+        if (!targetPath)
+            throw new RangeError(`Unknown planned module path '${moduleId}'.`);
+        const adjustedTarget = extension ? targetPath.replace(/\.[^./]+$/u, extension) : targetPath;
+        const from = this.filename.split("/").slice(0, -1);
+        const to = adjustedTarget.split("/");
+        let common = 0;
+        while (common < from.length && common < to.length && from[common] == to[common])
+            common++;
+        const relative = [...from.slice(common).map(() => ".."), ...to.slice(common)].join("/");
+        return relative.startsWith(".") ? relative : `./${relative}`;
+    }
+    /**
+     * Returns the protected native entry for one used stdlib provider operation.
+     * @param {import("../semantic/types.js").EffectOperationDeclaration} operation - Canonical operation declaration.
+     * @returns {string | undefined} Linked protected entry, or undefined when the operation stays inlined.
+     */
+    stdlibProviderEntryFor(operation) {
+        const module = this.effectOperationModules.get(operation.id);
+        return module === undefined ? undefined : this.stdlibProviderEntries?.[`${module}\u0000${operation.name}`];
+    }
+    /**
+     * Returns a relative specifier for the planned stdlib provider artifact.
+     * @param {string} [extension] - Optional replacement extension.
+     * @param {string} [providerPath] - One selected provider artifact path.
+     * @returns {string} Relative POSIX specifier.
+     */
+    stdlibProviderSpecifier(extension, providerPath) {
+        const targetPath = providerPath ?? this.stdlibProviderPath ?? this.stdlibProviderPaths?.[0];
+        if (!targetPath)
+            throw new RangeError("A stdlib provider specifier requires a planned provider path.");
+        const adjustedTarget = extension ? targetPath.replace(/\.[^./]+$/u, extension) : targetPath;
+        const from = this.filename.split("/").slice(0, -1);
+        const to = adjustedTarget.split("/");
+        let common = 0;
+        while (common < from.length && common < to.length && from[common] == to[common])
+            common++;
+        const relative = [...from.slice(common).map(() => ".."), ...to.slice(common)].join("/");
+        return relative.startsWith(".") ? relative : `./${relative}`;
+    }
+    /**
+     * Resolves a validated field identity for target emission.
+     * @param {string} fieldId - Semantic field identity.
+     * @returns {import("../semantic/types.js").RecordField} Record field.
+     */
+    fieldForId(fieldId) {
+        const field = this.fields.get(fieldId);
+        if (!field)
+            throw new RangeError(`Unknown validated field identity '${fieldId}'.`);
+        return field;
+    }
+    /**
+     * Resolves the record declaration that owns a validated field identity.
+     * @param {string} fieldId - Semantic field identity.
+     * @returns {import("../semantic/types.js").RecordDeclaration} Owning record.
+     */
+    recordForFieldId(fieldId) {
+        const record = this.fieldRecords.get(fieldId);
+        if (!record)
+            throw new RangeError(`Unknown validated field identity '${fieldId}'.`);
+        return record;
+    }
     /**
      * Reports whether an exact parser-owned role range is available.
      * @param {import("../semantic/types.js").SemanticNode} node - Semantic node occurrence.
@@ -204,4 +692,4 @@ function relatedOriginKey(origin) {
         origin.role ?? null
     ]);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"writer.js","sourceRoot":"","sources":["../../../src/backends/writer.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {createGenerationIndex} from \"../semantic/provenance.js\"\n\n/** Source-aware deterministic generated-output builder. */\nexport class SourceWriter {\n  /**\n   * Creates a source-aware writer.\n   * @param {object} options - Writer options.\n   * @param {string} options.filename - Output filename.\n   * @param {import(\"../semantic/types.js\").SemanticLanguage} options.language - Output language.\n   * @param {import(\"../semantic/types.js\").SemanticModule} options.module - Semantic module.\n   * @param {{filename: string, content: string, language?: import(\"../semantic/types.js\").SemanticLanguage}[]} [options.sources] - Caller-provided sources.\n   */\n  constructor({filename, language, module, sources}) {\n    const index = createGenerationIndex(module, sources)\n\n    this.filename = filename\n    this.language = language\n    this.index = index\n    /** @type {string[]} */\n    this.parts = []\n    /** @type {import(\"../semantic/types.js\").SemantifoldMappingSpan[]} */\n    this.spans = []\n    this.offset = 0\n    this.line = 1\n    this.column = 1\n  }\n\n  /**\n   * Returns generated content so far.\n   * @returns {string} Generated content.\n   */\n  get code() {\n    return this.parts.join(\"\")\n  }\n\n  /**\n   * Returns the current JSON Pointer for one unambiguous semantic occurrence.\n   * @param {import(\"../semantic/types.js\").SemanticNode} node - Semantic node occurrence.\n   * @returns {string} Current occurrence path.\n   */\n  occurrencePath(node) {\n    return this.index.recordFor(node).path\n  }\n\n  /**\n   * Reports whether an exact parser-owned role range is available.\n   * @param {import(\"../semantic/types.js\").SemanticNode} node - Semantic node occurrence.\n   * @param {string} path - JSON Pointer for a shared node occurrence.\n   * @param {string} role - Semantic token role.\n   * @returns {boolean} Whether the role has an exact source range.\n   */\n  hasRange(node, path, role) {\n    return this.index.recordFor(node, path).ranges[role] !== undefined\n  }\n\n  /**\n   * Writes text mapped to a semantic node.\n   * @param {string} text - Generated text.\n   * @param {object} annotation - Mapping annotation.\n   * @param {import(\"../semantic/types.js\").SemanticNode} annotation.node - Semantic node.\n   * @param {\"exact\" | \"anchor\"} annotation.mappingKind - Mapping precision.\n   * @param {string} [annotation.role] - Semantic token role.\n   * @param {string} [annotation.name] - Source Map name.\n   * @param {string} [annotation.path] - JSON Pointer for a shared node occurrence.\n   * @returns {void}\n   */\n  mapped(text, {mappingKind, name, node, path, role}) {\n    if (text.length == 0) return\n\n    const record = this.index.recordFor(node, path)\n    const roleLocation = role ? record.ranges[role] : undefined\n    const origin = roleLocation ? this.#sourceOrigin(roleLocation, record.origin) : record.origin\n    const precision = mappingKind == \"exact\" && role && !roleLocation ? \"anchor\" : mappingKind\n    const symbol = record.symbolId\n      ? this.index.provenance.symbols.find((candidate) => candidate.id == record.symbolId)\n      : undefined\n\n    this.#append(text, {\n      mappingKind: precision,\n      name: name ?? symbol?.name,\n      nodeId: record.id,\n      origin,\n      role,\n      symbolId: record.symbolId\n    })\n  }\n\n  /**\n   * Writes source-free scaffolding with optional semantic context.\n   * @param {string} text - Generated text.\n   * @param {string} reason - Stable reason.\n   * @param {import(\"../semantic/types.js\").SemanticNode[]} [relatedNodes] - Related nodes.\n   * @param {(string | undefined)[]} [relatedPaths] - Occurrence paths for shared related nodes.\n   * @returns {void}\n   */\n  synthetic(text, reason, relatedNodes = [], relatedPaths = []) {\n    if (text.length == 0) return\n\n    /** @type {Set<string>} */\n    const seen = new Set()\n    const relatedOrigins = relatedNodes.flatMap((node, index) => {\n      const record = this.index.recordFor(node, relatedPaths[index])\n\n      return relatedOriginsFor(record.origin).flatMap((related) => {\n        const contextual = {\n          ...related,\n          nodeId: related.nodeId ?? record.id,\n          role: related.role ?? \"context\"\n        }\n        const key = relatedOriginKey(contextual)\n\n        if (seen.has(key)) return []\n        seen.add(key)\n\n        return [contextual]\n      })\n    })\n\n    this.#append(text, {mappingKind: \"synthetic\", origin: {kind: \"synthetic\", reason, relatedOrigins}})\n  }\n\n  /**\n   * Returns the authoritative rich map for the current content.\n   * @returns {import(\"../semantic/types.js\").SemantifoldMapping} Mapping.\n   */\n  finish() {\n    return {\n      coordinateSystem: \"utf16\",\n      generated: {content: this.code, filename: this.filename, language: this.language},\n      nodes: [...this.index.provenance.nodes],\n      schema: \"SemantifoldMapping\",\n      sources: [...this.index.provenance.sources],\n      spans: [...this.spans],\n      symbols: [...this.index.provenance.symbols],\n      version: 1\n    }\n  }\n\n  /**\n   * Appends one mapped span.\n   * @param {string} text - Generated text.\n   * @param {Omit<import(\"../semantic/types.js\").SemantifoldMappingSpan, \"generated\">} annotation - Span annotation.\n   * @returns {void}\n   */\n  #append(text, annotation) {\n    if (text.includes(\"\\r\")) throw new TypeError(\"Generated output must use deterministic LF line endings.\")\n\n    const start = {column: this.column, line: this.line, offset: this.offset}\n\n    this.parts.push(text)\n    for (let index = 0; index < text.length; index++) {\n      this.offset++\n      if (text[index] == \"\\n\") {\n        this.line++\n        this.column = 1\n      } else this.column++\n    }\n    const compact = /** @type {Omit<import(\"../semantic/types.js\").SemantifoldMappingSpan, \"generated\">} */ (\n      Object.fromEntries(Object.entries(annotation).filter(([, value]) => value !== undefined))\n    )\n\n    this.spans.push({\n      ...compact,\n      generated: {\n        end: {column: this.column, line: this.line, offset: this.offset},\n        filename: this.filename,\n        start\n      }\n    })\n  }\n\n  /**\n   * Creates a direct role origin using canonical source identities.\n   * @param {import(\"../semantic/types.js\").SourceLocation} location - Exact role range.\n   * @param {import(\"../semantic/types.js\").SemanticOrigin} fallback - Owning origin.\n   * @returns {import(\"../semantic/types.js\").SemanticOrigin} Role origin.\n   */\n  #sourceOrigin(location, fallback) {\n    /** @type {string | undefined} */\n    let fallbackSourceId\n\n    if (fallback.kind == \"source\" && fallback.location.filename == location.filename) fallbackSourceId = fallback.sourceId\n    else if (fallback.kind == \"derived\") {\n      fallbackSourceId = fallback.origins.find((origin) => origin.location.filename == location.filename)?.sourceId\n    } else if (fallback.kind == \"synthetic\") {\n      fallbackSourceId = fallback.relatedOrigins.find((origin) => origin.location.filename == location.filename)?.sourceId\n    }\n    const source = this.index.provenance.sources.find((candidate) => candidate.id == fallbackSourceId) ??\n      this.index.provenance.sources.find((candidate) => candidate.filename == location.filename)\n\n    return source ? {kind: \"source\", location, sourceId: source.id} : fallback\n  }\n}\n\n/**\n * Expands every closed provenance range in semantic order.\n * @param {import(\"../semantic/types.js\").SemanticOrigin} origin - Closed provenance.\n * @returns {import(\"../semantic/types.js\").RelatedOrigin[]} Related ranges.\n */\nfunction relatedOriginsFor(origin) {\n  if (origin.kind == \"source\") return [{location: origin.location, sourceId: origin.sourceId}]\n  if (origin.kind == \"derived\") return origin.origins\n\n  return origin.relatedOrigins\n}\n\n/**\n * Builds a deterministic identity for one contextual related origin.\n * @param {import(\"../semantic/types.js\").RelatedOrigin} origin - Related origin.\n * @returns {string} Stable identity.\n */\nfunction relatedOriginKey(origin) {\n  return JSON.stringify([\n    origin.sourceId,\n    origin.location.filename,\n    origin.location.start.offset,\n    origin.location.end.offset,\n    origin.nodeId ?? null,\n    origin.symbolId ?? null,\n    origin.role ?? null\n  ])\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"writer.js","sourceRoot":"","sources":["../../../src/backends/writer.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {createGenerationIndex} from \"../semantic/provenance.js\"\n\n/**\n * Collects every caller-controlled binding spelling before synthetic names are chosen.\n * @param {unknown} root - Semantic graph.\n * @returns {Set<string>} Used source names.\n */\nfunction collectBindingNames(root) {\n  const names = new Set()\n  const pending = [root]\n  const seen = new Set()\n\n  while (pending.length > 0) {\n    const value = pending.pop()\n    if (!value || typeof value != \"object\" || seen.has(value)) continue\n    seen.add(value)\n    if (!Array.isArray(value) && typeof Reflect.get(value, \"name\") == \"string\") names.add(Reflect.get(value, \"name\"))\n    for (const child of Array.isArray(value) ? value : Object.values(value)) {\n      if (child && typeof child == \"object\") pending.push(child)\n    }\n  }\n  return names\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} Portable target class/module name.\n */\nfunction moduleClassName(id) {\n  return id.split(/[._-]+/u).map((part) => `${part[0].toUpperCase()}${part.slice(1)}`).join(\"\")\n}\n\n/**\n * Looks up one declaration name in its owning program module.\n * @param {Partial<import(\"../semantic/types.js\").SemanticProgramModule>} module - Owning module.\n * @param {string} declarationId - Stable declaration identity.\n * @returns {string} Declaration name.\n */\nfunction declarationName(module, declarationId) {\n  const declaration = [...module.functions ?? [], ...module.records ?? [], ...module.classes ?? [], ...module.errors ?? []]\n    .find(({id}) => id == declarationId)\n\n  if (!declaration) throw new RangeError(`Unknown program declaration '${declarationId}'.`)\n\n  return declaration.name\n}\n\n/**\n * Chooses an unqualified target binding without treating a source-profile qualifier as semantic identity.\n * @param {import(\"../semantic/types.js\").SemanticProgram} program - Owning program.\n * @param {import(\"../semantic/types.js\").SemanticProgramModule} module - Importing module.\n * @param {import(\"../semantic/types.js\").SemanticImport} imported - Resolved import.\n * @returns {string} Target-local binding spelling.\n */\nexport function programImportName(program, module, imported) {\n  const source = program.sources.find(({filename}) => filename == module.sourceFilename)\n\n  if (!source) throw new RangeError(`Program module '${module.id}' has no registered source.`)\n\n  return source.language == \"ruby\" || source.language == \"java\" ? imported.importedName : imported.localName\n}\n\n/** Source-aware deterministic generated-output builder. */\nexport class SourceWriter {\n  /**\n   * Creates a source-aware writer.\n   * @param {object} options - Writer options.\n   * @param {string} options.filename - Output filename.\n   * @param {import(\"../semantic/types.js\").GeneratedTextLanguage} options.language - Output text language.\n   * @param {import(\"../semantic/types.js\").SemanticModule} options.module - Semantic module.\n   * @param {import(\"../semantic/types.js\").SemanticProgram} [options.program] - Owning multi-file program.\n   * @param {Map<string, string>} [options.programPaths] - Planned artifact path by module identity.\n   * @param {{filename: string, content: string, language?: import(\"../semantic/types.js\").SemanticLanguage}[]} [options.sources] - Caller-provided sources.\n   * @param {Record<string, string>} [options.stdlibProviderEntries] - Used operation to protected native entry for a linked stdlib provider.\n   * @param {string} [options.stdlibProviderPath] - Planned stdlib provider artifact path.\n   * @param {string[]} [options.stdlibProviderPaths] - Planned stdlib provider artifact paths.\n   * @param {string[]} [options.stdlibProviderImports] - Ordered provider names this module must import.\n   * @param {string} [options.stdlibProviderOwnerModule] - Java owner module identity hosting the shared support block and shims.\n   * @param {string[]} [options.stdlibProviderShims] - Java owner program-wide used operations exposed as public static shims.\n   * @param {(expression: import(\"../semantic/types.js\").CallExpression) => string} [options.callNameResolver] - Target-container call spelling override.\n   * @param {string} [options.callArgumentSuffix] - Synthetic trailing argument for every semantic function call.\n   * @param {boolean} [options.methodStringEquality] - Emit string equality through the platform String method.\n   */\n  constructor({callArgumentSuffix, callNameResolver, filename, language, methodStringEquality, module, program, programPaths, sources,\n    stdlibProviderEntries, stdlibProviderPath, stdlibProviderPaths, stdlibProviderImports, stdlibProviderOwnerModule,\n    stdlibProviderShims}) {\n    const index = createGenerationIndex(module, sources)\n\n    this.filename = filename\n    this.language = language\n    this.module = module\n    this.program = program\n    this.programPaths = programPaths\n    this.callArgumentSuffix = callArgumentSuffix\n    this.callNameResolver = callNameResolver\n    this.methodStringEquality = methodStringEquality ?? false\n    this.index = index\n    this.stdlibProviderEntries = stdlibProviderEntries\n    this.stdlibProviderPath = stdlibProviderPath\n    this.stdlibProviderPaths = stdlibProviderPaths ?? (stdlibProviderPath ? [stdlibProviderPath] : undefined)\n    this.stdlibProviderImports = stdlibProviderImports\n    this.stdlibProviderOwnerModule = stdlibProviderOwnerModule\n    this.stdlibProviderShims = stdlibProviderShims\n    const programRecords = program?.modules.flatMap((programModule) => programModule.records ?? []) ?? module.records ?? []\n    const programClasses = program?.modules.flatMap((programModule) => programModule.classes ?? []) ?? module.classes ?? []\n    const capabilityFailures = module.capabilities?.flatMap(({failures}) => failures) ?? []\n    const programErrors = program?.modules.flatMap((programModule) => [\n      ...(programModule.errors ?? []),\n      ...(programModule.capabilities?.flatMap(({failures}) => failures) ?? [])\n    ]) ?? [...module.errors ?? [], ...capabilityFailures]\n    const programFunctions = program?.modules.flatMap((programModule) => programModule.functions) ?? module.functions\n\n    this.records = new Map(programRecords.map((record) => [record.id, record]))\n    this.classes = new Map(programClasses.map((declaration) => [declaration.id, declaration]))\n    this.errors = new Map(programErrors.map((error) => [error.id, error]))\n    this.resources = new Map((module.capabilities?.flatMap(({resources}) => resources) ?? []).map((resource) => [resource.id, resource]))\n    this.effectOperations = new Map((module.capabilities?.flatMap(({operations}) => operations) ?? []).map((operation) => [operation.id, operation]))\n    this.effectOperationModules = new Map((module.capabilities?.flatMap((capability) =>\n      capability.operations.map((operation) => [operation.id, capability.authorityId])) ?? []))\n    this.fields = new Map(programRecords.flatMap((record) => record.fields.map((field) => [field.id, field])))\n    this.fieldRecords = new Map(programRecords.flatMap((record) => record.fields.map((field) => [field.id, record])))\n    this.privateFields = new Map(programClasses.flatMap((declaration) => declaration.fields.map((field) => [field.id, field])))\n    this.methods = new Map(programClasses.flatMap((declaration) => declaration.methods.map((method) => [method.id, method])))\n    this.typeParameters = new Map([...programRecords, ...programFunctions].flatMap((declaration) =>\n      (declaration.typeParameters ?? []).map((parameter) => [parameter.id, parameter])))\n    this.referenceClassEmissionDepth = 0\n    /** @type {Map<string, import(\"../semantic/types.js\").SemanticProgramModule>} */\n    this.declarationModules = new Map(program?.modules.flatMap((programModule) => [\n      ...(programModule.records ?? []).map((declaration) => /** @type {const} */ ([/** @type {string} */ (declaration.id), programModule])),\n      ...(programModule.classes ?? []).map((declaration) => /** @type {const} */ ([/** @type {string} */ (declaration.id), programModule])),\n      ...(programModule.errors ?? []).map((declaration) => /** @type {const} */ ([/** @type {string} */ (declaration.id), programModule])),\n      ...programModule.functions.map((declaration) => /** @type {const} */ ([/** @type {string} */ (declaration.id), programModule]))\n    ]) ?? [])\n    /** @type {string[]} */\n    this.parts = []\n    /** @type {import(\"../semantic/types.js\").SemantifoldMappingSpan[]} */\n    this.spans = []\n    this.offset = 0\n    this.line = 1\n    this.column = 1\n    /** @type {Map<import(\"../semantic/types.js\").Expression, string>} */\n    this.effectTemporaryNames = new Map()\n    /** @type {Map<import(\"../semantic/types.js\").Expression, string>} */\n    this.effectReplacementNames = new Map()\n    /** @type {import(\"../semantic/types.js\").Expression | undefined} */\n    this.effectDefinition = undefined\n    this.usedBindingNames = collectBindingNames(module)\n  }\n\n  /**\n   * Installs the effect expressions lowered immediately before the current statement.\n   * @param {import(\"../semantic/types.js\").Expression[]} expressions - Ordered expressions.\n   * @returns {void}\n   */\n  planEffectReplacements(expressions) {\n    this.effectReplacementNames = new Map(expressions.map((expression) => [expression, this.effectTemporaryName(expression)]))\n  }\n\n  /**\n   * Allocates a collision-safe name for one deterministic effect site.\n   * @param {import(\"../semantic/types.js\").Expression} expression - Effectful expression.\n   * @returns {string} Stable temporary name.\n   */\n  effectTemporaryName(expression) {\n    const known = this.effectTemporaryNames.get(expression)\n    if (known) return known\n    const site = typeof Reflect.get(expression, \"effectSiteId\") == \"string\"\n      ? Reflect.get(expression, \"effectSiteId\").slice(\"effect:\".length) : String(this.effectTemporaryNames.size)\n    let name = `__semantifold_effect_${site}`\n\n    while (this.usedBindingNames.has(name)) name = `${name}_`\n    this.usedBindingNames.add(name)\n    this.effectTemporaryNames.set(expression, name)\n    return name\n  }\n\n  /**\n   * Returns the planned temporary replacement outside its own definition.\n   * @param {import(\"../semantic/types.js\").Expression} expression - Candidate expression.\n   * @returns {string | undefined} Temporary name.\n   */\n  effectReplacementName(expression) {\n    return this.effectDefinition === expression ? undefined : this.effectReplacementNames.get(expression)\n  }\n\n  /**\n   * Emits one effect definition without recursively replacing itself.\n   * @param {import(\"../semantic/types.js\").Expression} expression - Defined expression.\n   * @param {() => void} emit - Target expression emitter.\n   * @returns {void}\n   */\n  emitEffectDefinition(expression, emit) {\n    const previous = this.effectDefinition\n    this.effectDefinition = expression\n    try {\n      emit()\n    } finally {\n      this.effectDefinition = previous\n    }\n  }\n\n  /**\n   * Returns generated content so far.\n   * @returns {string} Generated content.\n   */\n  get code() {\n    return this.parts.join(\"\")\n  }\n\n  /**\n   * Returns the current JSON Pointer for one unambiguous semantic occurrence.\n   * @param {import(\"../semantic/types.js\").SemanticNode} node - Semantic node occurrence.\n   * @returns {string} Current occurrence path.\n   */\n  occurrencePath(node) {\n    return this.index.recordFor(node).path\n  }\n\n  /**\n   * Resolves a validated nominal declaration identity for target emission.\n   * @param {string} declarationId - Semantic record identity.\n   * @returns {import(\"../semantic/types.js\").RecordDeclaration} Record declaration.\n   */\n  recordForId(declarationId) {\n    const record = this.records.get(declarationId)\n\n    if (!record) throw new RangeError(`Unknown validated record identity '${declarationId}'.`)\n\n    return record\n  }\n\n  /**\n   * Returns the target spelling for a nominal record identity.\n   * @param {string} declarationId - Stable record declaration identity.\n   * @param {boolean} [valuePosition] - Whether the binding must exist at runtime.\n   * @returns {string} Target record spelling.\n   */\n  recordNameForId(declarationId, valuePosition = false) {\n    const record = this.recordForId(declarationId)\n    const owner = this.declarationModules.get(declarationId)\n    const imported = this.#programModule()?.imports.find((item) =>\n      item.declarationId == declarationId && (!valuePosition || !item.typeOnly))\n\n    if (this.program && owner && owner.id != Reflect.get(this.module, \"id\") && this.language == \"ruby\") {\n      return `${moduleClassName(owner.id)}::${record.name}`\n    }\n    if (imported && (this.language == \"javascript\" || this.language == \"typescript\" || this.language == \"php\")) {\n      return this.importNameFor(imported)\n    }\n\n    return record.name\n  }\n\n  /**\n   * Resolves one validated reference class.\n   * @param {string} declarationId - Stable class identity.\n   * @returns {import(\"../semantic/types.js\").ClassDeclaration} Class declaration.\n   */\n  classForId(declarationId) {\n    const declaration = this.classes.get(declarationId)\n\n    if (!declaration) throw new RangeError(`Unknown validated reference class identity '${declarationId}'.`)\n\n    return declaration\n  }\n\n  /**\n   * Returns the target spelling of one reference class.\n   * @param {string} declarationId - Stable class identity.\n   * @returns {string} Target spelling.\n   */\n  classNameForId(declarationId) {\n    const declaration = this.classForId(declarationId)\n    const imported = this.#programModule()?.imports.find((item) => item.declarationId == declarationId)\n\n    if (imported && (this.language == \"javascript\" || this.language == \"typescript\" || this.language == \"php\")) {\n      return this.importNameFor(imported)\n    }\n    return declaration.name\n  }\n\n  /**\n   * Resolves one validated owned-resource declaration.\n   * @param {string} resourceId - Stable resource identity.\n   * @returns {import(\"../semantic/types.js\").EffectResourceDeclaration} Resource declaration.\n   */\n  resourceForId(resourceId) {\n    const resource = this.resources.get(resourceId)\n    if (!resource) throw new RangeError(`Unknown validated resource identity '${resourceId}'.`)\n    return resource\n  }\n\n  /**\n   * Resolves one validated capability operation declaration.\n   * @param {string} operationId - Stable operation identity.\n   * @returns {import(\"../semantic/types.js\").EffectOperationDeclaration} Operation declaration.\n   */\n  effectOperationForId(operationId) {\n    const operation = this.effectOperations.get(operationId)\n    if (!operation) throw new RangeError(`Unknown validated effect operation identity '${operationId}'.`)\n    return operation\n  }\n\n  /**\n   * Resolves one validated private field.\n   * @param {string} fieldId - Stable private-field identity.\n   * @returns {import(\"../semantic/types.js\").PrivateField} Field declaration.\n   */\n  privateFieldForId(fieldId) {\n    const field = this.privateFields.get(fieldId)\n\n    if (!field) throw new RangeError(`Unknown validated private field identity '${fieldId}'.`)\n\n    return field\n  }\n\n  /**\n   * Resolves one validated receiver method.\n   * @param {string} methodId - Stable method identity.\n   * @returns {import(\"../semantic/types.js\").MethodDeclaration} Method declaration.\n   */\n  methodForId(methodId) {\n    const method = this.methods.get(methodId)\n\n    if (!method) throw new RangeError(`Unknown validated method identity '${methodId}'.`)\n\n    return method\n  }\n\n  /**\n   * Resolves one validated declaration-scoped type parameter.\n   * @param {string} parameterId - Stable type-parameter identity.\n   * @returns {import(\"../semantic/types.js\").TypeParameter} Type parameter.\n   */\n  typeParameterForId(parameterId) {\n    const parameter = this.typeParameters.get(parameterId)\n\n    if (!parameter) throw new RangeError(`Unknown validated type parameter identity '${parameterId}'.`)\n\n    return parameter\n  }\n\n  /**\n   * Returns the validated nominal error declaration for an identity.\n   * @param {string} declarationId - Stable error identity.\n   * @returns {import(\"../semantic/types.js\").ErrorDeclaration | import(\"../semantic/types.js\").EffectFailureDeclaration} Error declaration.\n   */\n  errorForId(declarationId) {\n    const error = this.errors.get(declarationId)\n\n    if (!error) throw new RangeError(`Unknown validated error identity '${declarationId}'.`)\n\n    return error\n  }\n\n  /**\n   * Returns the target-visible spelling for one nominal error identity.\n   * @param {string} declarationId - Stable error identity.\n   * @returns {string} Target-visible name.\n   */\n  errorNameForId(declarationId) {\n    const error = this.errorForId(declarationId)\n    const owner = this.declarationModules.get(declarationId)\n    const imported = this.#programModule()?.imports.find((item) => item.declarationId == declarationId)\n\n    if (this.program && owner && owner.id != Reflect.get(this.module, \"id\") && this.language == \"ruby\") {\n      return `${moduleClassName(owner.id)}::${error.name}`\n    }\n    if (imported && (this.language == \"javascript\" || this.language == \"typescript\" || this.language == \"php\")) {\n      return this.importNameFor(imported)\n    }\n\n    return owner ? error.name : this.capabilityNominalName(error.name)\n  }\n\n  /**\n   * Returns the target spelling for a nominal name owned by a compiler-authorized capability.\n   * PHP program entries live in a generated namespace while stdlib provider classes remain\n   * global, so PHP program mode fully qualifies capability names.\n   * @param {string} name - Declared nominal name.\n   * @returns {string} Target spelling.\n   */\n  capabilityNominalName(name) {\n    return this.program && this.language == \"php\" ? `\\\\${name}` : name\n  }\n\n  /**\n   * Returns the target spelling for a resolved function call.\n   * @param {import(\"../semantic/types.js\").CallExpression} expression - Resolved call.\n   * @returns {string} Target call name.\n   */\n  callNameFor(expression) {\n    if (this.callNameResolver) return this.callNameResolver(expression)\n    const declarationId = expression.resolution?.declarationId\n    const owner = declarationId ? this.declarationModules.get(declarationId) : undefined\n    const imported = declarationId ? this.#programModule()?.imports.find((item) => item.declarationId == declarationId) : undefined\n\n    if (this.language == \"java\" && !this.program && this.referenceClassEmissionDepth > 0) return `Main.${expression.callee}`\n    if (!declarationId || !this.program || !owner || owner.id == Reflect.get(this.module, \"id\")) return expression.callee\n    if (this.language == \"ruby\" || this.language == \"java\") return `${moduleClassName(owner.id)}.${declarationName(owner, declarationId)}`\n    if (imported) return this.importNameFor(imported)\n\n    return declarationName(owner, declarationId)\n  }\n\n  /**\n   * Returns a target-container trailing argument for a semantic call.\n   * @param {import(\"../semantic/types.js\").CallExpression} _expression - Resolved semantic call.\n   * @returns {string | undefined} Synthetic argument spelling, when configured.\n   */\n  callArgumentSuffixFor(_expression) {\n    return this.callArgumentSuffix\n  }\n\n  /**\n   * Reports whether string equality must avoid a target runtime helper.\n   * @returns {boolean} Whether to emit the platform String method.\n   */\n  usesMethodStringEquality() {\n    return this.methodStringEquality\n  }\n\n  /** Marks emission as occurring inside one top-level reference class. */\n  beginReferenceClassEmission() {\n    this.referenceClassEmissionDepth += 1\n  }\n\n  /** Ends one balanced top-level reference-class emission scope. */\n  endReferenceClassEmission() {\n    if (this.referenceClassEmissionDepth == 0) throw new RangeError(\"Reference-class emission scope is not active.\")\n    this.referenceClassEmissionDepth -= 1\n  }\n\n  /**\n   * Returns the target-local binding for one resolved import.\n   * @param {import(\"../semantic/types.js\").SemanticImport} imported - Resolved import.\n   * @returns {string} Emitted import name.\n   */\n  importNameFor(imported) {\n    const module = this.#programModule()\n\n    if (!this.program || !module) throw new RangeError(\"Import names require a validated semantic program.\")\n\n    return programImportName(this.program, module, imported)\n  }\n\n  /**\n   * Reports whether one local declaration is exported by the current program module.\n   * @param {string | undefined} declarationId - Declaration identity.\n   * @returns {boolean} Whether it has a same-name program export.\n   */\n  isDirectlyExported(declarationId) {\n    const module = /** @type {Partial<import(\"../semantic/types.js\").SemanticProgramModule>} */ (this.module)\n\n    return typeof declarationId == \"string\" && Boolean(module.exports?.some((item) =>\n      item.declarationId == declarationId && item.exportedName == declarationName(module, declarationId)))\n  }\n\n  /**\n   * Reports whether one export edge uses its declaration's emitted name.\n   * @param {import(\"../semantic/types.js\").SemanticExport} exported - Current export edge.\n   * @returns {boolean} Whether this edge is represented by the declaration prefix.\n   */\n  isDirectExport(exported) {\n    return exported.exportedName == declarationName(this.module, exported.declarationId)\n  }\n\n  /**\n   * Reports whether one local declaration has any public program export.\n   * @param {string | undefined} declarationId - Declaration identity.\n   * @returns {boolean} Whether the declaration is exported.\n   */\n  isExported(declarationId) {\n    const module = /** @type {Partial<import(\"../semantic/types.js\").SemanticProgramModule>} */ (this.module)\n\n    return typeof declarationId == \"string\" && Boolean(module.exports?.some((item) => item.declarationId == declarationId))\n  }\n\n  /**\n   * Returns whether this is the selected program entry module.\n   * @returns {boolean} Whether this writer owns the selected entry.\n   */\n  isProgramEntry() {\n    return this.program?.entryModule == Reflect.get(this.module, \"id\")\n  }\n\n  /**\n   * Returns the canonical class/module segment for a logical module identity.\n   * @param {string} moduleId - Logical module identity.\n   * @returns {string} Target class/module name.\n   */\n  programModuleName(moduleId) {\n    if (!this.program?.modules.some(({id}) => id == moduleId)) throw new RangeError(`Unknown program module '${moduleId}'.`)\n\n    return moduleClassName(moduleId)\n  }\n\n  /**\n   * Finds the current module in the complete program.\n   * @returns {import(\"../semantic/types.js\").SemanticProgramModule | undefined} Current program module.\n   */\n  #programModule() {\n    if (!this.program) return undefined\n\n    return this.program.modules.find(({id}) => id == Reflect.get(this.module, \"id\"))\n  }\n\n  /**\n   * Returns a relative ESM/require specifier for a planned dependency artifact.\n   * @param {string} moduleId - Dependency module identity.\n   * @param {string} [extension] - Optional replacement extension.\n   * @returns {string} Relative POSIX specifier.\n   */\n  relativeModuleSpecifier(moduleId, extension) {\n    const targetPath = this.programPaths?.get(moduleId)\n\n    if (!targetPath) throw new RangeError(`Unknown planned module path '${moduleId}'.`)\n    const adjustedTarget = extension ? targetPath.replace(/\\.[^./]+$/u, extension) : targetPath\n    const from = this.filename.split(\"/\").slice(0, -1)\n    const to = adjustedTarget.split(\"/\")\n    let common = 0\n\n    while (common < from.length && common < to.length && from[common] == to[common]) common++\n    const relative = [...from.slice(common).map(() => \"..\"), ...to.slice(common)].join(\"/\")\n\n    return relative.startsWith(\".\") ? relative : `./${relative}`\n  }\n\n  /**\n   * Returns the protected native entry for one used stdlib provider operation.\n   * @param {import(\"../semantic/types.js\").EffectOperationDeclaration} operation - Canonical operation declaration.\n   * @returns {string | undefined} Linked protected entry, or undefined when the operation stays inlined.\n   */\n  stdlibProviderEntryFor(operation) {\n    const module = this.effectOperationModules.get(operation.id)\n\n    return module === undefined ? undefined : this.stdlibProviderEntries?.[`${module}\\u0000${operation.name}`]\n  }\n\n  /**\n   * Returns a relative specifier for the planned stdlib provider artifact.\n   * @param {string} [extension] - Optional replacement extension.\n   * @param {string} [providerPath] - One selected provider artifact path.\n   * @returns {string} Relative POSIX specifier.\n   */\n  stdlibProviderSpecifier(extension, providerPath) {\n    const targetPath = providerPath ?? this.stdlibProviderPath ?? this.stdlibProviderPaths?.[0]\n\n    if (!targetPath) throw new RangeError(\"A stdlib provider specifier requires a planned provider path.\")\n    const adjustedTarget = extension ? targetPath.replace(/\\.[^./]+$/u, extension) : targetPath\n    const from = this.filename.split(\"/\").slice(0, -1)\n    const to = adjustedTarget.split(\"/\")\n    let common = 0\n\n    while (common < from.length && common < to.length && from[common] == to[common]) common++\n    const relative = [...from.slice(common).map(() => \"..\"), ...to.slice(common)].join(\"/\")\n\n    return relative.startsWith(\".\") ? relative : `./${relative}`\n  }\n\n  /**\n   * Resolves a validated field identity for target emission.\n   * @param {string} fieldId - Semantic field identity.\n   * @returns {import(\"../semantic/types.js\").RecordField} Record field.\n   */\n  fieldForId(fieldId) {\n    const field = this.fields.get(fieldId)\n\n    if (!field) throw new RangeError(`Unknown validated field identity '${fieldId}'.`)\n\n    return field\n  }\n\n  /**\n   * Resolves the record declaration that owns a validated field identity.\n   * @param {string} fieldId - Semantic field identity.\n   * @returns {import(\"../semantic/types.js\").RecordDeclaration} Owning record.\n   */\n  recordForFieldId(fieldId) {\n    const record = this.fieldRecords.get(fieldId)\n\n    if (!record) throw new RangeError(`Unknown validated field identity '${fieldId}'.`)\n\n    return record\n  }\n\n  /**\n   * Reports whether an exact parser-owned role range is available.\n   * @param {import(\"../semantic/types.js\").SemanticNode} node - Semantic node occurrence.\n   * @param {string} path - JSON Pointer for a shared node occurrence.\n   * @param {string} role - Semantic token role.\n   * @returns {boolean} Whether the role has an exact source range.\n   */\n  hasRange(node, path, role) {\n    return this.index.recordFor(node, path).ranges[role] !== undefined\n  }\n\n  /**\n   * Writes text mapped to a semantic node.\n   * @param {string} text - Generated text.\n   * @param {object} annotation - Mapping annotation.\n   * @param {import(\"../semantic/types.js\").SemanticNode} annotation.node - Semantic node.\n   * @param {\"exact\" | \"anchor\"} annotation.mappingKind - Mapping precision.\n   * @param {string} [annotation.role] - Semantic token role.\n   * @param {string} [annotation.name] - Source Map name.\n   * @param {string} [annotation.path] - JSON Pointer for a shared node occurrence.\n   * @returns {void}\n   */\n  mapped(text, {mappingKind, name, node, path, role}) {\n    if (text.length == 0) return\n\n    const record = this.index.recordFor(node, path)\n    const roleLocation = role ? record.ranges[role] : undefined\n    const origin = roleLocation ? this.#sourceOrigin(roleLocation, record.origin) : record.origin\n    const precision = mappingKind == \"exact\" && role && !roleLocation ? \"anchor\" : mappingKind\n    const symbol = record.symbolId\n      ? this.index.provenance.symbols.find((candidate) => candidate.id == record.symbolId)\n      : undefined\n\n    this.#append(text, {\n      mappingKind: precision,\n      name: name ?? symbol?.name,\n      nodeId: record.id,\n      origin,\n      role,\n      symbolId: record.symbolId\n    })\n  }\n\n  /**\n   * Writes source-free scaffolding with optional semantic context.\n   * @param {string} text - Generated text.\n   * @param {string} reason - Stable reason.\n   * @param {import(\"../semantic/types.js\").SemanticNode[]} [relatedNodes] - Related nodes.\n   * @param {(string | undefined)[]} [relatedPaths] - Occurrence paths for shared related nodes.\n   * @returns {void}\n   */\n  synthetic(text, reason, relatedNodes = [], relatedPaths = []) {\n    if (text.length == 0) return\n\n    /** @type {Set<string>} */\n    const seen = new Set()\n    const relatedOrigins = relatedNodes.flatMap((node, index) => {\n      const record = this.index.recordFor(node, relatedPaths[index])\n\n      return relatedOriginsFor(record.origin).flatMap((related) => {\n        const contextual = {\n          ...related,\n          nodeId: related.nodeId ?? record.id,\n          role: related.role ?? \"context\"\n        }\n        const key = relatedOriginKey(contextual)\n\n        if (seen.has(key)) return []\n        seen.add(key)\n\n        return [contextual]\n      })\n    })\n\n    this.#append(text, {mappingKind: \"synthetic\", origin: {kind: \"synthetic\", reason, relatedOrigins}})\n  }\n\n  /**\n   * Returns the authoritative rich map for the current content.\n   * @returns {import(\"../semantic/types.js\").SemantifoldMapping} Mapping.\n   */\n  finish() {\n    return {\n      coordinateSystem: \"utf16\",\n      generated: {content: this.code, filename: this.filename, language: this.language},\n      nodes: [...this.index.provenance.nodes],\n      schema: \"SemantifoldMapping\",\n      sources: [...this.index.provenance.sources],\n      spans: [...this.spans],\n      symbols: [...this.index.provenance.symbols],\n      version: 1\n    }\n  }\n\n  /**\n   * Appends one mapped span.\n   * @param {string} text - Generated text.\n   * @param {Omit<import(\"../semantic/types.js\").SemantifoldMappingSpan, \"generated\">} annotation - Span annotation.\n   * @returns {void}\n   */\n  #append(text, annotation) {\n    if (text.includes(\"\\r\")) throw new TypeError(\"Generated output must use deterministic LF line endings.\")\n\n    const start = {column: this.column, line: this.line, offset: this.offset}\n\n    this.parts.push(text)\n    for (let index = 0; index < text.length; index++) {\n      this.offset++\n      if (text[index] == \"\\n\") {\n        this.line++\n        this.column = 1\n      } else this.column++\n    }\n    const compact = /** @type {Omit<import(\"../semantic/types.js\").SemantifoldMappingSpan, \"generated\">} */ (\n      Object.fromEntries(Object.entries(annotation).filter(([, value]) => value !== undefined))\n    )\n\n    this.spans.push({\n      ...compact,\n      generated: {\n        end: {column: this.column, line: this.line, offset: this.offset},\n        filename: this.filename,\n        start\n      }\n    })\n  }\n\n  /**\n   * Creates a direct role origin using canonical source identities.\n   * @param {import(\"../semantic/types.js\").SourceLocation} location - Exact role range.\n   * @param {import(\"../semantic/types.js\").SemanticOrigin} fallback - Owning origin.\n   * @returns {import(\"../semantic/types.js\").SemanticOrigin} Role origin.\n   */\n  #sourceOrigin(location, fallback) {\n    /** @type {string | undefined} */\n    let fallbackSourceId\n\n    if (fallback.kind == \"source\" && fallback.location.filename == location.filename) fallbackSourceId = fallback.sourceId\n    else if (fallback.kind == \"derived\") {\n      fallbackSourceId = fallback.origins.find((origin) => origin.location.filename == location.filename)?.sourceId\n    } else if (fallback.kind == \"synthetic\") {\n      fallbackSourceId = fallback.relatedOrigins.find((origin) => origin.location.filename == location.filename)?.sourceId\n    }\n    const source = this.index.provenance.sources.find((candidate) => candidate.id == fallbackSourceId) ??\n      this.index.provenance.sources.find((candidate) => candidate.filename == location.filename)\n\n    return source ? {kind: \"source\", location, sourceId: source.id} : fallback\n  }\n}\n\n/**\n * Expands every closed provenance range in semantic order.\n * @param {import(\"../semantic/types.js\").SemanticOrigin} origin - Closed provenance.\n * @returns {import(\"../semantic/types.js\").RelatedOrigin[]} Related ranges.\n */\nfunction relatedOriginsFor(origin) {\n  if (origin.kind == \"source\") return [{location: origin.location, sourceId: origin.sourceId}]\n  if (origin.kind == \"derived\") return origin.origins\n\n  return origin.relatedOrigins\n}\n\n/**\n * Builds a deterministic identity for one contextual related origin.\n * @param {import(\"../semantic/types.js\").RelatedOrigin} origin - Related origin.\n * @returns {string} Stable identity.\n */\nfunction relatedOriginKey(origin) {\n  return JSON.stringify([\n    origin.sourceId,\n    origin.location.filename,\n    origin.location.start.offset,\n    origin.location.end.offset,\n    origin.nodeId ?? null,\n    origin.symbolId ?? null,\n    origin.role ?? null\n  ])\n}\n"]}