semantifold 0.3.0 → 0.5.0

package/build/src/semantic/validate.js

@@ -1,18 +1,40 @@
 // @ts-check
 import { semanticFailure, unsupportedCapability, unsupportedSyntax } from "../diagnostic.js";
-import { hasOnlyUnicodeScalars, isScalarTypeName } from "./scalars.js";
+import { recordTypeSubstitutions, substituteValueType, typeContainsAnyVariable } from "./generics.js";
+import { hasOnlyUnicodeScalars, isScalarTypeName, scalarType } from "./scalars.js";
 import { adaptedOperationFor } from "./operators.js";
+import { parserRangeFor } from "./provenance.js";
+import { validateEffectGraph } from "./effects.js";
+import { validateResourceLifetimes } from "./lifetime.js";
+const task005Languages = new Set(["php", "ruby", "javascript", "typescript", "java", "dart"]);
+/** @typedef {Map<string, import("./types.js").RecordDeclaration>} RecordRegistry */
+/** @typedef {Map<string, import("./types.js").ClassDeclaration>} ClassRegistry */
+/** @typedef {Map<string, import("./types.js").ErrorDeclaration>} ErrorRegistry */
+/** @type {WeakMap<RecordRegistry, ClassRegistry>} */
+const referenceClassesByRecordRegistry = new WeakMap();
+/** @type {WeakMap<RecordRegistry, Set<string>>} */
+const resourceIdsByRecordRegistry = new WeakMap();
 /**
  * @typedef Binding
  * @property {boolean} mutable - Whether assignment is allowed.
- * @property {import("./types.js").SemanticTypeName} type - Binding type.
+ * @property {import("./types.js").SemanticBindingType} type - Binding type.
+ * @property {import("./types.js").Expression | undefined} knownValue - Current statically known immutable value.
  */
 /**
  * @typedef Scope
  * @property {Map<string, Binding>} bindings - Bindings declared directly in this scope.
  * @property {Set<string>} pending - Names declared later in this scope.
+ * @property {Set<Binding>} presenceProofs - Optional bindings proven present on this path.
  * @property {Scope | undefined} parent - Enclosing lexical scope.
+ * @property {Set<string>} typeParameters - Type parameters visible throughout the enclosing declaration.
  * @property {Set<string>} usedNames - All names used by the enclosing function or entry point.
+ * @property {import("./types.js").ClassDeclaration | undefined} currentClass - Declaring class for receiver-private access.
+ */
+/**
+ * @typedef LoopFlowContext
+ * @property {import("./types.js").ForEachStatement | import("./types.js").ForEachMapStatement | import("./types.js").WhileStatement} [nearest] - Nearest active loop.
+ * @property {object} owner - Enclosing function or entry-point identity.
+ * @property {Map<string, object>} owners - Loop owner by module-local loop identity.
  */
 /**
  * @typedef SemanticFail
@@ -22,31 +44,89 @@ import { adaptedOperationFor } from "./operators.js";
  * Enforces the coherent release-candidate semantic subset after adaptation.
  * @param {import("./types.js").SemanticModule} module - Adapted semantic module.
  * @param {import("./types.js").SemanticLanguage} language - Source language.
+ * @param {{classes?: Map<string, import("./types.js").ClassDeclaration>, functions?: Map<string, import("./types.js").FunctionDeclaration>, records?: Map<string, import("./types.js").RecordDeclaration>, errors?: Map<string, import("./types.js").ErrorDeclaration>, callEffects?: Map<string, Set<string>>}} [visible] - Program imports visible during validation.
  * @returns {import("./types.js").SemanticModule} Validated module.
  */
-export function validateParsedModule(module, language) {
-    validateModuleShape(module, (detail, location) => unsupportedSyntax(language, detail, location));
-    validateModuleTypes(module, (code, detail, location) => semanticFailure(language, code, detail, location), true);
+export function validateParsedModule(module, language, visible = {}) {
+    normalizeParsedOwnedReferences(module, visible.classes);
+    validateModuleShape(module, language, (detail, location) => unsupportedSyntax(language, detail, location));
+    /**
+     * Converts one parser failure into a located semantic diagnostic.
+     * @type {SemanticFail}
+     */
+    const fail = (code, detail, location) => semanticFailure(language, code, detail, location);
+    validateModuleTypes(module, language, fail, true, visible);
+    validateResourceLifetimes(module, inferEscapingErrorEffects(module, visible.callEffects), fail);
     return module;
 }
+/**
+ * Promotes parser-authored class spellings after all private field types are known.
+ * @param {import("./types.js").SemanticModule} module - Parser-authored module.
+ * @param {Map<string, import("./types.js").ClassDeclaration>} [visibleClasses] - Imported reference classes.
+ * @returns {void}
+ */
+function normalizeParsedOwnedReferences(module, visibleClasses = new Map()) {
+    const ownedClassIds = new Set([...visibleClasses.values()].filter(({ ownership }) => ownership?.kind == "ownedResource")
+        .map(({ id }) => /** @type {string} */ (id)));
+    for (const declaration of module.classes ?? []) {
+        const fields = declaration.fields.filter(({ type }) => type?.kind == "OwnedResourceType");
+        if (fields.length != 1)
+            continue;
+        const field = /** @type {import("./types.js").PrivateField & {type: import("./types.js").OwnedResourceType}} */ (fields[0]);
+        declaration.ownership = { fieldId: /** @type {string} */ (field.id), kind: "ownedResource", resourceId: field.type.resourceId };
+        ownedClassIds.add(/** @type {string} */ (declaration.id));
+    }
+    /** @type {unknown[]} */
+    const pending = [module];
+    /** @type {Set<object>} */
+    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) && Reflect.get(value, "kind") == "ReferenceType" &&
+            ownedClassIds.has(Reflect.get(value, "declarationId")))
+            Reflect.set(value, "kind", "OwnedReferenceType");
+        for (const [key, child] of Object.entries(value)) {
+            if (["location", "sourceProvenance"].includes(key))
+                continue;
+            if (child && typeof child == "object")
+                pending.push(child);
+        }
+    }
+}
 /**
  * Validates scalar types and bindings for a caller-supplied semantic module before emission.
  * @param {import("./types.js").SemanticModule} module - Semantic module.
- * @param {import("./types.js").SemanticLanguage} language - Backend language.
+ * @param {import("./types.js").BackendLanguage} language - Backend language or binary target.
+ * @param {{classes?: Map<string, import("./types.js").ClassDeclaration>, functions?: Map<string, import("./types.js").FunctionDeclaration>, records?: Map<string, import("./types.js").RecordDeclaration>, errors?: Map<string, import("./types.js").ErrorDeclaration>, callEffects?: Map<string, Set<string>>}} [visible] - Resolved program imports.
  * @returns {void}
  */
-export function validateBackendTypes(module, language) {
-    validateModuleTypes(module, (_code, detail, location) => unsupportedCapability(language, detail, location), false);
+export function validateBackendTypes(module, language, visible = {}) {
+    /**
+     * Converts one backend validation failure into an unsupported-capability diagnostic.
+     * @type {SemanticFail}
+     */
+    const fail = (_code, detail, location) => unsupportedCapability(language, detail, location);
+    validateModuleTypes(module, language, fail, false, visible);
+    validateResourceLifetimes(module, inferEscapingErrorEffects(module, visible.callEffects), fail);
 }
 /**
  * Checks parser-authored block and statement layouts before semantic validation.
  * @param {import("./types.js").SemanticModule} module - Semantic module.
+ * @param {import("./types.js").SemanticLanguage} language - Source language.
  * @param {(detail: string, location: import("./types.js").SourceLocation) => never} fail - Shape failure.
  * @returns {void}
  */
-function validateModuleShape(module, fail) {
+function validateModuleShape(module, language, fail) {
+    for (const declaration of module.classes ?? []) {
+        validateBlockShape(declaration.constructor?.body, "constructor body", fail);
+        for (const method of declaration.methods ?? [])
+            validateBlockShape(method.body, "method body", fail);
+    }
     for (const functionDeclaration of module.functions) {
-        if (functionDeclaration.parameters.length != 2) {
+        if (!task005Languages.has(language) && functionDeclaration.parameters.length != 2) {
             fail("function parameter count other than two", functionDeclaration.location);
         }
         validateBlockShape(functionDeclaration.body, "function body", fail);
@@ -65,7 +145,7 @@ function validateBlockShape(block, detail, fail) {
         fail(`${detail} without Block`, block?.location ?? /** @type {never} */ (undefined));
     }
     for (const statement of block.statements) {
-        if (!["AssignmentStatement", "IfStatement", "LocalDeclaration", "PrintStatement", "ReturnStatement"].includes(statement.kind)) {
+        if (!["AssignmentStatement", "BreakStatement", "ContinueStatement", "ExpressionStatement", "ForEachMapStatement", "ForEachStatement", "IfStatement", "LocalDeclaration", "PrivateFieldWriteStatement", "PrintStatement", "RaiseStatement", "ReturnStatement", "TryStatement", "WhileStatement"].includes(statement.kind)) {
             fail(`${detail} statement ${statement.kind}`, statement.location);
         }
         if (statement.kind == "IfStatement") {
@@ -73,130 +153,1124 @@ function validateBlockShape(block, detail, fail) {
             if (statement.alternate)
                 validateBlockShape(statement.alternate, "if alternate", fail);
         }
+        if (statement.kind == "ForEachStatement" || statement.kind == "ForEachMapStatement" || statement.kind == "WhileStatement") {
+            validateBlockShape(statement.body, "loop body", fail);
+        }
+        if (statement.kind == "TryStatement") {
+            validateBlockShape(statement.body, "try body", fail);
+            validateBlockShape(statement.catchBody, "catch body", fail);
+        }
     }
 }
 /**
  * Validates declarations and expression types within lexical scopes.
  * @param {import("./types.js").SemanticModule} module - Semantic module.
+ * @param {string} language - Source or backend language identity.
  * @param {SemanticFail} fail - Diagnostic callback.
  * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.
+ * @param {{classes?: Map<string, import("./types.js").ClassDeclaration>, functions?: Map<string, import("./types.js").FunctionDeclaration>, records?: Map<string, import("./types.js").RecordDeclaration>, errors?: Map<string, import("./types.js").ErrorDeclaration>, callEffects?: Map<string, Set<string>>}} [visible] - Program imports visible during validation.
  * @returns {void}
  */
-function validateModuleTypes(module, fail, normalizeOperations) {
+function validateModuleTypes(module, language, fail, normalizeOperations, visible = {}) {
+    const classes = registerClassDeclarations(module.classes ?? [], fail, normalizeOperations, visible.classes);
+    const records = validateRecordDeclarations(module.records ?? [], fail, normalizeOperations, visible.records, classes);
+    const errors = validateErrorDeclarations(module.errors ?? [], fail, normalizeOperations, visible.errors);
     /** @type {Map<string, import("./types.js").FunctionDeclaration>} */
-    const functions = new Map();
-    for (const functionDeclaration of module.functions) {
+    const functions = new Map(visible.functions ?? []);
+    const declarationIds = new Set([...functions.values()].flatMap(({ id }) => typeof id == "string" ? [id] : []));
+    for (const [index, functionDeclaration] of module.functions.entries()) {
+        if (normalizeOperations)
+            functionDeclaration.id = `function:${index}`;
+        if (typeof functionDeclaration.id != "string" || !/^(?:[a-z][a-z0-9._-]*#)?function:[0-9]+$/u.test(functionDeclaration.id) ||
+            declarationIds.has(functionDeclaration.id)) {
+            fail("DUPLICATE_BINDING", "Duplicate or invalid function declaration identity.", functionDeclaration.location);
+        }
         if (functions.has(functionDeclaration.name)) {
-            fail("DUPLICATE_BINDING", `duplicate function '${functionDeclaration.name}'.`, functionDeclaration.location);
+            fail("DUPLICATE_BINDING", `duplicate function '${functionDeclaration.name}'.`, roleLocation(functionDeclaration, "name"));
         }
+        declarationIds.add(functionDeclaration.id);
+        validateTypeParameters(functionDeclaration, fail, normalizeOperations);
         functions.set(functionDeclaration.name, functionDeclaration);
     }
-    for (const functionDeclaration of module.functions)
-        validateFunction(functionDeclaration, functions, fail, normalizeOperations);
-    const callableNames = new Set(functions.keys());
-    const entryScope = createScope(undefined, module.entryPoint.body.statements, callableNames);
-    validateBlock(module.entryPoint.body, entryScope, undefined, functions, fail, normalizeOperations);
+    validateEffectGraph(module, language, functions, fail, normalizeOperations, classes);
+    const capabilityResources = (module.capabilities ?? []).flatMap(({ resources }) => resources);
+    const capabilityFailures = (module.capabilities ?? []).flatMap(({ failures }) => failures);
+    resourceIdsByRecordRegistry.set(records, new Set(capabilityResources.map(({ id }) => id)));
+    const existingErrorNames = new Set([...errors.values()].map(({ name }) => name));
+    for (const failure of capabilityFailures) {
+        if (errors.has(failure.id) || existingErrorNames.has(failure.name)) {
+            fail("DUPLICATE_ERROR", `Duplicate capability failure '${failure.name}'.`, module.location);
+        }
+        errors.set(failure.id, /** @type {import("./types.js").ErrorDeclaration} */ ( /** @type {unknown} */(failure)));
+        existingErrorNames.add(failure.name);
+    }
+    const loopOwners = prepareLoopIdentities(module, normalizeOperations, fail);
+    const reservedValueNames = new Set([
+        ...functions.keys(),
+        ...[...records.values()].map((declaration) => declaration.name),
+        ...[...classes.values()].map((declaration) => declaration.name),
+        ...[...errors.values()].map((declaration) => declaration.name),
+        ...capabilityResources.map(({ name }) => name)
+    ]);
+    const nominalNames = new Set();
+    for (const declaration of [...module.records ?? [], ...module.classes ?? [], ...module.errors ?? []]) {
+        if (nominalNames.has(declaration.name)) {
+            fail("DUPLICATE_BINDING", `Duplicate nominal declaration '${declaration.name}'.`, roleLocation(declaration, "name"));
+        }
+        nominalNames.add(declaration.name);
+    }
+    for (const declaration of [...capabilityResources, ...capabilityFailures]) {
+        if (nominalNames.has(declaration.name)) {
+            fail("DUPLICATE_BINDING", `Duplicate nominal declaration '${declaration.name}'.`, module.location);
+        }
+        nominalNames.add(declaration.name);
+    }
+    const localFunctionNames = new Set(module.functions.map(({ name }) => name));
+    const callEffects = inferCallEffects(functions, visible.callEffects, localFunctionNames);
+    for (const declaration of module.classes ?? []) {
+        validateClassDeclaration(declaration, functions, records, errors, callEffects, reservedValueNames, fail, normalizeOperations, loopOwners);
+    }
+    for (const functionDeclaration of module.functions) {
+        validateFunction(functionDeclaration, functions, records, errors, callEffects, reservedValueNames, fail, normalizeOperations, loopOwners);
+    }
+    const entryScope = createScope(undefined, module.entryPoint.body.statements, reservedValueNames);
+    validateBlock(module.entryPoint.body, entryScope, undefined, functions, records, errors, callEffects, fail, normalizeOperations, { owner: module.entryPoint, owners: loopOwners });
+    if (normalizeOperations)
+        validateEffectGraph(module, language, functions, fail, true, classes);
+}
+/**
+ * Assigns parser-authored loop/control identities and validates caller-owned identities without crossing a function boundary.
+ * @param {import("./types.js").SemanticModule} module - Semantic module.
+ * @param {boolean} normalizeOperations - Whether parser-authored identities are assigned.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @returns {Map<string, object>} Loop owner by identity.
+ */
+function prepareLoopIdentities(module, normalizeOperations, fail) {
+    const owners = new Map();
+    let nextLoop = 0;
+    const classOwners = (module.classes ?? []).flatMap((declaration) => [declaration.constructor, ...declaration.methods]);
+    for (const owner of [...classOwners, ...module.functions, module.entryPoint])
+        visit(owner.body, owner, []);
+    return owners;
+    /**
+     * Visits one block in lexical semantic order.
+     * @param {import("./types.js").Block} block - Candidate block.
+     * @param {object} owner - Enclosing function or entry point.
+     * @param {(import("./types.js").ForEachStatement | import("./types.js").ForEachMapStatement | import("./types.js").WhileStatement)[]} active - Active loops.
+     * @returns {void}
+     */
+    function visit(block, owner, active) {
+        if (!block || !Array.isArray(block.statements))
+            return;
+        for (const statement of block.statements) {
+            if (!statement || typeof statement != "object")
+                continue;
+            if (["ForEachStatement", "ForEachMapStatement", "WhileStatement"].includes(statement.kind)) {
+                const loop = /** @type {import("./types.js").ForEachStatement | import("./types.js").ForEachMapStatement | import("./types.js").WhileStatement} */ (statement);
+                if (normalizeOperations)
+                    loop.id = `loop:${nextLoop}`;
+                nextLoop += 1;
+                if (typeof loop.id != "string" || !/^loop:[0-9]+$/u.test(loop.id) || owners.has(loop.id)) {
+                    fail("INVALID_LOOP_TARGET", "Duplicate or invalid loop identity.", loop.location);
+                }
+                owners.set(loop.id, owner);
+                visit(loop.body, owner, [...active, loop]);
+            }
+            else if (statement.kind == "BreakStatement" || statement.kind == "ContinueStatement") {
+                if (normalizeOperations && active.length > 0)
+                    statement.targetLoopId = /** @type {string} */ (active.at(-1)?.id);
+            }
+            else if (statement.kind == "IfStatement") {
+                visit(statement.consequent, owner, active);
+                if (statement.alternate)
+                    visit(statement.alternate, owner, active);
+            }
+            else if (statement.kind == "TryStatement") {
+                visit(statement.body, owner, active);
+                visit(statement.catchBody, owner, active);
+            }
+        }
+    }
+}
+/**
+ * Derives validator-only unchecked-error effects for a validated module's local functions.
+ * These effects never enter semantic function declarations or public signatures.
+ * @param {import("./types.js").SemanticModule} module - Validated semantic module.
+ * @param {{functions?: Map<string, import("./types.js").FunctionDeclaration>, callEffects?: Map<string, Set<string>>}} [visible] - Imported functions and already-resolved effects by local binding.
+ * @returns {Map<string, Set<string>>} Local function effects by source-visible name.
+ */
+export function moduleUncheckedErrorEffects(module, visible = {}) {
+    const functions = new Map(visible.functions ?? []);
+    for (const declaration of module.functions)
+        functions.set(declaration.name, declaration);
+    const localFunctionNames = new Set(module.functions.map(({ name }) => name));
+    const effects = inferCallEffects(functions, visible.callEffects, localFunctionNames);
+    return new Map(module.functions.map((declaration) => [declaration.name, new Set(effects.get(declaration.name) ?? [])]));
+}
+/**
+ * Assigns and validates the closed nominal identities owned by reference classes.
+ * @param {unknown} declarations - Candidate declarations.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @param {boolean} normalizeOperations - Whether parser-authored identities are assigned.
+ * @param {Map<string, import("./types.js").ClassDeclaration>} [visibleClasses] - Imported classes by identity.
+ * @returns {ClassRegistry} Classes by stable identity.
+ */
+function registerClassDeclarations(declarations, fail, normalizeOperations, visibleClasses = new Map()) {
+    if (!Array.isArray(declarations)) {
+        return fail("TYPE_MISMATCH", "Reference class declarations must be an ordered array.", /** @type {never} */ (undefined));
+    }
+    /** @type {ClassRegistry} */
+    const classes = new Map(visibleClasses);
+    const names = new Set([...visibleClasses.values()].map(({ name }) => name));
+    for (let classIndex = 0; classIndex < declarations.length; classIndex += 1) {
+        const declaration = /** @type {import("./types.js").ClassDeclaration} */ (declarations[classIndex]);
+        if (!declaration || declaration.kind != "ClassDeclaration" || !Array.isArray(declaration.fields) ||
+            !Array.isArray(declaration.methods) || !declaration.constructor || declaration.constructor.kind != "ConstructorDeclaration") {
+            return fail("DUPLICATE_CLASS", "Malformed or invalid reference class declaration.", declaration?.location);
+        }
+        if (declaration.fields.length == 0) {
+            fail("INCOMPLETE_INITIALIZATION", "Reference classes must declare private instance state.", declaration.location);
+        }
+        if (normalizeOperations)
+            declaration.id = `class:${classIndex}`;
+        if (typeof declaration.id != "string" || !/^(?:[a-z][a-z0-9._-]*#)?class:[0-9]+$/u.test(declaration.id) ||
+            classes.has(declaration.id) || typeof declaration.name != "string" || declaration.name.length == 0 || names.has(declaration.name)) {
+            fail("DUPLICATE_CLASS", `Duplicate or invalid reference class '${String(declaration.name)}'.`, roleLocation(declaration, "name"));
+        }
+        names.add(declaration.name);
+        classes.set(declaration.id, declaration);
+        const fieldNames = new Set();
+        for (let fieldIndex = 0; fieldIndex < declaration.fields.length; fieldIndex += 1) {
+            const field = declaration.fields[fieldIndex];
+            const expectedId = `${declaration.id}:field:${fieldIndex}`;
+            if (!field || field.kind != "PrivateField") {
+                fail("DUPLICATE_PRIVATE_FIELD", "Malformed or invalid private field.", field?.location ?? declaration.location);
+            }
+            if (normalizeOperations)
+                field.id = expectedId;
+            if (field.id != expectedId || typeof field.name != "string" || field.name.length == 0 || fieldNames.has(field.name)) {
+                fail("DUPLICATE_PRIVATE_FIELD", `Duplicate or invalid private field '${String(field.name)}'.`, roleLocation(field, "name"));
+            }
+            fieldNames.add(field.name);
+        }
+        const invalidOwnedField = declaration.fields.find(({ type }) => containsOwnedType(type) && type.kind != "OwnedResourceType");
+        if (invalidOwnedField) {
+            fail("RESOURCE_ALIAS", `Class '${declaration.name}' may contain ownership only in one direct resource field.`, invalidOwnedField.location);
+        }
+        const ownedFields = declaration.fields.filter(({ type }) => type?.kind == "OwnedResourceType");
+        if (ownedFields.length > 1) {
+            fail("RESOURCE_ALIAS", `Class '${declaration.name}' may own exactly one direct resource field.`, declaration.location);
+        }
+        if (ownedFields.length == 1) {
+            const field = /** @type {import("./types.js").PrivateField & {type: import("./types.js").OwnedResourceType}} */ (ownedFields[0]);
+            const expected = { fieldId: /** @type {string} */ (field.id), kind: /** @type {const} */ ("ownedResource"),
+                resourceId: field.type.resourceId };
+            if (normalizeOperations)
+                declaration.ownership = expected;
+            else if (JSON.stringify(declaration.ownership) != JSON.stringify(expected)) {
+                fail("RESOURCE_TYPE_MISMATCH", `Class '${declaration.name}' has malformed resource ownership metadata.`, declaration.location);
+            }
+        }
+        else if (declaration.ownership?.kind == "ownedResource") {
+            fail("RESOURCE_TYPE_MISMATCH", `Class '${declaration.name}' does not contain its declared resource field.`, declaration.location);
+        }
+        const constructorId = `${declaration.id}:constructor`;
+        if (normalizeOperations)
+            declaration.constructor.id = constructorId;
+        if (declaration.constructor.id != constructorId || !Array.isArray(declaration.constructor.parameters) ||
+            !declaration.constructor.body || declaration.constructor.body.kind != "Block") {
+            fail("DUPLICATE_CONSTRUCTOR", "Malformed or invalid constructor declaration.", declaration.constructor.location);
+        }
+        const methodNames = new Set();
+        for (let methodIndex = 0; methodIndex < declaration.methods.length; methodIndex += 1) {
+            const method = declaration.methods[methodIndex];
+            const expectedId = `${declaration.id}:method:${methodIndex}`;
+            if (!method || method.kind != "MethodDeclaration") {
+                fail("DUPLICATE_METHOD", "Malformed or invalid method declaration.", method?.location ?? declaration.location);
+            }
+            if (normalizeOperations)
+                method.id = expectedId;
+            if (method.id != expectedId || typeof method.name != "string" || method.name.length == 0 || methodNames.has(method.name) ||
+                !Array.isArray(method.parameters) || !method.body || method.body.kind != "Block") {
+                fail("DUPLICATE_METHOD", `Duplicate or invalid method '${String(method.name)}'.`, roleLocation(method, "name"));
+            }
+            methodNames.add(method.name);
+        }
+    }
+    return classes;
+}
+/**
+ * Validates exact construction, private state, and method bodies for one class.
+ * @param {import("./types.js").ClassDeclaration} declaration - Class declaration.
+ * @param {Map<string, import("./types.js").FunctionDeclaration>} functions - Function signatures.
+ * @param {RecordRegistry} records - Record and reference-class registries.
+ * @param {ErrorRegistry} errors - Error declarations.
+ * @param {Map<string, Set<string>>} callEffects - Function call effects.
+ * @param {Set<string>} reservedValueNames - Module-reserved names.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @param {boolean} normalizeOperations - Whether parser-authored resolutions are assigned.
+ * @param {Map<string, object>} loopOwners - Loop ownership registry.
+ * @returns {void}
+ */
+function validateClassDeclaration(declaration, functions, records, errors, callEffects, reservedValueNames, fail, normalizeOperations, loopOwners) {
+    for (const field of declaration.fields) {
+        validateValueTypeReference(field.type, field.location, fail, undefined, records);
+    }
+    const constructor = declaration.constructor;
+    const acquisitionStatement = constructor.body.statements[0];
+    const acquisitionExpression = acquisitionStatement?.kind == "PrivateFieldWriteStatement"
+        ? acquisitionStatement.expression : undefined;
+    const ownedAcquisition = declaration.ownership?.kind == "ownedResource" && declaration.fields.length == 1 &&
+        constructor.body.statements.length == 1 && acquisitionStatement?.kind == "PrivateFieldWriteStatement" &&
+        acquisitionStatement.field == declaration.ownership.fieldId && acquisitionStatement.receiver.kind == "ReceiverExpression" &&
+        acquisitionStatement.receiver.classId == declaration.id && acquisitionExpression?.kind == "EffectCallExpression" &&
+        acquisitionExpression.resolution.resourceFlow.kind == "acquire" &&
+        acquisitionExpression.resolution.resourceFlow.resourceId == declaration.ownership.resourceId;
+    if (syntacticBlockEffects(constructor.body, callEffects).size > 0 && !ownedAcquisition) {
+        fail("UNSUPPORTED_STATEMENT", "Reference constructors cannot expose unchecked-error effects in Task 033.", constructor.location);
+    }
+    if (!ownedAcquisition &&
+        (constructor.parameters.length != declaration.fields.length || constructor.body.statements.length != declaration.fields.length)) {
+        fail("INCOMPLETE_INITIALIZATION", `Constructor for '${declaration.name}' must initialize every private field exactly once in declaration order.`, constructor.location);
+    }
+    const constructorScope = createScope(undefined, constructor.body.statements, reservedValueNames, new Set(), declaration);
+    for (let index = 0; index < constructor.parameters.length; index += 1) {
+        const parameter = constructor.parameters[index];
+        const field = declaration.fields[index];
+        const type = validateValueTypeReference(parameter.type, parameter.location, fail, undefined, records);
+        if (!ownedAcquisition && !sameType(type, field.type)) {
+            fail("TYPE_MISMATCH", `Constructor parameter '${parameter.name}' must exactly match private field '${field.name}'.`, parameter.location);
+        }
+        declareBinding(parameter.name, { knownValue: undefined, mutable: false, type }, roleLocation(parameter, "name"), constructorScope, fail);
+        if (ownedAcquisition)
+            continue;
+        const statement = constructor.body.statements[index];
+        const initializer = statement?.kind == "PrivateFieldWriteStatement"
+            ? statement.expression.kind == "OwnedMoveExpression" ? statement.expression.expression : statement.expression
+            : undefined;
+        if (!statement || statement.kind != "PrivateFieldWriteStatement" || statement.field != field.id ||
+            statement.receiver?.kind != "ReceiverExpression" || statement.receiver.classId != declaration.id ||
+            initializer?.kind != "IdentifierExpression" || initializer.name != parameter.name) {
+            fail("INCOMPLETE_INITIALIZATION", `Constructor for '${declaration.name}' must initialize '${field.name}' from its corresponding parameter.`, statement?.location ?? constructor.location);
+        }
+    }
+    validateBlock(constructor.body, constructorScope, { kind: "TypeReference", name: "void" }, functions, records, errors, callEffects, fail, normalizeOperations, { owner: constructor, owners: loopOwners });
+    for (const method of declaration.methods) {
+        const unsupportedMethodEffects = [...syntacticBlockEffects(method.body, callEffects)]
+            .filter((id) => !/^(?:module:[0-9]+\/)?capability:[0-9]+\/failure:[0-9]+$/u.test(id));
+        if (declaration.ownership?.kind != "ownedResource" && unsupportedMethodEffects.length > 0) {
+            fail("UNSUPPORTED_STATEMENT", `Reference method '${method.name}' cannot expose unchecked-error effects in Task 033.`, method.location);
+        }
+        const scope = createScope(undefined, method.body.statements, reservedValueNames, new Set(), declaration);
+        for (const parameter of method.parameters) {
+            const type = validateValueTypeReference(parameter.type, parameter.location, fail, undefined, records);
+            declareBinding(parameter.name, { knownValue: undefined, mutable: false, type }, roleLocation(parameter, "name"), scope, fail);
+        }
+        const returnType = validateReturnTypeReference(method.returnType, method.location, fail, records);
+        const flow = validateBlock(method.body, scope, returnType, functions, records, errors, callEffects, fail, normalizeOperations, { owner: method, owners: loopOwners });
+        if (declaration.ownership?.kind == "ownedResource")
+            ownedMethodResourceFlow(declaration, method, fail);
+        if (!isVoidType(returnType) && flow.normal) {
+            fail("MISSING_RETURN", `Method '${method.name}' does not return on every reachable path.`, method.location);
+        }
+    }
+}
+/**
+ * Validates nominal unchecked-error declarations.
+ * @param {unknown} declarations - Candidate declarations.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @param {boolean} normalizeOperations - Whether parser-authored identities are assigned.
+ * @param {Map<string, import("./types.js").ErrorDeclaration>} [visibleErrors] - Imported error declarations by identity.
+ * @returns {ErrorRegistry} Validated declarations by identity.
+ */
+function validateErrorDeclarations(declarations, fail, normalizeOperations, visibleErrors = new Map()) {
+    if (!Array.isArray(declarations))
+        return fail("TYPE_MISMATCH", "Error declarations must be an ordered array.", /** @type {never} */ (undefined));
+    /** @type {ErrorRegistry} */
+    const errors = new Map(visibleErrors);
+    const names = new Set();
+    for (let index = 0; index < declarations.length; index += 1) {
+        const declaration = declarations[index];
+        if (!declaration || declaration.kind != "ErrorDeclaration") {
+            return fail("TYPE_MISMATCH", "Malformed error declaration.", declaration?.location);
+        }
+        if (normalizeOperations)
+            declaration.id = `error:${index}`;
+        if (typeof declaration.id != "string" || !/^(?:[a-z][a-z0-9._-]*#)?error:[0-9]+$/u.test(declaration.id) || errors.has(declaration.id)) {
+            fail("DUPLICATE_ERROR", "Duplicate or invalid error declaration identity.", declaration.location);
+        }
+        if (typeof declaration.name != "string" || names.has(declaration.name)) {
+            fail("DUPLICATE_ERROR", `Duplicate or invalid error '${String(declaration.name)}'.`, roleLocation(declaration, "name"));
+        }
+        names.add(declaration.name);
+        errors.set(declaration.id, declaration);
+    }
+    return errors;
+}
+/**
+ * Assigns and validates one declaration's invariant unbounded type parameters.
+ * @param {import("./types.js").FunctionDeclaration | import("./types.js").RecordDeclaration} declaration - Owning declaration.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @param {boolean} normalizeOperations - Whether parser-authored identities are assigned.
+ * @returns {void}
+ */
+function validateTypeParameters(declaration, fail, normalizeOperations) {
+    if (declaration.typeParameters === undefined)
+        return;
+    if (!Array.isArray(declaration.typeParameters)) {
+        fail("TYPE_MISMATCH", "Type parameters must be a dense ordered array.", declaration.location);
+    }
+    const names = new Set();
+    for (let index = 0; index < declaration.typeParameters.length; index += 1) {
+        const parameter = declaration.typeParameters[index];
+        const keys = parameter && typeof parameter == "object" && !Array.isArray(parameter)
+            ? Object.keys(parameter).filter((key) => key != "sourceProvenance").sort().join(",") : "";
+        if (!Object.hasOwn(declaration.typeParameters, index) || !parameter || parameter.kind != "TypeParameter" ||
+            keys != "id,kind,location,name" || typeof parameter.name != "string" || parameter.name.length == 0) {
+            fail("TYPE_MISMATCH", "Malformed type parameter declaration.", parameter?.location ?? declaration.location);
+        }
+        if (names.has(parameter.name)) {
+            fail("DUPLICATE_TYPE_PARAMETER", `Duplicate type parameter '${parameter.name}'.`, roleLocation(parameter, "name"));
+        }
+        names.add(parameter.name);
+        const expectedId = `${declaration.id}:type:${index}`;
+        if (normalizeOperations)
+            parameter.id = expectedId;
+        if (parameter.id != expectedId) {
+            fail("DUPLICATE_TYPE_PARAMETER", "Duplicate or invalid type parameter identity.", parameter.location);
+        }
+    }
+}
+/**
+ * Returns the closed identity scope owned by one validated declaration.
+ * @param {import("./types.js").FunctionDeclaration | import("./types.js").RecordDeclaration} declaration - Declaration.
+ * @returns {Set<string>} Type-parameter identities.
+ */
+function declarationTypeParameterIds(declaration) {
+    return new Set((declaration.typeParameters ?? []).map(({ id }) => /** @type {string} */ (id)));
+}
+/**
+ * Validates nominal declarations and returns their stable identity registry.
+ * @param {unknown} declarations - Candidate ordered declarations.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @param {boolean} normalizeOperations - Whether parser-authored identities are assigned.
+ * @param {Map<string, import("./types.js").RecordDeclaration>} [visibleRecords] - Imported record declarations by identity.
+ * @param {ClassRegistry} [classes] - Module reference classes by identity.
+ * @returns {RecordRegistry} Validated declarations by identity.
+ */
+function validateRecordDeclarations(declarations, fail, normalizeOperations, visibleRecords = new Map(), classes = new Map()) {
+    if (!Array.isArray(declarations))
+        return fail("TYPE_MISMATCH", "Record declarations must be an ordered array.", /** @type {never} */ (undefined));
+    /** @type {RecordRegistry} */
+    const records = new Map(visibleRecords);
+    referenceClassesByRecordRegistry.set(records, classes);
+    const names = new Set();
+    for (let recordIndex = 0; recordIndex < declarations.length; recordIndex += 1) {
+        const declaration = declarations[recordIndex];
+        if (!declaration || declaration.kind != "RecordDeclaration" || !Array.isArray(declaration.fields)) {
+            return fail("TYPE_MISMATCH", "Malformed record declaration.", declaration?.location);
+        }
+        if (normalizeOperations)
+            declaration.id = `record:${recordIndex}`;
+        if (typeof declaration.id != "string" || !/^(?:[a-z][a-z0-9._-]*#)?record:[0-9]+$/u.test(declaration.id) || records.has(declaration.id)) {
+            fail("DUPLICATE_RECORD", "Duplicate or invalid record declaration identity.", declaration.location);
+        }
+        if (names.has(declaration.name)) {
+            fail("DUPLICATE_RECORD", `Duplicate record '${declaration.name}'.`, roleLocation(declaration, "name"));
+        }
+        names.add(declaration.name);
+        validateTypeParameters(declaration, fail, normalizeOperations);
+        records.set(declaration.id, declaration);
+    }
+    for (const declaration of declarations) {
+        const fieldNames = new Set();
+        const typeParameters = declarationTypeParameterIds(declaration);
+        for (let fieldIndex = 0; fieldIndex < declaration.fields.length; fieldIndex += 1) {
+            const field = declaration.fields[fieldIndex];
+            if (!field || field.kind != "RecordField")
+                fail("TYPE_MISMATCH", "Malformed record field.", field?.location ?? declaration.location);
+            if (normalizeOperations)
+                field.id = `${declaration.id}:field:${fieldIndex}`;
+            if (typeof field.id != "string" || field.id != `${declaration.id}:field:${fieldIndex}`) {
+                fail("DUPLICATE_FIELD", "Duplicate or invalid record field identity.", field.location);
+            }
+            if (fieldNames.has(field.name))
+                fail("DUPLICATE_FIELD", `Duplicate field '${field.name}'.`, roleLocation(field, "name"));
+            fieldNames.add(field.name);
+            if (containsOwnedType(field.type)) {
+                fail("RESOURCE_ALIAS", "Owned resources cannot be stored in immutable records.", field.location);
+            }
+            validateValueTypeReference(field.type, field.location, fail, undefined, records, typeParameters);
+        }
+    }
+    validateDirectRecordRecursion(declarations, records, fail);
+    return records;
+}
+/**
+ * Rejects cycles composed solely of unmediated record fields.
+ * @param {import("./types.js").RecordDeclaration[]} declarations - Valid declarations.
+ * @param {RecordRegistry} records - Declarations by identity.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @returns {void}
+ */
+function validateDirectRecordRecursion(declarations, records, fail) {
+    const complete = new Set();
+    /**
+     * Visits one declaration along an unmediated record path.
+     * @param {import("./types.js").RecordDeclaration} declaration - Current declaration.
+     * @param {Set<string>} active - Declaration identities active on this path.
+     * @returns {void}
+     */
+    function visit(declaration, active) {
+        if (complete.has(/** @type {string} */ (declaration.id)))
+            return;
+        const next = new Set(active);
+        next.add(/** @type {string} */ (declaration.id));
+        for (const field of declaration.fields) {
+            if (field.type.kind != "RecordType")
+                continue;
+            if (next.has(field.type.declarationId)) {
+                fail("ILLEGAL_RECORD_RECURSION", `Direct value-recursive field '${field.name}'.`, typeLocation(field.type, field.location));
+            }
+            const referenced = records.get(field.type.declarationId);
+            if (referenced)
+                visit(referenced, next);
+        }
+        complete.add(/** @type {string} */ (declaration.id));
+    }
+    for (const declaration of declarations)
+        visit(declaration, new Set());
 }
 /**
  * Validates one non-void function and its complete control flow.
  * @param {import("./types.js").FunctionDeclaration} declaration - Function declaration.
  * @param {Map<string, import("./types.js").FunctionDeclaration>} functions - Function signatures.
+ * @param {RecordRegistry} records - Record declarations by identity.
+ * @param {ErrorRegistry} errors - Error declarations by identity.
+ * @param {Map<string, Set<string>>} callEffects - Internally inferred unchecked-error effects.
+ * @param {Set<string>} reservedValueNames - Module functions and nominal constructors unavailable to lexical bindings.
  * @param {SemanticFail} fail - Diagnostic callback.
  * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.
+ * @param {Map<string, object>} loopOwners - Loop owner by module-local identity.
  * @returns {void}
  */
-function validateFunction(declaration, functions, fail, normalizeOperations) {
-    const scope = createScope(undefined, declaration.body.statements, new Set(functions.keys()));
+function validateFunction(declaration, functions, records, errors, callEffects, reservedValueNames, fail, normalizeOperations, loopOwners) {
+    const typeParameters = declarationTypeParameterIds(declaration);
+    const scope = createScope(undefined, declaration.body.statements, reservedValueNames, typeParameters);
     for (const parameter of declaration.parameters) {
-        const type = validateTypeReference(parameter.type, parameter.location, fail);
-        declareBinding(parameter.name, { mutable: false, type }, parameter.location, scope, fail);
+        const type = validateValueTypeReference(parameter.type, parameter.location, fail, undefined, records, typeParameters);
+        declareBinding(parameter.name, { knownValue: undefined, mutable: false, type }, roleLocation(parameter, "name"), scope, fail);
     }
-    const returnType = validateTypeReference(declaration.returnType, declaration.location, fail);
-    const returns = validateBlock(declaration.body, scope, returnType, functions, fail, normalizeOperations);
-    if (!returns)
+    const returnType = validateReturnTypeReference(declaration.returnType, declaration.location, fail, records, typeParameters);
+    const returns = validateBlock(declaration.body, scope, returnType, functions, records, errors, callEffects, fail, normalizeOperations, { owner: declaration, owners: loopOwners });
+    if (!isVoidType(returnType) && returns.normal) {
         fail("MISSING_RETURN", `Function '${declaration.name}' does not return on every reachable path.`, declaration.location);
+    }
 }
 /**
  * Validates one ordered block and reports whether every path returns.
  * @param {import("./types.js").Block} block - Semantic block.
  * @param {Scope} scope - Scope belonging to this block.
- * @param {import("./types.js").SemanticTypeName | undefined} returnType - Function return type, absent for entry points.
+ * @param {import("./types.js").SemanticFunctionReturnType | undefined} returnType - Function return type, absent for entry points.
  * @param {Map<string, import("./types.js").FunctionDeclaration>} functions - Function signatures.
+ * @param {RecordRegistry} records - Record declarations by identity.
+ * @param {ErrorRegistry} errors - Error declarations by identity.
+ * @param {Map<string, Set<string>>} callEffects - Internally inferred unchecked-error effects.
  * @param {SemanticFail} fail - Diagnostic callback.
  * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.
- * @returns {boolean} Whether every path through the block returns.
+ * @param {LoopFlowContext} loopContext - Active loop and owner identities.
+ * @returns {{normal: boolean, raises: Set<string>}} Reachable normal continuation and escaping error identities.
  */
-function validateBlock(block, scope, returnType, functions, fail, normalizeOperations) {
-    let alwaysReturns = false;
+function validateBlock(block, scope, returnType, functions, records, errors, callEffects, fail, normalizeOperations, loopContext) {
+    let normal = true;
+    const raises = new Set();
     for (const statement of block.statements) {
-        if (alwaysReturns)
+        if (!normal)
             fail("UNREACHABLE_STATEMENT", "Statement is unreachable.", statement.location);
         if (statement.kind == "LocalDeclaration") {
-            const declaredType = validateTypeReference(statement.type, statement.location, fail);
-            const initializerType = inferExpressionType(statement.initializer, scope, functions, fail, normalizeOperations);
+            const declaredType = validateValueTypeReference(statement.type, statement.location, fail, undefined, records, scope.typeParameters);
+            statement.initializer = normalizeOwnedMove(statement.initializer, declaredType, normalizeOperations, fail);
+            const initializerType = inferValueExpressionType(statement.initializer, scope, functions, records, fail, normalizeOperations, "an initializer", declaredType);
             scope.pending.delete(statement.name);
-            if (initializerType != declaredType) {
-                fail("TYPE_MISMATCH", `Initializer type ${initializerType}; expected ${declaredType}.`, statement.initializer.location);
+            if (!sameType(initializerType, declaredType)) {
+                if (initializerType.kind == "OptionalType" && declaredType.kind != "OptionalType") {
+                    fail("FAILURE_ABSENCE_CONFLATION", "Optional absence cannot be coerced into a value or typed failure.", statement.initializer.location);
+                }
+                fail("TYPE_MISMATCH", `Initializer type ${typeDescription(initializerType)}; expected ${typeDescription(declaredType)}.`, statement.initializer.location);
             }
-            declareBinding(statement.name, { mutable: statement.mutable, type: declaredType }, statement.location, scope, fail);
+            declareBinding(statement.name, {
+                knownValue: knownValueForExpression(statement.initializer, scope),
+                mutable: statement.mutable,
+                type: declaredType
+            }, roleLocation(statement, "name"), scope, fail);
+            addExpressionEffects(raises, statement.initializer, callEffects);
             continue;
         }
         if (statement.kind == "AssignmentStatement") {
-            const expressionType = inferExpressionType(statement.expression, scope, functions, fail, normalizeOperations);
             const binding = resolveBinding(statement.target.name, statement.target.location, scope, fail);
+            if (binding.type.kind == "ErrorType") {
+                fail("IMMUTABLE_ASSIGNMENT", `Cannot assign to immutable catch binding '${statement.target.name}'.`, statement.target.location);
+            }
+            if (binding.type.kind == "OwnedResourceType" || binding.type.kind == "OwnedReferenceType") {
+                fail("RESOURCE_ALIAS", "Owned resources cannot be reassigned or aliased.", statement.location);
+            }
+            const expressionType = inferValueExpressionType(statement.expression, scope, functions, records, fail, normalizeOperations, "an assignment", binding.type);
             if (!binding.mutable) {
                 fail("IMMUTABLE_ASSIGNMENT", `Cannot assign to immutable binding '${statement.target.name}'.`, statement.target.location);
             }
-            if (expressionType != binding.type) {
-                fail("TYPE_MISMATCH", `Assignment type ${expressionType}; expected ${binding.type}.`, statement.expression.location);
+            if (!sameType(expressionType, binding.type)) {
+                fail("TYPE_MISMATCH", `Assignment type ${typeDescription(expressionType)}; expected ${typeDescription(binding.type)}.`, statement.expression.location);
             }
+            binding.knownValue = knownValueForExpression(statement.expression, scope);
+            scope.presenceProofs.delete(binding);
+            addExpressionEffects(raises, statement.expression, callEffects);
+            continue;
+        }
+        if (statement.kind == "PrivateFieldWriteStatement") {
+            const declaration = scope.currentClass;
+            if (!declaration || !statement.receiver || statement.receiver.kind != "ReceiverExpression" ||
+                statement.receiver.classId != declaration.id) {
+                fail("ILLEGAL_PRIVATE_ACCESS", "Private field receiver must be the declaring class receiver.", statement.location);
+            }
+            const field = declaration.fields.find((candidate) => candidate.id == statement.field);
+            if (!field)
+                fail("ILLEGAL_PRIVATE_ACCESS", "Private field identity is not owned by the declaring class.", statement.location);
+            statement.expression = normalizeOwnedMove(statement.expression, field.type, normalizeOperations, fail);
+            const expressionType = inferValueExpressionType(statement.expression, scope, functions, records, fail, normalizeOperations, "a private field assignment", field.type);
+            if (!sameType(expressionType, field.type)) {
+                fail("TYPE_MISMATCH", `Private field assignment type ${typeDescription(expressionType)}; expected ${typeDescription(field.type)}.`, statement.expression.location);
+            }
+            addExpressionEffects(raises, statement.expression, callEffects);
             continue;
         }
         if (statement.kind == "PrintStatement") {
-            inferExpressionType(statement.expression, scope, functions, fail, normalizeOperations);
+            const printedType = inferValueExpressionType(statement.expression, scope, functions, records, fail, normalizeOperations, "a print value");
+            if (printedType.kind == "OwnedResourceType" || printedType.kind == "OwnedReferenceType") {
+                fail("BORROW_ESCAPE", "Owned values cannot escape through printing or serialization.", statement.expression.location);
+            }
+            if (printedType.kind != "TypeReference") {
+                fail("TYPE_MISMATCH", "Collections and records cannot be printed directly.", statement.expression.location);
+            }
+            addExpressionEffects(raises, statement.expression, callEffects);
+            continue;
+        }
+        if (statement.kind == "ExpressionStatement") {
+            if (!statement.expression || !["CallExpression", "EffectCallExpression", "MethodCallExpression"].includes(statement.expression.kind)) {
+                fail("TYPE_MISMATCH", "Expression statement must contain a direct or receiver call.", statement.location);
+            }
+            const expressionType = inferExpressionType(statement.expression, scope, functions, records, fail, normalizeOperations);
+            if (expressionType != "void") {
+                fail("TYPE_MISMATCH", "Expression statements may contain only void calls.", statement.expression.location);
+            }
+            addExpressionEffects(raises, statement.expression, callEffects);
+            continue;
+        }
+        if (statement.kind == "BreakStatement" || statement.kind == "ContinueStatement") {
+            const control = statement.kind == "BreakStatement" ? "break" : "continue";
+            if (!loopContext.nearest) {
+                if (typeof statement.targetLoopId == "string" && loopContext.owners.has(statement.targetLoopId) &&
+                    loopContext.owners.get(statement.targetLoopId) !== loopContext.owner) {
+                    fail("CROSS_FUNCTION_LOOP_TARGET", `${control[0].toUpperCase()}${control.slice(1)} target crosses a function boundary.`, statement.location);
+                }
+                fail(`ILLEGAL_${control.toUpperCase()}_CONTEXT`, `${control[0].toUpperCase()}${control.slice(1)} statement outside a loop.`, statement.location);
+            }
+            if (typeof statement.targetLoopId != "string" || !loopContext.owners.has(statement.targetLoopId)) {
+                fail("INVALID_LOOP_TARGET", `${control[0].toUpperCase()}${control.slice(1)} has an invalid loop target identity.`, statement.location);
+            }
+            if (loopContext.owners.get(statement.targetLoopId) !== loopContext.owner) {
+                fail("CROSS_FUNCTION_LOOP_TARGET", `${control[0].toUpperCase()}${control.slice(1)} target crosses a function boundary.`, statement.location);
+            }
+            if (statement.targetLoopId != loopContext.nearest.id) {
+                fail("INVALID_LOOP_TARGET", `${control[0].toUpperCase()}${control.slice(1)} must target the nearest enclosing loop.`, statement.location);
+            }
+            normal = false;
             continue;
         }
         if (statement.kind == "ReturnStatement") {
             if (!returnType)
                 fail("ILLEGAL_RETURN_CONTEXT", "Return statement outside a function.", statement.location);
-            const actualType = inferExpressionType(statement.expression, scope, functions, fail, normalizeOperations);
-            if (actualType != returnType) {
-                fail("TYPE_MISMATCH", `Return type ${actualType}; expected ${returnType}.`, statement.expression.location);
+            if (isVoidType(returnType)) {
+                if (statement.expression) {
+                    fail("VOID_RETURN_VALUE", "Void function cannot return a value.", statement.expression.location);
+                }
             }
-            alwaysReturns = true;
+            else {
+                if (!statement.expression) {
+                    fail("MISSING_RETURN_VALUE", `Function return requires a ${typeDescription(returnType)} value.`, statement.location);
+                }
+                statement.expression = normalizeOwnedMove(statement.expression, returnType, normalizeOperations, fail);
+                const actualType = inferValueExpressionType(statement.expression, scope, functions, records, fail, normalizeOperations, "a returned value", returnType);
+                if (!sameType(actualType, returnType)) {
+                    fail("TYPE_MISMATCH", `Return type ${typeDescription(actualType)}; expected ${typeDescription(returnType)}.`, statement.expression.location);
+                }
+            }
+            if (statement.expression)
+                addExpressionEffects(raises, statement.expression, callEffects);
+            normal = false;
             continue;
         }
         if (statement.kind == "IfStatement") {
-            const conditionType = inferExpressionType(statement.condition, scope, functions, fail, normalizeOperations);
-            if (conditionType != "boolean") {
-                fail("NON_BOOLEAN_CONDITION", `If condition type ${conditionType}; expected boolean.`, statement.condition.location);
+            const conditionType = inferValueExpressionType(statement.condition, scope, functions, records, fail, normalizeOperations, "a condition");
+            if (!isScalarType(conditionType, "boolean")) {
+                fail("NON_BOOLEAN_CONDITION", `If condition type ${typeDescription(conditionType)}; expected boolean.`, statement.condition.location);
             }
+            const visibleBindings = bindingsVisibleFrom(scope);
+            const initialKnownValues = visibleBindings.map((binding) => binding.knownValue);
             const consequentScope = createScope(scope, statement.consequent.statements);
-            const consequentReturns = validateBlock(statement.consequent, consequentScope, returnType, functions, fail, normalizeOperations);
-            let alternateReturns = false;
+            const alternateScope = createScope(scope, statement.alternate?.statements ?? []);
+            applyPresenceNarrowing(statement.condition, scope, consequentScope, true);
+            applyPresenceNarrowing(statement.condition, scope, alternateScope, false);
+            const consequentReturns = validateBlock(statement.consequent, consequentScope, returnType, functions, records, errors, callEffects, fail, normalizeOperations, loopContext);
+            const consequentKnownValues = visibleBindings.map((binding) => binding.knownValue);
+            visibleBindings.forEach((binding, index) => {
+                binding.knownValue = initialKnownValues[index];
+            });
+            let alternateReturns = { normal: true, raises: new Set() };
             if (statement.alternate) {
-                const alternateScope = createScope(scope, statement.alternate.statements);
-                alternateReturns = validateBlock(statement.alternate, alternateScope, returnType, functions, fail, normalizeOperations);
+                alternateReturns = validateBlock(statement.alternate, alternateScope, returnType, functions, records, errors, callEffects, fail, normalizeOperations, loopContext);
+            }
+            const alternateKnownValues = visibleBindings.map((binding) => binding.knownValue);
+            visibleBindings.forEach((binding, index) => {
+                if (!consequentReturns.normal && alternateReturns.normal)
+                    binding.knownValue = alternateKnownValues[index];
+                else if (consequentReturns.normal && !alternateReturns.normal)
+                    binding.knownValue = consequentKnownValues[index];
+                else if (consequentReturns.normal && alternateReturns.normal && consequentKnownValues[index] === alternateKnownValues[index]) {
+                    binding.knownValue = consequentKnownValues[index];
+                }
+                else
+                    binding.knownValue = undefined;
+            });
+            const continuingProofs = !consequentReturns.normal && alternateReturns.normal
+                ? alternateScope.presenceProofs
+                : consequentReturns.normal && !alternateReturns.normal
+                    ? consequentScope.presenceProofs
+                    : consequentReturns.normal && alternateReturns.normal
+                        ? new Set([...consequentScope.presenceProofs].filter((binding) => alternateScope.presenceProofs.has(binding)))
+                        : new Set();
+            const visibleSet = new Set(visibleBindings);
+            scope.presenceProofs.clear();
+            for (const binding of continuingProofs) {
+                if (visibleSet.has(binding))
+                    scope.presenceProofs.add(binding);
+            }
+            addExpressionEffects(raises, statement.condition, callEffects);
+            addAll(raises, consequentReturns.raises);
+            addAll(raises, alternateReturns.raises);
+            normal = consequentReturns.normal || alternateReturns.normal;
+            continue;
+        }
+        if (statement.kind == "WhileStatement") {
+            const assignedOuterBindings = outerMutableBindingsAssignedBy(statement.body, scope);
+            for (const binding of assignedOuterBindings) {
+                binding.knownValue = undefined;
+                scope.presenceProofs.delete(binding);
+            }
+            const conditionType = inferValueExpressionType(statement.condition, scope, functions, records, fail, normalizeOperations, "a condition-controlled loop condition");
+            if (!isScalarType(conditionType, "boolean")) {
+                fail("NON_BOOLEAN_CONDITION", `While condition type ${typeDescription(conditionType)}; expected boolean.`, statement.condition.location);
+            }
+            const loopScope = createScope(scope, statement.body.statements);
+            applyPresenceNarrowing(statement.condition, scope, loopScope, true);
+            const bodyFlow = validateBlock(statement.body, loopScope, returnType, functions, records, errors, callEffects, fail, normalizeOperations, { nearest: statement, owner: loopContext.owner, owners: loopContext.owners });
+            addExpressionEffects(raises, statement.condition, callEffects);
+            addAll(raises, bodyFlow.raises);
+            for (const binding of assignedOuterBindings) {
+                binding.knownValue = undefined;
+                scope.presenceProofs.delete(binding);
+            }
+            continue;
+        }
+        if (statement.kind == "ForEachStatement") {
+            const listType = inferValueExpressionType(statement.list, scope, functions, records, fail, normalizeOperations, "an iteration collection");
+            if (listType.kind != "ListType") {
+                fail("TYPE_MISMATCH", `Iteration collection type ${typeDescription(listType)}; expected list.`, statement.list.location);
+            }
+            if (!statement.valueBinding || statement.valueBinding.kind != "ValueBinding") {
+                fail("TYPE_MISMATCH", "Iteration requires one typed value binding.", statement.location);
+            }
+            if (statement.valueBinding.mutable !== false) {
+                fail("TYPE_MISMATCH", "Iteration binding must be immutable.", statement.valueBinding.location ?? statement.location);
+            }
+            const bindingType = validateValueTypeReference(statement.valueBinding.type, statement.valueBinding.location, fail, undefined, records, scope.typeParameters);
+            if (!sameType(bindingType, listType.elementType)) {
+                fail("TYPE_MISMATCH", `Iteration binding type ${typeDescription(bindingType)}; expected ${typeDescription(listType.elementType)}.`, typeLocation(statement.valueBinding.type, statement.valueBinding.location));
+            }
+            const assignedOuterBindings = outerMutableBindingsAssignedBy(statement.body, scope);
+            for (const binding of assignedOuterBindings) {
+                binding.knownValue = undefined;
+                scope.presenceProofs.delete(binding);
+            }
+            const loopScope = createScope(scope, statement.body.statements);
+            declareBinding(statement.valueBinding.name, {
+                knownValue: undefined,
+                mutable: false,
+                type: bindingType
+            }, roleLocation(statement.valueBinding, "name"), loopScope, fail);
+            const bodyFlow = validateBlock(statement.body, loopScope, returnType, functions, records, errors, callEffects, fail, normalizeOperations, { nearest: statement, owner: loopContext.owner, owners: loopContext.owners });
+            addExpressionEffects(raises, statement.list, callEffects);
+            addAll(raises, bodyFlow.raises);
+            for (const binding of assignedOuterBindings) {
+                binding.knownValue = undefined;
+                scope.presenceProofs.delete(binding);
+            }
+            continue;
+        }
+        if (statement.kind == "ForEachMapStatement") {
+            const mapType = inferValueExpressionType(statement.map, scope, functions, records, fail, normalizeOperations, "a map iteration collection");
+            if (mapType.kind != "OrderedMapType") {
+                fail("TYPE_MISMATCH", `Map iteration collection type ${typeDescription(mapType)}; expected ordered map.`, statement.map.location);
+            }
+            if (!statement.keyBinding || statement.keyBinding.kind != "ValueBinding" ||
+                !statement.valueBinding || statement.valueBinding.kind != "ValueBinding") {
+                fail("TYPE_MISMATCH", "Map iteration requires exact key and value bindings.", statement.location);
+            }
+            if (statement.keyBinding.mutable !== false || statement.valueBinding.mutable !== false) {
+                fail("TYPE_MISMATCH", "Map iteration bindings must be immutable.", statement.keyBinding.mutable !== false ? statement.keyBinding.location : statement.valueBinding.location);
+            }
+            const keyType = validateValueTypeReference(statement.keyBinding.type, statement.keyBinding.location, fail, undefined, records, scope.typeParameters);
+            const valueType = validateValueTypeReference(statement.valueBinding.type, statement.valueBinding.location, fail, undefined, records, scope.typeParameters);
+            if (!sameType(keyType, mapType.keyType)) {
+                fail("TYPE_MISMATCH", `Map iteration key binding type ${typeDescription(keyType)}; expected ${typeDescription(mapType.keyType)}.`, typeLocation(statement.keyBinding.type, statement.keyBinding.location));
+            }
+            if (!sameType(valueType, mapType.valueType)) {
+                fail("TYPE_MISMATCH", `Map iteration value binding type ${typeDescription(valueType)}; expected ${typeDescription(mapType.valueType)}.`, typeLocation(statement.valueBinding.type, statement.valueBinding.location));
+            }
+            const assignedOuterBindings = outerMutableBindingsAssignedBy(statement.body, scope);
+            for (const binding of assignedOuterBindings) {
+                binding.knownValue = undefined;
+                scope.presenceProofs.delete(binding);
+            }
+            const loopScope = createScope(scope, statement.body.statements);
+            declareBinding(statement.keyBinding.name, { knownValue: undefined, mutable: false, type: keyType }, roleLocation(statement.keyBinding, "name"), loopScope, fail);
+            declareBinding(statement.valueBinding.name, { knownValue: undefined, mutable: false, type: valueType }, roleLocation(statement.valueBinding, "name"), loopScope, fail);
+            const bodyFlow = validateBlock(statement.body, loopScope, returnType, functions, records, errors, callEffects, fail, normalizeOperations, { nearest: statement, owner: loopContext.owner, owners: loopContext.owners });
+            addExpressionEffects(raises, statement.map, callEffects);
+            addAll(raises, bodyFlow.raises);
+            for (const binding of assignedOuterBindings) {
+                binding.knownValue = undefined;
+                scope.presenceProofs.delete(binding);
+            }
+            continue;
+        }
+        if (statement.kind == "RaiseStatement") {
+            if (!statement.error || statement.error.kind != "ErrorConstruction") {
+                fail("NON_ERROR_RAISE", "Raise requires one constructed semantic error.", statement.location);
+            }
+            const raisedType = validateErrorType(statement.error.error, statement.error.location, errors, fail);
+            const messageType = inferValueExpressionType(statement.error.message, scope, functions, records, fail, normalizeOperations, "an error message", scalarType("string"));
+            if (!isScalarType(messageType, "string")) {
+                fail("NON_ERROR_RAISE", `Error message type ${typeDescription(messageType)}; expected string.`, statement.error.message.location);
+            }
+            addExpressionEffects(raises, statement.error.message, callEffects);
+            raises.add(raisedType.declarationId);
+            normal = false;
+            continue;
+        }
+        if (statement.kind == "TryStatement") {
+            const caughtType = validateErrorType(statement.catchType, statement.location, errors, fail);
+            if (!statement.catchBinding || statement.catchBinding.kind != "CatchBinding" || statement.catchBinding.mutable !== false) {
+                fail("INVALID_ERROR_HANDLER", "Catch requires one immutable typed binding.", statement.catchBinding?.location ?? statement.location);
+            }
+            const bindingType = validateErrorType(statement.catchBinding.type, statement.catchBinding.location, errors, fail);
+            if (bindingType.declarationId != caughtType.declarationId) {
+                fail("INVALID_ERROR_HANDLER", "Catch binding type must exactly match its handler type.", statement.catchBinding.location);
+            }
+            const bodyAssignedOuterBindings = outerMutableBindingsAssignedBy(statement.body, scope);
+            const assignedOuterBindings = new Set(bodyAssignedOuterBindings);
+            outerMutableBindingsAssignedBy(statement.catchBody, scope, assignedOuterBindings);
+            const bodyScope = createScope(scope, statement.body.statements);
+            const bodyFlow = validateBlock(statement.body, bodyScope, returnType, functions, records, errors, callEffects, fail, normalizeOperations, loopContext);
+            const catchScope = createScope(scope, statement.catchBody.statements);
+            for (const binding of bodyAssignedOuterBindings) {
+                binding.knownValue = undefined;
+                catchScope.presenceProofs.delete(binding);
+            }
+            declareBinding(statement.catchBinding.name, {
+                knownValue: undefined,
+                mutable: false,
+                type: bindingType
+            }, roleLocation(statement.catchBinding, "name"), catchScope, fail);
+            const catchFlow = validateBlock(statement.catchBody, catchScope, returnType, functions, records, errors, callEffects, fail, normalizeOperations, loopContext);
+            if (!bodyFlow.raises.has(caughtType.declarationId)) {
+                fail("UNREACHABLE_HANDLER", `Handler for '${errors.get(caughtType.declarationId)?.name}' cannot be reached.`, typeLocation(statement.catchType, statement.location));
+            }
+            bodyFlow.raises.delete(caughtType.declarationId);
+            addAll(raises, bodyFlow.raises);
+            addAll(raises, catchFlow.raises);
+            normal = bodyFlow.normal || catchFlow.normal;
+            for (const binding of assignedOuterBindings) {
+                binding.knownValue = undefined;
+                scope.presenceProofs.delete(binding);
             }
-            alwaysReturns = consequentReturns && alternateReturns;
             continue;
         }
         const unexpected = /** @type {{kind: string, location: import("./types.js").SourceLocation}} */ (statement);
         fail("UNSUPPORTED_STATEMENT", unexpected.kind, unexpected.location);
     }
-    return alwaysReturns;
+    return { normal, raises };
+}
+/**
+ * Validates one exact nominal error type.
+ * @param {unknown} type - Candidate type.
+ * @param {import("./types.js").SourceLocation} location - Owning location.
+ * @param {ErrorRegistry} errors - Visible error declarations.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @returns {import("./types.js").ErrorType} Validated type.
+ */
+function validateErrorType(type, location, errors, fail) {
+    if (!type || typeof type != "object" || Array.isArray(type)) {
+        return fail("UNKNOWN_ERROR", "Handler or raise is missing an exact error type.", location);
+    }
+    const candidate = /** @type {import("./types.js").ErrorType} */ (type);
+    if (candidate.kind != "ErrorType" ||
+        Object.keys(candidate).filter((key) => key != "sourceProvenance").sort().join(",") != "declarationId,kind" ||
+        typeof candidate.declarationId != "string" || !errors.has(candidate.declarationId)) {
+        fail("UNKNOWN_ERROR", `Unknown error declaration '${String(candidate.declarationId)}'.`, typeLocation(candidate, location));
+    }
+    return candidate;
+}
+/**
+ * Adds every source value to one set.
+ * @param {Set<string>} target - Destination identities.
+ * @param {Set<string>} source - Source identities.
+ * @returns {void}
+ */
+function addAll(target, source) {
+    for (const value of source)
+        target.add(value);
+}
+/**
+ * Adds unchecked errors raised while evaluating one expression.
+ * @param {Set<string>} target - Destination identities.
+ * @param {unknown} expression - Candidate semantic expression.
+ * @param {Map<string, Set<string>>} callEffects - Inferred call effects.
+ * @param {Map<string, Set<string>>} [methodEffects] - Inferred effects by resolved method identity.
+ * @returns {void}
+ */
+function addExpressionEffects(target, expression, callEffects, methodEffects = new Map()) {
+    const pending = [expression];
+    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 (Reflect.get(value, "kind") == "CallExpression")
+            addAll(target, callEffects.get(Reflect.get(value, "callee")) ?? new Set());
+        if (Reflect.get(value, "kind") == "MethodCallExpression" || Reflect.get(value, "kind") == "ReferenceConstruction") {
+            const failures = Reflect.get(value, "failureIds");
+            if (Array.isArray(failures))
+                for (const failure of failures)
+                    if (typeof failure == "string")
+                        target.add(failure);
+            if (Reflect.get(value, "kind") == "MethodCallExpression") {
+                addAll(target, methodEffects.get(Reflect.get(value, "method")) ?? new Set());
+            }
+        }
+        if (Reflect.get(value, "kind") == "EffectCallExpression") {
+            const resolution = Reflect.get(value, "resolution");
+            const failures = resolution && typeof resolution == "object" ? Reflect.get(resolution, "failureIds") : undefined;
+            if (Array.isArray(failures))
+                for (const failure of failures)
+                    if (typeof failure == "string")
+                        target.add(failure);
+        }
+        for (const [key, child] of Object.entries(value)) {
+            if (["location", "sourceProvenance", "resolution"].includes(key))
+                continue;
+            if (Array.isArray(child))
+                pending.push(...child);
+            else if (child && typeof child == "object")
+                pending.push(child);
+        }
+    }
+}
+/**
+ * Derives unchecked-error propagation over the resolved finite function graph.
+ * This is validator state, never a checked effect in the public function signature.
+ * @param {Map<string, import("./types.js").FunctionDeclaration>} functions - Resolved functions.
+ * @param {Map<string, Set<string>>} [seedEffects] - Dependency effects keyed by local import name.
+ * @param {Set<string>} [localFunctionNames] - Functions whose bodies belong to the current module.
+ * @returns {Map<string, Set<string>>} Escaping error identities by source-visible function name.
+ */
+function inferCallEffects(functions, seedEffects = new Map(), localFunctionNames = new Set(functions.keys())) {
+    const effects = new Map([...functions.keys()].map((name) => [name, new Set(seedEffects.get(name) ?? [])]));
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const name of localFunctionNames) {
+            const declaration = functions.get(name);
+            if (!declaration)
+                continue;
+            const next = syntacticBlockEffects(declaration.body, effects);
+            const current = /** @type {Set<string>} */ (effects.get(name));
+            for (const error of next) {
+                if (!current.has(error)) {
+                    current.add(error);
+                    changed = true;
+                }
+            }
+        }
+    }
+    return effects;
+}
+/**
+ * Computes escaping identities from one block for the call-effect fixed point.
+ * @param {unknown} block - Candidate block.
+ * @param {Map<string, Set<string>>} callEffects - Current fixed-point state.
+ * @param {Map<string, Set<string>>} [methodEffects] - Current method fixed-point state.
+ * @returns {Set<string>} Escaping identities.
+ */
+function syntacticBlockEffects(block, callEffects, methodEffects = new Map()) {
+    const result = new Set();
+    const statements = Reflect.get(/** @type {object} */ (block ?? {}), "statements");
+    if (!Array.isArray(statements))
+        return result;
+    for (const statement of statements) {
+        if (!statement || typeof statement != "object")
+            continue;
+        const kind = Reflect.get(statement, "kind");
+        if (kind == "RaiseStatement") {
+            const construction = Reflect.get(statement, "error");
+            const type = construction && typeof construction == "object" ? Reflect.get(construction, "error") : undefined;
+            const declarationId = type && typeof type == "object" ? Reflect.get(type, "declarationId") : undefined;
+            if (typeof declarationId == "string")
+                result.add(declarationId);
+            if (construction && typeof construction == "object") {
+                addExpressionEffects(result, Reflect.get(construction, "message"), callEffects, methodEffects);
+            }
+            continue;
+        }
+        if (kind == "TryStatement") {
+            const bodyEffects = syntacticBlockEffects(Reflect.get(statement, "body"), callEffects, methodEffects);
+            const catchType = Reflect.get(statement, "catchType");
+            const caughtId = catchType && typeof catchType == "object" ? Reflect.get(catchType, "declarationId") : undefined;
+            if (typeof caughtId == "string" && bodyEffects.delete(caughtId)) {
+                addAll(bodyEffects, syntacticBlockEffects(Reflect.get(statement, "catchBody"), callEffects, methodEffects));
+            }
+            addAll(result, bodyEffects);
+            continue;
+        }
+        if (kind == "IfStatement") {
+            addExpressionEffects(result, Reflect.get(statement, "condition"), callEffects, methodEffects);
+            addAll(result, syntacticBlockEffects(Reflect.get(statement, "consequent"), callEffects, methodEffects));
+            addAll(result, syntacticBlockEffects(Reflect.get(statement, "alternate"), callEffects, methodEffects));
+            continue;
+        }
+        if (kind == "ForEachStatement" || kind == "ForEachMapStatement") {
+            addExpressionEffects(result, Reflect.get(statement, kind == "ForEachStatement" ? "list" : "map"), callEffects, methodEffects);
+            addAll(result, syntacticBlockEffects(Reflect.get(statement, "body"), callEffects, methodEffects));
+            continue;
+        }
+        if (kind == "WhileStatement") {
+            addExpressionEffects(result, Reflect.get(statement, "condition"), callEffects, methodEffects);
+            addAll(result, syntacticBlockEffects(Reflect.get(statement, "body"), callEffects, methodEffects));
+            continue;
+        }
+        for (const key of ["expression", "initializer"]) {
+            addExpressionEffects(result, Reflect.get(statement, key), callEffects, methodEffects);
+        }
+    }
+    return result;
+}
+/**
+ * Derives the escaping user-defined error sets for local functions and resolved class methods.
+ * The fixed point is computed over every unchecked error; capability failures are projected out
+ * because call sites already carry their capability-failure boundary through resolution metadata.
+ * @param {import("./types.js").SemanticModule} module - Resolved module.
+ * @param {Map<string, Set<string>>} [seedEffects] - Dependency effects keyed by local import name.
+ * @returns {{functions: Map<string, Set<string>>, methods: Map<string, Set<string>>}} Escaping user-defined error identities by function name and method identity.
+ */
+export function inferEscapingErrorEffects(module, seedEffects = new Map()) {
+    const functions = new Map(module.functions.map((declaration) => [declaration.name, declaration]));
+    const functionEffects = new Map([...functions.keys()].map((name) => [name, new Set(seedEffects.get(name) ?? [])]));
+    const classes = module.classes ?? [];
+    const methodEffects = new Map();
+    const capabilityFailureIds = new Set((module.capabilities ?? []).flatMap(({ failures }) => failures).map(({ id }) => id));
+    for (const declaration of classes)
+        for (const method of declaration.methods)
+            methodEffects.set(method.id, new Set());
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const declaration of module.functions) {
+            const current = /** @type {Set<string>} */ (functionEffects.get(declaration.name));
+            for (const error of syntacticBlockEffects(declaration.body, functionEffects, methodEffects)) {
+                if (!current.has(error)) {
+                    current.add(error);
+                    changed = true;
+                }
+            }
+        }
+        for (const declaration of classes) {
+            for (const method of declaration.methods) {
+                const current = /** @type {Set<string>} */ (methodEffects.get(method.id));
+                for (const error of syntacticBlockEffects(method.body, functionEffects, methodEffects)) {
+                    if (!current.has(error)) {
+                        current.add(error);
+                        changed = true;
+                    }
+                }
+            }
+        }
+    }
+    for (const effects of [functionEffects, methodEffects]) {
+        for (const errors of effects.values()) {
+            for (const error of [...errors])
+                if (capabilityFailureIds.has(error))
+                    errors.delete(error);
+        }
+    }
+    return { functions: functionEffects, methods: methodEffects };
 }
 /**
  * Creates a lexical scope with declarations marked pending until visited.
  * @param {Scope | undefined} parent - Enclosing scope.
  * @param {{kind: string, name?: string}[]} statements - Scope statements.
  * @param {Set<string>} [reservedNames] - Names unavailable to root bindings.
+ * @param {Set<string>} [typeParameters] - Declaration-scoped type parameters.
+ * @param {import("./types.js").ClassDeclaration} [currentClass] - Declaring class for receiver-private access.
  * @returns {Scope} Scope.
  */
-function createScope(parent, statements, reservedNames = new Set()) {
+function createScope(parent, statements, reservedNames = new Set(), typeParameters = parent?.typeParameters ?? new Set(), currentClass = parent?.currentClass) {
     const pending = new Set(statements.filter((statement) => statement.kind == "LocalDeclaration")
         .map((statement) => /** @type {{name: string}} */ (statement).name));
-    return { bindings: new Map(), parent, pending, usedNames: parent?.usedNames ?? new Set(reservedNames) };
+    return {
+        bindings: new Map(),
+        currentClass,
+        parent,
+        pending,
+        presenceProofs: new Set(parent?.presenceProofs ?? []),
+        typeParameters,
+        usedNames: parent?.usedNames ?? new Set(reservedNames)
+    };
+}
+/**
+ * Applies a simple-identifier presence proof to exactly the branch where the test is true.
+ * @param {import("./types.js").Expression} condition - Validated branch condition.
+ * @param {Scope} sourceScope - Scope containing the tested binding.
+ * @param {Scope} branchScope - Branch-local proof scope.
+ * @param {boolean} branchWhenTrue - Whether this is the condition's true branch.
+ * @returns {void}
+ */
+function applyPresenceNarrowing(condition, sourceScope, branchScope, branchWhenTrue) {
+    let test = condition;
+    let presentWhenTrue = true;
+    if (condition.kind == "UnaryExpression" && condition.operation == "BooleanNot" &&
+        condition.operand.kind == "OptionalIsPresent") {
+        test = condition.operand;
+        presentWhenTrue = false;
+    }
+    if (test.kind != "OptionalIsPresent")
+        return;
+    const binding = findBinding(test.operand.name, sourceScope);
+    if (!binding)
+        return;
+    if (branchWhenTrue == presentWhenTrue)
+        branchScope.presenceProofs.add(binding);
+    else
+        branchScope.presenceProofs.delete(binding);
 }
 /**
  * Adds one binding while rejecting duplicates and shadowing.
@@ -233,71 +1307,698 @@ function resolveBinding(name, location, scope, fail) {
     return fail("UNRESOLVED_BINDING", `Unknown binding '${name}'.`, location);
 }
 /**
- * Validates one semantic type reference.
+ * Validates one semantic value type reference.
  * @param {unknown} type - Candidate semantic type reference.
  * @param {import("./types.js").SourceLocation} location - Owning source location.
  * @param {SemanticFail} fail - Diagnostic callback.
- * @returns {import("./types.js").SemanticTypeName} Validated scalar name.
+ * @param {Set<object>} [seen] - Active recursive type path.
+ * @param {RecordRegistry} [records] - Record declarations by identity.
+ * @param {Set<string>} [typeParameters] - Type-variable identities in declaration scope.
+ * @returns {import("./types.js").SemanticValueType} Validated value type.
  */
-function validateTypeReference(type, location, fail) {
-    if (!type || typeof type != "object" || Array.isArray(type)) {
-        return fail("TYPE_MISMATCH", "Unsupported scalar type.", location);
-    }
-    const candidate = /** @type {import("./types.js").TypeReference} */ (type);
-    if (candidate.kind != "TypeReference" || !isScalarTypeName(candidate.name)) {
-        fail("TYPE_MISMATCH", "Unsupported scalar type.", location);
-    }
-    return candidate.name;
+function validateValueTypeReference(type, location, fail, seen, records = new Map(), typeParameters = new Set()) {
+    const candidate = validateTypeReference(type, location, fail, seen, records, typeParameters);
+    if (isVoidType(candidate))
+        return fail("VOID_AS_VALUE", "Void is valid only as a function return type.", typeLocation(type, location));
+    return candidate;
 }
 /**
- * Infers and validates one expression.
- * @param {import("./types.js").Expression} expression - Semantic expression.
- * @param {Scope} scope - Visible lexical scope.
- * @param {Map<string, import("./types.js").FunctionDeclaration>} functions - Module function signatures.
+ * Validates one function return type reference.
+ * @param {unknown} type - Candidate semantic return type reference.
+ * @param {import("./types.js").SourceLocation} location - Owning source location.
  * @param {SemanticFail} fail - Diagnostic callback.
- * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.
- * @returns {import("./types.js").SemanticTypeName} Expression type.
+ * @param {RecordRegistry} [records] - Record declarations by identity.
+ * @param {Set<string>} [typeParameters] - Type-variable identities in declaration scope.
+ * @returns {import("./types.js").SemanticFunctionReturnType} Validated return type.
  */
-function inferExpressionType(expression, scope, functions, fail, normalizeOperations) {
-    if (expression.kind == "IdentifierExpression")
-        return resolveBinding(expression.name, expression.location, scope, fail).type;
-    if (expression.kind == "IntegerLiteral") {
-        if (!Number.isSafeInteger(expression.value))
-            fail("TYPE_MISMATCH", "Non-safe integer literal.", expression.location);
-        return "integer";
-    }
-    if (expression.kind == "BooleanLiteral") {
-        if (typeof Reflect.get(expression, "value") != "boolean") {
+function validateReturnTypeReference(type, location, fail, records = new Map(), typeParameters = new Set()) {
+    return validateTypeReference(type, location, fail, new Set(), records, typeParameters);
+}
+/**
+ * Validates one recursive semantic type-reference shape.
+ * @param {unknown} type - Candidate semantic type reference.
+ * @param {import("./types.js").SourceLocation} location - Owning source location.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @param {Set<object>} [seen] - Active recursive type path.
+ * @param {RecordRegistry} [records] - Record declarations by identity.
+ * @param {Set<string>} [typeParameters] - Type-variable identities in declaration scope.
+ * @returns {import("./types.js").SemanticFunctionReturnType} Validated type.
+ */
+function validateTypeReference(type, location, fail, seen = new Set(), records = new Map(), typeParameters = new Set()) {
+    if (!type || typeof type != "object" || Array.isArray(type)) {
+        return fail("TYPE_MISMATCH", "Unsupported semantic type.", location);
+    }
+    const candidate = /** @type {import("./types.js").SemanticFunctionReturnType} */ (type);
+    if (["ListType", "MapType", "OptionalType", "OrderedMapType", "RecordType"].includes(candidate.kind) &&
+        containsOwnedType(candidate)) {
+        fail("RESOURCE_ALIAS", "Owned resources and references cannot be nested in value or generic types.", typeLocation(candidate, location));
+    }
+    if (candidate.kind == "TypeReference") {
+        if (!isScalarTypeName(candidate.name) && candidate.name != "void") {
+            fail("TYPE_MISMATCH", "Unsupported scalar or void return type.", typeLocation(candidate, location));
+        }
+        return candidate;
+    }
+    if (candidate.kind == "TypeVariableReference") {
+        if (Object.keys(candidate).filter((key) => key != "sourceProvenance").sort().join(",") != "kind,location,parameterId" ||
+            typeof candidate.parameterId != "string" || !typeParameters.has(candidate.parameterId)) {
+            fail("FREE_TYPE_VARIABLE", `Free or unknown type variable '${String(candidate.parameterId)}'.`, typeLocation(candidate, location));
+        }
+        return candidate;
+    }
+    if (candidate.kind == "RecordType") {
+        const keys = Object.keys(candidate).filter((key) => key != "sourceProvenance").sort().join(",");
+        const declaration = records.get(candidate.declarationId);
+        if (!(["arguments,declarationId,kind", "declarationId,kind"].includes(keys)) ||
+            typeof candidate.declarationId != "string" || !declaration) {
+            fail("UNKNOWN_RECORD", `Unknown record declaration '${String(candidate.declarationId)}'.`, typeLocation(candidate, location));
+        }
+        const expectedArity = declaration.typeParameters?.length ?? 0;
+        if (expectedArity > 0 && candidate.arguments === undefined) {
+            fail("RAW_GENERIC_APPLICATION", `Generic record '${declaration.name}' requires ${expectedArity} type arguments.`, typeLocation(candidate, location));
+        }
+        if (expectedArity == 0 && candidate.arguments !== undefined) {
+            fail("GENERIC_ARITY_MISMATCH", `Non-generic record '${declaration.name}' does not accept type arguments.`, typeLocation(candidate, location));
+        }
+        const candidateArguments = candidate.arguments;
+        if (candidateArguments !== undefined && (!Array.isArray(candidateArguments) ||
+            candidateArguments.some((_argument, index) => !Object.hasOwn(candidateArguments, index)))) {
+            fail("TYPE_MISMATCH", "Generic record arguments must be a dense ordered array.", typeLocation(candidate, location));
+        }
+        const arguments_ = candidate.arguments ?? [];
+        if (arguments_.length != expectedArity) {
+            fail("GENERIC_ARITY_MISMATCH", `Record '${declaration.name}' has ${arguments_.length} type arguments; expected ${expectedArity}.`, typeLocation(candidate, location));
+        }
+        if (seen.has(candidate)) {
+            return fail("TYPE_MISMATCH", "Recursive generic applications cannot contain cycles.", typeLocation(candidate, location));
+        }
+        seen.add(candidate);
+        for (const argument of arguments_) {
+            validateValueTypeReference(argument, typeLocation(argument, location), fail, seen, records, typeParameters);
+        }
+        seen.delete(candidate);
+        return candidate;
+    }
+    if (candidate.kind == "ReferenceType") {
+        const classes = referenceClassesFor(records);
+        if (Object.keys(candidate).filter((key) => key != "sourceProvenance").sort().join(",") != "declarationId,kind" ||
+            typeof candidate.declarationId != "string" || !classes.has(candidate.declarationId)) {
+            fail("UNKNOWN_CLASS", `Unknown reference class declaration '${String(candidate.declarationId)}'.`, typeLocation(candidate, location));
+        }
+        return candidate;
+    }
+    if (candidate.kind == "OwnedResourceType") {
+        if (Object.keys(candidate).filter((key) => key != "sourceProvenance").sort().join(",") != "kind,resourceId" ||
+            typeof candidate.resourceId != "string" || !resourceIdsByRecordRegistry.get(records)?.has(candidate.resourceId)) {
+            fail("RESOURCE_TYPE_MISMATCH", `Unknown owned resource '${String(candidate.resourceId)}'.`, typeLocation(candidate, location));
+        }
+        return candidate;
+    }
+    if (candidate.kind == "OwnedReferenceType") {
+        const classes = referenceClassesFor(records);
+        if (Object.keys(candidate).filter((key) => key != "sourceProvenance").sort().join(",") != "declarationId,kind" ||
+            typeof candidate.declarationId != "string" || classes.get(candidate.declarationId)?.ownership?.kind != "ownedResource") {
+            fail("RESOURCE_TYPE_MISMATCH", `Unknown owned reference '${String(candidate.declarationId)}'.`, typeLocation(candidate, location));
+        }
+        return candidate;
+    }
+    if (candidate.kind == "ListType") {
+        if (seen.has(candidate))
+            return fail("TYPE_MISMATCH", "Recursive collection types cannot contain cycles.", typeLocation(candidate, location));
+        seen.add(candidate);
+        const elementType = validateValueTypeReference(candidate.elementType, typeLocation(candidate, location, "elementType"), fail, seen, records, typeParameters);
+        seen.delete(candidate);
+        if (candidate.elementType !== elementType)
+            candidate.elementType = elementType;
+        return candidate;
+    }
+    if (candidate.kind == "MapType" || candidate.kind == "OrderedMapType") {
+        const expectedFields = candidate.kind == "OrderedMapType" ? "keyType,kind,order,valueType" : "keyType,kind,valueType";
+        if (Object.keys(candidate).filter((key) => key != "sourceProvenance").sort().join(",") != expectedFields) {
+            return fail("TYPE_MISMATCH", `Malformed ${candidate.kind == "OrderedMapType" ? "ordered map" : "map"} type.`, typeLocation(candidate, location));
+        }
+        if (candidate.kind == "OrderedMapType" && candidate.order != "insertion") {
+            return fail("TYPE_MISMATCH", "Ordered map type requires insertion order.", typeLocation(candidate, location));
+        }
+        if (seen.has(candidate))
+            return fail("TYPE_MISMATCH", "Recursive collection types cannot contain cycles.", typeLocation(candidate, location));
+        seen.add(candidate);
+        const keyType = validateValueTypeReference(candidate.keyType, typeLocation(candidate, location, "keyType"), fail, seen, records, typeParameters);
+        if (!isScalarType(keyType, "string")) {
+            fail("TYPE_MISMATCH", `Map key type ${typeDescription(keyType)}; expected string.`, typeLocation(candidate.keyType, location));
+        }
+        const valueType = validateValueTypeReference(candidate.valueType, typeLocation(candidate, location, "valueType"), fail, seen, records, typeParameters);
+        seen.delete(candidate);
+        if (candidate.keyType !== keyType)
+            candidate.keyType = /** @type {import("./types.js").TypeReference} */ (keyType);
+        if (candidate.valueType !== valueType)
+            candidate.valueType = valueType;
+        return candidate;
+    }
+    if (candidate.kind == "OptionalType") {
+        if (Object.keys(candidate).filter((key) => key != "sourceProvenance").sort().join(",") != "kind,valueType") {
+            return fail("TYPE_MISMATCH", "Malformed optional type.", typeLocation(candidate, location));
+        }
+        if (seen.has(candidate))
+            return fail("TYPE_MISMATCH", "Recursive optional types cannot contain cycles.", typeLocation(candidate, location));
+        seen.add(candidate);
+        const valueType = validateValueTypeReference(candidate.valueType, typeLocation(candidate, location, "valueType"), fail, seen, records, typeParameters);
+        seen.delete(candidate);
+        if (valueType.kind == "OptionalType") {
+            fail("INVALID_OPTIONAL_CONSTITUENT", "Optional values cannot directly contain another optional.", typeLocation(candidate, location, "valueType"));
+        }
+        if (candidate.valueType !== valueType)
+            candidate.valueType = valueType;
+        return candidate;
+    }
+    return fail("TYPE_MISMATCH", "Unsupported semantic type.", typeLocation(candidate, location));
+}
+/**
+ * Retrieves the reference-class registry attached to the record validation context.
+ * @param {RecordRegistry} records - Record validation registry.
+ * @returns {ClassRegistry} Reference classes.
+ */
+function referenceClassesFor(records) {
+    return referenceClassesByRecordRegistry.get(records) ?? new Map();
+}
+/**
+ * Infers a value expression and rejects the non-value result of a void call.
+ * @param {import("./types.js").Expression} expression - Semantic expression.
+ * @param {Scope} scope - Visible lexical scope.
+ * @param {Map<string, import("./types.js").FunctionDeclaration>} functions - Module function signatures.
+ * @param {RecordRegistry} records - Record declarations by identity.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @param {boolean} normalizeOperations - Whether to normalize frontend intent and call resolution.
+ * @param {string} context - Value context for diagnostics.
+ * @param {import("./types.js").SemanticValueType} [expectedType] - Contextual collection type.
+ * @param {boolean} [inferCollectionElements] - Whether a generic-call evidence pass may infer nonempty collection literals.
+ * @returns {import("./types.js").SemanticValueType} Expression value type.
+ */
+function inferValueExpressionType(expression, scope, functions, records, fail, normalizeOperations, context, expectedType, inferCollectionElements = false) {
+    const allowOwnedBorrow = context == "an effect argument" || context == "a method receiver";
+    const type = inferExpressionType(expression, scope, functions, records, fail, normalizeOperations, expectedType, inferCollectionElements, allowOwnedBorrow);
+    if (type == "void")
+        return fail("VOID_AS_VALUE", `Void call cannot be used as ${context}.`, expression.location);
+    if (type.kind == "ErrorType")
+        return fail("TYPE_MISMATCH", `Error value cannot be used as ${context}.`, expression.location);
+    return type;
+}
+/**
+ * Infers and validates one expression.
+ * @param {import("./types.js").Expression} expression - Semantic expression.
+ * @param {Scope} scope - Visible lexical scope.
+ * @param {Map<string, import("./types.js").FunctionDeclaration>} functions - Module function signatures.
+ * @param {RecordRegistry} records - Record declarations by identity.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.
+ * @param {import("./types.js").SemanticValueType} [expectedType] - Contextual collection type.
+ * @param {boolean} [inferCollectionElements] - Whether a generic-call evidence pass may infer nonempty collection literals.
+ * @param {boolean} [allowOwnedBorrow] - Whether this exact call position admits an immediate borrow.
+ * @returns {import("./types.js").SemanticBindingType | "void"} Expression type.
+ */
+function inferExpressionType(expression, scope, functions, records, fail, normalizeOperations, expectedType, inferCollectionElements = false, allowOwnedBorrow = false) {
+    if (expression.kind == "IdentifierExpression")
+        return resolveBinding(expression.name, expression.location, scope, fail).type;
+    if (expression.kind == "ReceiverExpression") {
+        if (!scope.currentClass || expression.classId != scope.currentClass.id) {
+            return fail("ILLEGAL_PRIVATE_ACCESS", "Receiver expression is valid only inside its declaring class.", expression.location);
+        }
+        return { declarationId: /** @type {string} */ (scope.currentClass.id), kind: "ReferenceType" };
+    }
+    if (expression.kind == "PrivateFieldRead") {
+        const declaration = scope.currentClass;
+        if (!declaration || !expression.receiver || expression.receiver.kind != "ReceiverExpression" ||
+            expression.receiver.classId != declaration.id) {
+            return fail("ILLEGAL_PRIVATE_ACCESS", "Private field receiver must be the declaring class receiver.", expression.location);
+        }
+        const field = declaration.fields.find((candidate) => candidate.id == expression.field);
+        if (!field)
+            return fail("ILLEGAL_PRIVATE_ACCESS", "Private field identity is not owned by the declaring class.", expression.location);
+        return field.type;
+    }
+    if (expression.kind == "OwnedBorrowExpression") {
+        if (!allowOwnedBorrow) {
+            return fail("BORROW_ESCAPE", "BORROW_ESCAPE: Owned borrows are valid only as immediate capability arguments or method receivers.", expression.location);
+        }
+        if (expression.mode != "shared" && expression.mode != "exclusive") {
+            return fail("INVALID_RESOURCE_BORROW", "INVALID_RESOURCE_BORROW: Owned borrow mode must be shared or exclusive.", expression.location);
+        }
+        const borrowed = inferValueExpressionType(expression.expression, scope, functions, records, fail, normalizeOperations, "an owned borrow");
+        if (borrowed.kind != "OwnedResourceType" && borrowed.kind != "OwnedReferenceType") {
+            return fail("INVALID_RESOURCE_BORROW", "Borrowed expression must be an owned resource or owned reference.", expression.location);
+        }
+        if (!sameType(borrowed, expression.type)) {
+            fail("RESOURCE_TYPE_MISMATCH", "Borrow metadata does not match its resource place.", expression.location);
+        }
+        return borrowed;
+    }
+    if (expression.kind == "OwnedMoveExpression") {
+        const moved = inferValueExpressionType(expression.expression, scope, functions, records, fail, normalizeOperations, "an owned move");
+        if (moved.kind != "OwnedResourceType" && moved.kind != "OwnedReferenceType") {
+            return fail("INVALID_RESOURCE_TRANSFER", "Moved expression must be an owned resource or owned reference.", expression.location);
+        }
+        if (!sameType(moved, expression.type)) {
+            fail("RESOURCE_TYPE_MISMATCH", "Move metadata does not match its resource place.", expression.location);
+        }
+        return moved;
+    }
+    if (expression.kind == "ErrorMessageRead") {
+        if (!expression.receiver || expression.receiver.kind != "IdentifierExpression") {
+            return fail("INVALID_MEMBER_RECEIVER", "Error message receiver must be one catch binding.", expression.location);
+        }
+        const receiver = resolveBinding(expression.receiver.name, expression.receiver.location, scope, fail);
+        if (receiver.type.kind != "ErrorType") {
+            return fail("INVALID_MEMBER_RECEIVER", "Message member requires a typed error catch binding.", expression.receiver.location);
+        }
+        return scalarType("string");
+    }
+    if (expression.kind == "IntegerLiteral") {
+        if (!Number.isSafeInteger(expression.value))
+            fail("TYPE_MISMATCH", "Non-safe integer literal.", expression.location);
+        return scalarType("integer");
+    }
+    if (expression.kind == "BooleanLiteral") {
+        if (typeof Reflect.get(expression, "value") != "boolean") {
             fail("TYPE_MISMATCH", "Invalid boolean literal value.", expression.location);
         }
-        return "boolean";
+        return scalarType("boolean");
     }
     if (expression.kind == "StringLiteral") {
         const value = Reflect.get(expression, "value");
         if (typeof value != "string" || !hasOnlyUnicodeScalars(value)) {
             fail("TYPE_MISMATCH", "Invalid Unicode string literal.", expression.location);
         }
-        return "string";
+        return scalarType("string");
+    }
+    if (expression.kind == "OptionalNone") {
+        if (!expectedType || expectedType.kind != "OptionalType") {
+            return fail("MISSING_TYPE", "Optional absence requires an explicit optional type.", expression.location);
+        }
+        return expectedType;
+    }
+    if (expression.kind == "OptionalSome") {
+        if (!expectedType || expectedType.kind != "OptionalType") {
+            const valueType = inferValueExpressionType(expression.value, scope, functions, records, fail, normalizeOperations, "an optional present value");
+            if (valueType.kind == "OptionalType") {
+                return fail("INVALID_OPTIONAL_CONSTITUENT", "Optional values cannot directly contain another optional.", expression.value.location);
+            }
+            return { kind: "OptionalType", valueType };
+        }
+        const valueType = inferValueExpressionType(expression.value, scope, functions, records, fail, normalizeOperations, "an optional present value", expectedType.valueType);
+        if (!sameType(valueType, expectedType.valueType)) {
+            fail("TYPE_MISMATCH", `Optional present type ${typeDescription(valueType)}; expected ${typeDescription(expectedType.valueType)}.`, expression.value.location);
+        }
+        return expectedType;
+    }
+    if (expression.kind == "OptionalIsPresent") {
+        if (!expression.operand || expression.operand.kind != "IdentifierExpression") {
+            return fail("TYPE_MISMATCH", "Optional presence test requires one simple identifier.", expression.location);
+        }
+        const operandType = resolveBinding(expression.operand.name, expression.operand.location, scope, fail).type;
+        if (operandType.kind != "OptionalType") {
+            return fail("TYPE_MISMATCH", `Presence test received ${typeDescription(operandType)}; expected optional.`, expression.operand.location);
+        }
+        return scalarType("boolean");
+    }
+    if (expression.kind == "OptionalUnwrap") {
+        if (!expression.operand || expression.operand.kind != "IdentifierExpression") {
+            return fail("TYPE_MISMATCH", "Optional unwrap requires one simple identifier.", expression.location);
+        }
+        const binding = resolveBinding(expression.operand.name, expression.operand.location, scope, fail);
+        if (binding.type.kind != "OptionalType") {
+            return fail("TYPE_MISMATCH", `Optional unwrap received ${typeDescription(binding.type)}; expected optional.`, expression.operand.location);
+        }
+        if (!scope.presenceProofs.has(binding)) {
+            return fail("UNCHECKED_OPTIONAL_UNWRAP", `Optional binding '${expression.operand.name}' is not proven present.`, expression.location);
+        }
+        return binding.type.valueType;
+    }
+    if (expression.kind == "ListLiteral") {
+        if (!Array.isArray(expression.elements)) {
+            return fail("TYPE_MISMATCH", "List literal elements must be a dense source-ordered array.", expression.location);
+        }
+        if ((!expectedType || expectedType.kind != "ListType") &&
+            (!inferCollectionElements || expression.elements.length == 0)) {
+            return fail("MISSING_TYPE", "List literal requires an explicit recursive list type.", expression.location);
+        }
+        /** @type {import("./types.js").SemanticValueType | undefined} */
+        let inferredElementType;
+        for (let index = 0; index < expression.elements.length; index++) {
+            if (!Object.hasOwn(expression.elements, index)) {
+                fail("TYPE_MISMATCH", "Sparse list literals are outside the implemented subset.", expression.location);
+            }
+            const element = expression.elements[index];
+            const actual = inferValueExpressionType(element, scope, functions, records, fail, normalizeOperations, "a list element", expectedType?.kind == "ListType" ? expectedType.elementType : inferredElementType, inferCollectionElements);
+            inferredElementType ??= actual;
+            const requiredElementType = expectedType?.kind == "ListType" ? expectedType.elementType : inferredElementType;
+            if (!sameType(actual, requiredElementType)) {
+                fail("TYPE_MISMATCH", `List element type ${typeDescription(actual)}; expected ${typeDescription(requiredElementType)}.`, element.location);
+            }
+        }
+        return expectedType?.kind == "ListType"
+            ? expectedType
+            : { elementType: /** @type {import("./types.js").SemanticValueType} */ (inferredElementType), kind: "ListType" };
+    }
+    if (expression.kind == "MapLiteral") {
+        if (expectedType && expectedType.kind != "MapType") {
+            return fail("TYPE_MISMATCH", `Map literal context ${typeDescription(expectedType)}; expected map.`, expression.location);
+        }
+        if (!expectedType && !inferCollectionElements) {
+            return fail("MISSING_TYPE", "Map literal requires an explicit recursive map type.", expression.location);
+        }
+        if (expectedType?.kind == "MapType" && !isScalarType(expectedType.keyType, "string")) {
+            return fail("TYPE_MISMATCH", "Map key type must be string.", typeLocation(expectedType.keyType, expression.location));
+        }
+        const entries = validateMapLiteralEntries(expression, scope, functions, records, fail, normalizeOperations, inferCollectionElements);
+        if (!expectedType && entries.length == 0) {
+            return fail("MISSING_TYPE", "Empty map literal requires an explicit recursive map type.", expression.location);
+        }
+        /** @type {import("./types.js").SemanticValueType | undefined} */
+        let inferredValueType;
+        for (const entry of entries) {
+            const actual = inferValueExpressionType(entry.value, scope, functions, records, fail, normalizeOperations, "a map value", expectedType?.kind == "MapType" ? expectedType.valueType : inferredValueType, inferCollectionElements);
+            inferredValueType ??= actual;
+            const requiredValueType = expectedType?.kind == "MapType" ? expectedType.valueType : inferredValueType;
+            if (!sameType(actual, requiredValueType)) {
+                fail("TYPE_MISMATCH", `Map value type ${typeDescription(actual)}; expected ${typeDescription(requiredValueType)}.`, entry.value.location);
+            }
+        }
+        return expectedType?.kind == "MapType" ? expectedType : {
+            keyType: scalarType("string"),
+            kind: "MapType",
+            valueType: /** @type {import("./types.js").SemanticValueType} */ (inferredValueType)
+        };
+    }
+    if (expression.kind == "OrderedMapLiteral") {
+        if (expectedType && expectedType.kind != "OrderedMapType") {
+            return fail("TYPE_MISMATCH", `Ordered-map literal context ${typeDescription(expectedType)}; expected ordered map.`, expression.location);
+        }
+        if (!expectedType && !inferCollectionElements) {
+            return fail("MISSING_TYPE", "Ordered-map literal requires an explicit recursive ordered-map type.", expression.location);
+        }
+        if (expectedType?.kind == "OrderedMapType" && !isScalarType(expectedType.keyType, "string")) {
+            return fail("TYPE_MISMATCH", "Ordered-map key type must be string.", typeLocation(expectedType.keyType, expression.location));
+        }
+        const entries = validateMapLiteralEntries(expression, scope, functions, records, fail, normalizeOperations, inferCollectionElements);
+        if (!expectedType && entries.length == 0) {
+            return fail("MISSING_TYPE", "Empty ordered-map literal requires an explicit recursive ordered-map type.", expression.location);
+        }
+        /** @type {import("./types.js").SemanticValueType | undefined} */
+        let inferredValueType;
+        for (const entry of entries) {
+            const actual = inferValueExpressionType(entry.value, scope, functions, records, fail, normalizeOperations, "an ordered-map value", expectedType?.kind == "OrderedMapType" ? expectedType.valueType : inferredValueType, inferCollectionElements);
+            inferredValueType ??= actual;
+            const requiredValueType = expectedType?.kind == "OrderedMapType" ? expectedType.valueType : inferredValueType;
+            if (!sameType(actual, requiredValueType)) {
+                fail("TYPE_MISMATCH", `Ordered-map value type ${typeDescription(actual)}; expected ${typeDescription(requiredValueType)}.`, entry.value.location);
+            }
+        }
+        return expectedType?.kind == "OrderedMapType" ? expectedType : {
+            keyType: scalarType("string"),
+            kind: "OrderedMapType",
+            order: "insertion",
+            valueType: /** @type {import("./types.js").SemanticValueType} */ (inferredValueType)
+        };
+    }
+    if (expression.kind == "ListIndexExpression") {
+        const collectionType = inferValueExpressionType(expression.collection, scope, functions, records, fail, normalizeOperations, "a list receiver");
+        const indexType = inferValueExpressionType(expression.index, scope, functions, records, fail, normalizeOperations, "a list index", scalarType("integer"));
+        if (collectionType.kind != "ListType") {
+            return fail("TYPE_MISMATCH", `List index receiver type ${typeDescription(collectionType)}; expected list.`, expression.collection.location);
+        }
+        if (!isScalarType(indexType, "integer")) {
+            fail("TYPE_MISMATCH", `List index type ${typeDescription(indexType)}; expected integer.`, expression.index.location);
+        }
+        const knownCollection = knownValueForExpression(expression.collection, scope);
+        const knownIndex = knownValueForExpression(expression.index, scope);
+        if (knownCollection?.kind == "ListLiteral" && knownIndex?.kind == "IntegerLiteral" &&
+            (knownIndex.value < 0 || knownIndex.value >= knownCollection.elements.length)) {
+            fail("INDEX_OUT_OF_BOUNDS", `List index ${knownIndex.value} is outside a literal list of size ${knownCollection.elements.length}.`, expression.location);
+        }
+        const proven = provenListElement(expression.collection, expression.index, scope);
+        validateAccessTotality(expression, proven !== undefined, normalizeOperations, fail);
+        return collectionType.elementType;
+    }
+    if (expression.kind == "MapLookupExpression") {
+        const collectionType = inferValueExpressionType(expression.collection, scope, functions, records, fail, normalizeOperations, "a map receiver");
+        const keyType = inferValueExpressionType(expression.key, scope, functions, records, fail, normalizeOperations, "a map key", scalarType("string"));
+        if (collectionType.kind != "MapType" && collectionType.kind != "OrderedMapType") {
+            return fail("TYPE_MISMATCH", `Map lookup receiver type ${typeDescription(collectionType)}; expected map.`, expression.collection.location);
+        }
+        if (!isScalarType(keyType, "string")) {
+            fail("TYPE_MISMATCH", `Map lookup key type ${typeDescription(keyType)}; expected string.`, expression.key.location);
+        }
+        const knownCollection = knownValueForExpression(expression.collection, scope);
+        const knownKey = knownValueForExpression(expression.key, scope);
+        if ((knownCollection?.kind == "MapLiteral" || knownCollection?.kind == "OrderedMapLiteral") &&
+            knownKey?.kind == "StringLiteral" &&
+            !knownCollection.entries.some((entry) => entry.key.value == knownKey.value)) {
+            fail("MISSING_MAP_KEY", `Map key '${knownKey.value}' is absent from the literal initializer.`, expression.location);
+        }
+        const proven = provenMapValue(expression.collection, expression.key, scope);
+        validateAccessTotality(expression, proven !== undefined, normalizeOperations, fail);
+        return collectionType.valueType;
+    }
+    if (expression.kind == "CollectionSizeExpression") {
+        const collectionType = inferValueExpressionType(expression.collection, scope, functions, records, fail, normalizeOperations, "a collection-size receiver");
+        if (collectionType.kind != "ListType" && collectionType.kind != "MapType" && collectionType.kind != "OrderedMapType") {
+            return fail("TYPE_MISMATCH", `Collection size receiver type ${typeDescription(collectionType)}; expected list or map.`, expression.collection.location);
+        }
+        const collectionKind = collectionType.kind == "ListType" ? "list" : "map";
+        if (normalizeOperations) {
+            if (expression.collectionKind !== undefined && expression.collectionKind != collectionKind) {
+                fail("TYPE_MISMATCH", "Collection size operation does not match its receiver type.", expression.location);
+            }
+            expression.collectionKind = collectionKind;
+        }
+        else if (expression.collectionKind != collectionKind) {
+            fail("TYPE_MISMATCH", "Collection size kind does not match its receiver type.", expression.location);
+        }
+        return scalarType("integer");
+    }
+    if (expression.kind == "EffectCallExpression") {
+        if (!Array.isArray(expression.arguments) || expression.arguments.length != expression.resolution.parameterTypes.length) {
+            return fail("TYPE_MISMATCH", "Effect call argument count does not match its authorized operation.", expression.location);
+        }
+        const resourceFlow = expression.resolution.resourceFlow;
+        if (resourceFlow.kind == "borrow" || resourceFlow.kind == "close") {
+            const borrow = expression.arguments[resourceFlow.parameterIndex];
+            const expectedMode = resourceFlow.kind == "close" ? "exclusive" : "shared";
+            if (borrow?.kind != "OwnedBorrowExpression" || borrow.mode != expectedMode) {
+                fail("INVALID_RESOURCE_BORROW", `INVALID_RESOURCE_BORROW: ${resourceFlow.kind} requires an immediate ${expectedMode} borrow.`, borrow?.location ?? expression.location);
+            }
+        }
+        for (let index = 0; index < expression.arguments.length; index += 1) {
+            const expected = identityAsValueType(expression.resolution.parameterTypes[index], expression.arguments[index].location, fail);
+            const actual = inferValueExpressionType(expression.arguments[index], scope, functions, records, fail, normalizeOperations, "an effect argument", expected);
+            if (!sameType(actual, expected)) {
+                fail("RESOURCE_TYPE_MISMATCH", `Effect argument type ${typeDescription(actual)}; expected ${typeDescription(expected)}.`, expression.arguments[index].location);
+            }
+        }
+        if (expression.resolution.returnType == "void")
+            return "void";
+        return identityAsValueType(expression.resolution.returnType, expression.location, fail);
+    }
+    if (expression.kind == "ReferenceConstruction") {
+        const referenceType = validateValueTypeReference(expression.reference, expression.location, fail, undefined, records, scope.typeParameters);
+        if (referenceType.kind != "ReferenceType" && referenceType.kind != "OwnedReferenceType") {
+            return fail("TYPE_MISMATCH", "Reference construction requires a nominal reference class type.", expression.location);
+        }
+        const declaration = referenceClassesFor(records).get(referenceType.declarationId);
+        if (!declaration)
+            return fail("UNKNOWN_CLASS", `Unknown reference class '${referenceType.declarationId}'.`, expression.location);
+        if (!isDenseArray(expression.arguments)) {
+            return fail("TYPE_MISMATCH", "Constructor arguments must be a dense ordered array.", expression.location);
+        }
+        if (expression.arguments.length != declaration.constructor.parameters.length) {
+            return fail("CONSTRUCTOR_ARITY_MISMATCH", `Constructor for '${declaration.name}' has ${expression.arguments.length} arguments; expected ${declaration.constructor.parameters.length}.`, expression.location);
+        }
+        const parameterTypes = declaration.constructor.parameters.map((parameter) => validateValueTypeReference(parameter.type, parameter.location, fail, undefined, records));
+        for (let index = 0; index < expression.arguments.length; index += 1) {
+            expression.arguments[index] = normalizeOwnedMove(expression.arguments[index], parameterTypes[index], normalizeOperations, fail);
+            const actual = inferValueExpressionType(expression.arguments[index], scope, functions, records, fail, normalizeOperations, "a constructor argument", parameterTypes[index]);
+            if (!sameType(actual, parameterTypes[index])) {
+                fail("TYPE_MISMATCH", `Constructor argument type ${typeDescription(actual)}; expected ${typeDescription(parameterTypes[index])}.`, expression.arguments[index].location);
+            }
+        }
+        const resolution = {
+            declarationId: /** @type {string} */ (declaration.constructor.id),
+            kind: /** @type {const} */ ("ResolvedConstructorSignature"),
+            parameterTypes: parameterTypes.map((type) => /** @type {import("./types.js").SemanticTypeIdentity} */ (typeIdentity(type)))
+        };
+        if (normalizeOperations)
+            expression.resolution = resolution;
+        else
+            validateReferenceResolution(expression.resolution, resolution, expression.location, fail, "constructor");
+        return referenceType;
+    }
+    if (expression.kind == "MethodCallExpression") {
+        const receiverType = inferValueExpressionType(expression.receiver, scope, functions, records, fail, normalizeOperations, "a method receiver");
+        if (receiverType.kind != "ReferenceType" && receiverType.kind != "OwnedReferenceType") {
+            return fail("INVALID_METHOD_RECEIVER", "Method call receiver must have a reference class type.", expression.receiver.location);
+        }
+        const declaration = referenceClassesFor(records).get(receiverType.declarationId);
+        if (!declaration)
+            return fail("UNKNOWN_CLASS", `Unknown reference class '${receiverType.declarationId}'.`, expression.receiver.location);
+        const method = declaration.methods.find((candidate) => candidate.id == expression.method) ??
+            (normalizeOperations ? declaration.methods.find((candidate) => candidate.name == expression.method) : undefined);
+        if (!method)
+            return fail("UNKNOWN_METHOD", `Class '${declaration.name}' has no method '${expression.method}'.`, roleLocation(expression, "member"));
+        if (normalizeOperations)
+            expression.method = /** @type {string} */ (method.id);
+        if (!isDenseArray(expression.arguments))
+            return fail("TYPE_MISMATCH", "Method arguments must be a dense ordered array.", expression.location);
+        if (expression.arguments.length != method.parameters.length) {
+            return fail("METHOD_ARITY_MISMATCH", `Method '${method.name}' has ${expression.arguments.length} arguments; expected ${method.parameters.length}.`, expression.location);
+        }
+        const parameterTypes = method.parameters.map((parameter) => validateValueTypeReference(parameter.type, parameter.location, fail, undefined, records));
+        for (let index = 0; index < expression.arguments.length; index += 1) {
+            expression.arguments[index] = normalizeOwnedMove(expression.arguments[index], parameterTypes[index], normalizeOperations, fail);
+            const actual = inferValueExpressionType(expression.arguments[index], scope, functions, records, fail, normalizeOperations, "a method argument", parameterTypes[index]);
+            if (!sameType(actual, parameterTypes[index])) {
+                fail("TYPE_MISMATCH", `Method argument type ${typeDescription(actual)}; expected ${typeDescription(parameterTypes[index])}.`, expression.arguments[index].location);
+            }
+        }
+        const returnType = validateReturnTypeReference(method.returnType, method.location, fail, records);
+        const resourceFlow = declaration.ownership?.kind == "ownedResource"
+            ? ownedMethodResourceFlow(declaration, method, fail) : undefined;
+        const resolution = {
+            declarationId: /** @type {string} */ (method.id),
+            kind: /** @type {const} */ ("ResolvedMethodSignature"),
+            parameterTypes: parameterTypes.map((type) => /** @type {import("./types.js").SemanticTypeIdentity} */ (typeIdentity(type))),
+            returnType: typeIdentity(returnType),
+            ...(resourceFlow ? { resourceFlow } : {})
+        };
+        if (expression.receiver.kind == "OwnedBorrowExpression" && resourceFlow) {
+            const expectedMode = resourceFlow.kind == "terminal" ? "exclusive" : "shared";
+            if (expression.receiver.mode != expectedMode) {
+                fail("INVALID_RESOURCE_BORROW", `INVALID_RESOURCE_BORROW: Owned method requires an immediate ${expectedMode} receiver borrow.`, expression.receiver.location);
+            }
+        }
+        if (receiverType.kind == "OwnedReferenceType" && expression.receiver.kind != "OwnedBorrowExpression") {
+            if (!normalizeOperations)
+                fail("INVALID_RESOURCE_BORROW", "Owned method receiver requires an immediate borrow.", expression.receiver.location);
+            if (expression.receiver.kind != "IdentifierExpression") {
+                fail("BORROW_ESCAPE", "Owned method receiver borrow must name one immediate binding.", expression.receiver.location);
+            }
+            expression.receiver = {
+                expression: expression.receiver,
+                kind: "OwnedBorrowExpression",
+                location: expression.receiver.location,
+                mode: resourceFlow?.kind == "terminal" ? "exclusive" : "shared",
+                sourceProvenance: expression.receiver.sourceProvenance,
+                type: receiverType
+            };
+        }
+        if (normalizeOperations)
+            expression.resolution = resolution;
+        else
+            validateReferenceResolution(expression.resolution, resolution, expression.location, fail, "method");
+        return isVoidType(returnType) ? "void" : returnType;
+    }
+    if (expression.kind == "RecordConstruction") {
+        const recordType = validateValueTypeReference(expression.record, expression.location, fail, undefined, records, scope.typeParameters);
+        if (recordType.kind != "RecordType") {
+            return fail("TYPE_MISMATCH", "Record construction requires a nominal record type.", expression.location);
+        }
+        const declaration = records.get(recordType.declarationId);
+        if (!declaration)
+            return fail("UNKNOWN_RECORD", `Unknown record declaration '${recordType.declarationId}'.`, expression.location);
+        if (!Array.isArray(expression.arguments) || expression.arguments.some((_argument, index) => !Object.hasOwn(expression.arguments, index))) {
+            return fail("TYPE_MISMATCH", "Record construction arguments must be a dense ordered array.", expression.location);
+        }
+        if (expression.arguments.length != declaration.fields.length) {
+            return fail("RECORD_ARITY_MISMATCH", `Record '${declaration.name}' construction has ${expression.arguments.length} arguments; expected ${declaration.fields.length}.`, expression.location);
+        }
+        const substitutions = recordTypeSubstitutions(recordType, declaration);
+        for (let index = 0; index < expression.arguments.length; index += 1) {
+            const argument = expression.arguments[index];
+            const field = declaration.fields[index];
+            const fieldType = substituteValueType(field.type, substitutions);
+            const actual = inferValueExpressionType(argument, scope, functions, records, fail, normalizeOperations, `record field '${field.name}'`, fieldType);
+            if (!sameType(actual, fieldType)) {
+                fail("TYPE_MISMATCH", `Record field '${field.name}' argument type ${typeDescription(actual)}; expected ${typeDescription(fieldType)}.`, argument.location);
+            }
+        }
+        return recordType;
+    }
+    if (expression.kind == "MemberRead") {
+        const receiverType = inferValueExpressionType(expression.receiver, scope, functions, records, fail, normalizeOperations, "a member receiver");
+        if (receiverType.kind != "RecordType") {
+            return fail("INVALID_MEMBER_RECEIVER", `Member receiver type ${typeDescription(receiverType)}; expected record.`, expression.receiver.location);
+        }
+        const declaration = records.get(receiverType.declarationId);
+        if (!declaration)
+            return fail("UNKNOWN_RECORD", `Unknown record declaration '${receiverType.declarationId}'.`, expression.receiver.location);
+        const field = declaration.fields.find((candidate) => candidate.id == expression.field) ??
+            (normalizeOperations ? declaration.fields.find((candidate) => candidate.name == expression.field) : undefined);
+        if (!field)
+            fail("UNKNOWN_FIELD", `Record '${declaration.name}' has no field '${expression.field}'.`, roleLocation(expression, "member"));
+        if (normalizeOperations)
+            expression.field = /** @type {string} */ (field.id);
+        return substituteValueType(field.type, recordTypeSubstitutions(receiverType, declaration));
     }
     if (expression.kind == "CallExpression") {
         const functionDeclaration = functions.get(expression.callee);
-        if (!functionDeclaration)
-            return fail("UNRESOLVED_BINDING", `Unknown function '${expression.callee}'.`, expression.location);
+        if (!functionDeclaration) {
+            return fail("UNRESOLVED_BINDING", `Unknown function '${expression.callee}'.`, roleLocation(expression, "callee"));
+        }
         if (expression.arguments.length != functionDeclaration.parameters.length) {
             return fail("TYPE_MISMATCH", `Call argument count for '${expression.callee}'.`, expression.location);
         }
+        const declarationTypeParameters = declarationTypeParameterIds(functionDeclaration);
+        /** @type {Map<string, import("./types.js").SemanticValueType>} */
+        const substitutions = new Map();
+        const parameterTypes = functionDeclaration.parameters.map((parameter) => validateValueTypeReference(parameter.type, parameter.location, fail, undefined, records, declarationTypeParameters));
+        for (let index = 0; index < expression.arguments.length; index += 1) {
+            expression.arguments[index] = normalizeOwnedMove(expression.arguments[index], parameterTypes[index], normalizeOperations, fail);
+        }
         for (let index = 0; index < expression.arguments.length; index++) {
             const argument = expression.arguments[index];
-            const actualType = inferExpressionType(argument, scope, functions, fail, normalizeOperations);
-            const expectedType = validateTypeReference(functionDeclaration.parameters[index].type, functionDeclaration.parameters[index].location, fail);
-            if (actualType != expectedType) {
-                fail("TYPE_MISMATCH", `Call argument type ${actualType}; expected ${expectedType}.`, argument.location);
+            const expectedType = parameterTypes[index];
+            const gathersGenericEvidence = typeContainsAnyVariable(expectedType);
+            if (gathersGenericEvidence) {
+                inferGenericArgumentEvidence(expectedType, argument, substitutions, scope, functions, records, fail, normalizeOperations);
+                continue;
+            }
+            const actualType = inferValueExpressionType(argument, scope, functions, records, fail, normalizeOperations, "a call argument", expectedType);
+            if ((functionDeclaration.typeParameters?.length ?? 0) > 0) {
+                inferTypeArguments(expectedType, actualType, substitutions, argument.location, fail);
+            }
+            else if (!sameType(actualType, expectedType)) {
+                fail("TYPE_MISMATCH", `Call argument type ${typeDescription(actualType)}; expected ${typeDescription(expectedType)}.`, argument.location);
+            }
+        }
+        for (const parameter of functionDeclaration.typeParameters ?? []) {
+            if (!substitutions.has(/** @type {string} */ (parameter.id))) {
+                const evidenceFreeIndex = parameterTypes.findIndex((type) => typeContainsVariable(type, /** @type {string} */ (parameter.id)));
+                if (evidenceFreeIndex >= 0) {
+                    fail("GENERIC_INFERENCE_FAILURE", "Cannot infer a type parameter from an evidence-free call argument.", expression.arguments[evidenceFreeIndex].location);
+                }
+                fail("GENERIC_INFERENCE_FAILURE", `Cannot infer type parameter '${parameter.name}' from call arguments.`, expression.location);
+            }
+        }
+        if ([...substitutions.values()].some((type) => containsOwnedType(type))) {
+            fail("RESOURCE_ALIAS", "Owned resources and references cannot be inferred as generic arguments.", expression.location);
+        }
+        for (let index = 0; index < functionDeclaration.parameters.length; index += 1) {
+            const expected = substituteValueType(functionDeclaration.parameters[index].type, substitutions);
+            const actual = inferValueExpressionType(expression.arguments[index], scope, functions, records, fail, normalizeOperations, "a call argument", expected);
+            if (!sameType(actual, expected)) {
+                fail("TYPE_MISMATCH", `Call argument type ${typeDescription(actual)}; expected ${typeDescription(expected)}.`, expression.arguments[index].location);
             }
         }
-        return validateTypeReference(functionDeclaration.returnType, functionDeclaration.location, fail);
+        const resolution = signatureFor(functionDeclaration, records, fail, substitutions);
+        if (normalizeOperations)
+            expression.resolution = resolution;
+        else
+            validateResolution(expression.resolution, resolution, expression.location, fail);
+        const returnType = substituteReturnType(validateReturnTypeReference(functionDeclaration.returnType, functionDeclaration.location, fail, records, declarationTypeParameters), substitutions);
+        return isVoidType(returnType) ? "void" : returnType;
     }
     if (expression.kind == "UnaryExpression") {
-        const operandType = inferExpressionType(expression.operand, scope, functions, fail, normalizeOperations);
+        const operand = inferValueExpressionType(expression.operand, scope, functions, records, fail, normalizeOperations, "a unary operand");
+        const operandType = scalarNameForOperation(operand, expression.operand.location, fail);
         const operation = normalizeOperations
             ? normalizeUnaryOperation(adaptedOperationFor(expression), operandType, expression.operand.location, fail)
             : expression.operation;
@@ -312,11 +2013,13 @@ function inferExpressionType(expression, scope, functions, fail, normalizeOperat
         if (expression.type != signature.result) {
             return fail("TYPE_MISMATCH", `${operation} result type ${String(expression.type)}; expected ${signature.result}.`, expression.location);
         }
-        return signature.result;
+        return scalarType(signature.result);
     }
     if (expression.kind == "BinaryExpression") {
-        const leftType = inferExpressionType(expression.left, scope, functions, fail, normalizeOperations);
-        const rightType = inferExpressionType(expression.right, scope, functions, fail, normalizeOperations);
+        const left = inferValueExpressionType(expression.left, scope, functions, records, fail, normalizeOperations, "a binary operand");
+        const right = inferValueExpressionType(expression.right, scope, functions, records, fail, normalizeOperations, "a binary operand");
+        const leftType = scalarNameForOperation(left, expression.left.location, fail);
+        const rightType = scalarNameForOperation(right, expression.right.location, fail);
         const operation = normalizeOperations
             ? normalizeBinaryOperation(adaptedOperationFor(expression), leftType, rightType, expression.left.location, expression.right.location, expression.location, fail)
             : expression.operation;
@@ -334,11 +2037,786 @@ function inferExpressionType(expression, scope, functions, fail, normalizeOperat
         if (expression.type != signature.result) {
             return fail("TYPE_MISMATCH", `${operation} result type ${String(expression.type)}; expected ${signature.result}.`, expression.location);
         }
-        return signature.result;
+        return scalarType(signature.result);
     }
     const unexpected = /** @type {{kind: string, location: import("./types.js").SourceLocation}} */ (expression);
     return fail("TYPE_MISMATCH", unexpected.kind, unexpected.location);
 }
+/**
+ * Validates map layout and fixed string keys independently of contextual value inference.
+ * @param {import("./types.js").MapLiteral | import("./types.js").OrderedMapLiteral} expression - Candidate map literal.
+ * @param {Scope} scope - Visible lexical scope.
+ * @param {Map<string, import("./types.js").FunctionDeclaration>} functions - Module function signatures.
+ * @param {RecordRegistry} records - Record declarations by identity.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @param {boolean} normalizeOperations - Whether to normalize frontend intent.
+ * @param {boolean} inferCollectionElements - Whether nested collection evidence may be inferred.
+ * @returns {import("./types.js").MapEntry[]} Validated dense entries.
+ */
+function validateMapLiteralEntries(expression, scope, functions, records, fail, normalizeOperations, inferCollectionElements) {
+    if (!Array.isArray(expression.entries)) {
+        return fail("TYPE_MISMATCH", "Map literal entries must be a dense source-ordered array.", expression.location);
+    }
+    if (!isDenseArray(expression.entries)) {
+        return fail("TYPE_MISMATCH", "Sparse map literals are outside the implemented subset.", expression.location);
+    }
+    const keys = new Set();
+    for (const entry of expression.entries) {
+        if (!entry || entry.kind != "MapEntry" || !entry.key || entry.key.kind != "StringLiteral") {
+            fail("TYPE_MISMATCH", "Map entries require literal string keys.", entry?.location ?? expression.location);
+        }
+        inferValueExpressionType(entry.key, scope, functions, records, fail, normalizeOperations, "a map key", scalarType("string"), inferCollectionElements);
+        if (isNumericString(entry.key.value)) {
+            fail("INVALID_MAP_KEY", "Map initializer keys must be nonnumeric strings.", entry.key.location);
+        }
+        if (keys.has(entry.key.value)) {
+            fail("DUPLICATE_MAP_KEY", `Duplicate ${expression.kind == "OrderedMapLiteral" ? "ordered-map" : "map"} key '${entry.key.value}'.`, entry.key.location);
+        }
+        keys.add(entry.key.value);
+    }
+    return expression.entries;
+}
+/**
+ * Collects argument-only generic evidence while deferring recursively contextual literals.
+ * The complete argument is validated against its closed substituted type after inference.
+ * @param {import("./types.js").SemanticValueType} formal - Open declaration parameter type.
+ * @param {import("./types.js").Expression} expression - Call argument or nested collection value.
+ * @param {Map<string, import("./types.js").SemanticValueType>} substitutions - Inference state.
+ * @param {Scope} scope - Visible lexical scope.
+ * @param {Map<string, import("./types.js").FunctionDeclaration>} functions - Module function signatures.
+ * @param {RecordRegistry} records - Record declarations by identity.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @param {boolean} normalizeOperations - Whether to normalize frontend intent.
+ * @returns {void}
+ */
+function inferGenericArgumentEvidence(formal, expression, substitutions, scope, functions, records, fail, normalizeOperations) {
+    if (expression.kind == "OptionalNone")
+        return;
+    if (formal.kind == "OptionalType" && expression.kind == "OptionalSome") {
+        inferGenericArgumentEvidence(formal.valueType, expression.value, substitutions, scope, functions, records, fail, normalizeOperations);
+        return;
+    }
+    if (formal.kind == "ListType" && expression.kind == "ListLiteral") {
+        if (!Array.isArray(expression.elements)) {
+            fail("TYPE_MISMATCH", "List literal elements must be a dense source-ordered array.", expression.location);
+        }
+        if (!isDenseArray(expression.elements)) {
+            fail("TYPE_MISMATCH", "Sparse list literals are outside the implemented subset.", expression.location);
+        }
+        for (const element of expression.elements) {
+            inferGenericArgumentEvidence(formal.elementType, element, substitutions, scope, functions, records, fail, normalizeOperations);
+        }
+        return;
+    }
+    if ((formal.kind == "MapType" && expression.kind == "MapLiteral") ||
+        (formal.kind == "OrderedMapType" && expression.kind == "OrderedMapLiteral")) {
+        const entries = validateMapLiteralEntries(expression, scope, functions, records, fail, normalizeOperations, true);
+        for (const entry of entries) {
+            inferGenericArgumentEvidence(formal.valueType, entry.value, substitutions, scope, functions, records, fail, normalizeOperations);
+        }
+        return;
+    }
+    const actual = inferValueExpressionType(expression, scope, functions, records, fail, normalizeOperations, "a call argument", undefined, true);
+    inferTypeArguments(formal, actual, substitutions, expression.location, fail);
+}
+/**
+ * Unifies one declaration-owned formal type with one argument type.
+ * @param {import("./types.js").SemanticValueType} formal - Generic signature type.
+ * @param {import("./types.js").SemanticValueType} actual - Inferred argument type.
+ * @param {Map<string, import("./types.js").SemanticValueType>} substitutions - Inference state.
+ * @param {import("./types.js").SourceLocation} location - Argument location.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @returns {void}
+ */
+function inferTypeArguments(formal, actual, substitutions, location, fail) {
+    if (formal.kind == "TypeVariableReference") {
+        const prior = substitutions.get(formal.parameterId);
+        if (prior) {
+            if (!sameType(prior, actual)) {
+                fail("GENERIC_INFERENCE_CONFLICT", `Conflicting inference for type parameter '${formal.parameterId}'.`, location);
+            }
+            return;
+        }
+        if (!(actual.kind == "TypeVariableReference" && actual.parameterId == formal.parameterId) &&
+            typeContainsVariable(actual, formal.parameterId)) {
+            fail("GENERIC_INFERENCE_RECURSION", `Recursive inference for type parameter '${formal.parameterId}'.`, location);
+        }
+        substitutions.set(formal.parameterId, actual);
+        return;
+    }
+    if (formal.kind != actual.kind) {
+        fail("TYPE_MISMATCH", `Call argument type ${typeDescription(actual)}; expected ${typeDescription(formal)}.`, location);
+    }
+    if (formal.kind == "TypeReference") {
+        if (!sameType(formal, actual)) {
+            fail("TYPE_MISMATCH", `Call argument type ${typeDescription(actual)}; expected ${typeDescription(formal)}.`, location);
+        }
+        return;
+    }
+    if (formal.kind == "ReferenceType" && actual.kind == "ReferenceType") {
+        if (formal.declarationId != actual.declarationId) {
+            fail("TYPE_MISMATCH", `Call argument type ${typeDescription(actual)}; expected ${typeDescription(formal)}.`, location);
+        }
+        return;
+    }
+    if (formal.kind == "RecordType" && actual.kind == "RecordType") {
+        if (formal.declarationId != actual.declarationId || (formal.arguments?.length ?? 0) != (actual.arguments?.length ?? 0)) {
+            fail("TYPE_MISMATCH", `Call argument type ${typeDescription(actual)}; expected ${typeDescription(formal)}.`, location);
+        }
+        for (let index = 0; index < (formal.arguments?.length ?? 0); index += 1) {
+            inferTypeArguments(/** @type {import("./types.js").SemanticValueType} */ (formal.arguments?.[index]), 
+            /** @type {import("./types.js").SemanticValueType} */ (actual.arguments?.[index]), substitutions, location, fail);
+        }
+        return;
+    }
+    if (formal.kind == "ListType" && actual.kind == "ListType") {
+        inferTypeArguments(formal.elementType, actual.elementType, substitutions, location, fail);
+        return;
+    }
+    if (formal.kind == "OptionalType" && actual.kind == "OptionalType") {
+        inferTypeArguments(formal.valueType, actual.valueType, substitutions, location, fail);
+        return;
+    }
+    if ((formal.kind == "MapType" && actual.kind == "MapType") ||
+        (formal.kind == "OrderedMapType" && actual.kind == "OrderedMapType")) {
+        inferTypeArguments(formal.keyType, actual.keyType, substitutions, location, fail);
+        inferTypeArguments(formal.valueType, actual.valueType, substitutions, location, fail);
+    }
+}
+/**
+ * Checks the occurs constraint for first-order inference.
+ * @param {import("./types.js").SemanticValueType} type - Candidate inferred type.
+ * @param {string} parameterId - Parameter being inferred.
+ * @returns {boolean} Whether the type recursively contains the parameter.
+ */
+function typeContainsVariable(type, parameterId) {
+    if (type.kind == "TypeVariableReference")
+        return type.parameterId == parameterId;
+    if (type.kind == "RecordType")
+        return type.arguments?.some((argument) => typeContainsVariable(argument, parameterId)) ?? false;
+    if (type.kind == "ListType")
+        return typeContainsVariable(type.elementType, parameterId);
+    if (type.kind == "MapType" || type.kind == "OrderedMapType") {
+        return typeContainsVariable(type.keyType, parameterId) || typeContainsVariable(type.valueType, parameterId);
+    }
+    if (type.kind == "OptionalType")
+        return typeContainsVariable(type.valueType, parameterId);
+    return false;
+}
+/**
+ * Applies substitutions to a value or void return type.
+ * @param {import("./types.js").SemanticFunctionReturnType} type - Open return type.
+ * @param {Map<string, import("./types.js").SemanticValueType>} substitutions - Closed substitutions.
+ * @returns {import("./types.js").SemanticFunctionReturnType} Substituted return type.
+ */
+function substituteReturnType(type, substitutions) {
+    return isVoidType(type) ? type : substituteValueType(type, substitutions);
+}
+/**
+ * Builds the exact semantic signature bound to one declaration.
+ * @param {import("./types.js").FunctionDeclaration} declaration - Resolved declaration.
+ * @param {RecordRegistry} records - Record declarations by identity.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @param {Map<string, import("./types.js").SemanticValueType>} [substitutions] - Inferred generic substitutions.
+ * @returns {import("./types.js").ResolvedFunctionSignature} Detached signature binding.
+ */
+function signatureFor(declaration, records, fail, substitutions = new Map()) {
+    const typeParameters = declarationTypeParameterIds(declaration);
+    const declaredParameters = declaration.typeParameters ?? [];
+    const parameterTypes = declaration.parameters.map((parameter) => substituteValueType(validateValueTypeReference(parameter.type, parameter.location, fail, undefined, records, typeParameters), substitutions));
+    const returnType = substituteReturnType(validateReturnTypeReference(declaration.returnType, declaration.location, fail, records, typeParameters), substitutions);
+    return {
+        declarationId: /** @type {string} */ (declaration.id),
+        kind: "ResolvedFunctionSignature",
+        parameterTypes: parameterTypes.map((type) => /** @type {import("./types.js").SemanticTypeIdentity} */ (typeIdentity(type))),
+        returnType: typeIdentity(returnType),
+        ...(declaredParameters.length > 0 ? {
+            typeArguments: declaredParameters.map((parameter) => 
+            /** @type {import("./types.js").SemanticTypeIdentity} */ (typeIdentity(/** @type {import("./types.js").SemanticValueType} */ (substitutions.get(/** @type {string} */ (parameter.id))))))
+        } : {})
+    };
+}
+/**
+ * Validates an externally supplied call binding against the declaration collected for this module.
+ * @param {unknown} actual - Candidate call resolution.
+ * @param {import("./types.js").ResolvedFunctionSignature} expected - Exact declaration signature.
+ * @param {import("./types.js").SourceLocation} location - Call location.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @returns {void}
+ */
+function validateResolution(actual, expected, location, fail) {
+    const expectedKeys = expected.typeArguments ? "declarationId,kind,parameterTypes,returnType,typeArguments" :
+        "declarationId,kind,parameterTypes,returnType";
+    if (!actual || typeof actual != "object" || Array.isArray(actual) ||
+        Object.keys(actual).sort().join(",") != expectedKeys) {
+        fail("TYPE_MISMATCH", "Call is missing an exact resolved function signature.", location);
+    }
+    const candidate = /** @type {import("./types.js").ResolvedFunctionSignature} */ (actual);
+    if (candidate.kind != "ResolvedFunctionSignature" || typeof candidate.declarationId != "string" ||
+        !Array.isArray(candidate.parameterTypes) || !validTypeIdentity(candidate.returnType, true) ||
+        candidate.declarationId != expected.declarationId ||
+        !sameTypeIdentity(candidate.returnType, expected.returnType) || candidate.parameterTypes.length != expected.parameterTypes.length) {
+        fail("TYPE_MISMATCH", "Call resolution does not match its declaration signature.", location);
+    }
+    if (expected.typeArguments) {
+        const candidateTypeArguments = candidate.typeArguments;
+        if (!isDenseArray(candidateTypeArguments) || candidateTypeArguments.length != expected.typeArguments.length ||
+            candidateTypeArguments.some((type, index) => !validTypeIdentity(type, false) || !sameTypeIdentity(type, expected.typeArguments?.[index]))) {
+            fail("TYPE_MISMATCH", "Call resolution does not match its inferred type arguments.", location);
+        }
+    }
+    for (let index = 0; index < candidate.parameterTypes.length; index++) {
+        const type = candidate.parameterTypes[index];
+        if (!Object.hasOwn(candidate.parameterTypes, index) || !validTypeIdentity(type, false) ||
+            !sameTypeIdentity(type, expected.parameterTypes[index])) {
+            fail("TYPE_MISMATCH", "Call resolution does not match its declaration signature.", location);
+        }
+    }
+}
+/**
+ * Validates exact caller-owned constructor or method resolution metadata.
+ * @param {unknown} actual - Candidate resolution.
+ * @param {import("./types.js").ResolvedConstructorSignature | import("./types.js").ResolvedMethodSignature} expected - Exact resolution.
+ * @param {import("./types.js").SourceLocation} location - Expression location.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @param {"constructor" | "method"} role - Resolution role.
+ * @returns {void}
+ */
+function validateReferenceResolution(actual, expected, location, fail, role) {
+    const expectedMethod = role == "method" ? /** @type {import("./types.js").ResolvedMethodSignature} */ (expected) : undefined;
+    const expectedKeys = role == "constructor" ? "declarationId,kind,parameterTypes" :
+        expectedMethod?.resourceFlow ? "declarationId,kind,parameterTypes,resourceFlow,returnType" :
+            "declarationId,kind,parameterTypes,returnType";
+    if (!actual || typeof actual != "object" || Array.isArray(actual) || Object.keys(actual).sort().join(",") != expectedKeys) {
+        fail("TYPE_MISMATCH", `Reference ${role} call is missing an exact resolved ${role} signature.`, location);
+    }
+    const candidate = /** @type {Record<string, unknown>} */ (actual);
+    if (candidate.kind != expected.kind || candidate.declarationId != expected.declarationId ||
+        !isDenseArray(candidate.parameterTypes) || candidate.parameterTypes.length != expected.parameterTypes.length ||
+        candidate.parameterTypes.some((type, index) => !validTypeIdentity(type, false) ||
+            !sameTypeIdentity(type, expected.parameterTypes[index])) ||
+        role == "method" && (!validTypeIdentity(candidate.returnType, true) ||
+            !sameTypeIdentity(candidate.returnType, /** @type {import("./types.js").ResolvedMethodSignature} */ (expected).returnType) ||
+            JSON.stringify(candidate.resourceFlow) != JSON.stringify(expectedMethod?.resourceFlow))) {
+        fail("TYPE_MISMATCH", `Resolved ${role} signature does not match its declaration.`, location);
+    }
+}
+/**
+ * Makes a source identifier's ownership transfer explicit in normalized IR.
+ * @param {import("./types.js").Expression} expression - Candidate transfer expression.
+ * @param {import("./types.js").SemanticFunctionReturnType} expected - Destination type.
+ * @param {boolean} normalize - Whether parser intent may be normalized.
+ * @param {SemanticFail} fail - Located failure.
+ * @returns {import("./types.js").Expression} Explicit expression.
+ */
+function normalizeOwnedMove(expression, expected, normalize, fail) {
+    if (expected.kind != "OwnedResourceType" && expected.kind != "OwnedReferenceType")
+        return expression;
+    if (expression.kind == "OwnedMoveExpression")
+        return expression;
+    if (expression.kind == "PrivateFieldRead") {
+        return fail("INVALID_RESOURCE_TRANSFER", "Private resource fields cannot be moved or exposed; transfer the owning reference.", expression.location);
+    }
+    if (expression.kind != "IdentifierExpression")
+        return expression;
+    if (!normalize)
+        return fail("RESOURCE_MOVE_REQUIRED", "Owned transfer requires an explicit move expression.", expression.location);
+    return {
+        expression,
+        kind: "OwnedMoveExpression",
+        location: expression.location,
+        sourceProvenance: expression.sourceProvenance,
+        type: expected
+    };
+}
+/**
+ * Classifies the deliberately bounded Task 034 receiver transition.
+ * @param {import("./types.js").ClassDeclaration} declaration - Owned class.
+ * @param {import("./types.js").MethodDeclaration} method - Candidate method.
+ * @param {SemanticFail} fail - Located failure.
+ * @returns {{kind: "preserve" | "terminal", terminalFailureId?: string}} Receiver transition.
+ */
+function ownedMethodResourceFlow(declaration, method, fail) {
+    const effectStatements = method.body.statements.flatMap((statement) => {
+        const expression = statement.kind == "ExpressionStatement" || statement.kind == "ReturnStatement" ? statement.expression :
+            statement.kind == "LocalDeclaration" ? statement.initializer : undefined;
+        return expression?.kind == "EffectCallExpression" ? [expression] : [];
+    });
+    const allEffects = methodEffectExpressions(method.body);
+    if (allEffects.length == 0)
+        return { kind: "preserve" };
+    if (method.body.statements.length != 1 || effectStatements.length != 1 || allEffects.length != 1 ||
+        allEffects[0] !== effectStatements[0]) {
+        return fail("UNSUPPORTED_STATEMENT", `Owned method '${method.name}' must contain one direct resource operation or only pure statements.`, method.location);
+    }
+    const operation = effectStatements[0];
+    const flow = operation.resolution.resourceFlow;
+    if (flow.kind == "none" || flow.kind == "acquire")
+        return { kind: "preserve" };
+    const argument = operation.arguments[flow.parameterIndex];
+    const owned = declaration.ownership?.kind == "ownedResource" ? declaration.ownership : undefined;
+    const borrowedParameterName = argument?.kind == "OwnedBorrowExpression" && argument.expression.kind == "IdentifierExpression"
+        ? argument.expression.name : undefined;
+    const borrowedParameter = borrowedParameterName !== undefined &&
+        method.parameters.some((parameter) => parameter.name == borrowedParameterName && containsOwnedType(parameter.type));
+    if (borrowedParameter)
+        return { kind: "preserve" };
+    if (!argument || argument.kind != "OwnedBorrowExpression" || argument.expression.kind != "PrivateFieldRead" ||
+        argument.expression.field != owned?.fieldId) {
+        return fail("INVALID_RESOURCE_BORROW", `Owned method '${method.name}' must operate on its private resource field.`, operation.location);
+    }
+    return { kind: flow.kind == "close" ? "terminal" : "preserve", terminalFailureId: flow.terminalFailureId };
+}
+/**
+ * Collects every host-effect site nested in one owned method body.
+ * @param {import("./types.js").Block} block - Method body.
+ * @returns {import("./types.js").Expression[]} Effectful expressions.
+ */
+function methodEffectExpressions(block) {
+    /** @type {import("./types.js").Expression[]} */
+    const effects = [];
+    const pending = [/** @type {unknown} */ (block)];
+    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) && (Reflect.get(value, "kind") == "EffectCallExpression" ||
+            typeof Reflect.get(value, "effectSiteId") == "string")) {
+            effects.push(/** @type {import("./types.js").Expression} */ (value));
+        }
+        for (const [key, child] of Object.entries(value)) {
+            if (["location", "resolution", "sourceProvenance"].includes(key))
+                continue;
+            if (Array.isArray(child))
+                pending.push(...child);
+            else if (child && typeof child == "object")
+                pending.push(child);
+        }
+    }
+    return effects;
+}
+/**
+ * Rehydrates a closed capability type identity for ordinary expression checks.
+ * @param {import("./types.js").FunctionReturnTypeIdentity} identity - Closed identity.
+ * @param {import("./types.js").SourceLocation} location - Diagnostic location.
+ * @param {SemanticFail} fail - Located failure.
+ * @returns {import("./types.js").SemanticValueType} Value type.
+ */
+function identityAsValueType(identity, location, fail) {
+    if (typeof identity == "string") {
+        if (!isScalarTypeName(identity))
+            return fail("TYPE_MISMATCH", "Void or invalid identity used as an effect value type.", location);
+        return scalarType(identity);
+    }
+    if (!identity || typeof identity != "object" || Array.isArray(identity)) {
+        return fail("TYPE_MISMATCH", "Malformed effect type identity.", location);
+    }
+    const candidate = /** @type {Exclude<import("./types.js").SemanticTypeIdentity, string>} */ (identity);
+    if (candidate.kind == "OwnedResourceType")
+        return { kind: "OwnedResourceType", resourceId: candidate.resourceId };
+    if (candidate.kind == "OwnedReferenceType")
+        return { declarationId: candidate.declarationId, kind: "OwnedReferenceType" };
+    if (candidate.kind == "OptionalType")
+        return { kind: "OptionalType", valueType: identityAsValueType(candidate.valueType, location, fail) };
+    return fail("TYPE_MISMATCH", "Unsupported effect type identity.", location);
+}
+/**
+ * Converts a semantic type to its detached call-resolution identity.
+ * @param {import("./types.js").SemanticFunctionReturnType} type - Validated semantic type.
+ * @returns {import("./types.js").FunctionReturnTypeIdentity} Detached identity.
+ */
+function typeIdentity(type) {
+    if (type.kind == "TypeReference")
+        return type.name;
+    if (type.kind == "TypeVariableReference")
+        return { kind: "TypeVariableReference", parameterId: type.parameterId };
+    if (type.kind == "RecordType")
+        return {
+            declarationId: type.declarationId,
+            kind: "RecordType",
+            ...(type.arguments ? { arguments: type.arguments.map((argument) => 
+                /** @type {import("./types.js").SemanticTypeIdentity} */ (typeIdentity(argument))) } : {})
+        };
+    if (type.kind == "ReferenceType")
+        return { declarationId: type.declarationId, kind: "ReferenceType" };
+    if (type.kind == "OwnedResourceType")
+        return { kind: "OwnedResourceType", resourceId: type.resourceId };
+    if (type.kind == "OwnedReferenceType")
+        return { declarationId: type.declarationId, kind: "OwnedReferenceType" };
+    if (type.kind == "ListType")
+        return { elementType: /** @type {import("./types.js").SemanticTypeIdentity} */ (typeIdentity(type.elementType)), kind: "ListType" };
+    if (type.kind == "OptionalType")
+        return { kind: "OptionalType", valueType: /** @type {import("./types.js").SemanticTypeIdentity} */ (typeIdentity(type.valueType)) };
+    if (type.kind == "OrderedMapType")
+        return {
+            keyType: /** @type {import("./types.js").SemanticTypeIdentity} */ (typeIdentity(type.keyType)),
+            kind: "OrderedMapType",
+            order: "insertion",
+            valueType: /** @type {import("./types.js").SemanticTypeIdentity} */ (typeIdentity(type.valueType))
+        };
+    return {
+        keyType: /** @type {import("./types.js").SemanticTypeIdentity} */ (typeIdentity(type.keyType)),
+        kind: "MapType",
+        valueType: /** @type {import("./types.js").SemanticTypeIdentity} */ (typeIdentity(type.valueType))
+    };
+}
+/**
+ * Checks one externally supplied recursive type identity.
+ * @param {unknown} type - Candidate identity.
+ * @param {boolean} allowVoid - Whether void is permitted.
+ * @param {Set<object>} [seen] - Active recursion path.
+ * @returns {boolean} Whether the identity is closed and acyclic.
+ */
+function validTypeIdentity(type, allowVoid, seen = new Set()) {
+    if (typeof type == "string")
+        return isScalarTypeName(type) || allowVoid && type == "void";
+    if (!type || typeof type != "object" || Array.isArray(type) || seen.has(type))
+        return false;
+    seen.add(type);
+    const candidate = /** @type {Record<string, unknown>} */ (type);
+    let valid = false;
+    if (candidate.kind == "ListType" && Object.keys(candidate).sort().join(",") == "elementType,kind") {
+        valid = validTypeIdentity(candidate.elementType, false, seen);
+    }
+    else if (candidate.kind == "MapType" && Object.keys(candidate).sort().join(",") == "keyType,kind,valueType") {
+        valid = candidate.keyType == "string" && validTypeIdentity(candidate.valueType, false, seen);
+    }
+    else if (candidate.kind == "OrderedMapType" &&
+        Object.keys(candidate).sort().join(",") == "keyType,kind,order,valueType") {
+        valid = candidate.keyType == "string" && candidate.order == "insertion" &&
+            validTypeIdentity(candidate.valueType, false, seen);
+    }
+    else if (candidate.kind == "OptionalType" && Object.keys(candidate).sort().join(",") == "kind,valueType") {
+        valid = validTypeIdentity(candidate.valueType, false, seen) &&
+            !(candidate.valueType && typeof candidate.valueType == "object" && Reflect.get(candidate.valueType, "kind") == "OptionalType");
+    }
+    else if (candidate.kind == "TypeVariableReference" && Object.keys(candidate).sort().join(",") == "kind,parameterId") {
+        valid = typeof candidate.parameterId == "string" && /^(?:[a-z][a-z0-9._-]*#)?(?:record|function):[0-9]+:type:[0-9]+$/u.test(candidate.parameterId);
+    }
+    else if (candidate.kind == "RecordType" &&
+        ["arguments,declarationId,kind", "declarationId,kind"].includes(Object.keys(candidate).sort().join(","))) {
+        const candidateArguments = candidate.arguments;
+        valid = typeof candidate.declarationId == "string" && /^(?:[a-z][a-z0-9._-]*#)?record:[0-9]+$/u.test(candidate.declarationId) &&
+            (candidateArguments === undefined || isDenseArray(candidateArguments) &&
+                candidateArguments.every((argument) => validTypeIdentity(argument, false, seen)));
+    }
+    else if (candidate.kind == "ReferenceType" && Object.keys(candidate).sort().join(",") == "declarationId,kind") {
+        valid = typeof candidate.declarationId == "string" &&
+            /^(?:[a-z][a-z0-9._-]*#)?class:[0-9]+$/u.test(candidate.declarationId);
+    }
+    else if (candidate.kind == "OwnedResourceType" && Object.keys(candidate).sort().join(",") == "kind,resourceId") {
+        valid = typeof candidate.resourceId == "string" && /^(?:module:[0-9]+\/)?capability:[0-9]+\/resource:[0-9]+$/u
+            .test(candidate.resourceId);
+    }
+    else if (candidate.kind == "OwnedReferenceType" && Object.keys(candidate).sort().join(",") == "declarationId,kind") {
+        valid = typeof candidate.declarationId == "string" && /^(?:[a-z][a-z0-9._-]*#)?class:[0-9]+$/u.test(candidate.declarationId);
+    }
+    seen.delete(type);
+    return valid;
+}
+/**
+ * Checks array identity without relying on iteration methods that skip sparse slots.
+ * @param {unknown} value - Candidate array.
+ * @returns {value is unknown[]} Whether every indexed slot is present.
+ */
+function isDenseArray(value) {
+    if (!Array.isArray(value))
+        return false;
+    for (let index = 0; index < value.length; index += 1) {
+        if (!Object.hasOwn(value, index))
+            return false;
+    }
+    return true;
+}
+/**
+ * Compares two closed type identities structurally.
+ * @param {unknown} left - First identity.
+ * @param {unknown} right - Second identity.
+ * @returns {boolean} Whether the identities are equal.
+ */
+function sameTypeIdentity(left, right) {
+    if (typeof left == "string" || typeof right == "string")
+        return left === right;
+    if (!left || !right || typeof left != "object" || typeof right != "object")
+        return false;
+    const leftType = /** @type {Record<string, unknown>} */ (left);
+    const rightType = /** @type {Record<string, unknown>} */ (right);
+    if (leftType.kind != rightType.kind)
+        return false;
+    if (leftType.kind == "ListType")
+        return sameTypeIdentity(leftType.elementType, rightType.elementType);
+    if (leftType.kind == "OptionalType")
+        return sameTypeIdentity(leftType.valueType, rightType.valueType);
+    if (leftType.kind == "TypeVariableReference")
+        return leftType.parameterId == rightType.parameterId;
+    if (leftType.kind == "RecordType") {
+        const leftArguments = Array.isArray(leftType.arguments) ? leftType.arguments : [];
+        const rightArguments = Array.isArray(rightType.arguments) ? rightType.arguments : [];
+        return leftType.declarationId == rightType.declarationId && leftArguments.length == rightArguments.length &&
+            leftArguments.every((argument, index) => sameTypeIdentity(argument, rightArguments[index]));
+    }
+    if (leftType.kind == "ReferenceType")
+        return leftType.declarationId == rightType.declarationId;
+    if (leftType.kind == "OwnedResourceType")
+        return leftType.resourceId == rightType.resourceId;
+    if (leftType.kind == "OwnedReferenceType")
+        return leftType.declarationId == rightType.declarationId;
+    if (leftType.kind == "MapType" || leftType.kind == "OrderedMapType") {
+        return sameTypeIdentity(leftType.keyType, rightType.keyType) && sameTypeIdentity(leftType.valueType, rightType.valueType);
+    }
+    return false;
+}
+/**
+ * Compares two validated semantic types structurally.
+ * @param {import("./types.js").SemanticFunctionReturnType} left - First type.
+ * @param {import("./types.js").SemanticFunctionReturnType} right - Second type.
+ * @returns {boolean} Whether the types are equal.
+ */
+function sameType(left, right) {
+    return sameTypeIdentity(typeIdentity(left), typeIdentity(right));
+}
+/**
+ * Formats one validated semantic type for diagnostics.
+ * @param {import("./types.js").SemanticFunctionReturnType | import("./types.js").ErrorType} type - Semantic type.
+ * @returns {string} Stable recursive spelling.
+ */
+function typeDescription(type) {
+    if (type.kind == "TypeReference")
+        return type.name;
+    if (type.kind == "TypeVariableReference")
+        return `type-variable<${type.parameterId}>`;
+    if (type.kind == "RecordType")
+        return `record<${type.declarationId}${type.arguments?.length
+            ? `, ${type.arguments.map(typeDescription).join(", ")}` : ""}>`;
+    if (type.kind == "ReferenceType")
+        return `reference<${type.declarationId}>`;
+    if (type.kind == "OwnedResourceType")
+        return `owned-resource<${type.resourceId}>`;
+    if (type.kind == "OwnedReferenceType")
+        return `owned-reference<${type.declarationId}>`;
+    if (type.kind == "ErrorType")
+        return `error<${type.declarationId}>`;
+    if (type.kind == "ListType")
+        return `list<${typeDescription(type.elementType)}>`;
+    if (type.kind == "OptionalType")
+        return `optional<${typeDescription(type.valueType)}>`;
+    if (type.kind == "OrderedMapType")
+        return `ordered-map<string, ${typeDescription(type.valueType)}, insertion>`;
+    return `map<string, ${typeDescription(type.valueType)}>`;
+}
+/**
+ * Checks whether a type graph contains linear ownership.
+ * @param {unknown} type - Candidate semantic type.
+ * @param {Set<object>} [seen] - Visited type containers.
+ * @returns {boolean} Whether ownership occurs at any depth.
+ */
+function containsOwnedType(type, seen = new Set()) {
+    if (!type || typeof type != "object" || Array.isArray(type) || seen.has(type))
+        return false;
+    seen.add(type);
+    const kind = Reflect.get(type, "kind");
+    if (kind == "OwnedResourceType" || kind == "OwnedReferenceType")
+        return true;
+    if (kind == "ListType")
+        return containsOwnedType(Reflect.get(type, "elementType"), seen);
+    if (kind == "OptionalType")
+        return containsOwnedType(Reflect.get(type, "valueType"), seen);
+    if (kind == "MapType" || kind == "OrderedMapType") {
+        return containsOwnedType(Reflect.get(type, "keyType"), seen) || containsOwnedType(Reflect.get(type, "valueType"), seen);
+    }
+    if (kind == "RecordType") {
+        const arguments_ = Reflect.get(type, "arguments");
+        return Array.isArray(arguments_) && arguments_.some((argument) => containsOwnedType(argument, seen));
+    }
+    return false;
+}
+/**
+ * Checks one scalar semantic type.
+ * @param {import("./types.js").SemanticFunctionReturnType} type - Semantic type.
+ * @param {import("./types.js").SemanticTypeName} [name] - Optional required scalar.
+ * @returns {type is import("./types.js").TypeReference} Whether it is the requested scalar.
+ */
+function isScalarType(type, name) {
+    return type.kind == "TypeReference" && isScalarTypeName(type.name) && (name === undefined || type.name == name);
+}
+/**
+ * Checks the sole non-value return type.
+ * @param {import("./types.js").SemanticFunctionReturnType} type - Semantic type.
+ * @returns {type is import("./types.js").FunctionReturnTypeReference} Whether it is void.
+ */
+function isVoidType(type) {
+    return type.kind == "TypeReference" && type.name == "void";
+}
+/**
+ * Requires a scalar type for the pre-collection operator contract.
+ * @param {import("./types.js").SemanticValueType} type - Operand type.
+ * @param {import("./types.js").SourceLocation} location - Operand location.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @returns {import("./types.js").SemanticTypeName} Scalar name.
+ */
+function scalarNameForOperation(type, location, fail) {
+    if (!isScalarType(type)) {
+        return fail("INVALID_OPERAND_TYPE", `Scalar operation received ${typeDescription(type)}.`, location);
+    }
+    return type.name;
+}
+/**
+ * Enforces that a total collection access is proven or uses a source operation that fails on absence.
+ * @param {import("./types.js").ListIndexExpression | import("./types.js").MapLookupExpression} expression - Access.
+ * @param {boolean} proven - Whether static literal propagation proves presence.
+ * @param {boolean} normalizeOperations - Whether this is frontend admission.
+ * @param {SemanticFail} fail - Diagnostic callback.
+ * @returns {void}
+ */
+function validateAccessTotality(expression, proven, normalizeOperations, fail) {
+    if (proven) {
+        if (normalizeOperations)
+            expression.totality = "proven";
+        else if (expression.totality != "proven" && expression.totality != "fail-on-absence") {
+            fail("UNCHECKED_COLLECTION_ACCESS", "Collection access lacks a totality guarantee.", expression.location);
+        }
+        return;
+    }
+    if (expression.totality != "fail-on-absence") {
+        fail("UNCHECKED_COLLECTION_ACCESS", "Collection access is not statically proven and does not fail on absence.", expression.location);
+    }
+}
+/**
+ * Resolves a binding without producing a diagnostic.
+ * @param {string} name - Binding name.
+ * @param {Scope} scope - Visible scope.
+ * @returns {Binding | undefined} Binding when visible.
+ */
+function findBinding(name, scope) {
+    for (let current = /** @type {Scope | undefined} */ (scope); current; current = current.parent) {
+        const binding = current.bindings.get(name);
+        if (binding)
+            return binding;
+    }
+    return undefined;
+}
+/**
+ * Returns the existing bindings whose known values must be merged across a conditional.
+ * @param {Scope} scope - Visible scope.
+ * @returns {Binding[]} Nearest-to-farthest bindings.
+ */
+function bindingsVisibleFrom(scope) {
+    const bindings = [];
+    for (let current = /** @type {Scope | undefined} */ (scope); current; current = current.parent) {
+        bindings.push(...current.bindings.values());
+    }
+    return bindings;
+}
+/**
+ * Finds visible mutable bindings that a loop body may assign on any nested path.
+ * The set is computed after validating the list expression because collection evaluation precedes body effects.
+ * @param {import("./types.js").Block} block - Candidate loop body.
+ * @param {Scope} outerScope - Scope visible before entering the loop.
+ * @param {Set<Binding>} [assigned] - Accumulated binding identities.
+ * @returns {Set<Binding>} Exactly the visible mutable bindings targeted by nested assignments.
+ */
+function outerMutableBindingsAssignedBy(block, outerScope, assigned = new Set()) {
+    for (const statement of block.statements) {
+        if (statement.kind == "AssignmentStatement") {
+            const binding = findBinding(statement.target.name, outerScope);
+            if (binding?.mutable)
+                assigned.add(binding);
+        }
+        else if (statement.kind == "IfStatement") {
+            outerMutableBindingsAssignedBy(statement.consequent, outerScope, assigned);
+            if (statement.alternate)
+                outerMutableBindingsAssignedBy(statement.alternate, outerScope, assigned);
+        }
+        else if (statement.kind == "ForEachStatement" || statement.kind == "ForEachMapStatement" || statement.kind == "WhileStatement") {
+            outerMutableBindingsAssignedBy(statement.body, outerScope, assigned);
+        }
+        else if (statement.kind == "TryStatement") {
+            outerMutableBindingsAssignedBy(statement.body, outerScope, assigned);
+            outerMutableBindingsAssignedBy(statement.catchBody, outerScope, assigned);
+        }
+    }
+    return assigned;
+}
+/**
+ * Propagates only immutable values whose exact collection contents remain known.
+ * @param {import("./types.js").Expression} expression - Expression.
+ * @param {Scope} scope - Visible scope.
+ * @returns {import("./types.js").Expression | undefined} Known value.
+ */
+function knownValueForExpression(expression, scope) {
+    if (["IntegerLiteral", "BooleanLiteral", "StringLiteral", "ListLiteral", "MapLiteral", "OrderedMapLiteral"].includes(expression.kind))
+        return expression;
+    if (expression.kind == "IdentifierExpression")
+        return findBinding(expression.name, scope)?.knownValue;
+    if (expression.kind == "ListIndexExpression")
+        return provenListElement(expression.collection, expression.index, scope);
+    if (expression.kind == "MapLookupExpression")
+        return provenMapValue(expression.collection, expression.key, scope);
+    return undefined;
+}
+/**
+ * Finds the statically selected list element.
+ * @param {import("./types.js").Expression} collection - List receiver.
+ * @param {import("./types.js").Expression} index - Index expression.
+ * @param {Scope} scope - Visible scope.
+ * @returns {import("./types.js").Expression | undefined} Proven element.
+ */
+function provenListElement(collection, index, scope) {
+    const knownCollection = knownValueForExpression(collection, scope);
+    const knownIndex = knownValueForExpression(index, scope);
+    if (knownCollection?.kind != "ListLiteral" || knownIndex?.kind != "IntegerLiteral" ||
+        knownIndex.value < 0 || knownIndex.value >= knownCollection.elements.length)
+        return undefined;
+    return knownCollection.elements[knownIndex.value];
+}
+/**
+ * Finds the statically selected map value.
+ * @param {import("./types.js").Expression} collection - Map receiver.
+ * @param {import("./types.js").Expression} key - Key expression.
+ * @param {Scope} scope - Visible scope.
+ * @returns {import("./types.js").Expression | undefined} Proven value.
+ */
+function provenMapValue(collection, key, scope) {
+    const knownCollection = knownValueForExpression(collection, scope);
+    const knownKey = knownValueForExpression(key, scope);
+    if (knownCollection?.kind != "MapLiteral" && knownCollection?.kind != "OrderedMapLiteral" ||
+        knownKey?.kind != "StringLiteral")
+        return undefined;
+    return knownCollection.entries.find((entry) => entry.key.value == knownKey.value)?.value;
+}
+/**
+ * Identifies numeric strings independently from any target's key coercions.
+ * @param {string} value - Literal key.
+ * @returns {boolean} Whether it is numeric.
+ */
+function isNumericString(value) {
+    return /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/iu.test(value.trim());
+}
+/**
+ * Selects an exact semantic token location when parser provenance is available.
+ * @param {{location: import("./types.js").SourceLocation, sourceProvenance?: import("./types.js").SemanticNodeSourceProvenance}} node - Located semantic node.
+ * @param {string} role - Token role.
+ * @returns {import("./types.js").SourceLocation} Exact or owning location.
+ */
+function roleLocation(node, role) {
+    return node.sourceProvenance?.ranges[role] ?? parserRangeFor(node, role) ?? node.location;
+}
+/**
+ * Selects the exact type token or the owning declaration location.
+ * @param {unknown} type - Candidate type reference.
+ * @param {import("./types.js").SourceLocation} ownerLocation - Owning declaration location.
+ * @param {string} [role] - Recursive type role.
+ * @returns {import("./types.js").SourceLocation} Exact type location when known.
+ */
+function typeLocation(type, ownerLocation, role = "type") {
+    if (!type || typeof type != "object" || Array.isArray(type))
+        return ownerLocation;
+    const candidate = /** @type {import("./types.js").SemanticFunctionReturnType} */ (type);
+    return candidate.sourceProvenance?.ranges[role] ?? parserRangeFor(candidate, role) ??
+        candidate.sourceProvenance?.ranges.type ?? parserRangeFor(candidate, "type") ?? ownerLocation;
+}
 /** @type {Readonly<Record<import("./types.js").SemanticUnaryOperation, {operand: import("./types.js").SemanticTypeName, result: import("./types.js").SemanticTypeName}>>} */
 const unaryOperationSignatures = Object.freeze({
     BooleanNot: Object.freeze({ operand: "boolean", result: "boolean" }),
@@ -469,4 +2947,4 @@ function setNormalizedOperation(expression, operation, type) {
     Reflect.set(expression, "operation", operation);
     Reflect.set(expression, "type", type);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validate.js","sourceRoot":"","sources":["../../../src/semantic/validate.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {semanticFailure, unsupportedCapability, unsupportedSyntax} from \"../diagnostic.js\"\nimport {hasOnlyUnicodeScalars, isScalarTypeName} from \"./scalars.js\"\nimport {adaptedOperationFor} from \"./operators.js\"\n\n/**\n * @typedef Binding\n * @property {boolean} mutable - Whether assignment is allowed.\n * @property {import(\"./types.js\").SemanticTypeName} type - Binding type.\n */\n\n/**\n * @typedef Scope\n * @property {Map<string, Binding>} bindings - Bindings declared directly in this scope.\n * @property {Set<string>} pending - Names declared later in this scope.\n * @property {Scope | undefined} parent - Enclosing lexical scope.\n * @property {Set<string>} usedNames - All names used by the enclosing function or entry point.\n */\n\n/**\n * @typedef SemanticFail\n * @type {(code: string, detail: string, location: import(\"./types.js\").SourceLocation) => never}\n */\n\n/**\n * Enforces the coherent release-candidate semantic subset after adaptation.\n * @param {import(\"./types.js\").SemanticModule} module - Adapted semantic module.\n * @param {import(\"./types.js\").SemanticLanguage} language - Source language.\n * @returns {import(\"./types.js\").SemanticModule} Validated module.\n */\nexport function validateParsedModule(module, language) {\n  validateModuleShape(module, (detail, location) => unsupportedSyntax(language, detail, location))\n  validateModuleTypes(module, (code, detail, location) => semanticFailure(language, code, detail, location), true)\n\n  return module\n}\n\n/**\n * Validates scalar types and bindings for a caller-supplied semantic module before emission.\n * @param {import(\"./types.js\").SemanticModule} module - Semantic module.\n * @param {import(\"./types.js\").SemanticLanguage} language - Backend language.\n * @returns {void}\n */\nexport function validateBackendTypes(module, language) {\n  validateModuleTypes(module, (_code, detail, location) => unsupportedCapability(language, detail, location), false)\n}\n\n/**\n * Checks parser-authored block and statement layouts before semantic validation.\n * @param {import(\"./types.js\").SemanticModule} module - Semantic module.\n * @param {(detail: string, location: import(\"./types.js\").SourceLocation) => never} fail - Shape failure.\n * @returns {void}\n */\nfunction validateModuleShape(module, fail) {\n  for (const functionDeclaration of module.functions) {\n    if (functionDeclaration.parameters.length != 2) {\n      fail(\"function parameter count other than two\", functionDeclaration.location)\n    }\n\n    validateBlockShape(functionDeclaration.body, \"function body\", fail)\n  }\n\n  validateBlockShape(module.entryPoint.body, \"entry point\", fail)\n}\n\n/**\n * Checks one recursively nested semantic block produced by a frontend.\n * @param {import(\"./types.js\").Block} block - Semantic block.\n * @param {string} detail - Diagnostic detail.\n * @param {(detail: string, location: import(\"./types.js\").SourceLocation) => never} fail - Shape failure.\n * @returns {void}\n */\nfunction validateBlockShape(block, detail, fail) {\n  if (!block || block.kind != \"Block\" || !Array.isArray(block.statements)) {\n    fail(`${detail} without Block`, block?.location ?? /** @type {never} */ (undefined))\n  }\n\n  for (const statement of block.statements) {\n    if (![\"AssignmentStatement\", \"IfStatement\", \"LocalDeclaration\", \"PrintStatement\", \"ReturnStatement\"].includes(statement.kind)) {\n      fail(`${detail} statement ${statement.kind}`, statement.location)\n    }\n    if (statement.kind == \"IfStatement\") {\n      validateBlockShape(statement.consequent, \"if consequent\", fail)\n      if (statement.alternate) validateBlockShape(statement.alternate, \"if alternate\", fail)\n    }\n  }\n}\n\n/**\n * Validates declarations and expression types within lexical scopes.\n * @param {import(\"./types.js\").SemanticModule} module - Semantic module.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.\n * @returns {void}\n */\nfunction validateModuleTypes(module, fail, normalizeOperations) {\n  /** @type {Map<string, import(\"./types.js\").FunctionDeclaration>} */\n  const functions = new Map()\n\n  for (const functionDeclaration of module.functions) {\n    if (functions.has(functionDeclaration.name)) {\n      fail(\"DUPLICATE_BINDING\", `duplicate function '${functionDeclaration.name}'.`, functionDeclaration.location)\n    }\n    functions.set(functionDeclaration.name, functionDeclaration)\n  }\n\n  for (const functionDeclaration of module.functions) validateFunction(functionDeclaration, functions, fail, normalizeOperations)\n\n  const callableNames = new Set(functions.keys())\n\n  const entryScope = createScope(undefined, module.entryPoint.body.statements, callableNames)\n\n  validateBlock(module.entryPoint.body, entryScope, undefined, functions, fail, normalizeOperations)\n}\n\n/**\n * Validates one non-void function and its complete control flow.\n * @param {import(\"./types.js\").FunctionDeclaration} declaration - Function declaration.\n * @param {Map<string, import(\"./types.js\").FunctionDeclaration>} functions - Function signatures.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.\n * @returns {void}\n */\nfunction validateFunction(declaration, functions, fail, normalizeOperations) {\n  const scope = createScope(undefined, declaration.body.statements, new Set(functions.keys()))\n\n  for (const parameter of declaration.parameters) {\n    const type = validateTypeReference(parameter.type, parameter.location, fail)\n\n    declareBinding(parameter.name, {mutable: false, type}, parameter.location, scope, fail)\n  }\n\n  const returnType = validateTypeReference(declaration.returnType, declaration.location, fail)\n  const returns = validateBlock(declaration.body, scope, returnType, functions, fail, normalizeOperations)\n\n  if (!returns) fail(\"MISSING_RETURN\", `Function '${declaration.name}' does not return on every reachable path.`, declaration.location)\n}\n\n/**\n * Validates one ordered block and reports whether every path returns.\n * @param {import(\"./types.js\").Block} block - Semantic block.\n * @param {Scope} scope - Scope belonging to this block.\n * @param {import(\"./types.js\").SemanticTypeName | undefined} returnType - Function return type, absent for entry points.\n * @param {Map<string, import(\"./types.js\").FunctionDeclaration>} functions - Function signatures.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.\n * @returns {boolean} Whether every path through the block returns.\n */\nfunction validateBlock(block, scope, returnType, functions, fail, normalizeOperations) {\n  let alwaysReturns = false\n\n  for (const statement of block.statements) {\n    if (alwaysReturns) fail(\"UNREACHABLE_STATEMENT\", \"Statement is unreachable.\", statement.location)\n\n    if (statement.kind == \"LocalDeclaration\") {\n      const declaredType = validateTypeReference(statement.type, statement.location, fail)\n      const initializerType = inferExpressionType(statement.initializer, scope, functions, fail, normalizeOperations)\n\n      scope.pending.delete(statement.name)\n      if (initializerType != declaredType) {\n        fail(\"TYPE_MISMATCH\", `Initializer type ${initializerType}; expected ${declaredType}.`, statement.initializer.location)\n      }\n      declareBinding(statement.name, {mutable: statement.mutable, type: declaredType}, statement.location, scope, fail)\n      continue\n    }\n    if (statement.kind == \"AssignmentStatement\") {\n      const expressionType = inferExpressionType(statement.expression, scope, functions, fail, normalizeOperations)\n      const binding = resolveBinding(statement.target.name, statement.target.location, scope, fail)\n\n      if (!binding.mutable) {\n        fail(\"IMMUTABLE_ASSIGNMENT\", `Cannot assign to immutable binding '${statement.target.name}'.`, statement.target.location)\n      }\n      if (expressionType != binding.type) {\n        fail(\"TYPE_MISMATCH\", `Assignment type ${expressionType}; expected ${binding.type}.`, statement.expression.location)\n      }\n      continue\n    }\n    if (statement.kind == \"PrintStatement\") {\n      inferExpressionType(statement.expression, scope, functions, fail, normalizeOperations)\n      continue\n    }\n    if (statement.kind == \"ReturnStatement\") {\n      if (!returnType) fail(\"ILLEGAL_RETURN_CONTEXT\", \"Return statement outside a function.\", statement.location)\n      const actualType = inferExpressionType(statement.expression, scope, functions, fail, normalizeOperations)\n\n      if (actualType != returnType) {\n        fail(\"TYPE_MISMATCH\", `Return type ${actualType}; expected ${returnType}.`, statement.expression.location)\n      }\n      alwaysReturns = true\n      continue\n    }\n    if (statement.kind == \"IfStatement\") {\n      const conditionType = inferExpressionType(statement.condition, scope, functions, fail, normalizeOperations)\n\n      if (conditionType != \"boolean\") {\n        fail(\"NON_BOOLEAN_CONDITION\", `If condition type ${conditionType}; expected boolean.`, statement.condition.location)\n      }\n      const consequentScope = createScope(scope, statement.consequent.statements)\n      const consequentReturns = validateBlock(statement.consequent, consequentScope, returnType, functions, fail, normalizeOperations)\n      let alternateReturns = false\n\n      if (statement.alternate) {\n        const alternateScope = createScope(scope, statement.alternate.statements)\n\n        alternateReturns = validateBlock(statement.alternate, alternateScope, returnType, functions, fail, normalizeOperations)\n      }\n      alwaysReturns = consequentReturns && alternateReturns\n      continue\n    }\n\n    const unexpected = /** @type {{kind: string, location: import(\"./types.js\").SourceLocation}} */ (statement)\n\n    fail(\"UNSUPPORTED_STATEMENT\", unexpected.kind, unexpected.location)\n  }\n\n  return alwaysReturns\n}\n\n/**\n * Creates a lexical scope with declarations marked pending until visited.\n * @param {Scope | undefined} parent - Enclosing scope.\n * @param {{kind: string, name?: string}[]} statements - Scope statements.\n * @param {Set<string>} [reservedNames] - Names unavailable to root bindings.\n * @returns {Scope} Scope.\n */\nfunction createScope(parent, statements, reservedNames = new Set()) {\n  const pending = new Set(statements.filter((statement) => statement.kind == \"LocalDeclaration\")\n    .map((statement) => /** @type {{name: string}} */ (statement).name))\n\n  return {bindings: new Map(), parent, pending, usedNames: parent?.usedNames ?? new Set(reservedNames)}\n}\n\n/**\n * Adds one binding while rejecting duplicates and shadowing.\n * @param {string} name - Binding name.\n * @param {Binding} binding - Binding metadata.\n * @param {import(\"./types.js\").SourceLocation} location - Declaration location.\n * @param {Scope} scope - Current scope.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {void}\n */\nfunction declareBinding(name, binding, location, scope, fail) {\n  if (scope.usedNames.has(name)) fail(\"DUPLICATE_BINDING\", `Duplicate or shadowed binding '${name}'.`, location)\n\n  scope.bindings.set(name, binding)\n  scope.usedNames.add(name)\n}\n\n/**\n * Resolves one identifier and distinguishes use-before-declaration.\n * @param {string} name - Binding name.\n * @param {import(\"./types.js\").SourceLocation} location - Reference location.\n * @param {Scope} scope - Current scope.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {Binding} Binding.\n */\nfunction resolveBinding(name, location, scope, fail) {\n  for (let current = /** @type {Scope | undefined} */ (scope); current; current = current.parent) {\n    const binding = current.bindings.get(name)\n\n    if (binding) return binding\n    if (current.pending.has(name)) {\n      return fail(\"USE_BEFORE_DECLARATION\", `Binding '${name}' is used before its declaration.`, location)\n    }\n  }\n\n  return fail(\"UNRESOLVED_BINDING\", `Unknown binding '${name}'.`, location)\n}\n\n/**\n * Validates one semantic type reference.\n * @param {unknown} type - Candidate semantic type reference.\n * @param {import(\"./types.js\").SourceLocation} location - Owning source location.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {import(\"./types.js\").SemanticTypeName} Validated scalar name.\n */\nfunction validateTypeReference(type, location, fail) {\n  if (!type || typeof type != \"object\" || Array.isArray(type)) {\n    return fail(\"TYPE_MISMATCH\", \"Unsupported scalar type.\", location)\n  }\n\n  const candidate = /** @type {import(\"./types.js\").TypeReference} */ (type)\n\n  if (candidate.kind != \"TypeReference\" || !isScalarTypeName(candidate.name)) {\n    fail(\"TYPE_MISMATCH\", \"Unsupported scalar type.\", location)\n  }\n\n  return candidate.name\n}\n\n/**\n * Infers and validates one expression.\n * @param {import(\"./types.js\").Expression} expression - Semantic expression.\n * @param {Scope} scope - Visible lexical scope.\n * @param {Map<string, import(\"./types.js\").FunctionDeclaration>} functions - Module function signatures.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.\n * @returns {import(\"./types.js\").SemanticTypeName} Expression type.\n */\nfunction inferExpressionType(expression, scope, functions, fail, normalizeOperations) {\n  if (expression.kind == \"IdentifierExpression\") return resolveBinding(expression.name, expression.location, scope, fail).type\n\n  if (expression.kind == \"IntegerLiteral\") {\n    if (!Number.isSafeInteger(expression.value)) fail(\"TYPE_MISMATCH\", \"Non-safe integer literal.\", expression.location)\n    return \"integer\"\n  }\n  if (expression.kind == \"BooleanLiteral\") {\n    if (typeof Reflect.get(expression, \"value\") != \"boolean\") {\n      fail(\"TYPE_MISMATCH\", \"Invalid boolean literal value.\", expression.location)\n    }\n    return \"boolean\"\n  }\n  if (expression.kind == \"StringLiteral\") {\n    const value = Reflect.get(expression, \"value\")\n\n    if (typeof value != \"string\" || !hasOnlyUnicodeScalars(value)) {\n      fail(\"TYPE_MISMATCH\", \"Invalid Unicode string literal.\", expression.location)\n    }\n    return \"string\"\n  }\n  if (expression.kind == \"CallExpression\") {\n    const functionDeclaration = functions.get(expression.callee)\n\n    if (!functionDeclaration) return fail(\"UNRESOLVED_BINDING\", `Unknown function '${expression.callee}'.`, expression.location)\n    if (expression.arguments.length != functionDeclaration.parameters.length) {\n      return fail(\"TYPE_MISMATCH\", `Call argument count for '${expression.callee}'.`, expression.location)\n    }\n    for (let index = 0; index < expression.arguments.length; index++) {\n      const argument = expression.arguments[index]\n      const actualType = inferExpressionType(argument, scope, functions, fail, normalizeOperations)\n      const expectedType = validateTypeReference(functionDeclaration.parameters[index].type, functionDeclaration.parameters[index].location, fail)\n\n      if (actualType != expectedType) {\n        fail(\"TYPE_MISMATCH\", `Call argument type ${actualType}; expected ${expectedType}.`, argument.location)\n      }\n    }\n    return validateTypeReference(functionDeclaration.returnType, functionDeclaration.location, fail)\n  }\n  if (expression.kind == \"UnaryExpression\") {\n    const operandType = inferExpressionType(expression.operand, scope, functions, fail, normalizeOperations)\n    const operation = normalizeOperations\n      ? normalizeUnaryOperation(adaptedOperationFor(expression), operandType, expression.operand.location, fail)\n      : expression.operation\n\n    if (normalizeOperations) setNormalizedOperation(expression, operation, unaryOperationSignatures[operation].result)\n\n    const signature = unaryOperationSignatures[operation]\n\n    if (!signature) return fail(\"TYPE_MISMATCH\", `Unknown unary operation ${String(operation)}.`, expression.location)\n    if (operandType != signature.operand) {\n      return fail(\"INVALID_OPERAND_TYPE\", `${operation} requires ${signature.operand}; received ${operandType}.`, expression.operand.location)\n    }\n    if (expression.type != signature.result) {\n      return fail(\"TYPE_MISMATCH\", `${operation} result type ${String(expression.type)}; expected ${signature.result}.`, expression.location)\n    }\n    return signature.result\n  }\n  if (expression.kind == \"BinaryExpression\") {\n    const leftType = inferExpressionType(expression.left, scope, functions, fail, normalizeOperations)\n    const rightType = inferExpressionType(expression.right, scope, functions, fail, normalizeOperations)\n    const operation = normalizeOperations\n      ? normalizeBinaryOperation(adaptedOperationFor(expression), leftType, rightType, expression.left.location, expression.right.location, expression.location, fail)\n      : expression.operation\n\n    if (normalizeOperations) setNormalizedOperation(expression, operation, binaryOperationSignatures[operation].result)\n\n    const signature = binaryOperationSignatures[operation]\n\n    if (!signature) return fail(\"TYPE_MISMATCH\", `Unknown binary operation ${String(operation)}.`, expression.location)\n    if (leftType != signature.left) {\n      return fail(\"INVALID_OPERAND_TYPE\", `${operation} requires ${signature.left} left operand; received ${leftType}.`, expression.left.location)\n    }\n    if (rightType != signature.right) {\n      return fail(\"INVALID_OPERAND_TYPE\", `${operation} requires ${signature.right} right operand; received ${rightType}.`, expression.right.location)\n    }\n    if (expression.type != signature.result) {\n      return fail(\"TYPE_MISMATCH\", `${operation} result type ${String(expression.type)}; expected ${signature.result}.`, expression.location)\n    }\n    return signature.result\n  }\n\n  const unexpected = /** @type {{kind: string, location: import(\"./types.js\").SourceLocation}} */ (expression)\n\n  return fail(\"TYPE_MISMATCH\", unexpected.kind, unexpected.location)\n}\n\n/** @type {Readonly<Record<import(\"./types.js\").SemanticUnaryOperation, {operand: import(\"./types.js\").SemanticTypeName, result: import(\"./types.js\").SemanticTypeName}>>} */\nconst unaryOperationSignatures = Object.freeze({\n  BooleanNot: Object.freeze({operand: \"boolean\", result: \"boolean\"}),\n  IntegerNegate: Object.freeze({operand: \"integer\", result: \"integer\"})\n})\n\n/** @type {Readonly<Record<import(\"./types.js\").SemanticBinaryOperation, {left: import(\"./types.js\").SemanticTypeName, right: import(\"./types.js\").SemanticTypeName, result: import(\"./types.js\").SemanticTypeName}>>} */\nconst binaryOperationSignatures = Object.freeze({\n  BooleanAnd: Object.freeze({left: \"boolean\", result: \"boolean\", right: \"boolean\"}),\n  BooleanEqual: Object.freeze({left: \"boolean\", result: \"boolean\", right: \"boolean\"}),\n  BooleanNotEqual: Object.freeze({left: \"boolean\", result: \"boolean\", right: \"boolean\"}),\n  BooleanOr: Object.freeze({left: \"boolean\", result: \"boolean\", right: \"boolean\"}),\n  IntegerAdd: Object.freeze({left: \"integer\", result: \"integer\", right: \"integer\"}),\n  IntegerEqual: Object.freeze({left: \"integer\", result: \"boolean\", right: \"integer\"}),\n  IntegerGreaterThan: Object.freeze({left: \"integer\", result: \"boolean\", right: \"integer\"}),\n  IntegerGreaterThanOrEqual: Object.freeze({left: \"integer\", result: \"boolean\", right: \"integer\"}),\n  IntegerLessThan: Object.freeze({left: \"integer\", result: \"boolean\", right: \"integer\"}),\n  IntegerLessThanOrEqual: Object.freeze({left: \"integer\", result: \"boolean\", right: \"integer\"}),\n  IntegerMultiply: Object.freeze({left: \"integer\", result: \"integer\", right: \"integer\"}),\n  IntegerNotEqual: Object.freeze({left: \"integer\", result: \"boolean\", right: \"integer\"}),\n  IntegerSubtract: Object.freeze({left: \"integer\", result: \"integer\", right: \"integer\"}),\n  StringConcat: Object.freeze({left: \"string\", result: \"string\", right: \"string\"}),\n  StringEqual: Object.freeze({left: \"string\", result: \"boolean\", right: \"string\"}),\n  StringNotEqual: Object.freeze({left: \"string\", result: \"boolean\", right: \"string\"})\n})\n\n/**\n * Selects one typed unary meaning from parser-normalized source intent.\n * @param {unknown} sourceOperation - Transient frontend operation.\n * @param {import(\"./types.js\").SemanticTypeName} operandType - Resolved operand type.\n * @param {import(\"./types.js\").SourceLocation} location - Operand location.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {import(\"./types.js\").SemanticUnaryOperation} Semantic operation.\n */\nfunction normalizeUnaryOperation(sourceOperation, operandType, location, fail) {\n  if (sourceOperation == \"Negate\") {\n    if (operandType != \"integer\") fail(\"INVALID_OPERAND_TYPE\", `Integer negation requires integer; received ${operandType}.`, location)\n    return \"IntegerNegate\"\n  }\n  if (sourceOperation == \"Not\") {\n    if (operandType != \"boolean\") fail(\"INVALID_OPERAND_TYPE\", `Boolean not requires boolean; received ${operandType}.`, location)\n    return \"BooleanNot\"\n  }\n\n  return fail(\"TYPE_MISMATCH\", `Unknown unary source operation ${String(sourceOperation)}.`, location)\n}\n\n/**\n * Selects one typed binary meaning from parser-normalized source intent.\n * @param {unknown} sourceOperation - Transient frontend operation.\n * @param {import(\"./types.js\").SemanticTypeName} leftType - Resolved left type.\n * @param {import(\"./types.js\").SemanticTypeName} rightType - Resolved right type.\n * @param {import(\"./types.js\").SourceLocation} leftLocation - Left operand location.\n * @param {import(\"./types.js\").SourceLocation} rightLocation - Right operand location.\n * @param {import(\"./types.js\").SourceLocation} expressionLocation - Whole operation location.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {import(\"./types.js\").SemanticBinaryOperation} Semantic operation.\n */\nfunction normalizeBinaryOperation(sourceOperation, leftType, rightType, leftLocation, rightLocation, expressionLocation, fail) {\n  if (sourceOperation == \"PhpAdd\") {\n    if (leftType == \"string\" && rightType == \"string\") {\n      return fail(\"UNSUPPORTED_SYNTAX\", \"PHP binary + does not concatenate strings; use . instead.\", expressionLocation)\n    }\n\n    sourceOperation = \"Add\"\n  }\n\n  if (sourceOperation == \"StringConcat\") {\n    if (leftType != \"string\") fail(\"INVALID_OPERAND_TYPE\", `String concatenation requires string; received ${leftType}.`, leftLocation)\n    if (rightType != \"string\") fail(\"INVALID_OPERAND_TYPE\", `String concatenation requires string; received ${rightType}.`, rightLocation)\n    return \"StringConcat\"\n  }\n\n  if (sourceOperation == \"Add\") {\n    if (leftType == \"integer\" && rightType == \"integer\") return \"IntegerAdd\"\n    if (leftType == \"string\" && rightType == \"string\") return \"StringConcat\"\n\n    const location = leftType == \"integer\" || leftType == \"string\" ? rightLocation : leftLocation\n\n    return fail(\"INVALID_OPERAND_TYPE\", `Addition requires two integers or two strings; received ${leftType} and ${rightType}.`, location)\n  }\n\n  const fixedOperations = /** @type {const} */ ({\n    And: [\"boolean\", \"BooleanAnd\"],\n    GreaterThan: [\"integer\", \"IntegerGreaterThan\"],\n    GreaterThanOrEqual: [\"integer\", \"IntegerGreaterThanOrEqual\"],\n    LessThan: [\"integer\", \"IntegerLessThan\"],\n    LessThanOrEqual: [\"integer\", \"IntegerLessThanOrEqual\"],\n    Multiply: [\"integer\", \"IntegerMultiply\"],\n    Or: [\"boolean\", \"BooleanOr\"],\n    Subtract: [\"integer\", \"IntegerSubtract\"]\n  })\n  const fixed = Reflect.get(fixedOperations, String(sourceOperation))\n\n  if (fixed) {\n    const [requiredType, operation] = fixed\n\n    if (leftType != requiredType) fail(\"INVALID_OPERAND_TYPE\", `${String(sourceOperation)} requires ${requiredType}; received ${leftType}.`, leftLocation)\n    if (rightType != requiredType) fail(\"INVALID_OPERAND_TYPE\", `${String(sourceOperation)} requires ${requiredType}; received ${rightType}.`, rightLocation)\n\n    return /** @type {import(\"./types.js\").SemanticBinaryOperation} */ (operation)\n  }\n\n  if (sourceOperation == \"JavaEqual\" || sourceOperation == \"JavaNotEqual\") {\n    if (leftType == \"string\" || rightType == \"string\") {\n      return fail(\"UNSUPPORTED_SYNTAX\", \"Java reference equality is outside the implemented semantic subset.\", expressionLocation)\n    }\n\n    sourceOperation = sourceOperation == \"JavaEqual\" ? \"Equal\" : \"NotEqual\"\n  }\n\n  if (sourceOperation == \"StringEqual\" || sourceOperation == \"StringNotEqual\") {\n    if (leftType != \"string\") fail(\"INVALID_OPERAND_TYPE\", `String equality requires string; received ${leftType}.`, leftLocation)\n    if (rightType != \"string\") fail(\"INVALID_OPERAND_TYPE\", `String equality requires string; received ${rightType}.`, rightLocation)\n\n    return /** @type {\"StringEqual\" | \"StringNotEqual\"} */ (sourceOperation)\n  }\n\n  if (sourceOperation == \"Equal\" || sourceOperation == \"NotEqual\") {\n    if (leftType != rightType) {\n      return fail(\"MISMATCHED_EQUALITY_TYPES\", `Equality requires matching scalar types; received ${leftType} and ${rightType}.`, rightLocation)\n    }\n\n    const prefix = leftType == \"integer\" ? \"Integer\" : leftType == \"boolean\" ? \"Boolean\" : \"String\"\n\n    return /** @type {import(\"./types.js\").SemanticBinaryOperation} */ (`${prefix}${sourceOperation}`)\n  }\n\n  return fail(\"TYPE_MISMATCH\", `Unknown binary source operation ${String(sourceOperation)}.`, leftLocation)\n}\n\n/**\n * Replaces transient frontend intent with the public typed operation fields.\n * @param {object} expression - Mutable adapted expression.\n * @param {import(\"./types.js\").SemanticUnaryOperation | import(\"./types.js\").SemanticBinaryOperation} operation - Typed operation.\n * @param {import(\"./types.js\").SemanticTypeName} type - Explicit result type.\n * @returns {void}\n */\nfunction setNormalizedOperation(expression, operation, type) {\n  Reflect.set(expression, \"operation\", operation)\n  Reflect.set(expression, \"type\", type)\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"validate.js","sourceRoot":"","sources":["../../../src/semantic/validate.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {semanticFailure, unsupportedCapability, unsupportedSyntax} from \"../diagnostic.js\"\nimport {recordTypeSubstitutions, substituteValueType, typeContainsAnyVariable} from \"./generics.js\"\nimport {hasOnlyUnicodeScalars, isScalarTypeName, scalarType} from \"./scalars.js\"\nimport {adaptedOperationFor} from \"./operators.js\"\nimport {parserRangeFor} from \"./provenance.js\"\nimport {validateEffectGraph} from \"./effects.js\"\nimport {validateResourceLifetimes} from \"./lifetime.js\"\n\nconst task005Languages = new Set([\"php\", \"ruby\", \"javascript\", \"typescript\", \"java\", \"dart\"])\n\n/** @typedef {Map<string, import(\"./types.js\").RecordDeclaration>} RecordRegistry */\n/** @typedef {Map<string, import(\"./types.js\").ClassDeclaration>} ClassRegistry */\n/** @typedef {Map<string, import(\"./types.js\").ErrorDeclaration>} ErrorRegistry */\n/** @type {WeakMap<RecordRegistry, ClassRegistry>} */\nconst referenceClassesByRecordRegistry = new WeakMap()\n/** @type {WeakMap<RecordRegistry, Set<string>>} */\nconst resourceIdsByRecordRegistry = new WeakMap()\n\n/**\n * @typedef Binding\n * @property {boolean} mutable - Whether assignment is allowed.\n * @property {import(\"./types.js\").SemanticBindingType} type - Binding type.\n * @property {import(\"./types.js\").Expression | undefined} knownValue - Current statically known immutable value.\n */\n\n/**\n * @typedef Scope\n * @property {Map<string, Binding>} bindings - Bindings declared directly in this scope.\n * @property {Set<string>} pending - Names declared later in this scope.\n * @property {Set<Binding>} presenceProofs - Optional bindings proven present on this path.\n * @property {Scope | undefined} parent - Enclosing lexical scope.\n * @property {Set<string>} typeParameters - Type parameters visible throughout the enclosing declaration.\n * @property {Set<string>} usedNames - All names used by the enclosing function or entry point.\n * @property {import(\"./types.js\").ClassDeclaration | undefined} currentClass - Declaring class for receiver-private access.\n */\n\n/**\n * @typedef LoopFlowContext\n * @property {import(\"./types.js\").ForEachStatement | import(\"./types.js\").ForEachMapStatement | import(\"./types.js\").WhileStatement} [nearest] - Nearest active loop.\n * @property {object} owner - Enclosing function or entry-point identity.\n * @property {Map<string, object>} owners - Loop owner by module-local loop identity.\n */\n\n/**\n * @typedef SemanticFail\n * @type {(code: string, detail: string, location: import(\"./types.js\").SourceLocation) => never}\n */\n\n/**\n * Enforces the coherent release-candidate semantic subset after adaptation.\n * @param {import(\"./types.js\").SemanticModule} module - Adapted semantic module.\n * @param {import(\"./types.js\").SemanticLanguage} language - Source language.\n * @param {{classes?: Map<string, import(\"./types.js\").ClassDeclaration>, functions?: Map<string, import(\"./types.js\").FunctionDeclaration>, records?: Map<string, import(\"./types.js\").RecordDeclaration>, errors?: Map<string, import(\"./types.js\").ErrorDeclaration>, callEffects?: Map<string, Set<string>>}} [visible] - Program imports visible during validation.\n * @returns {import(\"./types.js\").SemanticModule} Validated module.\n */\nexport function validateParsedModule(module, language, visible = {}) {\n  normalizeParsedOwnedReferences(module, visible.classes)\n  validateModuleShape(module, language, (detail, location) => unsupportedSyntax(language, detail, location))\n  /**\n   * Converts one parser failure into a located semantic diagnostic.\n   * @type {SemanticFail}\n   */\n  const fail = (code, detail, location) => semanticFailure(language, code, detail, location)\n\n  validateModuleTypes(module, language, fail, true, visible)\n  validateResourceLifetimes(module, inferEscapingErrorEffects(module, visible.callEffects), fail)\n\n  return module\n}\n\n/**\n * Promotes parser-authored class spellings after all private field types are known.\n * @param {import(\"./types.js\").SemanticModule} module - Parser-authored module.\n * @param {Map<string, import(\"./types.js\").ClassDeclaration>} [visibleClasses] - Imported reference classes.\n * @returns {void}\n */\nfunction normalizeParsedOwnedReferences(module, visibleClasses = new Map()) {\n  const ownedClassIds = new Set([...visibleClasses.values()].filter(({ownership}) => ownership?.kind == \"ownedResource\")\n    .map(({id}) => /** @type {string} */ (id)))\n\n  for (const declaration of module.classes ?? []) {\n    const fields = declaration.fields.filter(({type}) => type?.kind == \"OwnedResourceType\")\n    if (fields.length != 1) continue\n    const field = /** @type {import(\"./types.js\").PrivateField & {type: import(\"./types.js\").OwnedResourceType}} */ (fields[0])\n\n    declaration.ownership = {fieldId: /** @type {string} */ (field.id), kind: \"ownedResource\", resourceId: field.type.resourceId}\n    ownedClassIds.add(/** @type {string} */ (declaration.id))\n  }\n  /** @type {unknown[]} */\n  const pending = [module]\n  /** @type {Set<object>} */\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) && Reflect.get(value, \"kind\") == \"ReferenceType\" &&\n      ownedClassIds.has(Reflect.get(value, \"declarationId\"))) Reflect.set(value, \"kind\", \"OwnedReferenceType\")\n    for (const [key, child] of Object.entries(value)) {\n      if ([\"location\", \"sourceProvenance\"].includes(key)) continue\n      if (child && typeof child == \"object\") pending.push(child)\n    }\n  }\n}\n\n/**\n * Validates scalar types and bindings for a caller-supplied semantic module before emission.\n * @param {import(\"./types.js\").SemanticModule} module - Semantic module.\n * @param {import(\"./types.js\").BackendLanguage} language - Backend language or binary target.\n * @param {{classes?: Map<string, import(\"./types.js\").ClassDeclaration>, functions?: Map<string, import(\"./types.js\").FunctionDeclaration>, records?: Map<string, import(\"./types.js\").RecordDeclaration>, errors?: Map<string, import(\"./types.js\").ErrorDeclaration>, callEffects?: Map<string, Set<string>>}} [visible] - Resolved program imports.\n * @returns {void}\n */\nexport function validateBackendTypes(module, language, visible = {}) {\n  /**\n   * Converts one backend validation failure into an unsupported-capability diagnostic.\n   * @type {SemanticFail}\n   */\n  const fail = (_code, detail, location) => unsupportedCapability(language, detail, location)\n\n  validateModuleTypes(module, language, fail, false, visible)\n  validateResourceLifetimes(module, inferEscapingErrorEffects(module, visible.callEffects), fail)\n}\n\n/**\n * Checks parser-authored block and statement layouts before semantic validation.\n * @param {import(\"./types.js\").SemanticModule} module - Semantic module.\n * @param {import(\"./types.js\").SemanticLanguage} language - Source language.\n * @param {(detail: string, location: import(\"./types.js\").SourceLocation) => never} fail - Shape failure.\n * @returns {void}\n */\nfunction validateModuleShape(module, language, fail) {\n  for (const declaration of module.classes ?? []) {\n    validateBlockShape(declaration.constructor?.body, \"constructor body\", fail)\n    for (const method of declaration.methods ?? []) validateBlockShape(method.body, \"method body\", fail)\n  }\n  for (const functionDeclaration of module.functions) {\n    if (!task005Languages.has(language) && functionDeclaration.parameters.length != 2) {\n      fail(\"function parameter count other than two\", functionDeclaration.location)\n    }\n\n    validateBlockShape(functionDeclaration.body, \"function body\", fail)\n  }\n\n  validateBlockShape(module.entryPoint.body, \"entry point\", fail)\n}\n\n/**\n * Checks one recursively nested semantic block produced by a frontend.\n * @param {import(\"./types.js\").Block} block - Semantic block.\n * @param {string} detail - Diagnostic detail.\n * @param {(detail: string, location: import(\"./types.js\").SourceLocation) => never} fail - Shape failure.\n * @returns {void}\n */\nfunction validateBlockShape(block, detail, fail) {\n  if (!block || block.kind != \"Block\" || !Array.isArray(block.statements)) {\n    fail(`${detail} without Block`, block?.location ?? /** @type {never} */ (undefined))\n  }\n\n  for (const statement of block.statements) {\n    if (![\"AssignmentStatement\", \"BreakStatement\", \"ContinueStatement\", \"ExpressionStatement\", \"ForEachMapStatement\", \"ForEachStatement\", \"IfStatement\", \"LocalDeclaration\", \"PrivateFieldWriteStatement\", \"PrintStatement\", \"RaiseStatement\", \"ReturnStatement\", \"TryStatement\", \"WhileStatement\"].includes(statement.kind)) {\n      fail(`${detail} statement ${statement.kind}`, statement.location)\n    }\n    if (statement.kind == \"IfStatement\") {\n      validateBlockShape(statement.consequent, \"if consequent\", fail)\n      if (statement.alternate) validateBlockShape(statement.alternate, \"if alternate\", fail)\n    }\n    if (statement.kind == \"ForEachStatement\" || statement.kind == \"ForEachMapStatement\" || statement.kind == \"WhileStatement\") {\n      validateBlockShape(statement.body, \"loop body\", fail)\n    }\n    if (statement.kind == \"TryStatement\") {\n      validateBlockShape(statement.body, \"try body\", fail)\n      validateBlockShape(statement.catchBody, \"catch body\", fail)\n    }\n  }\n}\n\n/**\n * Validates declarations and expression types within lexical scopes.\n * @param {import(\"./types.js\").SemanticModule} module - Semantic module.\n * @param {string} language - Source or backend language identity.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.\n * @param {{classes?: Map<string, import(\"./types.js\").ClassDeclaration>, functions?: Map<string, import(\"./types.js\").FunctionDeclaration>, records?: Map<string, import(\"./types.js\").RecordDeclaration>, errors?: Map<string, import(\"./types.js\").ErrorDeclaration>, callEffects?: Map<string, Set<string>>}} [visible] - Program imports visible during validation.\n * @returns {void}\n */\nfunction validateModuleTypes(module, language, fail, normalizeOperations, visible = {}) {\n  const classes = registerClassDeclarations(module.classes ?? [], fail, normalizeOperations, visible.classes)\n  const records = validateRecordDeclarations(module.records ?? [], fail, normalizeOperations, visible.records, classes)\n  const errors = validateErrorDeclarations(module.errors ?? [], fail, normalizeOperations, visible.errors)\n  /** @type {Map<string, import(\"./types.js\").FunctionDeclaration>} */\n  const functions = new Map(visible.functions ?? [])\n  const declarationIds = new Set([...functions.values()].flatMap(({id}) => typeof id == \"string\" ? [id] : []))\n\n  for (const [index, functionDeclaration] of module.functions.entries()) {\n    if (normalizeOperations) functionDeclaration.id = `function:${index}`\n    if (typeof functionDeclaration.id != \"string\" || !/^(?:[a-z][a-z0-9._-]*#)?function:[0-9]+$/u.test(functionDeclaration.id) ||\n      declarationIds.has(functionDeclaration.id)) {\n      fail(\"DUPLICATE_BINDING\", \"Duplicate or invalid function declaration identity.\", functionDeclaration.location)\n    }\n    if (functions.has(functionDeclaration.name)) {\n      fail(\"DUPLICATE_BINDING\", `duplicate function '${functionDeclaration.name}'.`, roleLocation(functionDeclaration, \"name\"))\n    }\n    declarationIds.add(functionDeclaration.id)\n    validateTypeParameters(functionDeclaration, fail, normalizeOperations)\n    functions.set(functionDeclaration.name, functionDeclaration)\n  }\n\n  validateEffectGraph(module, language, functions, fail, normalizeOperations, classes)\n  const capabilityResources = (module.capabilities ?? []).flatMap(({resources}) => resources)\n  const capabilityFailures = (module.capabilities ?? []).flatMap(({failures}) => failures)\n\n  resourceIdsByRecordRegistry.set(records, new Set(capabilityResources.map(({id}) => id)))\n  const existingErrorNames = new Set([...errors.values()].map(({name}) => name))\n  for (const failure of capabilityFailures) {\n    if (errors.has(failure.id) || existingErrorNames.has(failure.name)) {\n      fail(\"DUPLICATE_ERROR\", `Duplicate capability failure '${failure.name}'.`, module.location)\n    }\n    errors.set(failure.id, /** @type {import(\"./types.js\").ErrorDeclaration} */ (/** @type {unknown} */ (failure)))\n    existingErrorNames.add(failure.name)\n  }\n\n  const loopOwners = prepareLoopIdentities(module, normalizeOperations, fail)\n\n  const reservedValueNames = new Set([\n    ...functions.keys(),\n    ...[...records.values()].map((declaration) => declaration.name),\n    ...[...classes.values()].map((declaration) => declaration.name),\n    ...[...errors.values()].map((declaration) => declaration.name),\n    ...capabilityResources.map(({name}) => name)\n  ])\n\n  const nominalNames = new Set()\n\n  for (const declaration of [...module.records ?? [], ...module.classes ?? [], ...module.errors ?? []]) {\n    if (nominalNames.has(declaration.name)) {\n      fail(\"DUPLICATE_BINDING\", `Duplicate nominal declaration '${declaration.name}'.`, roleLocation(declaration, \"name\"))\n    }\n    nominalNames.add(declaration.name)\n  }\n  for (const declaration of [...capabilityResources, ...capabilityFailures]) {\n    if (nominalNames.has(declaration.name)) {\n      fail(\"DUPLICATE_BINDING\", `Duplicate nominal declaration '${declaration.name}'.`, module.location)\n    }\n    nominalNames.add(declaration.name)\n  }\n  const localFunctionNames = new Set(module.functions.map(({name}) => name))\n  const callEffects = inferCallEffects(functions, visible.callEffects, localFunctionNames)\n\n  for (const declaration of module.classes ?? []) {\n    validateClassDeclaration(declaration, functions, records, errors, callEffects, reservedValueNames, fail,\n      normalizeOperations, loopOwners)\n  }\n\n  for (const functionDeclaration of module.functions) {\n    validateFunction(functionDeclaration, functions, records, errors, callEffects, reservedValueNames, fail, normalizeOperations, loopOwners)\n  }\n\n  const entryScope = createScope(undefined, module.entryPoint.body.statements, reservedValueNames)\n\n  validateBlock(module.entryPoint.body, entryScope, undefined, functions, records, errors, callEffects, fail,\n    normalizeOperations, {owner: module.entryPoint, owners: loopOwners})\n  if (normalizeOperations) validateEffectGraph(module, language, functions, fail, true, classes)\n}\n\n/**\n * Assigns parser-authored loop/control identities and validates caller-owned identities without crossing a function boundary.\n * @param {import(\"./types.js\").SemanticModule} module - Semantic module.\n * @param {boolean} normalizeOperations - Whether parser-authored identities are assigned.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {Map<string, object>} Loop owner by identity.\n */\nfunction prepareLoopIdentities(module, normalizeOperations, fail) {\n  const owners = new Map()\n  let nextLoop = 0\n\n  const classOwners = (module.classes ?? []).flatMap((declaration) => [declaration.constructor, ...declaration.methods])\n\n  for (const owner of [...classOwners, ...module.functions, module.entryPoint]) visit(owner.body, owner, [])\n\n  return owners\n\n  /**\n   * Visits one block in lexical semantic order.\n   * @param {import(\"./types.js\").Block} block - Candidate block.\n   * @param {object} owner - Enclosing function or entry point.\n   * @param {(import(\"./types.js\").ForEachStatement | import(\"./types.js\").ForEachMapStatement | import(\"./types.js\").WhileStatement)[]} active - Active loops.\n   * @returns {void}\n   */\n  function visit(block, owner, active) {\n    if (!block || !Array.isArray(block.statements)) return\n    for (const statement of block.statements) {\n      if (!statement || typeof statement != \"object\") continue\n      if ([\"ForEachStatement\", \"ForEachMapStatement\", \"WhileStatement\"].includes(statement.kind)) {\n        const loop = /** @type {import(\"./types.js\").ForEachStatement | import(\"./types.js\").ForEachMapStatement | import(\"./types.js\").WhileStatement} */ (statement)\n\n        if (normalizeOperations) loop.id = `loop:${nextLoop}`\n        nextLoop += 1\n        if (typeof loop.id != \"string\" || !/^loop:[0-9]+$/u.test(loop.id) || owners.has(loop.id)) {\n          fail(\"INVALID_LOOP_TARGET\", \"Duplicate or invalid loop identity.\", loop.location)\n        }\n        owners.set(loop.id, owner)\n        visit(loop.body, owner, [...active, loop])\n      } else if (statement.kind == \"BreakStatement\" || statement.kind == \"ContinueStatement\") {\n        if (normalizeOperations && active.length > 0) statement.targetLoopId = /** @type {string} */ (active.at(-1)?.id)\n      } else if (statement.kind == \"IfStatement\") {\n        visit(statement.consequent, owner, active)\n        if (statement.alternate) visit(statement.alternate, owner, active)\n      } else if (statement.kind == \"TryStatement\") {\n        visit(statement.body, owner, active)\n        visit(statement.catchBody, owner, active)\n      }\n    }\n  }\n}\n\n/**\n * Derives validator-only unchecked-error effects for a validated module's local functions.\n * These effects never enter semantic function declarations or public signatures.\n * @param {import(\"./types.js\").SemanticModule} module - Validated semantic module.\n * @param {{functions?: Map<string, import(\"./types.js\").FunctionDeclaration>, callEffects?: Map<string, Set<string>>}} [visible] - Imported functions and already-resolved effects by local binding.\n * @returns {Map<string, Set<string>>} Local function effects by source-visible name.\n */\nexport function moduleUncheckedErrorEffects(module, visible = {}) {\n  const functions = new Map(visible.functions ?? [])\n\n  for (const declaration of module.functions) functions.set(declaration.name, declaration)\n  const localFunctionNames = new Set(module.functions.map(({name}) => name))\n  const effects = inferCallEffects(functions, visible.callEffects, localFunctionNames)\n\n  return new Map(module.functions.map((declaration) => [declaration.name, new Set(effects.get(declaration.name) ?? [])]))\n}\n\n/**\n * Assigns and validates the closed nominal identities owned by reference classes.\n * @param {unknown} declarations - Candidate declarations.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {boolean} normalizeOperations - Whether parser-authored identities are assigned.\n * @param {Map<string, import(\"./types.js\").ClassDeclaration>} [visibleClasses] - Imported classes by identity.\n * @returns {ClassRegistry} Classes by stable identity.\n */\nfunction registerClassDeclarations(declarations, fail, normalizeOperations, visibleClasses = new Map()) {\n  if (!Array.isArray(declarations)) {\n    return fail(\"TYPE_MISMATCH\", \"Reference class declarations must be an ordered array.\", /** @type {never} */ (undefined))\n  }\n  /** @type {ClassRegistry} */\n  const classes = new Map(visibleClasses)\n  const names = new Set([...visibleClasses.values()].map(({name}) => name))\n\n  for (let classIndex = 0; classIndex < declarations.length; classIndex += 1) {\n    const declaration = /** @type {import(\"./types.js\").ClassDeclaration} */ (declarations[classIndex])\n\n    if (!declaration || declaration.kind != \"ClassDeclaration\" || !Array.isArray(declaration.fields) ||\n      !Array.isArray(declaration.methods) || !declaration.constructor || declaration.constructor.kind != \"ConstructorDeclaration\") {\n      return fail(\"DUPLICATE_CLASS\", \"Malformed or invalid reference class declaration.\", declaration?.location)\n    }\n    if (declaration.fields.length == 0) {\n      fail(\"INCOMPLETE_INITIALIZATION\", \"Reference classes must declare private instance state.\", declaration.location)\n    }\n    if (normalizeOperations) declaration.id = `class:${classIndex}`\n    if (typeof declaration.id != \"string\" || !/^(?:[a-z][a-z0-9._-]*#)?class:[0-9]+$/u.test(declaration.id) ||\n      classes.has(declaration.id) || typeof declaration.name != \"string\" || declaration.name.length == 0 || names.has(declaration.name)) {\n      fail(\"DUPLICATE_CLASS\", `Duplicate or invalid reference class '${String(declaration.name)}'.`, roleLocation(declaration, \"name\"))\n    }\n    names.add(declaration.name)\n    classes.set(declaration.id, declaration)\n\n    const fieldNames = new Set()\n\n    for (let fieldIndex = 0; fieldIndex < declaration.fields.length; fieldIndex += 1) {\n      const field = declaration.fields[fieldIndex]\n      const expectedId = `${declaration.id}:field:${fieldIndex}`\n\n      if (!field || field.kind != \"PrivateField\") {\n        fail(\"DUPLICATE_PRIVATE_FIELD\", \"Malformed or invalid private field.\", field?.location ?? declaration.location)\n      }\n      if (normalizeOperations) field.id = expectedId\n      if (field.id != expectedId || typeof field.name != \"string\" || field.name.length == 0 || fieldNames.has(field.name)) {\n        fail(\"DUPLICATE_PRIVATE_FIELD\", `Duplicate or invalid private field '${String(field.name)}'.`, roleLocation(field, \"name\"))\n      }\n      fieldNames.add(field.name)\n    }\n    const invalidOwnedField = declaration.fields.find(({type}) => containsOwnedType(type) && type.kind != \"OwnedResourceType\")\n\n    if (invalidOwnedField) {\n      fail(\"RESOURCE_ALIAS\", `Class '${declaration.name}' may contain ownership only in one direct resource field.`, invalidOwnedField.location)\n    }\n    const ownedFields = declaration.fields.filter(({type}) => type?.kind == \"OwnedResourceType\")\n\n    if (ownedFields.length > 1) {\n      fail(\"RESOURCE_ALIAS\", `Class '${declaration.name}' may own exactly one direct resource field.`, declaration.location)\n    }\n    if (ownedFields.length == 1) {\n      const field = /** @type {import(\"./types.js\").PrivateField & {type: import(\"./types.js\").OwnedResourceType}} */ (ownedFields[0])\n      const expected = {fieldId: /** @type {string} */ (field.id), kind: /** @type {const} */ (\"ownedResource\"),\n        resourceId: field.type.resourceId}\n\n      if (normalizeOperations) declaration.ownership = expected\n      else if (JSON.stringify(declaration.ownership) != JSON.stringify(expected)) {\n        fail(\"RESOURCE_TYPE_MISMATCH\", `Class '${declaration.name}' has malformed resource ownership metadata.`, declaration.location)\n      }\n    } else if (declaration.ownership?.kind == \"ownedResource\") {\n      fail(\"RESOURCE_TYPE_MISMATCH\", `Class '${declaration.name}' does not contain its declared resource field.`, declaration.location)\n    }\n\n    const constructorId = `${declaration.id}:constructor`\n\n    if (normalizeOperations) declaration.constructor.id = constructorId\n    if (declaration.constructor.id != constructorId || !Array.isArray(declaration.constructor.parameters) ||\n      !declaration.constructor.body || declaration.constructor.body.kind != \"Block\") {\n      fail(\"DUPLICATE_CONSTRUCTOR\", \"Malformed or invalid constructor declaration.\", declaration.constructor.location)\n    }\n\n    const methodNames = new Set()\n\n    for (let methodIndex = 0; methodIndex < declaration.methods.length; methodIndex += 1) {\n      const method = declaration.methods[methodIndex]\n      const expectedId = `${declaration.id}:method:${methodIndex}`\n\n      if (!method || method.kind != \"MethodDeclaration\") {\n        fail(\"DUPLICATE_METHOD\", \"Malformed or invalid method declaration.\", method?.location ?? declaration.location)\n      }\n      if (normalizeOperations) method.id = expectedId\n      if (method.id != expectedId || typeof method.name != \"string\" || method.name.length == 0 || methodNames.has(method.name) ||\n        !Array.isArray(method.parameters) || !method.body || method.body.kind != \"Block\") {\n        fail(\"DUPLICATE_METHOD\", `Duplicate or invalid method '${String(method.name)}'.`, roleLocation(method, \"name\"))\n      }\n      methodNames.add(method.name)\n    }\n  }\n\n  return classes\n}\n\n/**\n * Validates exact construction, private state, and method bodies for one class.\n * @param {import(\"./types.js\").ClassDeclaration} declaration - Class declaration.\n * @param {Map<string, import(\"./types.js\").FunctionDeclaration>} functions - Function signatures.\n * @param {RecordRegistry} records - Record and reference-class registries.\n * @param {ErrorRegistry} errors - Error declarations.\n * @param {Map<string, Set<string>>} callEffects - Function call effects.\n * @param {Set<string>} reservedValueNames - Module-reserved names.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {boolean} normalizeOperations - Whether parser-authored resolutions are assigned.\n * @param {Map<string, object>} loopOwners - Loop ownership registry.\n * @returns {void}\n */\nfunction validateClassDeclaration(declaration, functions, records, errors, callEffects, reservedValueNames, fail,\n  normalizeOperations, loopOwners) {\n  for (const field of declaration.fields) {\n    validateValueTypeReference(field.type, field.location, fail, undefined, records)\n  }\n\n  const constructor = declaration.constructor\n  const acquisitionStatement = constructor.body.statements[0]\n  const acquisitionExpression = acquisitionStatement?.kind == \"PrivateFieldWriteStatement\"\n    ? acquisitionStatement.expression : undefined\n  const ownedAcquisition = declaration.ownership?.kind == \"ownedResource\" && declaration.fields.length == 1 &&\n    constructor.body.statements.length == 1 && acquisitionStatement?.kind == \"PrivateFieldWriteStatement\" &&\n    acquisitionStatement.field == declaration.ownership.fieldId && acquisitionStatement.receiver.kind == \"ReceiverExpression\" &&\n    acquisitionStatement.receiver.classId == declaration.id && acquisitionExpression?.kind == \"EffectCallExpression\" &&\n    acquisitionExpression.resolution.resourceFlow.kind == \"acquire\" &&\n    acquisitionExpression.resolution.resourceFlow.resourceId == declaration.ownership.resourceId\n\n  if (syntacticBlockEffects(constructor.body, callEffects).size > 0 && !ownedAcquisition) {\n    fail(\"UNSUPPORTED_STATEMENT\", \"Reference constructors cannot expose unchecked-error effects in Task 033.\", constructor.location)\n  }\n\n  if (!ownedAcquisition &&\n    (constructor.parameters.length != declaration.fields.length || constructor.body.statements.length != declaration.fields.length)) {\n    fail(\"INCOMPLETE_INITIALIZATION\", `Constructor for '${declaration.name}' must initialize every private field exactly once in declaration order.`,\n      constructor.location)\n  }\n  const constructorScope = createScope(undefined, constructor.body.statements, reservedValueNames, new Set(), declaration)\n\n  for (let index = 0; index < constructor.parameters.length; index += 1) {\n    const parameter = constructor.parameters[index]\n    const field = declaration.fields[index]\n    const type = validateValueTypeReference(parameter.type, parameter.location, fail, undefined, records)\n\n    if (!ownedAcquisition && !sameType(type, field.type)) {\n      fail(\"TYPE_MISMATCH\", `Constructor parameter '${parameter.name}' must exactly match private field '${field.name}'.`, parameter.location)\n    }\n    declareBinding(parameter.name, {knownValue: undefined, mutable: false, type}, roleLocation(parameter, \"name\"), constructorScope, fail)\n    if (ownedAcquisition) continue\n    const statement = constructor.body.statements[index]\n    const initializer = statement?.kind == \"PrivateFieldWriteStatement\"\n      ? statement.expression.kind == \"OwnedMoveExpression\" ? statement.expression.expression : statement.expression\n      : undefined\n\n    if (!statement || statement.kind != \"PrivateFieldWriteStatement\" || statement.field != field.id ||\n      statement.receiver?.kind != \"ReceiverExpression\" || statement.receiver.classId != declaration.id ||\n      initializer?.kind != \"IdentifierExpression\" || initializer.name != parameter.name) {\n      fail(\"INCOMPLETE_INITIALIZATION\", `Constructor for '${declaration.name}' must initialize '${field.name}' from its corresponding parameter.`,\n        statement?.location ?? constructor.location)\n    }\n  }\n  validateBlock(constructor.body, constructorScope, {kind: \"TypeReference\", name: \"void\"}, functions, records,\n    errors, callEffects, fail, normalizeOperations, {owner: constructor, owners: loopOwners})\n\n  for (const method of declaration.methods) {\n    const unsupportedMethodEffects = [...syntacticBlockEffects(method.body, callEffects)]\n      .filter((id) => !/^(?:module:[0-9]+\\/)?capability:[0-9]+\\/failure:[0-9]+$/u.test(id))\n\n    if (declaration.ownership?.kind != \"ownedResource\" && unsupportedMethodEffects.length > 0) {\n      fail(\"UNSUPPORTED_STATEMENT\", `Reference method '${method.name}' cannot expose unchecked-error effects in Task 033.`, method.location)\n    }\n    const scope = createScope(undefined, method.body.statements, reservedValueNames, new Set(), declaration)\n\n    for (const parameter of method.parameters) {\n      const type = validateValueTypeReference(parameter.type, parameter.location, fail, undefined, records)\n\n      declareBinding(parameter.name, {knownValue: undefined, mutable: false, type}, roleLocation(parameter, \"name\"), scope, fail)\n    }\n    const returnType = validateReturnTypeReference(method.returnType, method.location, fail, records)\n    const flow = validateBlock(method.body, scope, returnType, functions, records, errors, callEffects, fail,\n      normalizeOperations, {owner: method, owners: loopOwners})\n\n    if (declaration.ownership?.kind == \"ownedResource\") ownedMethodResourceFlow(declaration, method, fail)\n\n    if (!isVoidType(returnType) && flow.normal) {\n      fail(\"MISSING_RETURN\", `Method '${method.name}' does not return on every reachable path.`, method.location)\n    }\n  }\n}\n\n/**\n * Validates nominal unchecked-error declarations.\n * @param {unknown} declarations - Candidate declarations.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {boolean} normalizeOperations - Whether parser-authored identities are assigned.\n * @param {Map<string, import(\"./types.js\").ErrorDeclaration>} [visibleErrors] - Imported error declarations by identity.\n * @returns {ErrorRegistry} Validated declarations by identity.\n */\nfunction validateErrorDeclarations(declarations, fail, normalizeOperations, visibleErrors = new Map()) {\n  if (!Array.isArray(declarations)) return fail(\"TYPE_MISMATCH\", \"Error declarations must be an ordered array.\", /** @type {never} */ (undefined))\n  /** @type {ErrorRegistry} */\n  const errors = new Map(visibleErrors)\n  const names = new Set()\n\n  for (let index = 0; index < declarations.length; index += 1) {\n    const declaration = declarations[index]\n\n    if (!declaration || declaration.kind != \"ErrorDeclaration\") {\n      return fail(\"TYPE_MISMATCH\", \"Malformed error declaration.\", declaration?.location)\n    }\n    if (normalizeOperations) declaration.id = `error:${index}`\n    if (typeof declaration.id != \"string\" || !/^(?:[a-z][a-z0-9._-]*#)?error:[0-9]+$/u.test(declaration.id) || errors.has(declaration.id)) {\n      fail(\"DUPLICATE_ERROR\", \"Duplicate or invalid error declaration identity.\", declaration.location)\n    }\n    if (typeof declaration.name != \"string\" || names.has(declaration.name)) {\n      fail(\"DUPLICATE_ERROR\", `Duplicate or invalid error '${String(declaration.name)}'.`, roleLocation(declaration, \"name\"))\n    }\n    names.add(declaration.name)\n    errors.set(declaration.id, declaration)\n  }\n\n  return errors\n}\n\n/**\n * Assigns and validates one declaration's invariant unbounded type parameters.\n * @param {import(\"./types.js\").FunctionDeclaration | import(\"./types.js\").RecordDeclaration} declaration - Owning declaration.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {boolean} normalizeOperations - Whether parser-authored identities are assigned.\n * @returns {void}\n */\nfunction validateTypeParameters(declaration, fail, normalizeOperations) {\n  if (declaration.typeParameters === undefined) return\n  if (!Array.isArray(declaration.typeParameters)) {\n    fail(\"TYPE_MISMATCH\", \"Type parameters must be a dense ordered array.\", declaration.location)\n  }\n  const names = new Set()\n\n  for (let index = 0; index < declaration.typeParameters.length; index += 1) {\n    const parameter = declaration.typeParameters[index]\n    const keys = parameter && typeof parameter == \"object\" && !Array.isArray(parameter)\n      ? Object.keys(parameter).filter((key) => key != \"sourceProvenance\").sort().join(\",\") : \"\"\n\n    if (!Object.hasOwn(declaration.typeParameters, index) || !parameter || parameter.kind != \"TypeParameter\" ||\n      keys != \"id,kind,location,name\" || typeof parameter.name != \"string\" || parameter.name.length == 0) {\n      fail(\"TYPE_MISMATCH\", \"Malformed type parameter declaration.\", parameter?.location ?? declaration.location)\n    }\n    if (names.has(parameter.name)) {\n      fail(\"DUPLICATE_TYPE_PARAMETER\", `Duplicate type parameter '${parameter.name}'.`, roleLocation(parameter, \"name\"))\n    }\n    names.add(parameter.name)\n    const expectedId = `${declaration.id}:type:${index}`\n\n    if (normalizeOperations) parameter.id = expectedId\n    if (parameter.id != expectedId) {\n      fail(\"DUPLICATE_TYPE_PARAMETER\", \"Duplicate or invalid type parameter identity.\", parameter.location)\n    }\n  }\n}\n\n/**\n * Returns the closed identity scope owned by one validated declaration.\n * @param {import(\"./types.js\").FunctionDeclaration | import(\"./types.js\").RecordDeclaration} declaration - Declaration.\n * @returns {Set<string>} Type-parameter identities.\n */\nfunction declarationTypeParameterIds(declaration) {\n  return new Set((declaration.typeParameters ?? []).map(({id}) => /** @type {string} */ (id)))\n}\n\n/**\n * Validates nominal declarations and returns their stable identity registry.\n * @param {unknown} declarations - Candidate ordered declarations.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {boolean} normalizeOperations - Whether parser-authored identities are assigned.\n * @param {Map<string, import(\"./types.js\").RecordDeclaration>} [visibleRecords] - Imported record declarations by identity.\n * @param {ClassRegistry} [classes] - Module reference classes by identity.\n * @returns {RecordRegistry} Validated declarations by identity.\n */\nfunction validateRecordDeclarations(declarations, fail, normalizeOperations, visibleRecords = new Map(), classes = new Map()) {\n  if (!Array.isArray(declarations)) return fail(\"TYPE_MISMATCH\", \"Record declarations must be an ordered array.\", /** @type {never} */ (undefined))\n  /** @type {RecordRegistry} */\n  const records = new Map(visibleRecords)\n\n  referenceClassesByRecordRegistry.set(records, classes)\n  const names = new Set()\n\n  for (let recordIndex = 0; recordIndex < declarations.length; recordIndex += 1) {\n    const declaration = declarations[recordIndex]\n\n    if (!declaration || declaration.kind != \"RecordDeclaration\" || !Array.isArray(declaration.fields)) {\n      return fail(\"TYPE_MISMATCH\", \"Malformed record declaration.\", declaration?.location)\n    }\n    if (normalizeOperations) declaration.id = `record:${recordIndex}`\n    if (typeof declaration.id != \"string\" || !/^(?:[a-z][a-z0-9._-]*#)?record:[0-9]+$/u.test(declaration.id) || records.has(declaration.id)) {\n      fail(\"DUPLICATE_RECORD\", \"Duplicate or invalid record declaration identity.\", declaration.location)\n    }\n    if (names.has(declaration.name)) {\n      fail(\"DUPLICATE_RECORD\", `Duplicate record '${declaration.name}'.`, roleLocation(declaration, \"name\"))\n    }\n    names.add(declaration.name)\n    validateTypeParameters(declaration, fail, normalizeOperations)\n    records.set(declaration.id, declaration)\n  }\n\n  for (const declaration of declarations) {\n    const fieldNames = new Set()\n    const typeParameters = declarationTypeParameterIds(declaration)\n\n    for (let fieldIndex = 0; fieldIndex < declaration.fields.length; fieldIndex += 1) {\n      const field = declaration.fields[fieldIndex]\n\n      if (!field || field.kind != \"RecordField\") fail(\"TYPE_MISMATCH\", \"Malformed record field.\", field?.location ?? declaration.location)\n      if (normalizeOperations) field.id = `${declaration.id}:field:${fieldIndex}`\n      if (typeof field.id != \"string\" || field.id != `${declaration.id}:field:${fieldIndex}`) {\n        fail(\"DUPLICATE_FIELD\", \"Duplicate or invalid record field identity.\", field.location)\n      }\n      if (fieldNames.has(field.name)) fail(\"DUPLICATE_FIELD\", `Duplicate field '${field.name}'.`, roleLocation(field, \"name\"))\n      fieldNames.add(field.name)\n      if (containsOwnedType(field.type)) {\n        fail(\"RESOURCE_ALIAS\", \"Owned resources cannot be stored in immutable records.\", field.location)\n      }\n      validateValueTypeReference(field.type, field.location, fail, undefined, records, typeParameters)\n    }\n  }\n  validateDirectRecordRecursion(declarations, records, fail)\n\n  return records\n}\n\n/**\n * Rejects cycles composed solely of unmediated record fields.\n * @param {import(\"./types.js\").RecordDeclaration[]} declarations - Valid declarations.\n * @param {RecordRegistry} records - Declarations by identity.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {void}\n */\nfunction validateDirectRecordRecursion(declarations, records, fail) {\n  const complete = new Set()\n\n  /**\n   * Visits one declaration along an unmediated record path.\n   * @param {import(\"./types.js\").RecordDeclaration} declaration - Current declaration.\n   * @param {Set<string>} active - Declaration identities active on this path.\n   * @returns {void}\n   */\n  function visit(declaration, active) {\n    if (complete.has(/** @type {string} */ (declaration.id))) return\n    const next = new Set(active)\n\n    next.add(/** @type {string} */ (declaration.id))\n    for (const field of declaration.fields) {\n      if (field.type.kind != \"RecordType\") continue\n      if (next.has(field.type.declarationId)) {\n        fail(\"ILLEGAL_RECORD_RECURSION\", `Direct value-recursive field '${field.name}'.`, typeLocation(field.type, field.location))\n      }\n      const referenced = records.get(field.type.declarationId)\n\n      if (referenced) visit(referenced, next)\n    }\n    complete.add(/** @type {string} */ (declaration.id))\n  }\n\n  for (const declaration of declarations) visit(declaration, new Set())\n}\n\n/**\n * Validates one non-void function and its complete control flow.\n * @param {import(\"./types.js\").FunctionDeclaration} declaration - Function declaration.\n * @param {Map<string, import(\"./types.js\").FunctionDeclaration>} functions - Function signatures.\n * @param {RecordRegistry} records - Record declarations by identity.\n * @param {ErrorRegistry} errors - Error declarations by identity.\n * @param {Map<string, Set<string>>} callEffects - Internally inferred unchecked-error effects.\n * @param {Set<string>} reservedValueNames - Module functions and nominal constructors unavailable to lexical bindings.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.\n * @param {Map<string, object>} loopOwners - Loop owner by module-local identity.\n * @returns {void}\n */\nfunction validateFunction(declaration, functions, records, errors, callEffects, reservedValueNames, fail, normalizeOperations, loopOwners) {\n  const typeParameters = declarationTypeParameterIds(declaration)\n  const scope = createScope(undefined, declaration.body.statements, reservedValueNames, typeParameters)\n\n  for (const parameter of declaration.parameters) {\n    const type = validateValueTypeReference(parameter.type, parameter.location, fail, undefined, records, typeParameters)\n\n    declareBinding(parameter.name, {knownValue: undefined, mutable: false, type}, roleLocation(parameter, \"name\"), scope, fail)\n  }\n\n  const returnType = validateReturnTypeReference(declaration.returnType, declaration.location, fail, records, typeParameters)\n  const returns = validateBlock(declaration.body, scope, returnType, functions, records, errors, callEffects, fail,\n    normalizeOperations, {owner: declaration, owners: loopOwners})\n\n  if (!isVoidType(returnType) && returns.normal) {\n    fail(\"MISSING_RETURN\", `Function '${declaration.name}' does not return on every reachable path.`, declaration.location)\n  }\n}\n\n/**\n * Validates one ordered block and reports whether every path returns.\n * @param {import(\"./types.js\").Block} block - Semantic block.\n * @param {Scope} scope - Scope belonging to this block.\n * @param {import(\"./types.js\").SemanticFunctionReturnType | undefined} returnType - Function return type, absent for entry points.\n * @param {Map<string, import(\"./types.js\").FunctionDeclaration>} functions - Function signatures.\n * @param {RecordRegistry} records - Record declarations by identity.\n * @param {ErrorRegistry} errors - Error declarations by identity.\n * @param {Map<string, Set<string>>} callEffects - Internally inferred unchecked-error effects.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.\n * @param {LoopFlowContext} loopContext - Active loop and owner identities.\n * @returns {{normal: boolean, raises: Set<string>}} Reachable normal continuation and escaping error identities.\n */\nfunction validateBlock(block, scope, returnType, functions, records, errors, callEffects, fail, normalizeOperations, loopContext) {\n  let normal = true\n  const raises = new Set()\n\n  for (const statement of block.statements) {\n    if (!normal) fail(\"UNREACHABLE_STATEMENT\", \"Statement is unreachable.\", statement.location)\n\n    if (statement.kind == \"LocalDeclaration\") {\n      const declaredType = validateValueTypeReference(statement.type, statement.location, fail, undefined, records, scope.typeParameters)\n      statement.initializer = normalizeOwnedMove(statement.initializer, declaredType, normalizeOperations, fail)\n      const initializerType = inferValueExpressionType(\n        statement.initializer, scope, functions, records, fail, normalizeOperations, \"an initializer\", declaredType\n      )\n\n      scope.pending.delete(statement.name)\n      if (!sameType(initializerType, declaredType)) {\n        if (initializerType.kind == \"OptionalType\" && declaredType.kind != \"OptionalType\") {\n          fail(\"FAILURE_ABSENCE_CONFLATION\", \"Optional absence cannot be coerced into a value or typed failure.\", statement.initializer.location)\n        }\n        fail(\"TYPE_MISMATCH\", `Initializer type ${typeDescription(initializerType)}; expected ${typeDescription(declaredType)}.`, statement.initializer.location)\n      }\n      declareBinding(statement.name, {\n        knownValue: knownValueForExpression(statement.initializer, scope),\n        mutable: statement.mutable,\n        type: declaredType\n      }, roleLocation(statement, \"name\"), scope, fail)\n      addExpressionEffects(raises, statement.initializer, callEffects)\n      continue\n    }\n    if (statement.kind == \"AssignmentStatement\") {\n      const binding = resolveBinding(statement.target.name, statement.target.location, scope, fail)\n\n      if (binding.type.kind == \"ErrorType\") {\n        fail(\"IMMUTABLE_ASSIGNMENT\", `Cannot assign to immutable catch binding '${statement.target.name}'.`, statement.target.location)\n      }\n      if (binding.type.kind == \"OwnedResourceType\" || binding.type.kind == \"OwnedReferenceType\") {\n        fail(\"RESOURCE_ALIAS\", \"Owned resources cannot be reassigned or aliased.\", statement.location)\n      }\n      const expressionType = inferValueExpressionType(\n        statement.expression, scope, functions, records, fail, normalizeOperations, \"an assignment\", binding.type\n      )\n\n      if (!binding.mutable) {\n        fail(\"IMMUTABLE_ASSIGNMENT\", `Cannot assign to immutable binding '${statement.target.name}'.`, statement.target.location)\n      }\n      if (!sameType(expressionType, binding.type)) {\n        fail(\"TYPE_MISMATCH\", `Assignment type ${typeDescription(expressionType)}; expected ${typeDescription(binding.type)}.`, statement.expression.location)\n      }\n      binding.knownValue = knownValueForExpression(statement.expression, scope)\n      scope.presenceProofs.delete(binding)\n      addExpressionEffects(raises, statement.expression, callEffects)\n      continue\n    }\n    if (statement.kind == \"PrivateFieldWriteStatement\") {\n      const declaration = scope.currentClass\n\n      if (!declaration || !statement.receiver || statement.receiver.kind != \"ReceiverExpression\" ||\n        statement.receiver.classId != declaration.id) {\n        fail(\"ILLEGAL_PRIVATE_ACCESS\", \"Private field receiver must be the declaring class receiver.\", statement.location)\n      }\n      const field = declaration.fields.find((candidate) => candidate.id == statement.field)\n\n      if (!field) fail(\"ILLEGAL_PRIVATE_ACCESS\", \"Private field identity is not owned by the declaring class.\", statement.location)\n      statement.expression = normalizeOwnedMove(statement.expression, field.type, normalizeOperations, fail)\n      const expressionType = inferValueExpressionType(\n        statement.expression, scope, functions, records, fail, normalizeOperations, \"a private field assignment\", field.type\n      )\n\n      if (!sameType(expressionType, field.type)) {\n        fail(\"TYPE_MISMATCH\", `Private field assignment type ${typeDescription(expressionType)}; expected ${typeDescription(field.type)}.`,\n          statement.expression.location)\n      }\n      addExpressionEffects(raises, statement.expression, callEffects)\n      continue\n    }\n    if (statement.kind == \"PrintStatement\") {\n      const printedType = inferValueExpressionType(statement.expression, scope, functions, records, fail, normalizeOperations, \"a print value\")\n\n      if (printedType.kind == \"OwnedResourceType\" || printedType.kind == \"OwnedReferenceType\") {\n        fail(\"BORROW_ESCAPE\", \"Owned values cannot escape through printing or serialization.\", statement.expression.location)\n      }\n      if (printedType.kind != \"TypeReference\") {\n        fail(\"TYPE_MISMATCH\", \"Collections and records cannot be printed directly.\", statement.expression.location)\n      }\n      addExpressionEffects(raises, statement.expression, callEffects)\n      continue\n    }\n    if (statement.kind == \"ExpressionStatement\") {\n      if (!statement.expression || ![\"CallExpression\", \"EffectCallExpression\", \"MethodCallExpression\"].includes(statement.expression.kind)) {\n        fail(\"TYPE_MISMATCH\", \"Expression statement must contain a direct or receiver call.\", statement.location)\n      }\n      const expressionType = inferExpressionType(statement.expression, scope, functions, records, fail, normalizeOperations)\n\n      if (expressionType != \"void\") {\n        fail(\"TYPE_MISMATCH\", \"Expression statements may contain only void calls.\", statement.expression.location)\n      }\n      addExpressionEffects(raises, statement.expression, callEffects)\n      continue\n    }\n    if (statement.kind == \"BreakStatement\" || statement.kind == \"ContinueStatement\") {\n      const control = statement.kind == \"BreakStatement\" ? \"break\" : \"continue\"\n\n      if (!loopContext.nearest) {\n        if (typeof statement.targetLoopId == \"string\" && loopContext.owners.has(statement.targetLoopId) &&\n          loopContext.owners.get(statement.targetLoopId) !== loopContext.owner) {\n          fail(\"CROSS_FUNCTION_LOOP_TARGET\", `${control[0].toUpperCase()}${control.slice(1)} target crosses a function boundary.`, statement.location)\n        }\n        fail(`ILLEGAL_${control.toUpperCase()}_CONTEXT`, `${control[0].toUpperCase()}${control.slice(1)} statement outside a loop.`, statement.location)\n      }\n      if (typeof statement.targetLoopId != \"string\" || !loopContext.owners.has(statement.targetLoopId)) {\n        fail(\"INVALID_LOOP_TARGET\", `${control[0].toUpperCase()}${control.slice(1)} has an invalid loop target identity.`, statement.location)\n      }\n      if (loopContext.owners.get(statement.targetLoopId) !== loopContext.owner) {\n        fail(\"CROSS_FUNCTION_LOOP_TARGET\", `${control[0].toUpperCase()}${control.slice(1)} target crosses a function boundary.`, statement.location)\n      }\n      if (statement.targetLoopId != loopContext.nearest.id) {\n        fail(\"INVALID_LOOP_TARGET\", `${control[0].toUpperCase()}${control.slice(1)} must target the nearest enclosing loop.`, statement.location)\n      }\n      normal = false\n      continue\n    }\n    if (statement.kind == \"ReturnStatement\") {\n      if (!returnType) fail(\"ILLEGAL_RETURN_CONTEXT\", \"Return statement outside a function.\", statement.location)\n      if (isVoidType(returnType)) {\n        if (statement.expression) {\n          fail(\"VOID_RETURN_VALUE\", \"Void function cannot return a value.\", statement.expression.location)\n        }\n      } else {\n        if (!statement.expression) {\n          fail(\"MISSING_RETURN_VALUE\", `Function return requires a ${typeDescription(returnType)} value.`, statement.location)\n        }\n        statement.expression = normalizeOwnedMove(statement.expression, returnType, normalizeOperations, fail)\n        const actualType = inferValueExpressionType(\n          statement.expression,\n          scope,\n          functions,\n          records,\n          fail,\n          normalizeOperations,\n          \"a returned value\",\n          returnType\n        )\n\n        if (!sameType(actualType, returnType)) {\n          fail(\"TYPE_MISMATCH\", `Return type ${typeDescription(actualType)}; expected ${typeDescription(returnType)}.`, statement.expression.location)\n        }\n      }\n      if (statement.expression) addExpressionEffects(raises, statement.expression, callEffects)\n      normal = false\n      continue\n    }\n    if (statement.kind == \"IfStatement\") {\n      const conditionType = inferValueExpressionType(statement.condition, scope, functions, records, fail, normalizeOperations, \"a condition\")\n\n      if (!isScalarType(conditionType, \"boolean\")) {\n        fail(\"NON_BOOLEAN_CONDITION\", `If condition type ${typeDescription(conditionType)}; expected boolean.`, statement.condition.location)\n      }\n      const visibleBindings = bindingsVisibleFrom(scope)\n      const initialKnownValues = visibleBindings.map((binding) => binding.knownValue)\n      const consequentScope = createScope(scope, statement.consequent.statements)\n      const alternateScope = createScope(scope, statement.alternate?.statements ?? [])\n      applyPresenceNarrowing(statement.condition, scope, consequentScope, true)\n      applyPresenceNarrowing(statement.condition, scope, alternateScope, false)\n      const consequentReturns = validateBlock(statement.consequent, consequentScope, returnType, functions, records, errors, callEffects, fail, normalizeOperations, loopContext)\n      const consequentKnownValues = visibleBindings.map((binding) => binding.knownValue)\n\n      visibleBindings.forEach((binding, index) => {\n        binding.knownValue = initialKnownValues[index]\n      })\n      let alternateReturns = {normal: true, raises: new Set()}\n\n      if (statement.alternate) {\n        alternateReturns = validateBlock(statement.alternate, alternateScope, returnType, functions, records, errors, callEffects, fail, normalizeOperations, loopContext)\n      }\n      const alternateKnownValues = visibleBindings.map((binding) => binding.knownValue)\n\n      visibleBindings.forEach((binding, index) => {\n        if (!consequentReturns.normal && alternateReturns.normal) binding.knownValue = alternateKnownValues[index]\n        else if (consequentReturns.normal && !alternateReturns.normal) binding.knownValue = consequentKnownValues[index]\n        else if (consequentReturns.normal && alternateReturns.normal && consequentKnownValues[index] === alternateKnownValues[index]) {\n          binding.knownValue = consequentKnownValues[index]\n        } else binding.knownValue = undefined\n      })\n      const continuingProofs = !consequentReturns.normal && alternateReturns.normal\n        ? alternateScope.presenceProofs\n        : consequentReturns.normal && !alternateReturns.normal\n          ? consequentScope.presenceProofs\n          : consequentReturns.normal && alternateReturns.normal\n            ? new Set([...consequentScope.presenceProofs].filter((binding) => alternateScope.presenceProofs.has(binding)))\n            : new Set()\n      const visibleSet = new Set(visibleBindings)\n\n      scope.presenceProofs.clear()\n      for (const binding of continuingProofs) {\n        if (visibleSet.has(binding)) scope.presenceProofs.add(binding)\n      }\n      addExpressionEffects(raises, statement.condition, callEffects)\n      addAll(raises, consequentReturns.raises)\n      addAll(raises, alternateReturns.raises)\n      normal = consequentReturns.normal || alternateReturns.normal\n      continue\n    }\n    if (statement.kind == \"WhileStatement\") {\n      const assignedOuterBindings = outerMutableBindingsAssignedBy(statement.body, scope)\n\n      for (const binding of assignedOuterBindings) {\n        binding.knownValue = undefined\n        scope.presenceProofs.delete(binding)\n      }\n      const conditionType = inferValueExpressionType(\n        statement.condition, scope, functions, records, fail, normalizeOperations, \"a condition-controlled loop condition\"\n      )\n\n      if (!isScalarType(conditionType, \"boolean\")) {\n        fail(\"NON_BOOLEAN_CONDITION\", `While condition type ${typeDescription(conditionType)}; expected boolean.`, statement.condition.location)\n      }\n      const loopScope = createScope(scope, statement.body.statements)\n\n      applyPresenceNarrowing(statement.condition, scope, loopScope, true)\n      const bodyFlow = validateBlock(statement.body, loopScope, returnType, functions, records, errors, callEffects, fail,\n        normalizeOperations, {nearest: statement, owner: loopContext.owner, owners: loopContext.owners})\n\n      addExpressionEffects(raises, statement.condition, callEffects)\n      addAll(raises, bodyFlow.raises)\n      for (const binding of assignedOuterBindings) {\n        binding.knownValue = undefined\n        scope.presenceProofs.delete(binding)\n      }\n      continue\n    }\n    if (statement.kind == \"ForEachStatement\") {\n      const listType = inferValueExpressionType(statement.list, scope, functions, records, fail, normalizeOperations, \"an iteration collection\")\n\n      if (listType.kind != \"ListType\") {\n        fail(\"TYPE_MISMATCH\", `Iteration collection type ${typeDescription(listType)}; expected list.`, statement.list.location)\n      }\n      if (!statement.valueBinding || statement.valueBinding.kind != \"ValueBinding\") {\n        fail(\"TYPE_MISMATCH\", \"Iteration requires one typed value binding.\", statement.location)\n      }\n      if (statement.valueBinding.mutable !== false) {\n        fail(\"TYPE_MISMATCH\", \"Iteration binding must be immutable.\", statement.valueBinding.location ?? statement.location)\n      }\n      const bindingType = validateValueTypeReference(statement.valueBinding.type, statement.valueBinding.location, fail, undefined, records, scope.typeParameters)\n\n      if (!sameType(bindingType, listType.elementType)) {\n        fail(\"TYPE_MISMATCH\", `Iteration binding type ${typeDescription(bindingType)}; expected ${typeDescription(listType.elementType)}.`,\n          typeLocation(statement.valueBinding.type, statement.valueBinding.location))\n      }\n      const assignedOuterBindings = outerMutableBindingsAssignedBy(statement.body, scope)\n\n      for (const binding of assignedOuterBindings) {\n        binding.knownValue = undefined\n        scope.presenceProofs.delete(binding)\n      }\n      const loopScope = createScope(scope, statement.body.statements)\n\n      declareBinding(statement.valueBinding.name, {\n        knownValue: undefined,\n        mutable: false,\n        type: bindingType\n      }, roleLocation(statement.valueBinding, \"name\"), loopScope, fail)\n      const bodyFlow = validateBlock(statement.body, loopScope, returnType, functions, records, errors, callEffects, fail,\n        normalizeOperations, {nearest: statement, owner: loopContext.owner, owners: loopContext.owners})\n      addExpressionEffects(raises, statement.list, callEffects)\n      addAll(raises, bodyFlow.raises)\n      for (const binding of assignedOuterBindings) {\n        binding.knownValue = undefined\n        scope.presenceProofs.delete(binding)\n      }\n      continue\n    }\n    if (statement.kind == \"ForEachMapStatement\") {\n      const mapType = inferValueExpressionType(statement.map, scope, functions, records, fail, normalizeOperations,\n        \"a map iteration collection\")\n\n      if (mapType.kind != \"OrderedMapType\") {\n        fail(\"TYPE_MISMATCH\", `Map iteration collection type ${typeDescription(mapType)}; expected ordered map.`, statement.map.location)\n      }\n      if (!statement.keyBinding || statement.keyBinding.kind != \"ValueBinding\" ||\n        !statement.valueBinding || statement.valueBinding.kind != \"ValueBinding\") {\n        fail(\"TYPE_MISMATCH\", \"Map iteration requires exact key and value bindings.\", statement.location)\n      }\n      if (statement.keyBinding.mutable !== false || statement.valueBinding.mutable !== false) {\n        fail(\"TYPE_MISMATCH\", \"Map iteration bindings must be immutable.\",\n          statement.keyBinding.mutable !== false ? statement.keyBinding.location : statement.valueBinding.location)\n      }\n      const keyType = validateValueTypeReference(statement.keyBinding.type, statement.keyBinding.location, fail,\n        undefined, records, scope.typeParameters)\n      const valueType = validateValueTypeReference(statement.valueBinding.type, statement.valueBinding.location, fail,\n        undefined, records, scope.typeParameters)\n\n      if (!sameType(keyType, mapType.keyType)) {\n        fail(\"TYPE_MISMATCH\", `Map iteration key binding type ${typeDescription(keyType)}; expected ${typeDescription(mapType.keyType)}.`,\n          typeLocation(statement.keyBinding.type, statement.keyBinding.location))\n      }\n      if (!sameType(valueType, mapType.valueType)) {\n        fail(\"TYPE_MISMATCH\", `Map iteration value binding type ${typeDescription(valueType)}; expected ${typeDescription(mapType.valueType)}.`,\n          typeLocation(statement.valueBinding.type, statement.valueBinding.location))\n      }\n      const assignedOuterBindings = outerMutableBindingsAssignedBy(statement.body, scope)\n\n      for (const binding of assignedOuterBindings) {\n        binding.knownValue = undefined\n        scope.presenceProofs.delete(binding)\n      }\n      const loopScope = createScope(scope, statement.body.statements)\n\n      declareBinding(statement.keyBinding.name, {knownValue: undefined, mutable: false, type: keyType},\n        roleLocation(statement.keyBinding, \"name\"), loopScope, fail)\n      declareBinding(statement.valueBinding.name, {knownValue: undefined, mutable: false, type: valueType},\n        roleLocation(statement.valueBinding, \"name\"), loopScope, fail)\n      const bodyFlow = validateBlock(statement.body, loopScope, returnType, functions, records, errors, callEffects,\n        fail, normalizeOperations, {nearest: statement, owner: loopContext.owner, owners: loopContext.owners})\n\n      addExpressionEffects(raises, statement.map, callEffects)\n      addAll(raises, bodyFlow.raises)\n      for (const binding of assignedOuterBindings) {\n        binding.knownValue = undefined\n        scope.presenceProofs.delete(binding)\n      }\n      continue\n    }\n    if (statement.kind == \"RaiseStatement\") {\n      if (!statement.error || statement.error.kind != \"ErrorConstruction\") {\n        fail(\"NON_ERROR_RAISE\", \"Raise requires one constructed semantic error.\", statement.location)\n      }\n      const raisedType = validateErrorType(statement.error.error, statement.error.location, errors, fail)\n      const messageType = inferValueExpressionType(\n        statement.error.message, scope, functions, records, fail, normalizeOperations, \"an error message\", scalarType(\"string\")\n      )\n\n      if (!isScalarType(messageType, \"string\")) {\n        fail(\"NON_ERROR_RAISE\", `Error message type ${typeDescription(messageType)}; expected string.`, statement.error.message.location)\n      }\n      addExpressionEffects(raises, statement.error.message, callEffects)\n      raises.add(raisedType.declarationId)\n      normal = false\n      continue\n    }\n    if (statement.kind == \"TryStatement\") {\n      const caughtType = validateErrorType(statement.catchType, statement.location, errors, fail)\n\n      if (!statement.catchBinding || statement.catchBinding.kind != \"CatchBinding\" || statement.catchBinding.mutable !== false) {\n        fail(\"INVALID_ERROR_HANDLER\", \"Catch requires one immutable typed binding.\", statement.catchBinding?.location ?? statement.location)\n      }\n      const bindingType = validateErrorType(statement.catchBinding.type, statement.catchBinding.location, errors, fail)\n\n      if (bindingType.declarationId != caughtType.declarationId) {\n        fail(\"INVALID_ERROR_HANDLER\", \"Catch binding type must exactly match its handler type.\", statement.catchBinding.location)\n      }\n      const bodyAssignedOuterBindings = outerMutableBindingsAssignedBy(statement.body, scope)\n      const assignedOuterBindings = new Set(bodyAssignedOuterBindings)\n\n      outerMutableBindingsAssignedBy(statement.catchBody, scope, assignedOuterBindings)\n      const bodyScope = createScope(scope, statement.body.statements)\n      const bodyFlow = validateBlock(statement.body, bodyScope, returnType, functions, records, errors, callEffects, fail, normalizeOperations, loopContext)\n      const catchScope = createScope(scope, statement.catchBody.statements)\n\n      for (const binding of bodyAssignedOuterBindings) {\n        binding.knownValue = undefined\n        catchScope.presenceProofs.delete(binding)\n      }\n\n      declareBinding(statement.catchBinding.name, {\n        knownValue: undefined,\n        mutable: false,\n        type: bindingType\n      }, roleLocation(statement.catchBinding, \"name\"), catchScope, fail)\n      const catchFlow = validateBlock(statement.catchBody, catchScope, returnType, functions, records, errors, callEffects, fail, normalizeOperations, loopContext)\n\n      if (!bodyFlow.raises.has(caughtType.declarationId)) {\n        fail(\"UNREACHABLE_HANDLER\", `Handler for '${errors.get(caughtType.declarationId)?.name}' cannot be reached.`, typeLocation(statement.catchType, statement.location))\n      }\n      bodyFlow.raises.delete(caughtType.declarationId)\n      addAll(raises, bodyFlow.raises)\n      addAll(raises, catchFlow.raises)\n      normal = bodyFlow.normal || catchFlow.normal\n      for (const binding of assignedOuterBindings) {\n        binding.knownValue = undefined\n        scope.presenceProofs.delete(binding)\n      }\n      continue\n    }\n\n    const unexpected = /** @type {{kind: string, location: import(\"./types.js\").SourceLocation}} */ (statement)\n\n    fail(\"UNSUPPORTED_STATEMENT\", unexpected.kind, unexpected.location)\n  }\n\n  return {normal, raises}\n}\n\n/**\n * Validates one exact nominal error type.\n * @param {unknown} type - Candidate type.\n * @param {import(\"./types.js\").SourceLocation} location - Owning location.\n * @param {ErrorRegistry} errors - Visible error declarations.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {import(\"./types.js\").ErrorType} Validated type.\n */\nfunction validateErrorType(type, location, errors, fail) {\n  if (!type || typeof type != \"object\" || Array.isArray(type)) {\n    return fail(\"UNKNOWN_ERROR\", \"Handler or raise is missing an exact error type.\", location)\n  }\n  const candidate = /** @type {import(\"./types.js\").ErrorType} */ (type)\n\n  if (candidate.kind != \"ErrorType\" ||\n    Object.keys(candidate).filter((key) => key != \"sourceProvenance\").sort().join(\",\") != \"declarationId,kind\" ||\n    typeof candidate.declarationId != \"string\" || !errors.has(candidate.declarationId)) {\n    fail(\"UNKNOWN_ERROR\", `Unknown error declaration '${String(candidate.declarationId)}'.`, typeLocation(candidate, location))\n  }\n\n  return candidate\n}\n\n/**\n * Adds every source value to one set.\n * @param {Set<string>} target - Destination identities.\n * @param {Set<string>} source - Source identities.\n * @returns {void}\n */\nfunction addAll(target, source) {\n  for (const value of source) target.add(value)\n}\n\n/**\n * Adds unchecked errors raised while evaluating one expression.\n * @param {Set<string>} target - Destination identities.\n * @param {unknown} expression - Candidate semantic expression.\n * @param {Map<string, Set<string>>} callEffects - Inferred call effects.\n * @param {Map<string, Set<string>>} [methodEffects] - Inferred effects by resolved method identity.\n * @returns {void}\n */\nfunction addExpressionEffects(target, expression, callEffects, methodEffects = new Map()) {\n  const pending = [expression]\n  const seen = new Set()\n\n  while (pending.length > 0) {\n    const value = pending.pop()\n\n    if (!value || typeof value != \"object\" || seen.has(value)) continue\n    seen.add(value)\n    if (Reflect.get(value, \"kind\") == \"CallExpression\") addAll(target, callEffects.get(Reflect.get(value, \"callee\")) ?? new Set())\n    if (Reflect.get(value, \"kind\") == \"MethodCallExpression\" || Reflect.get(value, \"kind\") == \"ReferenceConstruction\") {\n      const failures = Reflect.get(value, \"failureIds\")\n      if (Array.isArray(failures)) for (const failure of failures) if (typeof failure == \"string\") target.add(failure)\n      if (Reflect.get(value, \"kind\") == \"MethodCallExpression\") {\n        addAll(target, methodEffects.get(Reflect.get(value, \"method\")) ?? new Set())\n      }\n    }\n    if (Reflect.get(value, \"kind\") == \"EffectCallExpression\") {\n      const resolution = Reflect.get(value, \"resolution\")\n      const failures = resolution && typeof resolution == \"object\" ? Reflect.get(resolution, \"failureIds\") : undefined\n\n      if (Array.isArray(failures)) for (const failure of failures) if (typeof failure == \"string\") target.add(failure)\n    }\n    for (const [key, child] of Object.entries(value)) {\n      if ([\"location\", \"sourceProvenance\", \"resolution\"].includes(key)) continue\n      if (Array.isArray(child)) pending.push(...child)\n      else if (child && typeof child == \"object\") pending.push(child)\n    }\n  }\n}\n\n/**\n * Derives unchecked-error propagation over the resolved finite function graph.\n * This is validator state, never a checked effect in the public function signature.\n * @param {Map<string, import(\"./types.js\").FunctionDeclaration>} functions - Resolved functions.\n * @param {Map<string, Set<string>>} [seedEffects] - Dependency effects keyed by local import name.\n * @param {Set<string>} [localFunctionNames] - Functions whose bodies belong to the current module.\n * @returns {Map<string, Set<string>>} Escaping error identities by source-visible function name.\n */\nfunction inferCallEffects(functions, seedEffects = new Map(), localFunctionNames = new Set(functions.keys())) {\n  const effects = new Map([...functions.keys()].map((name) => [name, new Set(seedEffects.get(name) ?? [])]))\n  let changed = true\n\n  while (changed) {\n    changed = false\n    for (const name of localFunctionNames) {\n      const declaration = functions.get(name)\n\n      if (!declaration) continue\n      const next = syntacticBlockEffects(declaration.body, effects)\n      const current = /** @type {Set<string>} */ (effects.get(name))\n\n      for (const error of next) {\n        if (!current.has(error)) {\n          current.add(error)\n          changed = true\n        }\n      }\n    }\n  }\n\n  return effects\n}\n\n/**\n * Computes escaping identities from one block for the call-effect fixed point.\n * @param {unknown} block - Candidate block.\n * @param {Map<string, Set<string>>} callEffects - Current fixed-point state.\n * @param {Map<string, Set<string>>} [methodEffects] - Current method fixed-point state.\n * @returns {Set<string>} Escaping identities.\n */\nfunction syntacticBlockEffects(block, callEffects, methodEffects = new Map()) {\n  const result = new Set()\n  const statements = Reflect.get(/** @type {object} */ (block ?? {}), \"statements\")\n\n  if (!Array.isArray(statements)) return result\n  for (const statement of statements) {\n    if (!statement || typeof statement != \"object\") continue\n    const kind = Reflect.get(statement, \"kind\")\n\n    if (kind == \"RaiseStatement\") {\n      const construction = Reflect.get(statement, \"error\")\n      const type = construction && typeof construction == \"object\" ? Reflect.get(construction, \"error\") : undefined\n      const declarationId = type && typeof type == \"object\" ? Reflect.get(type, \"declarationId\") : undefined\n\n      if (typeof declarationId == \"string\") result.add(declarationId)\n      if (construction && typeof construction == \"object\") {\n        addExpressionEffects(result, Reflect.get(construction, \"message\"), callEffects, methodEffects)\n      }\n      continue\n    }\n    if (kind == \"TryStatement\") {\n      const bodyEffects = syntacticBlockEffects(Reflect.get(statement, \"body\"), callEffects, methodEffects)\n      const catchType = Reflect.get(statement, \"catchType\")\n      const caughtId = catchType && typeof catchType == \"object\" ? Reflect.get(catchType, \"declarationId\") : undefined\n\n      if (typeof caughtId == \"string\" && bodyEffects.delete(caughtId)) {\n        addAll(bodyEffects, syntacticBlockEffects(Reflect.get(statement, \"catchBody\"), callEffects, methodEffects))\n      }\n      addAll(result, bodyEffects)\n      continue\n    }\n    if (kind == \"IfStatement\") {\n      addExpressionEffects(result, Reflect.get(statement, \"condition\"), callEffects, methodEffects)\n      addAll(result, syntacticBlockEffects(Reflect.get(statement, \"consequent\"), callEffects, methodEffects))\n      addAll(result, syntacticBlockEffects(Reflect.get(statement, \"alternate\"), callEffects, methodEffects))\n      continue\n    }\n    if (kind == \"ForEachStatement\" || kind == \"ForEachMapStatement\") {\n      addExpressionEffects(result, Reflect.get(statement, kind == \"ForEachStatement\" ? \"list\" : \"map\"), callEffects,\n        methodEffects)\n      addAll(result, syntacticBlockEffects(Reflect.get(statement, \"body\"), callEffects, methodEffects))\n      continue\n    }\n    if (kind == \"WhileStatement\") {\n      addExpressionEffects(result, Reflect.get(statement, \"condition\"), callEffects, methodEffects)\n      addAll(result, syntacticBlockEffects(Reflect.get(statement, \"body\"), callEffects, methodEffects))\n      continue\n    }\n    for (const key of [\"expression\", \"initializer\"]) {\n      addExpressionEffects(result, Reflect.get(statement, key), callEffects, methodEffects)\n    }\n  }\n\n  return result\n}\n\n/**\n * Derives the escaping user-defined error sets for local functions and resolved class methods.\n * The fixed point is computed over every unchecked error; capability failures are projected out\n * because call sites already carry their capability-failure boundary through resolution metadata.\n * @param {import(\"./types.js\").SemanticModule} module - Resolved module.\n * @param {Map<string, Set<string>>} [seedEffects] - Dependency effects keyed by local import name.\n * @returns {{functions: Map<string, Set<string>>, methods: Map<string, Set<string>>}} Escaping user-defined error identities by function name and method identity.\n */\nexport function inferEscapingErrorEffects(module, seedEffects = new Map()) {\n  const functions = new Map(module.functions.map((declaration) => [declaration.name, declaration]))\n  const functionEffects = new Map([...functions.keys()].map((name) => [name, new Set(seedEffects.get(name) ?? [])]))\n  const classes = module.classes ?? []\n  const methodEffects = new Map()\n  const capabilityFailureIds = new Set((module.capabilities ?? []).flatMap(({failures}) => failures).map(({id}) => id))\n\n  for (const declaration of classes) for (const method of declaration.methods) methodEffects.set(method.id, new Set())\n  let changed = true\n\n  while (changed) {\n    changed = false\n    for (const declaration of module.functions) {\n      const current = /** @type {Set<string>} */ (functionEffects.get(declaration.name))\n      for (const error of syntacticBlockEffects(declaration.body, functionEffects, methodEffects)) {\n        if (!current.has(error)) { current.add(error); changed = true }\n      }\n    }\n    for (const declaration of classes) {\n      for (const method of declaration.methods) {\n        const current = /** @type {Set<string>} */ (methodEffects.get(method.id))\n        for (const error of syntacticBlockEffects(method.body, functionEffects, methodEffects)) {\n          if (!current.has(error)) { current.add(error); changed = true }\n        }\n      }\n    }\n  }\n\n  for (const effects of [functionEffects, methodEffects]) {\n    for (const errors of effects.values()) {\n      for (const error of [...errors]) if (capabilityFailureIds.has(error)) errors.delete(error)\n    }\n  }\n\n  return {functions: functionEffects, methods: methodEffects}\n}\n\n/**\n * Creates a lexical scope with declarations marked pending until visited.\n * @param {Scope | undefined} parent - Enclosing scope.\n * @param {{kind: string, name?: string}[]} statements - Scope statements.\n * @param {Set<string>} [reservedNames] - Names unavailable to root bindings.\n * @param {Set<string>} [typeParameters] - Declaration-scoped type parameters.\n * @param {import(\"./types.js\").ClassDeclaration} [currentClass] - Declaring class for receiver-private access.\n * @returns {Scope} Scope.\n */\nfunction createScope(parent, statements, reservedNames = new Set(), typeParameters = parent?.typeParameters ?? new Set(),\n  currentClass = parent?.currentClass) {\n  const pending = new Set(statements.filter((statement) => statement.kind == \"LocalDeclaration\")\n    .map((statement) => /** @type {{name: string}} */ (statement).name))\n\n  return {\n    bindings: new Map(),\n    currentClass,\n    parent,\n    pending,\n    presenceProofs: new Set(parent?.presenceProofs ?? []),\n    typeParameters,\n    usedNames: parent?.usedNames ?? new Set(reservedNames)\n  }\n}\n\n/**\n * Applies a simple-identifier presence proof to exactly the branch where the test is true.\n * @param {import(\"./types.js\").Expression} condition - Validated branch condition.\n * @param {Scope} sourceScope - Scope containing the tested binding.\n * @param {Scope} branchScope - Branch-local proof scope.\n * @param {boolean} branchWhenTrue - Whether this is the condition's true branch.\n * @returns {void}\n */\nfunction applyPresenceNarrowing(condition, sourceScope, branchScope, branchWhenTrue) {\n  let test = condition\n  let presentWhenTrue = true\n\n  if (condition.kind == \"UnaryExpression\" && condition.operation == \"BooleanNot\" &&\n    condition.operand.kind == \"OptionalIsPresent\") {\n    test = condition.operand\n    presentWhenTrue = false\n  }\n  if (test.kind != \"OptionalIsPresent\") return\n  const binding = findBinding(test.operand.name, sourceScope)\n\n  if (!binding) return\n  if (branchWhenTrue == presentWhenTrue) branchScope.presenceProofs.add(binding)\n  else branchScope.presenceProofs.delete(binding)\n}\n\n/**\n * Adds one binding while rejecting duplicates and shadowing.\n * @param {string} name - Binding name.\n * @param {Binding} binding - Binding metadata.\n * @param {import(\"./types.js\").SourceLocation} location - Declaration location.\n * @param {Scope} scope - Current scope.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {void}\n */\nfunction declareBinding(name, binding, location, scope, fail) {\n  if (scope.usedNames.has(name)) fail(\"DUPLICATE_BINDING\", `Duplicate or shadowed binding '${name}'.`, location)\n\n  scope.bindings.set(name, binding)\n  scope.usedNames.add(name)\n}\n\n/**\n * Resolves one identifier and distinguishes use-before-declaration.\n * @param {string} name - Binding name.\n * @param {import(\"./types.js\").SourceLocation} location - Reference location.\n * @param {Scope} scope - Current scope.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {Binding} Binding.\n */\nfunction resolveBinding(name, location, scope, fail) {\n  for (let current = /** @type {Scope | undefined} */ (scope); current; current = current.parent) {\n    const binding = current.bindings.get(name)\n\n    if (binding) return binding\n    if (current.pending.has(name)) {\n      return fail(\"USE_BEFORE_DECLARATION\", `Binding '${name}' is used before its declaration.`, location)\n    }\n  }\n\n  return fail(\"UNRESOLVED_BINDING\", `Unknown binding '${name}'.`, location)\n}\n\n/**\n * Validates one semantic value type reference.\n * @param {unknown} type - Candidate semantic type reference.\n * @param {import(\"./types.js\").SourceLocation} location - Owning source location.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {Set<object>} [seen] - Active recursive type path.\n * @param {RecordRegistry} [records] - Record declarations by identity.\n * @param {Set<string>} [typeParameters] - Type-variable identities in declaration scope.\n * @returns {import(\"./types.js\").SemanticValueType} Validated value type.\n */\nfunction validateValueTypeReference(type, location, fail, seen, records = new Map(), typeParameters = new Set()) {\n  const candidate = validateTypeReference(type, location, fail, seen, records, typeParameters)\n\n  if (isVoidType(candidate)) return fail(\"VOID_AS_VALUE\", \"Void is valid only as a function return type.\", typeLocation(type, location))\n\n  return candidate\n}\n\n/**\n * Validates one function return type reference.\n * @param {unknown} type - Candidate semantic return type reference.\n * @param {import(\"./types.js\").SourceLocation} location - Owning source location.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {RecordRegistry} [records] - Record declarations by identity.\n * @param {Set<string>} [typeParameters] - Type-variable identities in declaration scope.\n * @returns {import(\"./types.js\").SemanticFunctionReturnType} Validated return type.\n */\nfunction validateReturnTypeReference(type, location, fail, records = new Map(), typeParameters = new Set()) {\n  return validateTypeReference(type, location, fail, new Set(), records, typeParameters)\n}\n\n/**\n * Validates one recursive semantic type-reference shape.\n * @param {unknown} type - Candidate semantic type reference.\n * @param {import(\"./types.js\").SourceLocation} location - Owning source location.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {Set<object>} [seen] - Active recursive type path.\n * @param {RecordRegistry} [records] - Record declarations by identity.\n * @param {Set<string>} [typeParameters] - Type-variable identities in declaration scope.\n * @returns {import(\"./types.js\").SemanticFunctionReturnType} Validated type.\n */\nfunction validateTypeReference(type, location, fail, seen = new Set(), records = new Map(), typeParameters = new Set()) {\n  if (!type || typeof type != \"object\" || Array.isArray(type)) {\n    return fail(\"TYPE_MISMATCH\", \"Unsupported semantic type.\", location)\n  }\n\n  const candidate = /** @type {import(\"./types.js\").SemanticFunctionReturnType} */ (type)\n\n  if ([\"ListType\", \"MapType\", \"OptionalType\", \"OrderedMapType\", \"RecordType\"].includes(candidate.kind) &&\n    containsOwnedType(candidate)) {\n    fail(\"RESOURCE_ALIAS\", \"Owned resources and references cannot be nested in value or generic types.\", typeLocation(candidate, location))\n  }\n\n  if (candidate.kind == \"TypeReference\") {\n    if (!isScalarTypeName(candidate.name) && candidate.name != \"void\") {\n      fail(\"TYPE_MISMATCH\", \"Unsupported scalar or void return type.\", typeLocation(candidate, location))\n    }\n\n    return candidate\n  }\n  if (candidate.kind == \"TypeVariableReference\") {\n    if (Object.keys(candidate).filter((key) => key != \"sourceProvenance\").sort().join(\",\") != \"kind,location,parameterId\" ||\n      typeof candidate.parameterId != \"string\" || !typeParameters.has(candidate.parameterId)) {\n      fail(\"FREE_TYPE_VARIABLE\", `Free or unknown type variable '${String(candidate.parameterId)}'.`, typeLocation(candidate, location))\n    }\n\n    return candidate\n  }\n  if (candidate.kind == \"RecordType\") {\n    const keys = Object.keys(candidate).filter((key) => key != \"sourceProvenance\").sort().join(\",\")\n    const declaration = records.get(candidate.declarationId)\n\n    if (!([\"arguments,declarationId,kind\", \"declarationId,kind\"].includes(keys)) ||\n      typeof candidate.declarationId != \"string\" || !declaration) {\n      fail(\"UNKNOWN_RECORD\", `Unknown record declaration '${String(candidate.declarationId)}'.`, typeLocation(candidate, location))\n    }\n    const expectedArity = declaration.typeParameters?.length ?? 0\n\n    if (expectedArity > 0 && candidate.arguments === undefined) {\n      fail(\"RAW_GENERIC_APPLICATION\", `Generic record '${declaration.name}' requires ${expectedArity} type arguments.`, typeLocation(candidate, location))\n    }\n    if (expectedArity == 0 && candidate.arguments !== undefined) {\n      fail(\"GENERIC_ARITY_MISMATCH\", `Non-generic record '${declaration.name}' does not accept type arguments.`, typeLocation(candidate, location))\n    }\n    const candidateArguments = candidate.arguments\n\n    if (candidateArguments !== undefined && (!Array.isArray(candidateArguments) ||\n      candidateArguments.some((_argument, index) => !Object.hasOwn(candidateArguments, index)))) {\n      fail(\"TYPE_MISMATCH\", \"Generic record arguments must be a dense ordered array.\", typeLocation(candidate, location))\n    }\n    const arguments_ = candidate.arguments ?? []\n\n    if (arguments_.length != expectedArity) {\n      fail(\"GENERIC_ARITY_MISMATCH\", `Record '${declaration.name}' has ${arguments_.length} type arguments; expected ${expectedArity}.`, typeLocation(candidate, location))\n    }\n    if (seen.has(candidate)) {\n      return fail(\"TYPE_MISMATCH\", \"Recursive generic applications cannot contain cycles.\", typeLocation(candidate, location))\n    }\n    seen.add(candidate)\n    for (const argument of arguments_) {\n      validateValueTypeReference(argument, typeLocation(argument, location), fail, seen, records, typeParameters)\n    }\n    seen.delete(candidate)\n\n    return candidate\n  }\n  if (candidate.kind == \"ReferenceType\") {\n    const classes = referenceClassesFor(records)\n\n    if (Object.keys(candidate).filter((key) => key != \"sourceProvenance\").sort().join(\",\") != \"declarationId,kind\" ||\n      typeof candidate.declarationId != \"string\" || !classes.has(candidate.declarationId)) {\n      fail(\"UNKNOWN_CLASS\", `Unknown reference class declaration '${String(candidate.declarationId)}'.`, typeLocation(candidate, location))\n    }\n\n    return candidate\n  }\n  if (candidate.kind == \"OwnedResourceType\") {\n    if (Object.keys(candidate).filter((key) => key != \"sourceProvenance\").sort().join(\",\") != \"kind,resourceId\" ||\n      typeof candidate.resourceId != \"string\" || !resourceIdsByRecordRegistry.get(records)?.has(candidate.resourceId)) {\n      fail(\"RESOURCE_TYPE_MISMATCH\", `Unknown owned resource '${String(candidate.resourceId)}'.`, typeLocation(candidate, location))\n    }\n    return candidate\n  }\n  if (candidate.kind == \"OwnedReferenceType\") {\n    const classes = referenceClassesFor(records)\n\n    if (Object.keys(candidate).filter((key) => key != \"sourceProvenance\").sort().join(\",\") != \"declarationId,kind\" ||\n      typeof candidate.declarationId != \"string\" || classes.get(candidate.declarationId)?.ownership?.kind != \"ownedResource\") {\n      fail(\"RESOURCE_TYPE_MISMATCH\", `Unknown owned reference '${String(candidate.declarationId)}'.`, typeLocation(candidate, location))\n    }\n    return candidate\n  }\n  if (candidate.kind == \"ListType\") {\n    if (seen.has(candidate)) return fail(\"TYPE_MISMATCH\", \"Recursive collection types cannot contain cycles.\", typeLocation(candidate, location))\n    seen.add(candidate)\n    const elementType = validateValueTypeReference(candidate.elementType, typeLocation(candidate, location, \"elementType\"), fail, seen, records, typeParameters)\n\n    seen.delete(candidate)\n\n    if (candidate.elementType !== elementType) candidate.elementType = elementType\n\n    return candidate\n  }\n  if (candidate.kind == \"MapType\" || candidate.kind == \"OrderedMapType\") {\n    const expectedFields = candidate.kind == \"OrderedMapType\" ? \"keyType,kind,order,valueType\" : \"keyType,kind,valueType\"\n\n    if (Object.keys(candidate).filter((key) => key != \"sourceProvenance\").sort().join(\",\") != expectedFields) {\n      return fail(\"TYPE_MISMATCH\", `Malformed ${candidate.kind == \"OrderedMapType\" ? \"ordered map\" : \"map\"} type.`,\n        typeLocation(candidate, location))\n    }\n    if (candidate.kind == \"OrderedMapType\" && candidate.order != \"insertion\") {\n      return fail(\"TYPE_MISMATCH\", \"Ordered map type requires insertion order.\", typeLocation(candidate, location))\n    }\n    if (seen.has(candidate)) return fail(\"TYPE_MISMATCH\", \"Recursive collection types cannot contain cycles.\", typeLocation(candidate, location))\n    seen.add(candidate)\n    const keyType = validateValueTypeReference(candidate.keyType, typeLocation(candidate, location, \"keyType\"), fail, seen, records, typeParameters)\n\n    if (!isScalarType(keyType, \"string\")) {\n      fail(\"TYPE_MISMATCH\", `Map key type ${typeDescription(keyType)}; expected string.`, typeLocation(candidate.keyType, location))\n    }\n    const valueType = validateValueTypeReference(candidate.valueType, typeLocation(candidate, location, \"valueType\"), fail, seen, records, typeParameters)\n\n    seen.delete(candidate)\n\n    if (candidate.keyType !== keyType) candidate.keyType = /** @type {import(\"./types.js\").TypeReference} */ (keyType)\n    if (candidate.valueType !== valueType) candidate.valueType = valueType\n\n    return candidate\n  }\n  if (candidate.kind == \"OptionalType\") {\n    if (Object.keys(candidate).filter((key) => key != \"sourceProvenance\").sort().join(\",\") != \"kind,valueType\") {\n      return fail(\"TYPE_MISMATCH\", \"Malformed optional type.\", typeLocation(candidate, location))\n    }\n    if (seen.has(candidate)) return fail(\"TYPE_MISMATCH\", \"Recursive optional types cannot contain cycles.\", typeLocation(candidate, location))\n    seen.add(candidate)\n    const valueType = validateValueTypeReference(candidate.valueType, typeLocation(candidate, location, \"valueType\"), fail, seen, records, typeParameters)\n\n    seen.delete(candidate)\n    if (valueType.kind == \"OptionalType\") {\n      fail(\"INVALID_OPTIONAL_CONSTITUENT\", \"Optional values cannot directly contain another optional.\", typeLocation(candidate, location, \"valueType\"))\n    }\n    if (candidate.valueType !== valueType) candidate.valueType = valueType\n\n    return candidate\n  }\n\n  return fail(\"TYPE_MISMATCH\", \"Unsupported semantic type.\", typeLocation(candidate, location))\n}\n\n/**\n * Retrieves the reference-class registry attached to the record validation context.\n * @param {RecordRegistry} records - Record validation registry.\n * @returns {ClassRegistry} Reference classes.\n */\nfunction referenceClassesFor(records) {\n  return referenceClassesByRecordRegistry.get(records) ?? new Map()\n}\n\n/**\n * Infers a value expression and rejects the non-value result of a void call.\n * @param {import(\"./types.js\").Expression} expression - Semantic expression.\n * @param {Scope} scope - Visible lexical scope.\n * @param {Map<string, import(\"./types.js\").FunctionDeclaration>} functions - Module function signatures.\n * @param {RecordRegistry} records - Record declarations by identity.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {boolean} normalizeOperations - Whether to normalize frontend intent and call resolution.\n * @param {string} context - Value context for diagnostics.\n * @param {import(\"./types.js\").SemanticValueType} [expectedType] - Contextual collection type.\n * @param {boolean} [inferCollectionElements] - Whether a generic-call evidence pass may infer nonempty collection literals.\n * @returns {import(\"./types.js\").SemanticValueType} Expression value type.\n */\nfunction inferValueExpressionType(expression, scope, functions, records, fail, normalizeOperations, context, expectedType,\n  inferCollectionElements = false) {\n  const allowOwnedBorrow = context == \"an effect argument\" || context == \"a method receiver\"\n  const type = inferExpressionType(expression, scope, functions, records, fail, normalizeOperations, expectedType,\n    inferCollectionElements, allowOwnedBorrow)\n\n  if (type == \"void\") return fail(\"VOID_AS_VALUE\", `Void call cannot be used as ${context}.`, expression.location)\n  if (type.kind == \"ErrorType\") return fail(\"TYPE_MISMATCH\", `Error value cannot be used as ${context}.`, expression.location)\n\n  return type\n}\n\n/**\n * Infers and validates one expression.\n * @param {import(\"./types.js\").Expression} expression - Semantic expression.\n * @param {Scope} scope - Visible lexical scope.\n * @param {Map<string, import(\"./types.js\").FunctionDeclaration>} functions - Module function signatures.\n * @param {RecordRegistry} records - Record declarations by identity.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {boolean} normalizeOperations - Whether to replace transient frontend operation intent.\n * @param {import(\"./types.js\").SemanticValueType} [expectedType] - Contextual collection type.\n * @param {boolean} [inferCollectionElements] - Whether a generic-call evidence pass may infer nonempty collection literals.\n * @param {boolean} [allowOwnedBorrow] - Whether this exact call position admits an immediate borrow.\n * @returns {import(\"./types.js\").SemanticBindingType | \"void\"} Expression type.\n */\nfunction inferExpressionType(expression, scope, functions, records, fail, normalizeOperations, expectedType,\n  inferCollectionElements = false, allowOwnedBorrow = false) {\n  if (expression.kind == \"IdentifierExpression\") return resolveBinding(expression.name, expression.location, scope, fail).type\n\n  if (expression.kind == \"ReceiverExpression\") {\n    if (!scope.currentClass || expression.classId != scope.currentClass.id) {\n      return fail(\"ILLEGAL_PRIVATE_ACCESS\", \"Receiver expression is valid only inside its declaring class.\", expression.location)\n    }\n\n    return {declarationId: /** @type {string} */ (scope.currentClass.id), kind: \"ReferenceType\"}\n  }\n\n  if (expression.kind == \"PrivateFieldRead\") {\n    const declaration = scope.currentClass\n\n    if (!declaration || !expression.receiver || expression.receiver.kind != \"ReceiverExpression\" ||\n      expression.receiver.classId != declaration.id) {\n      return fail(\"ILLEGAL_PRIVATE_ACCESS\", \"Private field receiver must be the declaring class receiver.\", expression.location)\n    }\n    const field = declaration.fields.find((candidate) => candidate.id == expression.field)\n\n    if (!field) return fail(\"ILLEGAL_PRIVATE_ACCESS\", \"Private field identity is not owned by the declaring class.\", expression.location)\n\n    return field.type\n  }\n\n  if (expression.kind == \"OwnedBorrowExpression\") {\n    if (!allowOwnedBorrow) {\n      return fail(\"BORROW_ESCAPE\", \"BORROW_ESCAPE: Owned borrows are valid only as immediate capability arguments or method receivers.\",\n        expression.location)\n    }\n    if (expression.mode != \"shared\" && expression.mode != \"exclusive\") {\n      return fail(\"INVALID_RESOURCE_BORROW\", \"INVALID_RESOURCE_BORROW: Owned borrow mode must be shared or exclusive.\",\n        expression.location)\n    }\n    const borrowed = inferValueExpressionType(expression.expression, scope, functions, records, fail, normalizeOperations, \"an owned borrow\")\n\n    if (borrowed.kind != \"OwnedResourceType\" && borrowed.kind != \"OwnedReferenceType\") {\n      return fail(\"INVALID_RESOURCE_BORROW\", \"Borrowed expression must be an owned resource or owned reference.\", expression.location)\n    }\n    if (!sameType(borrowed, expression.type)) {\n      fail(\"RESOURCE_TYPE_MISMATCH\", \"Borrow metadata does not match its resource place.\", expression.location)\n    }\n    return borrowed\n  }\n\n  if (expression.kind == \"OwnedMoveExpression\") {\n    const moved = inferValueExpressionType(expression.expression, scope, functions, records, fail, normalizeOperations, \"an owned move\")\n\n    if (moved.kind != \"OwnedResourceType\" && moved.kind != \"OwnedReferenceType\") {\n      return fail(\"INVALID_RESOURCE_TRANSFER\", \"Moved expression must be an owned resource or owned reference.\", expression.location)\n    }\n    if (!sameType(moved, expression.type)) {\n      fail(\"RESOURCE_TYPE_MISMATCH\", \"Move metadata does not match its resource place.\", expression.location)\n    }\n    return moved\n  }\n\n  if (expression.kind == \"ErrorMessageRead\") {\n    if (!expression.receiver || expression.receiver.kind != \"IdentifierExpression\") {\n      return fail(\"INVALID_MEMBER_RECEIVER\", \"Error message receiver must be one catch binding.\", expression.location)\n    }\n    const receiver = resolveBinding(expression.receiver.name, expression.receiver.location, scope, fail)\n\n    if (receiver.type.kind != \"ErrorType\") {\n      return fail(\"INVALID_MEMBER_RECEIVER\", \"Message member requires a typed error catch binding.\", expression.receiver.location)\n    }\n\n    return scalarType(\"string\")\n  }\n\n  if (expression.kind == \"IntegerLiteral\") {\n    if (!Number.isSafeInteger(expression.value)) fail(\"TYPE_MISMATCH\", \"Non-safe integer literal.\", expression.location)\n    return scalarType(\"integer\")\n  }\n  if (expression.kind == \"BooleanLiteral\") {\n    if (typeof Reflect.get(expression, \"value\") != \"boolean\") {\n      fail(\"TYPE_MISMATCH\", \"Invalid boolean literal value.\", expression.location)\n    }\n    return scalarType(\"boolean\")\n  }\n  if (expression.kind == \"StringLiteral\") {\n    const value = Reflect.get(expression, \"value\")\n\n    if (typeof value != \"string\" || !hasOnlyUnicodeScalars(value)) {\n      fail(\"TYPE_MISMATCH\", \"Invalid Unicode string literal.\", expression.location)\n    }\n    return scalarType(\"string\")\n  }\n  if (expression.kind == \"OptionalNone\") {\n    if (!expectedType || expectedType.kind != \"OptionalType\") {\n      return fail(\"MISSING_TYPE\", \"Optional absence requires an explicit optional type.\", expression.location)\n    }\n\n    return expectedType\n  }\n  if (expression.kind == \"OptionalSome\") {\n    if (!expectedType || expectedType.kind != \"OptionalType\") {\n      const valueType = inferValueExpressionType(\n        expression.value, scope, functions, records, fail, normalizeOperations, \"an optional present value\"\n      )\n\n      if (valueType.kind == \"OptionalType\") {\n        return fail(\"INVALID_OPTIONAL_CONSTITUENT\", \"Optional values cannot directly contain another optional.\", expression.value.location)\n      }\n\n      return {kind: \"OptionalType\", valueType}\n    }\n    const valueType = inferValueExpressionType(\n      expression.value, scope, functions, records, fail, normalizeOperations, \"an optional present value\", expectedType.valueType\n    )\n\n    if (!sameType(valueType, expectedType.valueType)) {\n      fail(\"TYPE_MISMATCH\", `Optional present type ${typeDescription(valueType)}; expected ${typeDescription(expectedType.valueType)}.`, expression.value.location)\n    }\n\n    return expectedType\n  }\n  if (expression.kind == \"OptionalIsPresent\") {\n    if (!expression.operand || expression.operand.kind != \"IdentifierExpression\") {\n      return fail(\"TYPE_MISMATCH\", \"Optional presence test requires one simple identifier.\", expression.location)\n    }\n    const operandType = resolveBinding(expression.operand.name, expression.operand.location, scope, fail).type\n\n    if (operandType.kind != \"OptionalType\") {\n      return fail(\"TYPE_MISMATCH\", `Presence test received ${typeDescription(operandType)}; expected optional.`, expression.operand.location)\n    }\n\n    return scalarType(\"boolean\")\n  }\n  if (expression.kind == \"OptionalUnwrap\") {\n    if (!expression.operand || expression.operand.kind != \"IdentifierExpression\") {\n      return fail(\"TYPE_MISMATCH\", \"Optional unwrap requires one simple identifier.\", expression.location)\n    }\n    const binding = resolveBinding(expression.operand.name, expression.operand.location, scope, fail)\n\n    if (binding.type.kind != \"OptionalType\") {\n      return fail(\"TYPE_MISMATCH\", `Optional unwrap received ${typeDescription(binding.type)}; expected optional.`, expression.operand.location)\n    }\n    if (!scope.presenceProofs.has(binding)) {\n      return fail(\"UNCHECKED_OPTIONAL_UNWRAP\", `Optional binding '${expression.operand.name}' is not proven present.`, expression.location)\n    }\n\n    return binding.type.valueType\n  }\n  if (expression.kind == \"ListLiteral\") {\n    if (!Array.isArray(expression.elements)) {\n      return fail(\"TYPE_MISMATCH\", \"List literal elements must be a dense source-ordered array.\", expression.location)\n    }\n    if ((!expectedType || expectedType.kind != \"ListType\") &&\n      (!inferCollectionElements || expression.elements.length == 0)) {\n      return fail(\"MISSING_TYPE\", \"List literal requires an explicit recursive list type.\", expression.location)\n    }\n    /** @type {import(\"./types.js\").SemanticValueType | undefined} */\n    let inferredElementType\n    for (let index = 0; index < expression.elements.length; index++) {\n      if (!Object.hasOwn(expression.elements, index)) {\n        fail(\"TYPE_MISMATCH\", \"Sparse list literals are outside the implemented subset.\", expression.location)\n      }\n      const element = expression.elements[index]\n      const actual = inferValueExpressionType(\n        element, scope, functions, records, fail, normalizeOperations, \"a list element\",\n        expectedType?.kind == \"ListType\" ? expectedType.elementType : inferredElementType, inferCollectionElements\n      )\n\n      inferredElementType ??= actual\n      const requiredElementType = expectedType?.kind == \"ListType\" ? expectedType.elementType : inferredElementType\n\n      if (!sameType(actual, requiredElementType)) {\n        fail(\"TYPE_MISMATCH\", `List element type ${typeDescription(actual)}; expected ${typeDescription(requiredElementType)}.`, element.location)\n      }\n    }\n\n    return expectedType?.kind == \"ListType\"\n      ? expectedType\n      : {elementType: /** @type {import(\"./types.js\").SemanticValueType} */ (inferredElementType), kind: \"ListType\"}\n  }\n  if (expression.kind == \"MapLiteral\") {\n    if (expectedType && expectedType.kind != \"MapType\") {\n      return fail(\"TYPE_MISMATCH\", `Map literal context ${typeDescription(expectedType)}; expected map.`, expression.location)\n    }\n    if (!expectedType && !inferCollectionElements) {\n      return fail(\"MISSING_TYPE\", \"Map literal requires an explicit recursive map type.\", expression.location)\n    }\n    if (expectedType?.kind == \"MapType\" && !isScalarType(expectedType.keyType, \"string\")) {\n      return fail(\"TYPE_MISMATCH\", \"Map key type must be string.\", typeLocation(expectedType.keyType, expression.location))\n    }\n    const entries = validateMapLiteralEntries(expression, scope, functions, records, fail, normalizeOperations,\n      inferCollectionElements)\n\n    if (!expectedType && entries.length == 0) {\n      return fail(\"MISSING_TYPE\", \"Empty map literal requires an explicit recursive map type.\", expression.location)\n    }\n    /** @type {import(\"./types.js\").SemanticValueType | undefined} */\n    let inferredValueType\n\n    for (const entry of entries) {\n      const actual = inferValueExpressionType(\n        entry.value, scope, functions, records, fail, normalizeOperations, \"a map value\",\n        expectedType?.kind == \"MapType\" ? expectedType.valueType : inferredValueType, inferCollectionElements\n      )\n      inferredValueType ??= actual\n      const requiredValueType = expectedType?.kind == \"MapType\" ? expectedType.valueType : inferredValueType\n\n      if (!sameType(actual, requiredValueType)) {\n        fail(\"TYPE_MISMATCH\", `Map value type ${typeDescription(actual)}; expected ${typeDescription(requiredValueType)}.`, entry.value.location)\n      }\n    }\n\n    return expectedType?.kind == \"MapType\" ? expectedType : {\n      keyType: scalarType(\"string\"),\n      kind: \"MapType\",\n      valueType: /** @type {import(\"./types.js\").SemanticValueType} */ (inferredValueType)\n    }\n  }\n  if (expression.kind == \"OrderedMapLiteral\") {\n    if (expectedType && expectedType.kind != \"OrderedMapType\") {\n      return fail(\"TYPE_MISMATCH\", `Ordered-map literal context ${typeDescription(expectedType)}; expected ordered map.`, expression.location)\n    }\n    if (!expectedType && !inferCollectionElements) {\n      return fail(\"MISSING_TYPE\", \"Ordered-map literal requires an explicit recursive ordered-map type.\", expression.location)\n    }\n    if (expectedType?.kind == \"OrderedMapType\" && !isScalarType(expectedType.keyType, \"string\")) {\n      return fail(\"TYPE_MISMATCH\", \"Ordered-map key type must be string.\", typeLocation(expectedType.keyType, expression.location))\n    }\n    const entries = validateMapLiteralEntries(expression, scope, functions, records, fail, normalizeOperations,\n      inferCollectionElements)\n\n    if (!expectedType && entries.length == 0) {\n      return fail(\"MISSING_TYPE\", \"Empty ordered-map literal requires an explicit recursive ordered-map type.\", expression.location)\n    }\n    /** @type {import(\"./types.js\").SemanticValueType | undefined} */\n    let inferredValueType\n\n    for (const entry of entries) {\n      const actual = inferValueExpressionType(\n        entry.value, scope, functions, records, fail, normalizeOperations, \"an ordered-map value\",\n        expectedType?.kind == \"OrderedMapType\" ? expectedType.valueType : inferredValueType, inferCollectionElements\n      )\n      inferredValueType ??= actual\n      const requiredValueType = expectedType?.kind == \"OrderedMapType\" ? expectedType.valueType : inferredValueType\n\n      if (!sameType(actual, requiredValueType)) {\n        fail(\"TYPE_MISMATCH\", `Ordered-map value type ${typeDescription(actual)}; expected ${typeDescription(requiredValueType)}.`,\n          entry.value.location)\n      }\n    }\n\n    return expectedType?.kind == \"OrderedMapType\" ? expectedType : {\n      keyType: scalarType(\"string\"),\n      kind: \"OrderedMapType\",\n      order: \"insertion\",\n      valueType: /** @type {import(\"./types.js\").SemanticValueType} */ (inferredValueType)\n    }\n  }\n  if (expression.kind == \"ListIndexExpression\") {\n    const collectionType = inferValueExpressionType(expression.collection, scope, functions, records, fail, normalizeOperations, \"a list receiver\")\n    const indexType = inferValueExpressionType(expression.index, scope, functions, records, fail, normalizeOperations, \"a list index\", scalarType(\"integer\"))\n\n    if (collectionType.kind != \"ListType\") {\n      return fail(\"TYPE_MISMATCH\", `List index receiver type ${typeDescription(collectionType)}; expected list.`, expression.collection.location)\n    }\n    if (!isScalarType(indexType, \"integer\")) {\n      fail(\"TYPE_MISMATCH\", `List index type ${typeDescription(indexType)}; expected integer.`, expression.index.location)\n    }\n    const knownCollection = knownValueForExpression(expression.collection, scope)\n    const knownIndex = knownValueForExpression(expression.index, scope)\n\n    if (knownCollection?.kind == \"ListLiteral\" && knownIndex?.kind == \"IntegerLiteral\" &&\n      (knownIndex.value < 0 || knownIndex.value >= knownCollection.elements.length)) {\n      fail(\"INDEX_OUT_OF_BOUNDS\", `List index ${knownIndex.value} is outside a literal list of size ${knownCollection.elements.length}.`, expression.location)\n    }\n    const proven = provenListElement(expression.collection, expression.index, scope)\n\n    validateAccessTotality(expression, proven !== undefined, normalizeOperations, fail)\n\n    return collectionType.elementType\n  }\n  if (expression.kind == \"MapLookupExpression\") {\n    const collectionType = inferValueExpressionType(expression.collection, scope, functions, records, fail, normalizeOperations, \"a map receiver\")\n    const keyType = inferValueExpressionType(expression.key, scope, functions, records, fail, normalizeOperations, \"a map key\", scalarType(\"string\"))\n\n    if (collectionType.kind != \"MapType\" && collectionType.kind != \"OrderedMapType\") {\n      return fail(\"TYPE_MISMATCH\", `Map lookup receiver type ${typeDescription(collectionType)}; expected map.`, expression.collection.location)\n    }\n    if (!isScalarType(keyType, \"string\")) {\n      fail(\"TYPE_MISMATCH\", `Map lookup key type ${typeDescription(keyType)}; expected string.`, expression.key.location)\n    }\n    const knownCollection = knownValueForExpression(expression.collection, scope)\n    const knownKey = knownValueForExpression(expression.key, scope)\n\n    if ((knownCollection?.kind == \"MapLiteral\" || knownCollection?.kind == \"OrderedMapLiteral\") &&\n      knownKey?.kind == \"StringLiteral\" &&\n      !knownCollection.entries.some((entry) => entry.key.value == knownKey.value)) {\n      fail(\"MISSING_MAP_KEY\", `Map key '${knownKey.value}' is absent from the literal initializer.`, expression.location)\n    }\n    const proven = provenMapValue(expression.collection, expression.key, scope)\n\n    validateAccessTotality(expression, proven !== undefined, normalizeOperations, fail)\n\n    return collectionType.valueType\n  }\n  if (expression.kind == \"CollectionSizeExpression\") {\n    const collectionType = inferValueExpressionType(expression.collection, scope, functions, records, fail, normalizeOperations, \"a collection-size receiver\")\n\n    if (collectionType.kind != \"ListType\" && collectionType.kind != \"MapType\" && collectionType.kind != \"OrderedMapType\") {\n      return fail(\"TYPE_MISMATCH\", `Collection size receiver type ${typeDescription(collectionType)}; expected list or map.`, expression.collection.location)\n    }\n    const collectionKind = collectionType.kind == \"ListType\" ? \"list\" : \"map\"\n\n    if (normalizeOperations) {\n      if (expression.collectionKind !== undefined && expression.collectionKind != collectionKind) {\n        fail(\"TYPE_MISMATCH\", \"Collection size operation does not match its receiver type.\", expression.location)\n      }\n      expression.collectionKind = collectionKind\n    }\n    else if (expression.collectionKind != collectionKind) {\n      fail(\"TYPE_MISMATCH\", \"Collection size kind does not match its receiver type.\", expression.location)\n    }\n\n    return scalarType(\"integer\")\n  }\n  if (expression.kind == \"EffectCallExpression\") {\n    if (!Array.isArray(expression.arguments) || expression.arguments.length != expression.resolution.parameterTypes.length) {\n      return fail(\"TYPE_MISMATCH\", \"Effect call argument count does not match its authorized operation.\", expression.location)\n    }\n    const resourceFlow = expression.resolution.resourceFlow\n\n    if (resourceFlow.kind == \"borrow\" || resourceFlow.kind == \"close\") {\n      const borrow = expression.arguments[resourceFlow.parameterIndex]\n      const expectedMode = resourceFlow.kind == \"close\" ? \"exclusive\" : \"shared\"\n\n      if (borrow?.kind != \"OwnedBorrowExpression\" || borrow.mode != expectedMode) {\n        fail(\"INVALID_RESOURCE_BORROW\", `INVALID_RESOURCE_BORROW: ${resourceFlow.kind} requires an immediate ${expectedMode} borrow.`,\n          borrow?.location ?? expression.location)\n      }\n    }\n    for (let index = 0; index < expression.arguments.length; index += 1) {\n      const expected = identityAsValueType(expression.resolution.parameterTypes[index], expression.arguments[index].location, fail)\n      const actual = inferValueExpressionType(expression.arguments[index], scope, functions, records, fail, normalizeOperations,\n        \"an effect argument\", expected)\n\n      if (!sameType(actual, expected)) {\n        fail(\"RESOURCE_TYPE_MISMATCH\", `Effect argument type ${typeDescription(actual)}; expected ${typeDescription(expected)}.`,\n          expression.arguments[index].location)\n      }\n    }\n    if (expression.resolution.returnType == \"void\") return \"void\"\n    return identityAsValueType(expression.resolution.returnType, expression.location, fail)\n  }\n  if (expression.kind == \"ReferenceConstruction\") {\n    const referenceType = validateValueTypeReference(expression.reference, expression.location, fail, undefined, records,\n      scope.typeParameters)\n\n    if (referenceType.kind != \"ReferenceType\" && referenceType.kind != \"OwnedReferenceType\") {\n      return fail(\"TYPE_MISMATCH\", \"Reference construction requires a nominal reference class type.\", expression.location)\n    }\n    const declaration = referenceClassesFor(records).get(referenceType.declarationId)\n\n    if (!declaration) return fail(\"UNKNOWN_CLASS\", `Unknown reference class '${referenceType.declarationId}'.`, expression.location)\n    if (!isDenseArray(expression.arguments)) {\n      return fail(\"TYPE_MISMATCH\", \"Constructor arguments must be a dense ordered array.\", expression.location)\n    }\n    if (expression.arguments.length != declaration.constructor.parameters.length) {\n      return fail(\"CONSTRUCTOR_ARITY_MISMATCH\",\n        `Constructor for '${declaration.name}' has ${expression.arguments.length} arguments; expected ${declaration.constructor.parameters.length}.`,\n        expression.location)\n    }\n    const parameterTypes = declaration.constructor.parameters.map((parameter) =>\n      validateValueTypeReference(parameter.type, parameter.location, fail, undefined, records))\n\n    for (let index = 0; index < expression.arguments.length; index += 1) {\n      expression.arguments[index] = normalizeOwnedMove(expression.arguments[index], parameterTypes[index], normalizeOperations, fail)\n      const actual = inferValueExpressionType(expression.arguments[index], scope, functions, records, fail,\n        normalizeOperations, \"a constructor argument\", parameterTypes[index])\n\n      if (!sameType(actual, parameterTypes[index])) {\n        fail(\"TYPE_MISMATCH\", `Constructor argument type ${typeDescription(actual)}; expected ${typeDescription(parameterTypes[index])}.`,\n          expression.arguments[index].location)\n      }\n    }\n    const resolution = {\n      declarationId: /** @type {string} */ (declaration.constructor.id),\n      kind: /** @type {const} */ (\"ResolvedConstructorSignature\"),\n      parameterTypes: parameterTypes.map((type) => /** @type {import(\"./types.js\").SemanticTypeIdentity} */ (typeIdentity(type)))\n    }\n\n    if (normalizeOperations) expression.resolution = resolution\n    else validateReferenceResolution(expression.resolution, resolution, expression.location, fail, \"constructor\")\n\n    return referenceType\n  }\n  if (expression.kind == \"MethodCallExpression\") {\n    const receiverType = inferValueExpressionType(expression.receiver, scope, functions, records, fail,\n      normalizeOperations, \"a method receiver\")\n\n    if (receiverType.kind != \"ReferenceType\" && receiverType.kind != \"OwnedReferenceType\") {\n      return fail(\"INVALID_METHOD_RECEIVER\", \"Method call receiver must have a reference class type.\", expression.receiver.location)\n    }\n    const declaration = referenceClassesFor(records).get(receiverType.declarationId)\n\n    if (!declaration) return fail(\"UNKNOWN_CLASS\", `Unknown reference class '${receiverType.declarationId}'.`, expression.receiver.location)\n    const method = declaration.methods.find((candidate) => candidate.id == expression.method) ??\n      (normalizeOperations ? declaration.methods.find((candidate) => candidate.name == expression.method) : undefined)\n\n    if (!method) return fail(\"UNKNOWN_METHOD\", `Class '${declaration.name}' has no method '${expression.method}'.`,\n      roleLocation(expression, \"member\"))\n    if (normalizeOperations) expression.method = /** @type {string} */ (method.id)\n    if (!isDenseArray(expression.arguments)) return fail(\"TYPE_MISMATCH\", \"Method arguments must be a dense ordered array.\", expression.location)\n    if (expression.arguments.length != method.parameters.length) {\n      return fail(\"METHOD_ARITY_MISMATCH\",\n        `Method '${method.name}' has ${expression.arguments.length} arguments; expected ${method.parameters.length}.`, expression.location)\n    }\n    const parameterTypes = method.parameters.map((parameter) =>\n      validateValueTypeReference(parameter.type, parameter.location, fail, undefined, records))\n\n    for (let index = 0; index < expression.arguments.length; index += 1) {\n      expression.arguments[index] = normalizeOwnedMove(expression.arguments[index], parameterTypes[index], normalizeOperations, fail)\n      const actual = inferValueExpressionType(expression.arguments[index], scope, functions, records, fail,\n        normalizeOperations, \"a method argument\", parameterTypes[index])\n\n      if (!sameType(actual, parameterTypes[index])) {\n        fail(\"TYPE_MISMATCH\", `Method argument type ${typeDescription(actual)}; expected ${typeDescription(parameterTypes[index])}.`,\n          expression.arguments[index].location)\n      }\n    }\n    const returnType = validateReturnTypeReference(method.returnType, method.location, fail, records)\n    const resourceFlow = declaration.ownership?.kind == \"ownedResource\"\n      ? ownedMethodResourceFlow(declaration, method, fail) : undefined\n    const resolution = {\n      declarationId: /** @type {string} */ (method.id),\n      kind: /** @type {const} */ (\"ResolvedMethodSignature\"),\n      parameterTypes: parameterTypes.map((type) => /** @type {import(\"./types.js\").SemanticTypeIdentity} */ (typeIdentity(type))),\n      returnType: typeIdentity(returnType),\n      ...(resourceFlow ? {resourceFlow} : {})\n    }\n\n    if (expression.receiver.kind == \"OwnedBorrowExpression\" && resourceFlow) {\n      const expectedMode = resourceFlow.kind == \"terminal\" ? \"exclusive\" : \"shared\"\n\n      if (expression.receiver.mode != expectedMode) {\n        fail(\"INVALID_RESOURCE_BORROW\", `INVALID_RESOURCE_BORROW: Owned method requires an immediate ${expectedMode} receiver borrow.`,\n          expression.receiver.location)\n      }\n    }\n\n    if (receiverType.kind == \"OwnedReferenceType\" && expression.receiver.kind != \"OwnedBorrowExpression\") {\n      if (!normalizeOperations) fail(\"INVALID_RESOURCE_BORROW\", \"Owned method receiver requires an immediate borrow.\", expression.receiver.location)\n      if (expression.receiver.kind != \"IdentifierExpression\") {\n        fail(\"BORROW_ESCAPE\", \"Owned method receiver borrow must name one immediate binding.\", expression.receiver.location)\n      }\n      expression.receiver = {\n        expression: expression.receiver,\n        kind: \"OwnedBorrowExpression\",\n        location: expression.receiver.location,\n        mode: resourceFlow?.kind == \"terminal\" ? \"exclusive\" : \"shared\",\n        sourceProvenance: expression.receiver.sourceProvenance,\n        type: receiverType\n      }\n    }\n\n    if (normalizeOperations) expression.resolution = resolution\n    else validateReferenceResolution(expression.resolution, resolution, expression.location, fail, \"method\")\n\n    return isVoidType(returnType) ? \"void\" : returnType\n  }\n  if (expression.kind == \"RecordConstruction\") {\n    const recordType = validateValueTypeReference(expression.record, expression.location, fail, undefined, records, scope.typeParameters)\n\n    if (recordType.kind != \"RecordType\") {\n      return fail(\"TYPE_MISMATCH\", \"Record construction requires a nominal record type.\", expression.location)\n    }\n    const declaration = records.get(recordType.declarationId)\n\n    if (!declaration) return fail(\"UNKNOWN_RECORD\", `Unknown record declaration '${recordType.declarationId}'.`, expression.location)\n    if (!Array.isArray(expression.arguments) || expression.arguments.some((_argument, index) => !Object.hasOwn(expression.arguments, index))) {\n      return fail(\"TYPE_MISMATCH\", \"Record construction arguments must be a dense ordered array.\", expression.location)\n    }\n    if (expression.arguments.length != declaration.fields.length) {\n      return fail(\n        \"RECORD_ARITY_MISMATCH\",\n        `Record '${declaration.name}' construction has ${expression.arguments.length} arguments; expected ${declaration.fields.length}.`,\n        expression.location\n      )\n    }\n    const substitutions = recordTypeSubstitutions(recordType, declaration)\n    for (let index = 0; index < expression.arguments.length; index += 1) {\n      const argument = expression.arguments[index]\n      const field = declaration.fields[index]\n      const fieldType = substituteValueType(field.type, substitutions)\n      const actual = inferValueExpressionType(\n        argument, scope, functions, records, fail, normalizeOperations, `record field '${field.name}'`, fieldType\n      )\n\n      if (!sameType(actual, fieldType)) {\n        fail(\"TYPE_MISMATCH\", `Record field '${field.name}' argument type ${typeDescription(actual)}; expected ${typeDescription(fieldType)}.`, argument.location)\n      }\n    }\n\n    return recordType\n  }\n  if (expression.kind == \"MemberRead\") {\n    const receiverType = inferValueExpressionType(expression.receiver, scope, functions, records, fail, normalizeOperations, \"a member receiver\")\n\n    if (receiverType.kind != \"RecordType\") {\n      return fail(\"INVALID_MEMBER_RECEIVER\", `Member receiver type ${typeDescription(receiverType)}; expected record.`, expression.receiver.location)\n    }\n    const declaration = records.get(receiverType.declarationId)\n\n    if (!declaration) return fail(\"UNKNOWN_RECORD\", `Unknown record declaration '${receiverType.declarationId}'.`, expression.receiver.location)\n    const field = declaration.fields.find((candidate) => candidate.id == expression.field) ??\n      (normalizeOperations ? declaration.fields.find((candidate) => candidate.name == expression.field) : undefined)\n\n    if (!field) fail(\"UNKNOWN_FIELD\", `Record '${declaration.name}' has no field '${expression.field}'.`, roleLocation(expression, \"member\"))\n    if (normalizeOperations) expression.field = /** @type {string} */ (field.id)\n\n    return substituteValueType(field.type, recordTypeSubstitutions(receiverType, declaration))\n  }\n  if (expression.kind == \"CallExpression\") {\n    const functionDeclaration = functions.get(expression.callee)\n\n    if (!functionDeclaration) {\n      return fail(\"UNRESOLVED_BINDING\", `Unknown function '${expression.callee}'.`, roleLocation(expression, \"callee\"))\n    }\n    if (expression.arguments.length != functionDeclaration.parameters.length) {\n      return fail(\"TYPE_MISMATCH\", `Call argument count for '${expression.callee}'.`, expression.location)\n    }\n    const declarationTypeParameters = declarationTypeParameterIds(functionDeclaration)\n    /** @type {Map<string, import(\"./types.js\").SemanticValueType>} */\n    const substitutions = new Map()\n    const parameterTypes = functionDeclaration.parameters.map((parameter) => validateValueTypeReference(\n      parameter.type, parameter.location, fail, undefined, records, declarationTypeParameters\n    ))\n    for (let index = 0; index < expression.arguments.length; index += 1) {\n      expression.arguments[index] = normalizeOwnedMove(expression.arguments[index], parameterTypes[index], normalizeOperations, fail)\n    }\n    for (let index = 0; index < expression.arguments.length; index++) {\n      const argument = expression.arguments[index]\n      const expectedType = parameterTypes[index]\n      const gathersGenericEvidence = typeContainsAnyVariable(expectedType)\n\n      if (gathersGenericEvidence) {\n        inferGenericArgumentEvidence(expectedType, argument, substitutions, scope, functions, records, fail,\n          normalizeOperations)\n        continue\n      }\n      const actualType = inferValueExpressionType(\n        argument, scope, functions, records, fail, normalizeOperations, \"a call argument\", expectedType\n      )\n\n      if ((functionDeclaration.typeParameters?.length ?? 0) > 0) {\n        inferTypeArguments(expectedType, actualType, substitutions, argument.location, fail)\n      } else if (!sameType(actualType, expectedType)) {\n        fail(\"TYPE_MISMATCH\", `Call argument type ${typeDescription(actualType)}; expected ${typeDescription(expectedType)}.`, argument.location)\n      }\n    }\n    for (const parameter of functionDeclaration.typeParameters ?? []) {\n      if (!substitutions.has(/** @type {string} */ (parameter.id))) {\n        const evidenceFreeIndex = parameterTypes.findIndex((type) =>\n          typeContainsVariable(type, /** @type {string} */ (parameter.id)))\n\n        if (evidenceFreeIndex >= 0) {\n          fail(\"GENERIC_INFERENCE_FAILURE\", \"Cannot infer a type parameter from an evidence-free call argument.\",\n            expression.arguments[evidenceFreeIndex].location)\n        }\n        fail(\"GENERIC_INFERENCE_FAILURE\", `Cannot infer type parameter '${parameter.name}' from call arguments.`, expression.location)\n      }\n    }\n    if ([...substitutions.values()].some((type) => containsOwnedType(type))) {\n      fail(\"RESOURCE_ALIAS\", \"Owned resources and references cannot be inferred as generic arguments.\", expression.location)\n    }\n    for (let index = 0; index < functionDeclaration.parameters.length; index += 1) {\n      const expected = substituteValueType(functionDeclaration.parameters[index].type, substitutions)\n      const actual = inferValueExpressionType(expression.arguments[index], scope, functions, records, fail,\n        normalizeOperations, \"a call argument\", expected)\n\n      if (!sameType(actual, expected)) {\n        fail(\"TYPE_MISMATCH\", `Call argument type ${typeDescription(actual)}; expected ${typeDescription(expected)}.`, expression.arguments[index].location)\n      }\n    }\n    const resolution = signatureFor(functionDeclaration, records, fail, substitutions)\n\n    if (normalizeOperations) expression.resolution = resolution\n    else validateResolution(expression.resolution, resolution, expression.location, fail)\n    const returnType = substituteReturnType(validateReturnTypeReference(functionDeclaration.returnType,\n      functionDeclaration.location, fail, records, declarationTypeParameters), substitutions)\n\n    return isVoidType(returnType) ? \"void\" : returnType\n  }\n  if (expression.kind == \"UnaryExpression\") {\n    const operand = inferValueExpressionType(expression.operand, scope, functions, records, fail, normalizeOperations, \"a unary operand\")\n    const operandType = scalarNameForOperation(operand, expression.operand.location, fail)\n    const operation = normalizeOperations\n      ? normalizeUnaryOperation(adaptedOperationFor(expression), operandType, expression.operand.location, fail)\n      : expression.operation\n\n    if (normalizeOperations) setNormalizedOperation(expression, operation, unaryOperationSignatures[operation].result)\n\n    const signature = unaryOperationSignatures[operation]\n\n    if (!signature) return fail(\"TYPE_MISMATCH\", `Unknown unary operation ${String(operation)}.`, expression.location)\n    if (operandType != signature.operand) {\n      return fail(\"INVALID_OPERAND_TYPE\", `${operation} requires ${signature.operand}; received ${operandType}.`, expression.operand.location)\n    }\n    if (expression.type != signature.result) {\n      return fail(\"TYPE_MISMATCH\", `${operation} result type ${String(expression.type)}; expected ${signature.result}.`, expression.location)\n    }\n    return scalarType(signature.result)\n  }\n  if (expression.kind == \"BinaryExpression\") {\n    const left = inferValueExpressionType(expression.left, scope, functions, records, fail, normalizeOperations, \"a binary operand\")\n    const right = inferValueExpressionType(expression.right, scope, functions, records, fail, normalizeOperations, \"a binary operand\")\n    const leftType = scalarNameForOperation(left, expression.left.location, fail)\n    const rightType = scalarNameForOperation(right, expression.right.location, fail)\n    const operation = normalizeOperations\n      ? normalizeBinaryOperation(adaptedOperationFor(expression), leftType, rightType, expression.left.location, expression.right.location, expression.location, fail)\n      : expression.operation\n\n    if (normalizeOperations) setNormalizedOperation(expression, operation, binaryOperationSignatures[operation].result)\n\n    const signature = binaryOperationSignatures[operation]\n\n    if (!signature) return fail(\"TYPE_MISMATCH\", `Unknown binary operation ${String(operation)}.`, expression.location)\n    if (leftType != signature.left) {\n      return fail(\"INVALID_OPERAND_TYPE\", `${operation} requires ${signature.left} left operand; received ${leftType}.`, expression.left.location)\n    }\n    if (rightType != signature.right) {\n      return fail(\"INVALID_OPERAND_TYPE\", `${operation} requires ${signature.right} right operand; received ${rightType}.`, expression.right.location)\n    }\n    if (expression.type != signature.result) {\n      return fail(\"TYPE_MISMATCH\", `${operation} result type ${String(expression.type)}; expected ${signature.result}.`, expression.location)\n    }\n    return scalarType(signature.result)\n  }\n\n  const unexpected = /** @type {{kind: string, location: import(\"./types.js\").SourceLocation}} */ (expression)\n\n  return fail(\"TYPE_MISMATCH\", unexpected.kind, unexpected.location)\n}\n\n/**\n * Validates map layout and fixed string keys independently of contextual value inference.\n * @param {import(\"./types.js\").MapLiteral | import(\"./types.js\").OrderedMapLiteral} expression - Candidate map literal.\n * @param {Scope} scope - Visible lexical scope.\n * @param {Map<string, import(\"./types.js\").FunctionDeclaration>} functions - Module function signatures.\n * @param {RecordRegistry} records - Record declarations by identity.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {boolean} normalizeOperations - Whether to normalize frontend intent.\n * @param {boolean} inferCollectionElements - Whether nested collection evidence may be inferred.\n * @returns {import(\"./types.js\").MapEntry[]} Validated dense entries.\n */\nfunction validateMapLiteralEntries(expression, scope, functions, records, fail, normalizeOperations,\n  inferCollectionElements) {\n  if (!Array.isArray(expression.entries)) {\n    return fail(\"TYPE_MISMATCH\", \"Map literal entries must be a dense source-ordered array.\", expression.location)\n  }\n  if (!isDenseArray(expression.entries)) {\n    return fail(\"TYPE_MISMATCH\", \"Sparse map literals are outside the implemented subset.\", expression.location)\n  }\n  const keys = new Set()\n\n  for (const entry of expression.entries) {\n    if (!entry || entry.kind != \"MapEntry\" || !entry.key || entry.key.kind != \"StringLiteral\") {\n      fail(\"TYPE_MISMATCH\", \"Map entries require literal string keys.\", entry?.location ?? expression.location)\n    }\n    inferValueExpressionType(entry.key, scope, functions, records, fail, normalizeOperations, \"a map key\",\n      scalarType(\"string\"), inferCollectionElements)\n    if (isNumericString(entry.key.value)) {\n      fail(\"INVALID_MAP_KEY\", \"Map initializer keys must be nonnumeric strings.\", entry.key.location)\n    }\n    if (keys.has(entry.key.value)) {\n      fail(\"DUPLICATE_MAP_KEY\", `Duplicate ${expression.kind == \"OrderedMapLiteral\" ? \"ordered-map\" : \"map\"} key '${entry.key.value}'.`,\n        entry.key.location)\n    }\n    keys.add(entry.key.value)\n  }\n\n  return expression.entries\n}\n\n/**\n * Collects argument-only generic evidence while deferring recursively contextual literals.\n * The complete argument is validated against its closed substituted type after inference.\n * @param {import(\"./types.js\").SemanticValueType} formal - Open declaration parameter type.\n * @param {import(\"./types.js\").Expression} expression - Call argument or nested collection value.\n * @param {Map<string, import(\"./types.js\").SemanticValueType>} substitutions - Inference state.\n * @param {Scope} scope - Visible lexical scope.\n * @param {Map<string, import(\"./types.js\").FunctionDeclaration>} functions - Module function signatures.\n * @param {RecordRegistry} records - Record declarations by identity.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {boolean} normalizeOperations - Whether to normalize frontend intent.\n * @returns {void}\n */\nfunction inferGenericArgumentEvidence(formal, expression, substitutions, scope, functions, records, fail,\n  normalizeOperations) {\n  if (expression.kind == \"OptionalNone\") return\n  if (formal.kind == \"OptionalType\" && expression.kind == \"OptionalSome\") {\n    inferGenericArgumentEvidence(formal.valueType, expression.value, substitutions, scope, functions, records, fail,\n      normalizeOperations)\n    return\n  }\n  if (formal.kind == \"ListType\" && expression.kind == \"ListLiteral\") {\n    if (!Array.isArray(expression.elements)) {\n      fail(\"TYPE_MISMATCH\", \"List literal elements must be a dense source-ordered array.\", expression.location)\n    }\n    if (!isDenseArray(expression.elements)) {\n      fail(\"TYPE_MISMATCH\", \"Sparse list literals are outside the implemented subset.\", expression.location)\n    }\n    for (const element of expression.elements) {\n      inferGenericArgumentEvidence(formal.elementType, element, substitutions, scope, functions, records, fail,\n        normalizeOperations)\n    }\n    return\n  }\n  if ((formal.kind == \"MapType\" && expression.kind == \"MapLiteral\") ||\n    (formal.kind == \"OrderedMapType\" && expression.kind == \"OrderedMapLiteral\")) {\n    const entries = validateMapLiteralEntries(expression, scope, functions, records, fail, normalizeOperations, true)\n\n    for (const entry of entries) {\n      inferGenericArgumentEvidence(formal.valueType, entry.value, substitutions, scope, functions, records, fail,\n        normalizeOperations)\n    }\n    return\n  }\n  const actual = inferValueExpressionType(\n    expression, scope, functions, records, fail, normalizeOperations, \"a call argument\", undefined, true\n  )\n\n  inferTypeArguments(formal, actual, substitutions, expression.location, fail)\n}\n\n/**\n * Unifies one declaration-owned formal type with one argument type.\n * @param {import(\"./types.js\").SemanticValueType} formal - Generic signature type.\n * @param {import(\"./types.js\").SemanticValueType} actual - Inferred argument type.\n * @param {Map<string, import(\"./types.js\").SemanticValueType>} substitutions - Inference state.\n * @param {import(\"./types.js\").SourceLocation} location - Argument location.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {void}\n */\nfunction inferTypeArguments(formal, actual, substitutions, location, fail) {\n  if (formal.kind == \"TypeVariableReference\") {\n    const prior = substitutions.get(formal.parameterId)\n\n    if (prior) {\n      if (!sameType(prior, actual)) {\n        fail(\"GENERIC_INFERENCE_CONFLICT\", `Conflicting inference for type parameter '${formal.parameterId}'.`, location)\n      }\n      return\n    }\n    if (!(actual.kind == \"TypeVariableReference\" && actual.parameterId == formal.parameterId) &&\n      typeContainsVariable(actual, formal.parameterId)) {\n      fail(\"GENERIC_INFERENCE_RECURSION\", `Recursive inference for type parameter '${formal.parameterId}'.`, location)\n    }\n    substitutions.set(formal.parameterId, actual)\n    return\n  }\n  if (formal.kind != actual.kind) {\n    fail(\"TYPE_MISMATCH\", `Call argument type ${typeDescription(actual)}; expected ${typeDescription(formal)}.`, location)\n  }\n  if (formal.kind == \"TypeReference\") {\n    if (!sameType(formal, actual)) {\n      fail(\"TYPE_MISMATCH\", `Call argument type ${typeDescription(actual)}; expected ${typeDescription(formal)}.`, location)\n    }\n    return\n  }\n  if (formal.kind == \"ReferenceType\" && actual.kind == \"ReferenceType\") {\n    if (formal.declarationId != actual.declarationId) {\n      fail(\"TYPE_MISMATCH\", `Call argument type ${typeDescription(actual)}; expected ${typeDescription(formal)}.`, location)\n    }\n    return\n  }\n  if (formal.kind == \"RecordType\" && actual.kind == \"RecordType\") {\n    if (formal.declarationId != actual.declarationId || (formal.arguments?.length ?? 0) != (actual.arguments?.length ?? 0)) {\n      fail(\"TYPE_MISMATCH\", `Call argument type ${typeDescription(actual)}; expected ${typeDescription(formal)}.`, location)\n    }\n    for (let index = 0; index < (formal.arguments?.length ?? 0); index += 1) {\n      inferTypeArguments(/** @type {import(\"./types.js\").SemanticValueType} */ (formal.arguments?.[index]),\n        /** @type {import(\"./types.js\").SemanticValueType} */ (actual.arguments?.[index]), substitutions, location, fail)\n    }\n    return\n  }\n  if (formal.kind == \"ListType\" && actual.kind == \"ListType\") {\n    inferTypeArguments(formal.elementType, actual.elementType, substitutions, location, fail)\n    return\n  }\n  if (formal.kind == \"OptionalType\" && actual.kind == \"OptionalType\") {\n    inferTypeArguments(formal.valueType, actual.valueType, substitutions, location, fail)\n    return\n  }\n  if ((formal.kind == \"MapType\" && actual.kind == \"MapType\") ||\n    (formal.kind == \"OrderedMapType\" && actual.kind == \"OrderedMapType\")) {\n    inferTypeArguments(formal.keyType, actual.keyType, substitutions, location, fail)\n    inferTypeArguments(formal.valueType, actual.valueType, substitutions, location, fail)\n  }\n}\n\n/**\n * Checks the occurs constraint for first-order inference.\n * @param {import(\"./types.js\").SemanticValueType} type - Candidate inferred type.\n * @param {string} parameterId - Parameter being inferred.\n * @returns {boolean} Whether the type recursively contains the parameter.\n */\nfunction typeContainsVariable(type, parameterId) {\n  if (type.kind == \"TypeVariableReference\") return type.parameterId == parameterId\n  if (type.kind == \"RecordType\") return type.arguments?.some((argument) => typeContainsVariable(argument, parameterId)) ?? false\n  if (type.kind == \"ListType\") return typeContainsVariable(type.elementType, parameterId)\n  if (type.kind == \"MapType\" || type.kind == \"OrderedMapType\") {\n    return typeContainsVariable(type.keyType, parameterId) || typeContainsVariable(type.valueType, parameterId)\n  }\n  if (type.kind == \"OptionalType\") return typeContainsVariable(type.valueType, parameterId)\n\n  return false\n}\n\n/**\n * Applies substitutions to a value or void return type.\n * @param {import(\"./types.js\").SemanticFunctionReturnType} type - Open return type.\n * @param {Map<string, import(\"./types.js\").SemanticValueType>} substitutions - Closed substitutions.\n * @returns {import(\"./types.js\").SemanticFunctionReturnType} Substituted return type.\n */\nfunction substituteReturnType(type, substitutions) {\n  return isVoidType(type) ? type : substituteValueType(type, substitutions)\n}\n\n/**\n * Builds the exact semantic signature bound to one declaration.\n * @param {import(\"./types.js\").FunctionDeclaration} declaration - Resolved declaration.\n * @param {RecordRegistry} records - Record declarations by identity.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {Map<string, import(\"./types.js\").SemanticValueType>} [substitutions] - Inferred generic substitutions.\n * @returns {import(\"./types.js\").ResolvedFunctionSignature} Detached signature binding.\n */\nfunction signatureFor(declaration, records, fail, substitutions = new Map()) {\n  const typeParameters = declarationTypeParameterIds(declaration)\n  const declaredParameters = declaration.typeParameters ?? []\n  const parameterTypes = declaration.parameters.map((parameter) =>\n    substituteValueType(validateValueTypeReference(parameter.type, parameter.location, fail, undefined, records, typeParameters), substitutions))\n  const returnType = substituteReturnType(\n    validateReturnTypeReference(declaration.returnType, declaration.location, fail, records, typeParameters), substitutions)\n\n  return {\n    declarationId: /** @type {string} */ (declaration.id),\n    kind: \"ResolvedFunctionSignature\",\n    parameterTypes: parameterTypes.map((type) => /** @type {import(\"./types.js\").SemanticTypeIdentity} */ (typeIdentity(type))),\n    returnType: typeIdentity(returnType),\n    ...(declaredParameters.length > 0 ? {\n      typeArguments: declaredParameters.map((parameter) =>\n        /** @type {import(\"./types.js\").SemanticTypeIdentity} */ (typeIdentity(/** @type {import(\"./types.js\").SemanticValueType} */ (\n          substitutions.get(/** @type {string} */ (parameter.id))\n        ))))\n    } : {})\n  }\n}\n\n/**\n * Validates an externally supplied call binding against the declaration collected for this module.\n * @param {unknown} actual - Candidate call resolution.\n * @param {import(\"./types.js\").ResolvedFunctionSignature} expected - Exact declaration signature.\n * @param {import(\"./types.js\").SourceLocation} location - Call location.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {void}\n */\nfunction validateResolution(actual, expected, location, fail) {\n  const expectedKeys = expected.typeArguments ? \"declarationId,kind,parameterTypes,returnType,typeArguments\" :\n    \"declarationId,kind,parameterTypes,returnType\"\n\n  if (!actual || typeof actual != \"object\" || Array.isArray(actual) ||\n    Object.keys(actual).sort().join(\",\") != expectedKeys) {\n    fail(\"TYPE_MISMATCH\", \"Call is missing an exact resolved function signature.\", location)\n  }\n  const candidate = /** @type {import(\"./types.js\").ResolvedFunctionSignature} */ (actual)\n\n  if (candidate.kind != \"ResolvedFunctionSignature\" || typeof candidate.declarationId != \"string\" ||\n    !Array.isArray(candidate.parameterTypes) || !validTypeIdentity(candidate.returnType, true) ||\n    candidate.declarationId != expected.declarationId ||\n    !sameTypeIdentity(candidate.returnType, expected.returnType) || candidate.parameterTypes.length != expected.parameterTypes.length) {\n    fail(\"TYPE_MISMATCH\", \"Call resolution does not match its declaration signature.\", location)\n  }\n  if (expected.typeArguments) {\n    const candidateTypeArguments = candidate.typeArguments\n\n    if (!isDenseArray(candidateTypeArguments) || candidateTypeArguments.length != expected.typeArguments.length ||\n      candidateTypeArguments.some((type, index) =>\n        !validTypeIdentity(type, false) || !sameTypeIdentity(type, expected.typeArguments?.[index]))) {\n      fail(\"TYPE_MISMATCH\", \"Call resolution does not match its inferred type arguments.\", location)\n    }\n  }\n  for (let index = 0; index < candidate.parameterTypes.length; index++) {\n    const type = candidate.parameterTypes[index]\n\n    if (!Object.hasOwn(candidate.parameterTypes, index) || !validTypeIdentity(type, false) ||\n      !sameTypeIdentity(type, expected.parameterTypes[index])) {\n      fail(\"TYPE_MISMATCH\", \"Call resolution does not match its declaration signature.\", location)\n    }\n  }\n}\n\n/**\n * Validates exact caller-owned constructor or method resolution metadata.\n * @param {unknown} actual - Candidate resolution.\n * @param {import(\"./types.js\").ResolvedConstructorSignature | import(\"./types.js\").ResolvedMethodSignature} expected - Exact resolution.\n * @param {import(\"./types.js\").SourceLocation} location - Expression location.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @param {\"constructor\" | \"method\"} role - Resolution role.\n * @returns {void}\n */\nfunction validateReferenceResolution(actual, expected, location, fail, role) {\n  const expectedMethod = role == \"method\" ? /** @type {import(\"./types.js\").ResolvedMethodSignature} */ (expected) : undefined\n  const expectedKeys = role == \"constructor\" ? \"declarationId,kind,parameterTypes\" :\n    expectedMethod?.resourceFlow ? \"declarationId,kind,parameterTypes,resourceFlow,returnType\" :\n      \"declarationId,kind,parameterTypes,returnType\"\n\n  if (!actual || typeof actual != \"object\" || Array.isArray(actual) || Object.keys(actual).sort().join(\",\") != expectedKeys) {\n    fail(\"TYPE_MISMATCH\", `Reference ${role} call is missing an exact resolved ${role} signature.`, location)\n  }\n  const candidate = /** @type {Record<string, unknown>} */ (actual)\n\n  if (candidate.kind != expected.kind || candidate.declarationId != expected.declarationId ||\n    !isDenseArray(candidate.parameterTypes) || candidate.parameterTypes.length != expected.parameterTypes.length ||\n    candidate.parameterTypes.some((type, index) => !validTypeIdentity(type, false) ||\n      !sameTypeIdentity(type, expected.parameterTypes[index])) ||\n    role == \"method\" && (!validTypeIdentity(candidate.returnType, true) ||\n      !sameTypeIdentity(candidate.returnType, /** @type {import(\"./types.js\").ResolvedMethodSignature} */ (expected).returnType) ||\n      JSON.stringify(candidate.resourceFlow) != JSON.stringify(expectedMethod?.resourceFlow))) {\n    fail(\"TYPE_MISMATCH\", `Resolved ${role} signature does not match its declaration.`, location)\n  }\n}\n\n/**\n * Makes a source identifier's ownership transfer explicit in normalized IR.\n * @param {import(\"./types.js\").Expression} expression - Candidate transfer expression.\n * @param {import(\"./types.js\").SemanticFunctionReturnType} expected - Destination type.\n * @param {boolean} normalize - Whether parser intent may be normalized.\n * @param {SemanticFail} fail - Located failure.\n * @returns {import(\"./types.js\").Expression} Explicit expression.\n */\nfunction normalizeOwnedMove(expression, expected, normalize, fail) {\n  if (expected.kind != \"OwnedResourceType\" && expected.kind != \"OwnedReferenceType\") return expression\n  if (expression.kind == \"OwnedMoveExpression\") return expression\n  if (expression.kind == \"PrivateFieldRead\") {\n    return fail(\"INVALID_RESOURCE_TRANSFER\", \"Private resource fields cannot be moved or exposed; transfer the owning reference.\",\n      expression.location)\n  }\n  if (expression.kind != \"IdentifierExpression\") return expression\n  if (!normalize) return fail(\"RESOURCE_MOVE_REQUIRED\", \"Owned transfer requires an explicit move expression.\", expression.location)\n\n  return {\n    expression,\n    kind: \"OwnedMoveExpression\",\n    location: expression.location,\n    sourceProvenance: expression.sourceProvenance,\n    type: expected\n  }\n}\n\n/**\n * Classifies the deliberately bounded Task 034 receiver transition.\n * @param {import(\"./types.js\").ClassDeclaration} declaration - Owned class.\n * @param {import(\"./types.js\").MethodDeclaration} method - Candidate method.\n * @param {SemanticFail} fail - Located failure.\n * @returns {{kind: \"preserve\" | \"terminal\", terminalFailureId?: string}} Receiver transition.\n */\nfunction ownedMethodResourceFlow(declaration, method, fail) {\n  const effectStatements = method.body.statements.flatMap((statement) => {\n    const expression = statement.kind == \"ExpressionStatement\" || statement.kind == \"ReturnStatement\" ? statement.expression :\n      statement.kind == \"LocalDeclaration\" ? statement.initializer : undefined\n\n    return expression?.kind == \"EffectCallExpression\" ? [expression] : []\n  })\n  const allEffects = methodEffectExpressions(method.body)\n\n  if (allEffects.length == 0) return {kind: \"preserve\"}\n  if (method.body.statements.length != 1 || effectStatements.length != 1 || allEffects.length != 1 ||\n    allEffects[0] !== effectStatements[0]) {\n    return fail(\"UNSUPPORTED_STATEMENT\",\n      `Owned method '${method.name}' must contain one direct resource operation or only pure statements.`, method.location)\n  }\n  const operation = effectStatements[0]\n  const flow = operation.resolution.resourceFlow\n\n  if (flow.kind == \"none\" || flow.kind == \"acquire\") return {kind: \"preserve\"}\n  const argument = operation.arguments[flow.parameterIndex]\n\n  const owned = declaration.ownership?.kind == \"ownedResource\" ? declaration.ownership : undefined\n  const borrowedParameterName = argument?.kind == \"OwnedBorrowExpression\" && argument.expression.kind == \"IdentifierExpression\"\n    ? argument.expression.name : undefined\n  const borrowedParameter = borrowedParameterName !== undefined &&\n    method.parameters.some((parameter) => parameter.name == borrowedParameterName && containsOwnedType(parameter.type))\n\n  if (borrowedParameter) return {kind: \"preserve\"}\n\n  if (!argument || argument.kind != \"OwnedBorrowExpression\" || argument.expression.kind != \"PrivateFieldRead\" ||\n    argument.expression.field != owned?.fieldId) {\n    return fail(\"INVALID_RESOURCE_BORROW\", `Owned method '${method.name}' must operate on its private resource field.`, operation.location)\n  }\n  return {kind: flow.kind == \"close\" ? \"terminal\" : \"preserve\", terminalFailureId: flow.terminalFailureId}\n}\n\n/**\n * Collects every host-effect site nested in one owned method body.\n * @param {import(\"./types.js\").Block} block - Method body.\n * @returns {import(\"./types.js\").Expression[]} Effectful expressions.\n */\nfunction methodEffectExpressions(block) {\n  /** @type {import(\"./types.js\").Expression[]} */\n  const effects = []\n  const pending = [/** @type {unknown} */ (block)]\n  const seen = new Set()\n\n  while (pending.length > 0) {\n    const value = pending.pop()\n\n    if (!value || typeof value != \"object\" || seen.has(value)) continue\n    seen.add(value)\n    if (!Array.isArray(value) && (Reflect.get(value, \"kind\") == \"EffectCallExpression\" ||\n      typeof Reflect.get(value, \"effectSiteId\") == \"string\")) {\n      effects.push(/** @type {import(\"./types.js\").Expression} */ (value))\n    }\n    for (const [key, child] of Object.entries(value)) {\n      if ([\"location\", \"resolution\", \"sourceProvenance\"].includes(key)) continue\n      if (Array.isArray(child)) pending.push(...child)\n      else if (child && typeof child == \"object\") pending.push(child)\n    }\n  }\n  return effects\n}\n\n/**\n * Rehydrates a closed capability type identity for ordinary expression checks.\n * @param {import(\"./types.js\").FunctionReturnTypeIdentity} identity - Closed identity.\n * @param {import(\"./types.js\").SourceLocation} location - Diagnostic location.\n * @param {SemanticFail} fail - Located failure.\n * @returns {import(\"./types.js\").SemanticValueType} Value type.\n */\nfunction identityAsValueType(identity, location, fail) {\n  if (typeof identity == \"string\") {\n    if (!isScalarTypeName(identity)) return fail(\"TYPE_MISMATCH\", \"Void or invalid identity used as an effect value type.\", location)\n    return scalarType(identity)\n  }\n  if (!identity || typeof identity != \"object\" || Array.isArray(identity)) {\n    return fail(\"TYPE_MISMATCH\", \"Malformed effect type identity.\", location)\n  }\n  const candidate = /** @type {Exclude<import(\"./types.js\").SemanticTypeIdentity, string>} */ (identity)\n\n  if (candidate.kind == \"OwnedResourceType\") return {kind: \"OwnedResourceType\", resourceId: candidate.resourceId}\n  if (candidate.kind == \"OwnedReferenceType\") return {declarationId: candidate.declarationId, kind: \"OwnedReferenceType\"}\n  if (candidate.kind == \"OptionalType\") return {kind: \"OptionalType\", valueType: identityAsValueType(candidate.valueType, location, fail)}\n  return fail(\"TYPE_MISMATCH\", \"Unsupported effect type identity.\", location)\n}\n\n/**\n * Converts a semantic type to its detached call-resolution identity.\n * @param {import(\"./types.js\").SemanticFunctionReturnType} type - Validated semantic type.\n * @returns {import(\"./types.js\").FunctionReturnTypeIdentity} Detached identity.\n */\nfunction typeIdentity(type) {\n  if (type.kind == \"TypeReference\") return type.name\n  if (type.kind == \"TypeVariableReference\") return {kind: \"TypeVariableReference\", parameterId: type.parameterId}\n  if (type.kind == \"RecordType\") return {\n    declarationId: type.declarationId,\n    kind: \"RecordType\",\n    ...(type.arguments ? {arguments: type.arguments.map((argument) =>\n      /** @type {import(\"./types.js\").SemanticTypeIdentity} */ (typeIdentity(argument)))} : {})\n  }\n  if (type.kind == \"ReferenceType\") return {declarationId: type.declarationId, kind: \"ReferenceType\"}\n  if (type.kind == \"OwnedResourceType\") return {kind: \"OwnedResourceType\", resourceId: type.resourceId}\n  if (type.kind == \"OwnedReferenceType\") return {declarationId: type.declarationId, kind: \"OwnedReferenceType\"}\n  if (type.kind == \"ListType\") return {elementType: /** @type {import(\"./types.js\").SemanticTypeIdentity} */ (typeIdentity(type.elementType)), kind: \"ListType\"}\n  if (type.kind == \"OptionalType\") return {kind: \"OptionalType\", valueType: /** @type {import(\"./types.js\").SemanticTypeIdentity} */ (typeIdentity(type.valueType))}\n  if (type.kind == \"OrderedMapType\") return {\n    keyType: /** @type {import(\"./types.js\").SemanticTypeIdentity} */ (typeIdentity(type.keyType)),\n    kind: \"OrderedMapType\",\n    order: \"insertion\",\n    valueType: /** @type {import(\"./types.js\").SemanticTypeIdentity} */ (typeIdentity(type.valueType))\n  }\n\n  return {\n    keyType: /** @type {import(\"./types.js\").SemanticTypeIdentity} */ (typeIdentity(type.keyType)),\n    kind: \"MapType\",\n    valueType: /** @type {import(\"./types.js\").SemanticTypeIdentity} */ (typeIdentity(type.valueType))\n  }\n}\n\n/**\n * Checks one externally supplied recursive type identity.\n * @param {unknown} type - Candidate identity.\n * @param {boolean} allowVoid - Whether void is permitted.\n * @param {Set<object>} [seen] - Active recursion path.\n * @returns {boolean} Whether the identity is closed and acyclic.\n */\nfunction validTypeIdentity(type, allowVoid, seen = new Set()) {\n  if (typeof type == \"string\") return isScalarTypeName(type) || allowVoid && type == \"void\"\n  if (!type || typeof type != \"object\" || Array.isArray(type) || seen.has(type)) return false\n\n  seen.add(type)\n  const candidate = /** @type {Record<string, unknown>} */ (type)\n  let valid = false\n\n  if (candidate.kind == \"ListType\" && Object.keys(candidate).sort().join(\",\") == \"elementType,kind\") {\n    valid = validTypeIdentity(candidate.elementType, false, seen)\n  } else if (candidate.kind == \"MapType\" && Object.keys(candidate).sort().join(\",\") == \"keyType,kind,valueType\") {\n    valid = candidate.keyType == \"string\" && validTypeIdentity(candidate.valueType, false, seen)\n  } else if (candidate.kind == \"OrderedMapType\" &&\n    Object.keys(candidate).sort().join(\",\") == \"keyType,kind,order,valueType\") {\n    valid = candidate.keyType == \"string\" && candidate.order == \"insertion\" &&\n      validTypeIdentity(candidate.valueType, false, seen)\n  } else if (candidate.kind == \"OptionalType\" && Object.keys(candidate).sort().join(\",\") == \"kind,valueType\") {\n    valid = validTypeIdentity(candidate.valueType, false, seen) &&\n      !(candidate.valueType && typeof candidate.valueType == \"object\" && Reflect.get(candidate.valueType, \"kind\") == \"OptionalType\")\n  } else if (candidate.kind == \"TypeVariableReference\" && Object.keys(candidate).sort().join(\",\") == \"kind,parameterId\") {\n    valid = typeof candidate.parameterId == \"string\" && /^(?:[a-z][a-z0-9._-]*#)?(?:record|function):[0-9]+:type:[0-9]+$/u.test(candidate.parameterId)\n  } else if (candidate.kind == \"RecordType\" &&\n    [\"arguments,declarationId,kind\", \"declarationId,kind\"].includes(Object.keys(candidate).sort().join(\",\"))) {\n    const candidateArguments = candidate.arguments\n\n    valid = typeof candidate.declarationId == \"string\" && /^(?:[a-z][a-z0-9._-]*#)?record:[0-9]+$/u.test(candidate.declarationId) &&\n      (candidateArguments === undefined || isDenseArray(candidateArguments) &&\n        candidateArguments.every((argument) => validTypeIdentity(argument, false, seen)))\n  } else if (candidate.kind == \"ReferenceType\" && Object.keys(candidate).sort().join(\",\") == \"declarationId,kind\") {\n    valid = typeof candidate.declarationId == \"string\" &&\n      /^(?:[a-z][a-z0-9._-]*#)?class:[0-9]+$/u.test(candidate.declarationId)\n  } else if (candidate.kind == \"OwnedResourceType\" && Object.keys(candidate).sort().join(\",\") == \"kind,resourceId\") {\n    valid = typeof candidate.resourceId == \"string\" && /^(?:module:[0-9]+\\/)?capability:[0-9]+\\/resource:[0-9]+$/u\n      .test(candidate.resourceId)\n  } else if (candidate.kind == \"OwnedReferenceType\" && Object.keys(candidate).sort().join(\",\") == \"declarationId,kind\") {\n    valid = typeof candidate.declarationId == \"string\" && /^(?:[a-z][a-z0-9._-]*#)?class:[0-9]+$/u.test(candidate.declarationId)\n  }\n  seen.delete(type)\n\n  return valid\n}\n\n/**\n * Checks array identity without relying on iteration methods that skip sparse slots.\n * @param {unknown} value - Candidate array.\n * @returns {value is unknown[]} Whether every indexed slot is present.\n */\nfunction isDenseArray(value) {\n  if (!Array.isArray(value)) return false\n\n  for (let index = 0; index < value.length; index += 1) {\n    if (!Object.hasOwn(value, index)) return false\n  }\n\n  return true\n}\n\n/**\n * Compares two closed type identities structurally.\n * @param {unknown} left - First identity.\n * @param {unknown} right - Second identity.\n * @returns {boolean} Whether the identities are equal.\n */\nfunction sameTypeIdentity(left, right) {\n  if (typeof left == \"string\" || typeof right == \"string\") return left === right\n  if (!left || !right || typeof left != \"object\" || typeof right != \"object\") return false\n  const leftType = /** @type {Record<string, unknown>} */ (left)\n  const rightType = /** @type {Record<string, unknown>} */ (right)\n\n  if (leftType.kind != rightType.kind) return false\n  if (leftType.kind == \"ListType\") return sameTypeIdentity(leftType.elementType, rightType.elementType)\n  if (leftType.kind == \"OptionalType\") return sameTypeIdentity(leftType.valueType, rightType.valueType)\n  if (leftType.kind == \"TypeVariableReference\") return leftType.parameterId == rightType.parameterId\n  if (leftType.kind == \"RecordType\") {\n    const leftArguments = Array.isArray(leftType.arguments) ? leftType.arguments : []\n    const rightArguments = Array.isArray(rightType.arguments) ? rightType.arguments : []\n\n    return leftType.declarationId == rightType.declarationId && leftArguments.length == rightArguments.length &&\n      leftArguments.every((argument, index) => sameTypeIdentity(argument, rightArguments[index]))\n  }\n  if (leftType.kind == \"ReferenceType\") return leftType.declarationId == rightType.declarationId\n  if (leftType.kind == \"OwnedResourceType\") return leftType.resourceId == rightType.resourceId\n  if (leftType.kind == \"OwnedReferenceType\") return leftType.declarationId == rightType.declarationId\n  if (leftType.kind == \"MapType\" || leftType.kind == \"OrderedMapType\") {\n    return sameTypeIdentity(leftType.keyType, rightType.keyType) && sameTypeIdentity(leftType.valueType, rightType.valueType)\n  }\n\n  return false\n}\n\n/**\n * Compares two validated semantic types structurally.\n * @param {import(\"./types.js\").SemanticFunctionReturnType} left - First type.\n * @param {import(\"./types.js\").SemanticFunctionReturnType} right - Second type.\n * @returns {boolean} Whether the types are equal.\n */\nfunction sameType(left, right) {\n  return sameTypeIdentity(typeIdentity(left), typeIdentity(right))\n}\n\n/**\n * Formats one validated semantic type for diagnostics.\n * @param {import(\"./types.js\").SemanticFunctionReturnType | import(\"./types.js\").ErrorType} type - Semantic type.\n * @returns {string} Stable recursive spelling.\n */\nfunction typeDescription(type) {\n  if (type.kind == \"TypeReference\") return type.name\n  if (type.kind == \"TypeVariableReference\") return `type-variable<${type.parameterId}>`\n  if (type.kind == \"RecordType\") return `record<${type.declarationId}${type.arguments?.length\n    ? `, ${type.arguments.map(typeDescription).join(\", \")}` : \"\"}>`\n  if (type.kind == \"ReferenceType\") return `reference<${type.declarationId}>`\n  if (type.kind == \"OwnedResourceType\") return `owned-resource<${type.resourceId}>`\n  if (type.kind == \"OwnedReferenceType\") return `owned-reference<${type.declarationId}>`\n  if (type.kind == \"ErrorType\") return `error<${type.declarationId}>`\n  if (type.kind == \"ListType\") return `list<${typeDescription(type.elementType)}>`\n  if (type.kind == \"OptionalType\") return `optional<${typeDescription(type.valueType)}>`\n  if (type.kind == \"OrderedMapType\") return `ordered-map<string, ${typeDescription(type.valueType)}, insertion>`\n\n  return `map<string, ${typeDescription(type.valueType)}>`\n}\n\n/**\n * Checks whether a type graph contains linear ownership.\n * @param {unknown} type - Candidate semantic type.\n * @param {Set<object>} [seen] - Visited type containers.\n * @returns {boolean} Whether ownership occurs at any depth.\n */\nfunction containsOwnedType(type, seen = new Set()) {\n  if (!type || typeof type != \"object\" || Array.isArray(type) || seen.has(type)) return false\n  seen.add(type)\n  const kind = Reflect.get(type, \"kind\")\n\n  if (kind == \"OwnedResourceType\" || kind == \"OwnedReferenceType\") return true\n  if (kind == \"ListType\") return containsOwnedType(Reflect.get(type, \"elementType\"), seen)\n  if (kind == \"OptionalType\") return containsOwnedType(Reflect.get(type, \"valueType\"), seen)\n  if (kind == \"MapType\" || kind == \"OrderedMapType\") {\n    return containsOwnedType(Reflect.get(type, \"keyType\"), seen) || containsOwnedType(Reflect.get(type, \"valueType\"), seen)\n  }\n  if (kind == \"RecordType\") {\n    const arguments_ = Reflect.get(type, \"arguments\")\n\n    return Array.isArray(arguments_) && arguments_.some((argument) => containsOwnedType(argument, seen))\n  }\n  return false\n}\n\n/**\n * Checks one scalar semantic type.\n * @param {import(\"./types.js\").SemanticFunctionReturnType} type - Semantic type.\n * @param {import(\"./types.js\").SemanticTypeName} [name] - Optional required scalar.\n * @returns {type is import(\"./types.js\").TypeReference} Whether it is the requested scalar.\n */\nfunction isScalarType(type, name) {\n  return type.kind == \"TypeReference\" && isScalarTypeName(type.name) && (name === undefined || type.name == name)\n}\n\n/**\n * Checks the sole non-value return type.\n * @param {import(\"./types.js\").SemanticFunctionReturnType} type - Semantic type.\n * @returns {type is import(\"./types.js\").FunctionReturnTypeReference} Whether it is void.\n */\nfunction isVoidType(type) {\n  return type.kind == \"TypeReference\" && type.name == \"void\"\n}\n\n/**\n * Requires a scalar type for the pre-collection operator contract.\n * @param {import(\"./types.js\").SemanticValueType} type - Operand type.\n * @param {import(\"./types.js\").SourceLocation} location - Operand location.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {import(\"./types.js\").SemanticTypeName} Scalar name.\n */\nfunction scalarNameForOperation(type, location, fail) {\n  if (!isScalarType(type)) {\n    return fail(\"INVALID_OPERAND_TYPE\", `Scalar operation received ${typeDescription(type)}.`, location)\n  }\n\n  return type.name\n}\n\n/**\n * Enforces that a total collection access is proven or uses a source operation that fails on absence.\n * @param {import(\"./types.js\").ListIndexExpression | import(\"./types.js\").MapLookupExpression} expression - Access.\n * @param {boolean} proven - Whether static literal propagation proves presence.\n * @param {boolean} normalizeOperations - Whether this is frontend admission.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {void}\n */\nfunction validateAccessTotality(expression, proven, normalizeOperations, fail) {\n  if (proven) {\n    if (normalizeOperations) expression.totality = \"proven\"\n    else if (expression.totality != \"proven\" && expression.totality != \"fail-on-absence\") {\n      fail(\"UNCHECKED_COLLECTION_ACCESS\", \"Collection access lacks a totality guarantee.\", expression.location)\n    }\n\n    return\n  }\n  if (expression.totality != \"fail-on-absence\") {\n    fail(\"UNCHECKED_COLLECTION_ACCESS\", \"Collection access is not statically proven and does not fail on absence.\", expression.location)\n  }\n}\n\n/**\n * Resolves a binding without producing a diagnostic.\n * @param {string} name - Binding name.\n * @param {Scope} scope - Visible scope.\n * @returns {Binding | undefined} Binding when visible.\n */\nfunction findBinding(name, scope) {\n  for (let current = /** @type {Scope | undefined} */ (scope); current; current = current.parent) {\n    const binding = current.bindings.get(name)\n\n    if (binding) return binding\n  }\n\n  return undefined\n}\n\n/**\n * Returns the existing bindings whose known values must be merged across a conditional.\n * @param {Scope} scope - Visible scope.\n * @returns {Binding[]} Nearest-to-farthest bindings.\n */\nfunction bindingsVisibleFrom(scope) {\n  const bindings = []\n\n  for (let current = /** @type {Scope | undefined} */ (scope); current; current = current.parent) {\n    bindings.push(...current.bindings.values())\n  }\n\n  return bindings\n}\n\n/**\n * Finds visible mutable bindings that a loop body may assign on any nested path.\n * The set is computed after validating the list expression because collection evaluation precedes body effects.\n * @param {import(\"./types.js\").Block} block - Candidate loop body.\n * @param {Scope} outerScope - Scope visible before entering the loop.\n * @param {Set<Binding>} [assigned] - Accumulated binding identities.\n * @returns {Set<Binding>} Exactly the visible mutable bindings targeted by nested assignments.\n */\nfunction outerMutableBindingsAssignedBy(block, outerScope, assigned = new Set()) {\n  for (const statement of block.statements) {\n    if (statement.kind == \"AssignmentStatement\") {\n      const binding = findBinding(statement.target.name, outerScope)\n\n      if (binding?.mutable) assigned.add(binding)\n    } else if (statement.kind == \"IfStatement\") {\n      outerMutableBindingsAssignedBy(statement.consequent, outerScope, assigned)\n      if (statement.alternate) outerMutableBindingsAssignedBy(statement.alternate, outerScope, assigned)\n    } else if (statement.kind == \"ForEachStatement\" || statement.kind == \"ForEachMapStatement\" || statement.kind == \"WhileStatement\") {\n      outerMutableBindingsAssignedBy(statement.body, outerScope, assigned)\n    } else if (statement.kind == \"TryStatement\") {\n      outerMutableBindingsAssignedBy(statement.body, outerScope, assigned)\n      outerMutableBindingsAssignedBy(statement.catchBody, outerScope, assigned)\n    }\n  }\n\n  return assigned\n}\n\n/**\n * Propagates only immutable values whose exact collection contents remain known.\n * @param {import(\"./types.js\").Expression} expression - Expression.\n * @param {Scope} scope - Visible scope.\n * @returns {import(\"./types.js\").Expression | undefined} Known value.\n */\nfunction knownValueForExpression(expression, scope) {\n  if ([\"IntegerLiteral\", \"BooleanLiteral\", \"StringLiteral\", \"ListLiteral\", \"MapLiteral\", \"OrderedMapLiteral\"].includes(expression.kind)) return expression\n  if (expression.kind == \"IdentifierExpression\") return findBinding(expression.name, scope)?.knownValue\n  if (expression.kind == \"ListIndexExpression\") return provenListElement(expression.collection, expression.index, scope)\n  if (expression.kind == \"MapLookupExpression\") return provenMapValue(expression.collection, expression.key, scope)\n\n  return undefined\n}\n\n/**\n * Finds the statically selected list element.\n * @param {import(\"./types.js\").Expression} collection - List receiver.\n * @param {import(\"./types.js\").Expression} index - Index expression.\n * @param {Scope} scope - Visible scope.\n * @returns {import(\"./types.js\").Expression | undefined} Proven element.\n */\nfunction provenListElement(collection, index, scope) {\n  const knownCollection = knownValueForExpression(collection, scope)\n  const knownIndex = knownValueForExpression(index, scope)\n\n  if (knownCollection?.kind != \"ListLiteral\" || knownIndex?.kind != \"IntegerLiteral\" ||\n    knownIndex.value < 0 || knownIndex.value >= knownCollection.elements.length) return undefined\n\n  return knownCollection.elements[knownIndex.value]\n}\n\n/**\n * Finds the statically selected map value.\n * @param {import(\"./types.js\").Expression} collection - Map receiver.\n * @param {import(\"./types.js\").Expression} key - Key expression.\n * @param {Scope} scope - Visible scope.\n * @returns {import(\"./types.js\").Expression | undefined} Proven value.\n */\nfunction provenMapValue(collection, key, scope) {\n  const knownCollection = knownValueForExpression(collection, scope)\n  const knownKey = knownValueForExpression(key, scope)\n\n  if (knownCollection?.kind != \"MapLiteral\" && knownCollection?.kind != \"OrderedMapLiteral\" ||\n    knownKey?.kind != \"StringLiteral\") return undefined\n\n  return knownCollection.entries.find((entry) => entry.key.value == knownKey.value)?.value\n}\n\n/**\n * Identifies numeric strings independently from any target's key coercions.\n * @param {string} value - Literal key.\n * @returns {boolean} Whether it is numeric.\n */\nfunction isNumericString(value) {\n  return /^[+-]?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?$/iu.test(value.trim())\n}\n\n/**\n * Selects an exact semantic token location when parser provenance is available.\n * @param {{location: import(\"./types.js\").SourceLocation, sourceProvenance?: import(\"./types.js\").SemanticNodeSourceProvenance}} node - Located semantic node.\n * @param {string} role - Token role.\n * @returns {import(\"./types.js\").SourceLocation} Exact or owning location.\n */\nfunction roleLocation(node, role) {\n  return node.sourceProvenance?.ranges[role] ?? parserRangeFor(node, role) ?? node.location\n}\n\n/**\n * Selects the exact type token or the owning declaration location.\n * @param {unknown} type - Candidate type reference.\n * @param {import(\"./types.js\").SourceLocation} ownerLocation - Owning declaration location.\n * @param {string} [role] - Recursive type role.\n * @returns {import(\"./types.js\").SourceLocation} Exact type location when known.\n */\nfunction typeLocation(type, ownerLocation, role = \"type\") {\n  if (!type || typeof type != \"object\" || Array.isArray(type)) return ownerLocation\n  const candidate = /** @type {import(\"./types.js\").SemanticFunctionReturnType} */ (type)\n\n  return candidate.sourceProvenance?.ranges[role] ?? parserRangeFor(candidate, role) ??\n    candidate.sourceProvenance?.ranges.type ?? parserRangeFor(candidate, \"type\") ?? ownerLocation\n}\n\n/** @type {Readonly<Record<import(\"./types.js\").SemanticUnaryOperation, {operand: import(\"./types.js\").SemanticTypeName, result: import(\"./types.js\").SemanticTypeName}>>} */\nconst unaryOperationSignatures = Object.freeze({\n  BooleanNot: Object.freeze({operand: \"boolean\", result: \"boolean\"}),\n  IntegerNegate: Object.freeze({operand: \"integer\", result: \"integer\"})\n})\n\n/** @type {Readonly<Record<import(\"./types.js\").SemanticBinaryOperation, {left: import(\"./types.js\").SemanticTypeName, right: import(\"./types.js\").SemanticTypeName, result: import(\"./types.js\").SemanticTypeName}>>} */\nconst binaryOperationSignatures = Object.freeze({\n  BooleanAnd: Object.freeze({left: \"boolean\", result: \"boolean\", right: \"boolean\"}),\n  BooleanEqual: Object.freeze({left: \"boolean\", result: \"boolean\", right: \"boolean\"}),\n  BooleanNotEqual: Object.freeze({left: \"boolean\", result: \"boolean\", right: \"boolean\"}),\n  BooleanOr: Object.freeze({left: \"boolean\", result: \"boolean\", right: \"boolean\"}),\n  IntegerAdd: Object.freeze({left: \"integer\", result: \"integer\", right: \"integer\"}),\n  IntegerEqual: Object.freeze({left: \"integer\", result: \"boolean\", right: \"integer\"}),\n  IntegerGreaterThan: Object.freeze({left: \"integer\", result: \"boolean\", right: \"integer\"}),\n  IntegerGreaterThanOrEqual: Object.freeze({left: \"integer\", result: \"boolean\", right: \"integer\"}),\n  IntegerLessThan: Object.freeze({left: \"integer\", result: \"boolean\", right: \"integer\"}),\n  IntegerLessThanOrEqual: Object.freeze({left: \"integer\", result: \"boolean\", right: \"integer\"}),\n  IntegerMultiply: Object.freeze({left: \"integer\", result: \"integer\", right: \"integer\"}),\n  IntegerNotEqual: Object.freeze({left: \"integer\", result: \"boolean\", right: \"integer\"}),\n  IntegerSubtract: Object.freeze({left: \"integer\", result: \"integer\", right: \"integer\"}),\n  StringConcat: Object.freeze({left: \"string\", result: \"string\", right: \"string\"}),\n  StringEqual: Object.freeze({left: \"string\", result: \"boolean\", right: \"string\"}),\n  StringNotEqual: Object.freeze({left: \"string\", result: \"boolean\", right: \"string\"})\n})\n\n/**\n * Selects one typed unary meaning from parser-normalized source intent.\n * @param {unknown} sourceOperation - Transient frontend operation.\n * @param {import(\"./types.js\").SemanticTypeName} operandType - Resolved operand type.\n * @param {import(\"./types.js\").SourceLocation} location - Operand location.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {import(\"./types.js\").SemanticUnaryOperation} Semantic operation.\n */\nfunction normalizeUnaryOperation(sourceOperation, operandType, location, fail) {\n  if (sourceOperation == \"Negate\") {\n    if (operandType != \"integer\") fail(\"INVALID_OPERAND_TYPE\", `Integer negation requires integer; received ${operandType}.`, location)\n    return \"IntegerNegate\"\n  }\n  if (sourceOperation == \"Not\") {\n    if (operandType != \"boolean\") fail(\"INVALID_OPERAND_TYPE\", `Boolean not requires boolean; received ${operandType}.`, location)\n    return \"BooleanNot\"\n  }\n\n  return fail(\"TYPE_MISMATCH\", `Unknown unary source operation ${String(sourceOperation)}.`, location)\n}\n\n/**\n * Selects one typed binary meaning from parser-normalized source intent.\n * @param {unknown} sourceOperation - Transient frontend operation.\n * @param {import(\"./types.js\").SemanticTypeName} leftType - Resolved left type.\n * @param {import(\"./types.js\").SemanticTypeName} rightType - Resolved right type.\n * @param {import(\"./types.js\").SourceLocation} leftLocation - Left operand location.\n * @param {import(\"./types.js\").SourceLocation} rightLocation - Right operand location.\n * @param {import(\"./types.js\").SourceLocation} expressionLocation - Whole operation location.\n * @param {SemanticFail} fail - Diagnostic callback.\n * @returns {import(\"./types.js\").SemanticBinaryOperation} Semantic operation.\n */\nfunction normalizeBinaryOperation(sourceOperation, leftType, rightType, leftLocation, rightLocation, expressionLocation, fail) {\n  if (sourceOperation == \"PhpAdd\") {\n    if (leftType == \"string\" && rightType == \"string\") {\n      return fail(\"UNSUPPORTED_SYNTAX\", \"PHP binary + does not concatenate strings; use . instead.\", expressionLocation)\n    }\n\n    sourceOperation = \"Add\"\n  }\n\n  if (sourceOperation == \"StringConcat\") {\n    if (leftType != \"string\") fail(\"INVALID_OPERAND_TYPE\", `String concatenation requires string; received ${leftType}.`, leftLocation)\n    if (rightType != \"string\") fail(\"INVALID_OPERAND_TYPE\", `String concatenation requires string; received ${rightType}.`, rightLocation)\n    return \"StringConcat\"\n  }\n\n  if (sourceOperation == \"Add\") {\n    if (leftType == \"integer\" && rightType == \"integer\") return \"IntegerAdd\"\n    if (leftType == \"string\" && rightType == \"string\") return \"StringConcat\"\n\n    const location = leftType == \"integer\" || leftType == \"string\" ? rightLocation : leftLocation\n\n    return fail(\"INVALID_OPERAND_TYPE\", `Addition requires two integers or two strings; received ${leftType} and ${rightType}.`, location)\n  }\n\n  const fixedOperations = /** @type {const} */ ({\n    And: [\"boolean\", \"BooleanAnd\"],\n    GreaterThan: [\"integer\", \"IntegerGreaterThan\"],\n    GreaterThanOrEqual: [\"integer\", \"IntegerGreaterThanOrEqual\"],\n    LessThan: [\"integer\", \"IntegerLessThan\"],\n    LessThanOrEqual: [\"integer\", \"IntegerLessThanOrEqual\"],\n    Multiply: [\"integer\", \"IntegerMultiply\"],\n    Or: [\"boolean\", \"BooleanOr\"],\n    Subtract: [\"integer\", \"IntegerSubtract\"]\n  })\n  const fixed = Reflect.get(fixedOperations, String(sourceOperation))\n\n  if (fixed) {\n    const [requiredType, operation] = fixed\n\n    if (leftType != requiredType) fail(\"INVALID_OPERAND_TYPE\", `${String(sourceOperation)} requires ${requiredType}; received ${leftType}.`, leftLocation)\n    if (rightType != requiredType) fail(\"INVALID_OPERAND_TYPE\", `${String(sourceOperation)} requires ${requiredType}; received ${rightType}.`, rightLocation)\n\n    return /** @type {import(\"./types.js\").SemanticBinaryOperation} */ (operation)\n  }\n\n  if (sourceOperation == \"JavaEqual\" || sourceOperation == \"JavaNotEqual\") {\n    if (leftType == \"string\" || rightType == \"string\") {\n      return fail(\"UNSUPPORTED_SYNTAX\", \"Java reference equality is outside the implemented semantic subset.\", expressionLocation)\n    }\n\n    sourceOperation = sourceOperation == \"JavaEqual\" ? \"Equal\" : \"NotEqual\"\n  }\n\n  if (sourceOperation == \"StringEqual\" || sourceOperation == \"StringNotEqual\") {\n    if (leftType != \"string\") fail(\"INVALID_OPERAND_TYPE\", `String equality requires string; received ${leftType}.`, leftLocation)\n    if (rightType != \"string\") fail(\"INVALID_OPERAND_TYPE\", `String equality requires string; received ${rightType}.`, rightLocation)\n\n    return /** @type {\"StringEqual\" | \"StringNotEqual\"} */ (sourceOperation)\n  }\n\n  if (sourceOperation == \"Equal\" || sourceOperation == \"NotEqual\") {\n    if (leftType != rightType) {\n      return fail(\"MISMATCHED_EQUALITY_TYPES\", `Equality requires matching scalar types; received ${leftType} and ${rightType}.`, rightLocation)\n    }\n\n    const prefix = leftType == \"integer\" ? \"Integer\" : leftType == \"boolean\" ? \"Boolean\" : \"String\"\n\n    return /** @type {import(\"./types.js\").SemanticBinaryOperation} */ (`${prefix}${sourceOperation}`)\n  }\n\n  return fail(\"TYPE_MISMATCH\", `Unknown binary source operation ${String(sourceOperation)}.`, leftLocation)\n}\n\n/**\n * Replaces transient frontend intent with the public typed operation fields.\n * @param {object} expression - Mutable adapted expression.\n * @param {import(\"./types.js\").SemanticUnaryOperation | import(\"./types.js\").SemanticBinaryOperation} operation - Typed operation.\n * @param {import(\"./types.js\").SemanticTypeName} type - Explicit result type.\n * @returns {void}\n */\nfunction setNormalizedOperation(expression, operation, type) {\n  Reflect.set(expression, \"operation\", operation)\n  Reflect.set(expression, \"type\", type)\n}\n"]}