semantifold 0.3.0 → 0.4.0

package/build/src/semantic/effects.js

@@ -0,0 +1,764 @@
+// @ts-check
+import { authorizedOperation, isTask034OperationName } from "./capabilities.js";
+import { parseProtectedEntryName } from "./stdlib.js";
+/** @typedef {{failureIds: Set<string>, host: boolean}} EffectSummary */
+/** @typedef {(expression: import("./types.js").Expression) => void} ExpressionVisitor */
+/**
+ * Resolves compiler-authorized calls before ordinary semantic type validation.
+ * Source functions always win; authority is never inferred from spelling alone.
+ * @param {import("./types.js").SemanticModule} module - Parser-authored module.
+ * @param {string} language - Source language identity for protected entry targets.
+ * @param {Map<string, import("./types.js").FunctionDeclaration>} functions - Visible ordinary functions.
+ * @param {(code: string, detail: string, location: import("./types.js").SourceLocation) => never} fail - Located failure.
+ * @param {boolean} normalize - Whether parser-authored operation intent may be normalized.
+ * @param {Map<string, import("./types.js").ClassDeclaration>} [visibleClasses] - Resolved reference classes.
+ * @returns {void}
+ */
+export function validateEffectGraph(module, language, functions, fail, normalize, visibleClasses = new Map()) {
+    const capabilities = module.capabilities ?? [];
+    const capabilityIds = new Set();
+    const operationIds = new Set();
+    const resourceIds = new Set();
+    const failureIds = new Set();
+    const operationNames = new Set();
+    if (!Array.isArray(capabilities))
+        fail("INVALID_CAPABILITY_AUTHORITY", "Capabilities must be an ordered array.", module.location);
+    for (const [capabilityIndex, capability] of capabilities.entries()) {
+        const legacyId = `capability:${capabilityIndex}`;
+        if (!capability || capability.kind != "EffectCapabilityDeclaration" ||
+            capability.id != legacyId && !/^module:\d+\/capability:\d+$/u.test(capability.id) || capabilityIds.has(capability.id) ||
+            typeof capability.authorityId != "string" || typeof capability.name != "string" || !Array.isArray(capability.resources) ||
+            !Array.isArray(capability.failures) || !Array.isArray(capability.operations)) {
+            fail("INVALID_CAPABILITY_AUTHORITY", "Malformed capability declaration graph.", module.location);
+        }
+        capabilityIds.add(capability.id);
+        for (const [index, resource] of capability.resources.entries()) {
+            if (resource.kind != "EffectResourceDeclaration" || resource.id != `${capability.id}/resource:${index}` ||
+                resourceIds.has(resource.id))
+                fail("INVALID_CAPABILITY_AUTHORITY", "Malformed capability resource identity.", module.location);
+            resourceIds.add(resource.id);
+        }
+        for (const [index, failure] of capability.failures.entries()) {
+            if (failure.kind != "EffectFailureDeclaration" || failure.id != `${capability.id}/failure:${index}` ||
+                failureIds.has(failure.id))
+                fail("INVALID_CAPABILITY_AUTHORITY", "Malformed capability failure identity.", module.location);
+            failureIds.add(failure.id);
+        }
+    }
+    for (const capability of capabilities) {
+        for (const [index, operation] of capability.operations.entries()) {
+            if (operation.kind != "EffectOperationDeclaration" || operation.id != `${capability.id}/operation:${index}` ||
+                operationIds.has(operation.id) || operationNames.has(operation.name) || !Array.isArray(operation.parameters) ||
+                !Array.isArray(operation.failureIds) || operation.effects?.length != 1 || operation.effects[0] != "host" ||
+                operation.failureIds.some((id) => !failureIds.has(id))) {
+                fail("INVALID_CAPABILITY_AUTHORITY", "Malformed or ambiguous capability operation graph.", module.location);
+            }
+            operationIds.add(operation.id);
+            operationNames.add(operation.name);
+        }
+    }
+    for (const declaration of [
+        ...module.functions,
+        ...(module.records ?? []),
+        ...(module.classes ?? []),
+        ...(module.errors ?? [])
+    ]) {
+        if (parseProtectedEntryName(declaration.name) !== null) {
+            fail("STDLIB_PROTECTED_BINDING_ACCESS", `Source declaration '${declaration.name}' captures a reserved protected provider binding.`, declaration.location);
+        }
+    }
+    forEachExpression(module, (expression) => {
+        if (expression.kind == "EffectCallExpression") {
+            const capability = capabilities.find(({ id }) => id == expression.resolution?.capabilityId);
+            const operation = capability?.operations.find(({ id }) => id == expression.operation);
+            if (operation && expression.resolution.operationId == operation.id &&
+                (!Array.isArray(expression.resolution.failureIds) ||
+                    expression.resolution.failureIds.join(",") != operation.failureIds.join(","))) {
+                fail("UNDECLARED_FAILURE", "UNDECLARED_FAILURE: Effect call failure boundary does not match its compiler authority.", expression.location);
+            }
+            if (!operation || expression.resolution.operationId != operation.id ||
+                JSON.stringify(expression.resolution) != JSON.stringify(signature(/** @type {import("./types.js").EffectCapabilityDeclaration} */ (capability), operation))) {
+                fail("UNDECLARED_EFFECT", "Effect call resolution does not match its compiler authority.", expression.location);
+            }
+            return;
+        }
+        if (expression.kind == "IdentifierExpression" && parseProtectedEntryName(expression.name) !== null) {
+            fail("STDLIB_PROTECTED_BINDING_ACCESS", `Reference to protected provider entry '${expression.name}' is not portable code.`, expression.location);
+        }
+        if (expression.kind != "CallExpression")
+            return;
+        if (functions.has(expression.callee))
+            return;
+        let operationName = expression.callee;
+        const protectedEntry = parseProtectedEntryName(expression.callee);
+        if (protectedEntry !== null) {
+            if (capabilities.length == 0) {
+                fail("STDLIB_PROTECTED_BINDING_ACCESS", `Protected provider entry '${expression.callee}' requires an explicit capability authority.`, expression.location);
+            }
+            if (protectedEntry.target != language) {
+                fail("STDLIB_PROTECTED_BINDING_ACCESS", `Protected provider entry target '${protectedEntry.target}' does not match source language '${language}'.`, expression.location);
+            }
+            operationName = protectedEntry.operation;
+        }
+        const match = authorizedOperation(capabilities, operationName);
+        if (!match) {
+            if (protectedEntry !== null) {
+                fail("STDLIB_PROTECTED_BINDING_ACCESS", `Protected provider entry for undeclared operation '${operationName}' has no authorized capability operation.`, expression.location);
+            }
+            if (isTask034OperationName(operationName)) {
+                fail("MISSING_CAPABILITY_AUTHORITY", `Operation '${operationName}' requires explicit compiler authority.`, expression.location);
+            }
+            return;
+        }
+        if (!normalize) {
+            fail("UNDECLARED_EFFECT", `Caller-authored ordinary call '${expression.callee}' cannot forge a capability operation.`, expression.location);
+        }
+        const { capability, operation } = match;
+        const flow = operation.resourceFlow;
+        if ((flow.kind == "borrow" || flow.kind == "close") && expression.arguments[flow.parameterIndex]) {
+            const argument = expression.arguments[flow.parameterIndex];
+            if (argument.kind != "IdentifierExpression" && argument.kind != "PrivateFieldRead" && argument.kind != "ReceiverExpression") {
+                fail("INVALID_RESOURCE_BORROW", "An owned borrow must name one immediate resource place.", argument.location);
+            }
+            expression.arguments[flow.parameterIndex] = {
+                expression: argument,
+                kind: "OwnedBorrowExpression",
+                location: argument.location,
+                mode: flow.kind == "close" ? "exclusive" : "shared",
+                sourceProvenance: argument.sourceProvenance,
+                type: /** @type {import("./types.js").OwnedResourceType | import("./types.js").OwnedReferenceType} */ (operation.parameters[flow.parameterIndex].type)
+            };
+        }
+        const replacement = /** @type {import("./types.js").EffectCallExpression} */ ( /** @type {unknown} */(expression));
+        delete /** @type {{callee?: string}} */ (replacement).callee;
+        replacement.kind = "EffectCallExpression";
+        replacement.operation = operation.id;
+        replacement.resolution = signature(capability, operation);
+    });
+    const complete = completeEffectSummaries(module, failureIds, visibleClasses);
+    const summaries = complete.functions;
+    const methodSummaries = complete.methods;
+    const constructorSummaries = complete.constructors;
+    for (const declaration of module.classes ?? []) {
+        applyDeclarationSummary(declaration.constructor, constructorSummaries.get(/** @type {string} */ (declaration.constructor.id)), normalize, fail);
+        for (const method of declaration.methods) {
+            applyDeclarationSummary(method, methodSummaries.get(/** @type {string} */ (method.id)), normalize, fail);
+        }
+    }
+    let site = 0;
+    forEachExpression(module, (expression) => {
+        if (expression.kind == "EffectCallExpression") {
+            if (normalize)
+                expression.effectSiteId = `effect:${site}`;
+            else
+                validateSite(expression, site, fail);
+            site += 1;
+            return;
+        }
+        if (expression.kind == "CallExpression") {
+            const summary = summaries.get(expression.callee);
+            if (!summary?.host) {
+                if (normalize) {
+                    delete expression.effectSiteId;
+                    delete expression.effects;
+                    delete expression.failureIds;
+                }
+                if (!normalize && Array.isArray(expression.failureIds) && expression.failureIds.length > 0) {
+                    fail("UNDECLARED_FAILURE", "UNDECLARED_FAILURE: Pure call carries a forged typed failure boundary.", expression.location);
+                }
+                if (!normalize && (expression.effectSiteId !== undefined || expression.effects !== undefined || expression.failureIds !== undefined)) {
+                    fail("UNDECLARED_EFFECT", "Pure call carries forged effect metadata.", expression.location);
+                }
+                return;
+            }
+            if (normalize) {
+                expression.effectSiteId = `effect:${site}`;
+                expression.effects = ["host"];
+                expression.failureIds = [...summary.failureIds];
+            }
+            else {
+                validateSite(expression, site, fail);
+                if (!Array.isArray(expression.failureIds) || expression.failureIds.join(",") != [...summary.failureIds].join(",")) {
+                    fail("UNDECLARED_FAILURE", "UNDECLARED_FAILURE: Call failure boundary does not match its resolved function.", expression.location);
+                }
+                if (expression.effects?.length != 1 || expression.effects[0] != "host") {
+                    fail("UNDECLARED_EFFECT", "Call effect summary does not match its resolved function.", expression.location);
+                }
+            }
+            site += 1;
+            return;
+        }
+        if (expression.kind == "MethodCallExpression" || expression.kind == "ReferenceConstruction") {
+            const summary = expression.kind == "MethodCallExpression"
+                ? methodSummaries.get(expression.method)
+                : constructorSummaries.get(expression.resolution?.declarationId ?? `${expression.reference.declarationId}:constructor`);
+            const label = expression.kind == "MethodCallExpression" ? "method call" : "construction";
+            if (!summary?.host) {
+                if (normalize) {
+                    delete expression.effectSiteId;
+                    delete expression.effects;
+                    delete expression.failureIds;
+                }
+                if (!normalize && Array.isArray(expression.failureIds) && expression.failureIds.length > 0) {
+                    fail("UNDECLARED_FAILURE", `UNDECLARED_FAILURE: Pure ${label} carries a forged typed failure boundary.`, expression.location);
+                }
+                if (!normalize && (expression.effectSiteId !== undefined || expression.effects !== undefined || expression.failureIds !== undefined)) {
+                    fail("UNDECLARED_EFFECT", `Pure ${label} carries forged effect metadata.`, expression.location);
+                }
+                return;
+            }
+            if (normalize) {
+                expression.effectSiteId = `effect:${site}`;
+                expression.effects = ["host"];
+                expression.failureIds = [...summary.failureIds];
+            }
+            else {
+                validateSite(expression, site, fail);
+                if (!Array.isArray(expression.failureIds) || expression.failureIds.join(",") != [...summary.failureIds].join(",")) {
+                    fail("UNDECLARED_FAILURE", `UNDECLARED_FAILURE: ${label} failure boundary does not match its resolved declaration.`, expression.location);
+                }
+                if (expression.effects?.length != 1 || expression.effects[0] != "host") {
+                    fail("UNDECLARED_EFFECT", `${label} effect summary does not match its resolved declaration.`, expression.location);
+                }
+            }
+            site += 1;
+        }
+    }, true);
+}
+/**
+ * Computes the joint finite fixed point across functions and resolved receiver methods.
+ * @param {import("./types.js").SemanticModule} module - Resolved module.
+ * @param {Set<string>} capabilityFailureIds - Declared capability failures.
+ * @param {Map<string, import("./types.js").ClassDeclaration>} visibleClasses - Resolved reference classes.
+ * @returns {{constructors: Map<string, EffectSummary>, functions: Map<string, EffectSummary>, methods: Map<string, EffectSummary>}} Complete summaries.
+ */
+function completeEffectSummaries(module, capabilityFailureIds, visibleClasses) {
+    const importedMethods = declaredClassSummaries(visibleClasses, "methods");
+    let functions = effectSummaries(module.functions, new Map(), capabilityFailureIds);
+    let methods = directMethodSummaries(module, functions, importedMethods, capabilityFailureIds, importedMethods);
+    while (true) {
+        const nextFunctions = effectSummaries(module.functions, methods, capabilityFailureIds);
+        const nextMethods = directMethodSummaries(module, nextFunctions, methods, capabilityFailureIds, importedMethods);
+        if (sameSummaries(functions, nextFunctions) && sameSummaries(methods, nextMethods)) {
+            return { constructors: directConstructorSummaries(module, nextFunctions, nextMethods, capabilityFailureIds, declaredClassSummaries(visibleClasses, "constructors")), functions: nextFunctions, methods: nextMethods };
+        }
+        functions = nextFunctions;
+        methods = nextMethods;
+    }
+}
+/**
+ * Compares stable host/failure summary maps.
+ * @param {Map<string, EffectSummary>} left - Previous summaries.
+ * @param {Map<string, EffectSummary>} right - Next summaries.
+ * @returns {boolean} Whether the summaries are identical.
+ */
+function sameSummaries(left, right) {
+    if (left.size != right.size)
+        return false;
+    for (const [name, summary] of left) {
+        const candidate = right.get(name);
+        if (!candidate || summary.host != candidate.host || summary.failureIds.size != candidate.failureIds.size ||
+            [...summary.failureIds].some((id) => !candidate.failureIds.has(id)))
+            return false;
+    }
+    return true;
+}
+/**
+ * Builds the complete immutable resolution recorded at an effect call site.
+ * @param {import("./types.js").EffectCapabilityDeclaration} capability - Declaring capability.
+ * @param {import("./types.js").EffectOperationDeclaration} operation - Resolved operation.
+ * @returns {import("./types.js").ResolvedEffectOperationSignature} Complete resolution.
+ */
+function signature(capability, operation) {
+    return {
+        capabilityId: capability.id,
+        effects: /** @type {const} */ (["host"]),
+        failureIds: [...operation.failureIds],
+        kind: /** @type {const} */ ("ResolvedEffectOperationSignature"),
+        operationId: operation.id,
+        parameterTypes: operation.parameters.map(({ type }) => /** @type {import("./types.js").SemanticTypeIdentity} */ (typeIdentity(type))),
+        resourceFlow: structuredClone(operation.resourceFlow),
+        returnType: typeIdentity(operation.returnType)
+    };
+}
+/**
+ * Removes locations and provenance from one resolved type.
+ * @param {import("./types.js").SemanticFunctionReturnType} type - Semantic type.
+ * @returns {import("./types.js").FunctionReturnTypeIdentity} Stable type identity.
+ */
+function typeIdentity(type) {
+    if (type.kind == "TypeReference")
+        return type.name;
+    if (type.kind == "OwnedResourceType")
+        return { kind: type.kind, resourceId: type.resourceId };
+    if (type.kind == "OwnedReferenceType")
+        return { declarationId: type.declarationId, kind: type.kind };
+    if (type.kind == "OptionalType")
+        return { kind: type.kind,
+            valueType: /** @type {import("./types.js").SemanticTypeIdentity} */ (typeIdentity(type.valueType)) };
+    if (type.kind == "ListType")
+        return {
+            elementType: /** @type {import("./types.js").SemanticTypeIdentity} */ (typeIdentity(type.elementType)), kind: type.kind
+        };
+    if (type.kind == "MapType" || type.kind == "OrderedMapType") {
+        const keyType = /** @type {import("./types.js").SemanticTypeIdentity} */ (typeIdentity(type.keyType));
+        const valueType = /** @type {import("./types.js").SemanticTypeIdentity} */ (typeIdentity(type.valueType));
+        return type.kind == "OrderedMapType" ? { keyType, kind: type.kind, order: "insertion", valueType } :
+            { keyType, kind: type.kind, valueType };
+    }
+    if (type.kind == "RecordType")
+        return { arguments: type.arguments?.map((argument) => 
+            /** @type {import("./types.js").SemanticTypeIdentity} */ (typeIdentity(argument))), declarationId: type.declarationId, kind: type.kind };
+    if (type.kind == "ReferenceType")
+        return { declarationId: type.declarationId, kind: type.kind };
+    return { kind: type.kind, parameterId: type.parameterId };
+}
+/**
+ * Computes the fixed-point host-effect summary for ordinary functions.
+ * @param {import("./types.js").FunctionDeclaration[]} functions - Module functions.
+ * @param {Map<string, EffectSummary>} [methodSummaries] - Receiver-call summaries from the current fixed-point round.
+ * @param {Set<string>} [capabilityFailureIds] - Capability failures eligible for call-site propagation.
+ * @returns {Map<string, EffectSummary>} Summaries by source function name.
+ */
+function effectSummaries(functions, methodSummaries = new Map(), capabilityFailureIds = new Set()) {
+    const summaries = new Map(functions.map(({ name }) => /** @type {[string, EffectSummary]} */ ([name, { failureIds: new Set(), host: false }])));
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const declaration of functions) {
+            const summary = summaries.get(declaration.name);
+            if (!summary)
+                continue;
+            forEachBlockExpression(declaration.body, (expression) => {
+                if (expression.kind == "EffectCallExpression") {
+                    if (!summary.host) {
+                        summary.host = true;
+                        changed = true;
+                    }
+                }
+                else if (expression.kind == "CallExpression") {
+                    const called = summaries.get(expression.callee);
+                    if (called?.host && !summary.host) {
+                        summary.host = true;
+                        changed = true;
+                    }
+                }
+                else if (expression.kind == "MethodCallExpression") {
+                    const called = methodSummaries.get(expression.method);
+                    if (called?.host && !summary.host) {
+                        summary.host = true;
+                        changed = true;
+                    }
+                }
+            }, false);
+            const escaping = escapingBlockFailures(declaration.body, summaries, methodSummaries, capabilityFailureIds);
+            for (const id of escaping)
+                if (!summary.failureIds.has(id)) {
+                    summary.failureIds.add(id);
+                    changed = true;
+                }
+        }
+    }
+    return summaries;
+}
+/**
+ * Computes the capability failures escaping one structured block.
+ * @param {import("./types.js").Block} block - Function body.
+ * @param {Map<string, EffectSummary>} functionSummaries - Current function fixed point.
+ * @param {Map<string, EffectSummary>} methodSummaries - Resolved method summaries.
+ * @param {Set<string>} capabilityFailureIds - Declared capability failures.
+ * @returns {Set<string>} Escaping failure identities.
+ */
+function escapingBlockFailures(block, functionSummaries, methodSummaries, capabilityFailureIds) {
+    const result = new Set();
+    for (const statement of block.statements) {
+        if (statement.kind == "TryStatement") {
+            const body = escapingBlockFailures(statement.body, functionSummaries, methodSummaries, capabilityFailureIds);
+            if (body.delete(statement.catchType.declarationId)) {
+                addFailures(result, escapingBlockFailures(statement.catchBody, functionSummaries, methodSummaries, capabilityFailureIds));
+            }
+            addFailures(result, body);
+            continue;
+        }
+        for (const expression of statementExpressions(statement)) {
+            addExpressionFailures(result, expression, functionSummaries, methodSummaries);
+        }
+        if (statement.kind == "RaiseStatement" && capabilityFailureIds.has(statement.error.error.declarationId)) {
+            result.add(statement.error.error.declarationId);
+        }
+        for (const child of statementBlocks(statement)) {
+            addFailures(result, escapingBlockFailures(child, functionSummaries, methodSummaries, capabilityFailureIds));
+        }
+    }
+    return result;
+}
+/**
+ * Adds failures evaluated by one expression subtree.
+ * @param {Set<string>} target - Destination identities.
+ * @param {import("./types.js").Expression} expression - Expression root.
+ * @param {Map<string, EffectSummary>} functionSummaries - Function summaries.
+ * @param {Map<string, EffectSummary>} methodSummaries - Method summaries.
+ * @returns {void}
+ */
+function addExpressionFailures(target, expression, functionSummaries, methodSummaries) {
+    if (expression.kind == "EffectCallExpression")
+        addFailures(target, expression.resolution.failureIds);
+    else if (expression.kind == "CallExpression")
+        addFailures(target, functionSummaries.get(expression.callee)?.failureIds ?? []);
+    else if (expression.kind == "MethodCallExpression")
+        addFailures(target, methodSummaries.get(expression.method)?.failureIds ?? []);
+    for (const child of expressionChildren(expression))
+        addExpressionFailures(target, child, functionSummaries, methodSummaries);
+}
+/**
+ * Returns directly evaluated expressions for one statement.
+ * @param {import("./types.js").Statement} statement - Statement.
+ * @returns {import("./types.js").Expression[]} Expression roots.
+ */
+function statementExpressions(statement) {
+    if (statement.kind == "LocalDeclaration")
+        return [statement.initializer];
+    if (statement.kind == "AssignmentStatement" || statement.kind == "PrivateFieldWriteStatement" ||
+        statement.kind == "ExpressionStatement" || statement.kind == "PrintStatement")
+        return [statement.expression];
+    if (statement.kind == "ReturnStatement")
+        return statement.expression ? [statement.expression] : [];
+    if (statement.kind == "RaiseStatement")
+        return [statement.error.message];
+    if (statement.kind == "IfStatement" || statement.kind == "WhileStatement")
+        return [statement.condition];
+    if (statement.kind == "ForEachStatement")
+        return [statement.list];
+    if (statement.kind == "ForEachMapStatement")
+        return [statement.map];
+    return [];
+}
+/**
+ * Returns nested blocks whose failures propagate through one statement.
+ * @param {import("./types.js").Statement} statement - Statement.
+ * @returns {import("./types.js").Block[]} Child blocks.
+ */
+function statementBlocks(statement) {
+    if (statement.kind == "IfStatement")
+        return [statement.consequent, ...(statement.alternate ? [statement.alternate] : [])];
+    if (statement.kind == "WhileStatement" || statement.kind == "ForEachStatement" || statement.kind == "ForEachMapStatement") {
+        return [statement.body];
+    }
+    return [];
+}
+/**
+ * Adds an iterable of failure identities to a set.
+ * @param {Set<string>} target - Destination.
+ * @param {Iterable<string>} source - Source identities.
+ * @returns {void}
+ */
+function addFailures(target, source) {
+    for (const id of source)
+        target.add(id);
+}
+/**
+ * Computes bounded direct summaries for class methods.
+ * @param {import("./types.js").SemanticModule} module - Resolved module.
+ * @param {Map<string, EffectSummary>} functionSummaries - Ordinary function summaries.
+ * @param {Map<string, EffectSummary>} priorMethodSummaries - Receiver summaries from the previous fixed-point round.
+ * @param {Set<string>} capabilityFailureIds - Declared capability failures.
+ * @param {Map<string, EffectSummary>} baseSummaries - Imported receiver summaries.
+ * @returns {Map<string, EffectSummary>} Summaries by resolved method identity.
+ */
+function directMethodSummaries(module, functionSummaries, priorMethodSummaries, capabilityFailureIds, baseSummaries = new Map()) {
+    /** @type {Map<string, EffectSummary>} */
+    const summaries = new Map(baseSummaries);
+    for (const declaration of module.classes ?? []) {
+        for (const method of declaration.methods) {
+            /** @type {EffectSummary} */
+            const summary = { failureIds: escapingBlockFailures(method.body, functionSummaries, priorMethodSummaries, capabilityFailureIds), host: false };
+            forEachBlockExpression(method.body, (expression) => {
+                if (expression.kind == "EffectCallExpression") {
+                    summary.host = true;
+                    const flow = expression.resolution.resourceFlow;
+                    const argument = flow.kind == "borrow" || flow.kind == "close" ? expression.arguments[flow.parameterIndex] : undefined;
+                    const borrowedParameterName = argument?.kind == "OwnedBorrowExpression" && argument.expression.kind == "IdentifierExpression"
+                        ? argument.expression.name : undefined;
+                    const knownOpenBorrow = declaration.ownership?.kind == "ownedResource" && argument?.kind == "OwnedBorrowExpression" && (argument.expression.kind == "PrivateFieldRead" && argument.expression.field == declaration.ownership.fieldId ||
+                        borrowedParameterName !== undefined && method.parameters.some((parameter) => parameter.name == borrowedParameterName &&
+                            (parameter.type.kind == "OwnedResourceType" || parameter.type.kind == "OwnedReferenceType")));
+                    const terminalFailureId = knownOpenBorrow
+                        ? flow.kind == "borrow" || flow.kind == "close" ? flow.terminalFailureId : undefined
+                        : undefined;
+                    if (terminalFailureId)
+                        summary.failureIds.delete(terminalFailureId);
+                }
+                else if (expression.kind == "CallExpression") {
+                    const called = functionSummaries.get(expression.callee);
+                    if (called?.host)
+                        summary.host = true;
+                }
+                else if (expression.kind == "MethodCallExpression") {
+                    const called = priorMethodSummaries.get(expression.method);
+                    if (called?.host)
+                        summary.host = true;
+                }
+            }, false);
+            summaries.set(/** @type {string} */ (method.id), summary);
+        }
+    }
+    return summaries;
+}
+/**
+ * Reads checked summaries already proved on imported class declarations.
+ * @param {Map<string, import("./types.js").ClassDeclaration>} classes - Visible classes.
+ * @param {"constructors" | "methods"} kind - Declaration cohort.
+ * @returns {Map<string, EffectSummary>} Imported summaries by declaration identity.
+ */
+function declaredClassSummaries(classes, kind) {
+    /** @type {Map<string, EffectSummary>} */
+    const summaries = new Map();
+    for (const declaration of classes.values()) {
+        const members = kind == "constructors" ? [declaration.constructor] : declaration.methods;
+        for (const member of members) {
+            if (member.effects?.length == 1 && member.effects[0] == "host" && Array.isArray(member.failureIds)) {
+                summaries.set(/** @type {string} */ (member.id), { failureIds: new Set(member.failureIds), host: true });
+            }
+        }
+    }
+    return summaries;
+}
+/**
+ * Computes direct constructor effects after function and method fixed points stabilize.
+ * @param {import("./types.js").SemanticModule} module - Resolved module.
+ * @param {Map<string, EffectSummary>} functionSummaries - Stable function summaries.
+ * @param {Map<string, EffectSummary>} methodSummaries - Stable method summaries.
+ * @param {Set<string>} capabilityFailureIds - Declared capability failures.
+ * @param {Map<string, EffectSummary>} baseSummaries - Imported constructor summaries.
+ * @returns {Map<string, EffectSummary>} Constructor summaries by identity.
+ */
+function directConstructorSummaries(module, functionSummaries, methodSummaries, capabilityFailureIds, baseSummaries) {
+    const summaries = new Map(baseSummaries);
+    for (const declaration of module.classes ?? []) {
+        const constructor = declaration.constructor;
+        /** @type {EffectSummary} */
+        const summary = {
+            failureIds: escapingBlockFailures(constructor.body, functionSummaries, methodSummaries, capabilityFailureIds),
+            host: false
+        };
+        forEachBlockExpression(constructor.body, (expression) => {
+            if (expression.kind == "EffectCallExpression")
+                summary.host = true;
+            else if (expression.kind == "CallExpression" && functionSummaries.get(expression.callee)?.host)
+                summary.host = true;
+            else if (expression.kind == "MethodCallExpression" && methodSummaries.get(expression.method)?.host)
+                summary.host = true;
+        }, false);
+        summaries.set(/** @type {string} */ (constructor.id), summary);
+    }
+    return summaries;
+}
+/**
+ * Records or verifies one checked class-member summary.
+ * @param {import("./types.js").ConstructorDeclaration | import("./types.js").MethodDeclaration} declaration - Class member.
+ * @param {EffectSummary | undefined} summary - Computed summary.
+ * @param {boolean} normalize - Whether metadata may be written.
+ * @param {(code: string, detail: string, location: import("./types.js").SourceLocation) => never} fail - Located failure.
+ * @returns {void}
+ */
+function applyDeclarationSummary(declaration, summary, normalize, fail) {
+    if (!summary?.host) {
+        if (normalize) {
+            delete declaration.effects;
+            delete declaration.failureIds;
+        }
+        else if (declaration.effects !== undefined || declaration.failureIds !== undefined) {
+            fail("UNDECLARED_EFFECT", "Pure class member carries forged effect metadata.", declaration.location);
+        }
+        return;
+    }
+    const failureIds = [...summary.failureIds];
+    if (normalize) {
+        declaration.effects = ["host"];
+        declaration.failureIds = failureIds;
+    }
+    else if (declaration.effects?.length != 1 || declaration.effects[0] != "host" ||
+        !Array.isArray(declaration.failureIds) || declaration.failureIds.join(",") != failureIds.join(",")) {
+        fail("UNDECLARED_EFFECT", "Class member effect summary does not match its body.", declaration.location);
+    }
+}
+/**
+ * Validates one deterministic effect-site identity.
+ * @param {import("./types.js").CallExpression | import("./types.js").EffectCallExpression | import("./types.js").MethodCallExpression | import("./types.js").ReferenceConstruction} expression - Effectful call.
+ * @param {number} site - Expected traversal index.
+ * @param {(code: string, detail: string, location: import("./types.js").SourceLocation) => never} fail - Located failure.
+ * @returns {void}
+ */
+function validateSite(expression, site, fail) {
+    if (expression.effectSiteId != `effect:${site}`) {
+        fail("INVALID_EFFECT_ORDER", `Effect site '${String(expression.effectSiteId)}' is not expected site 'effect:${site}'.`, expression.location);
+    }
+}
+/**
+ * Visits every expression in deterministic declaration and evaluation order.
+ * @param {import("./types.js").SemanticModule} module - Module to traverse.
+ * @param {ExpressionVisitor} visitor - Expression visitor.
+ * @param {boolean} [postorder] - Visit children before parents.
+ * @returns {void}
+ */
+function forEachExpression(module, visitor, postorder = false) {
+    for (const declaration of module.classes ?? []) {
+        forEachBlockExpression(declaration.constructor.body, visitor, postorder);
+        for (const method of declaration.methods)
+            forEachBlockExpression(method.body, visitor, postorder);
+    }
+    for (const declaration of module.functions)
+        forEachBlockExpression(declaration.body, visitor, postorder);
+    forEachBlockExpression(module.entryPoint.body, visitor, postorder);
+}
+/**
+ * Visits expressions in one structured block.
+ * @param {import("./types.js").Block} block - Block to traverse.
+ * @param {ExpressionVisitor} visitor - Expression visitor.
+ * @param {boolean} postorder - Visit children before parents.
+ * @returns {void}
+ */
+function forEachBlockExpression(block, visitor, postorder) {
+    for (const statement of block.statements) {
+        if (statement.kind == "LocalDeclaration")
+            visit(statement.initializer);
+        else if (statement.kind == "AssignmentStatement" || statement.kind == "PrivateFieldWriteStatement")
+            visit(statement.expression);
+        else if (statement.kind == "ReturnStatement" && statement.expression)
+            visit(statement.expression);
+        else if (statement.kind == "ExpressionStatement" || statement.kind == "PrintStatement")
+            visit(statement.expression);
+        else if (statement.kind == "IfStatement") {
+            visit(statement.condition);
+            forEachBlockExpression(statement.consequent, visitor, postorder);
+            if (statement.alternate)
+                forEachBlockExpression(statement.alternate, visitor, postorder);
+        }
+        else if (statement.kind == "ForEachStatement") {
+            visit(statement.list);
+            forEachBlockExpression(statement.body, visitor, postorder);
+        }
+        else if (statement.kind == "ForEachMapStatement") {
+            visit(statement.map);
+            forEachBlockExpression(statement.body, visitor, postorder);
+        }
+        else if (statement.kind == "WhileStatement") {
+            visit(statement.condition);
+            forEachBlockExpression(statement.body, visitor, postorder);
+        }
+        else if (statement.kind == "RaiseStatement")
+            visit(statement.error.message);
+        else if (statement.kind == "TryStatement") {
+            forEachBlockExpression(statement.body, visitor, postorder);
+            forEachBlockExpression(statement.catchBody, visitor, postorder);
+        }
+    }
+    /**
+     * Visits one expression subtree.
+     * @param {import("./types.js").Expression} expression - Expression root.
+     * @returns {void}
+     */
+    function visit(expression) {
+        if (!postorder)
+            visitor(expression);
+        for (const child of expressionChildren(expression))
+            visit(child);
+        if (postorder)
+            visitor(expression);
+    }
+}
+/**
+ * Reports whether one semantic block references a reserved protected provider entry.
+ * @param {import("./types.js").Block} block - Semantic block.
+ * @returns {boolean} Whether a protected entry name is referenced.
+ */
+export function blockReferencesProtectedEntry(block) {
+    return block.statements.some(statementReferencesProtectedEntry);
+}
+/**
+ * Reports whether one semantic statement references a reserved protected provider entry.
+ * @param {import("./types.js").Statement} statement - Semantic statement.
+ * @returns {boolean} Whether a protected entry name is referenced.
+ */
+function statementReferencesProtectedEntry(statement) {
+    switch (statement.kind) {
+        case "LocalDeclaration":
+            return expressionReferencesProtectedEntry(statement.initializer);
+        case "AssignmentStatement":
+        case "PrivateFieldWriteStatement":
+            return expressionReferencesProtectedEntry(statement.expression);
+        case "ReturnStatement":
+            return statement.expression ? expressionReferencesProtectedEntry(statement.expression) : false;
+        case "ExpressionStatement":
+        case "PrintStatement":
+            return expressionReferencesProtectedEntry(statement.expression);
+        case "IfStatement":
+            return expressionReferencesProtectedEntry(statement.condition) ||
+                blockReferencesProtectedEntry(statement.consequent) ||
+                (statement.alternate ? blockReferencesProtectedEntry(statement.alternate) : false);
+        case "ForEachStatement":
+            return expressionReferencesProtectedEntry(statement.list) || blockReferencesProtectedEntry(statement.body);
+        case "ForEachMapStatement":
+            return expressionReferencesProtectedEntry(statement.map) || blockReferencesProtectedEntry(statement.body);
+        case "WhileStatement":
+            return expressionReferencesProtectedEntry(statement.condition) || blockReferencesProtectedEntry(statement.body);
+        case "RaiseStatement":
+            return expressionReferencesProtectedEntry(statement.error.message);
+        case "TryStatement":
+            return blockReferencesProtectedEntry(statement.body) || blockReferencesProtectedEntry(statement.catchBody);
+        default:
+            return false;
+    }
+}
+/**
+ * Reports whether one semantic expression references a reserved protected provider entry.
+ * @param {import("./types.js").Expression} expression - Semantic expression.
+ * @returns {boolean} Whether a protected entry name is referenced.
+ */
+function expressionReferencesProtectedEntry(expression) {
+    if (expression.kind == "IdentifierExpression" && parseProtectedEntryName(expression.name) !== null)
+        return true;
+    if (expression.kind == "CallExpression" && parseProtectedEntryName(expression.callee) !== null)
+        return true;
+    return expressionChildren(expression).some(expressionReferencesProtectedEntry);
+}
+/**
+ * Returns semantic child expressions in evaluation order.
+ * @param {import("./types.js").Expression} expression - Parent expression.
+ * @returns {import("./types.js").Expression[]} Children.
+ */
+function expressionChildren(expression) {
+    if (expression.kind == "CallExpression" || expression.kind == "EffectCallExpression" || expression.kind == "ReferenceConstruction" ||
+        expression.kind == "RecordConstruction")
+        return expression.arguments;
+    if (expression.kind == "MethodCallExpression")
+        return [expression.receiver, ...expression.arguments];
+    if (expression.kind == "OwnedBorrowExpression" || expression.kind == "OwnedMoveExpression")
+        return [expression.expression];
+    if (expression.kind == "BinaryExpression")
+        return [expression.left, expression.right];
+    if (expression.kind == "UnaryExpression")
+        return [expression.operand];
+    if (expression.kind == "OptionalSome")
+        return [expression.value];
+    if (expression.kind == "OptionalIsPresent" || expression.kind == "OptionalUnwrap")
+        return [expression.operand];
+    if (expression.kind == "ListLiteral")
+        return expression.elements;
+    if (expression.kind == "MapLiteral" || expression.kind == "OrderedMapLiteral")
+        return expression.entries.map(({ value }) => value);
+    if (expression.kind == "ListIndexExpression")
+        return [expression.collection, expression.index];
+    if (expression.kind == "MapLookupExpression")
+        return [expression.collection, expression.key];
+    if (expression.kind == "CollectionSizeExpression")
+        return [expression.collection];
+    if (expression.kind == "MemberRead")
+        return [expression.receiver];
+    if (expression.kind == "PrivateFieldRead")
+        return [expression.receiver];
+    if (expression.kind == "ErrorMessageRead")
+        return [expression.receiver];
+    return [];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"effects.js","sourceRoot":"","sources":["../../../src/semantic/effects.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {authorizedOperation, isTask034OperationName} from \"./capabilities.js\"\nimport {parseProtectedEntryName} from \"./stdlib.js\"\n\n/** @typedef {{failureIds: Set<string>, host: boolean}} EffectSummary */\n/** @typedef {(expression: import(\"./types.js\").Expression) => void} ExpressionVisitor */\n\n/**\n * Resolves compiler-authorized calls before ordinary semantic type validation.\n * Source functions always win; authority is never inferred from spelling alone.\n * @param {import(\"./types.js\").SemanticModule} module - Parser-authored module.\n * @param {string} language - Source language identity for protected entry targets.\n * @param {Map<string, import(\"./types.js\").FunctionDeclaration>} functions - Visible ordinary functions.\n * @param {(code: string, detail: string, location: import(\"./types.js\").SourceLocation) => never} fail - Located failure.\n * @param {boolean} normalize - Whether parser-authored operation intent may be normalized.\n * @param {Map<string, import(\"./types.js\").ClassDeclaration>} [visibleClasses] - Resolved reference classes.\n * @returns {void}\n */\nexport function validateEffectGraph(module, language, functions, fail, normalize, visibleClasses = new Map()) {\n  const capabilities = module.capabilities ?? []\n  const capabilityIds = new Set()\n  const operationIds = new Set()\n  const resourceIds = new Set()\n  const failureIds = new Set()\n  const operationNames = new Set()\n\n  if (!Array.isArray(capabilities)) fail(\"INVALID_CAPABILITY_AUTHORITY\", \"Capabilities must be an ordered array.\", module.location)\n  for (const [capabilityIndex, capability] of capabilities.entries()) {\n    const legacyId = `capability:${capabilityIndex}`\n\n    if (!capability || capability.kind != \"EffectCapabilityDeclaration\" ||\n      capability.id != legacyId && !/^module:\\d+\\/capability:\\d+$/u.test(capability.id) || capabilityIds.has(capability.id) ||\n      typeof capability.authorityId != \"string\" || typeof capability.name != \"string\" || !Array.isArray(capability.resources) ||\n      !Array.isArray(capability.failures) || !Array.isArray(capability.operations)) {\n      fail(\"INVALID_CAPABILITY_AUTHORITY\", \"Malformed capability declaration graph.\", module.location)\n    }\n    capabilityIds.add(capability.id)\n    for (const [index, resource] of capability.resources.entries()) {\n      if (resource.kind != \"EffectResourceDeclaration\" || resource.id != `${capability.id}/resource:${index}` ||\n        resourceIds.has(resource.id)) fail(\"INVALID_CAPABILITY_AUTHORITY\", \"Malformed capability resource identity.\", module.location)\n      resourceIds.add(resource.id)\n    }\n    for (const [index, failure] of capability.failures.entries()) {\n      if (failure.kind != \"EffectFailureDeclaration\" || failure.id != `${capability.id}/failure:${index}` ||\n        failureIds.has(failure.id)) fail(\"INVALID_CAPABILITY_AUTHORITY\", \"Malformed capability failure identity.\", module.location)\n      failureIds.add(failure.id)\n    }\n  }\n  for (const capability of capabilities) {\n    for (const [index, operation] of capability.operations.entries()) {\n      if (operation.kind != \"EffectOperationDeclaration\" || operation.id != `${capability.id}/operation:${index}` ||\n        operationIds.has(operation.id) || operationNames.has(operation.name) || !Array.isArray(operation.parameters) ||\n        !Array.isArray(operation.failureIds) || operation.effects?.length != 1 || operation.effects[0] != \"host\" ||\n        operation.failureIds.some((id) => !failureIds.has(id))) {\n        fail(\"INVALID_CAPABILITY_AUTHORITY\", \"Malformed or ambiguous capability operation graph.\", module.location)\n      }\n      operationIds.add(operation.id)\n      operationNames.add(operation.name)\n    }\n  }\n\n  for (const declaration of [\n    ...module.functions,\n    ...(module.records ?? []),\n    ...(module.classes ?? []),\n    ...(module.errors ?? [])\n  ]) {\n    if (parseProtectedEntryName(declaration.name) !== null) {\n      fail(\"STDLIB_PROTECTED_BINDING_ACCESS\",\n        `Source declaration '${declaration.name}' captures a reserved protected provider binding.`, declaration.location)\n    }\n  }\n\n  forEachExpression(module, (expression) => {\n    if (expression.kind == \"EffectCallExpression\") {\n      const capability = capabilities.find(({id}) => id == expression.resolution?.capabilityId)\n      const operation = capability?.operations.find(({id}) => id == expression.operation)\n\n      if (operation && expression.resolution.operationId == operation.id &&\n        (!Array.isArray(expression.resolution.failureIds) ||\n          expression.resolution.failureIds.join(\",\") != operation.failureIds.join(\",\"))) {\n        fail(\"UNDECLARED_FAILURE\", \"UNDECLARED_FAILURE: Effect call failure boundary does not match its compiler authority.\",\n          expression.location)\n      }\n      if (!operation || expression.resolution.operationId != operation.id ||\n        JSON.stringify(expression.resolution) != JSON.stringify(signature(/** @type {import(\"./types.js\").EffectCapabilityDeclaration} */ (capability), operation))) {\n        fail(\"UNDECLARED_EFFECT\", \"Effect call resolution does not match its compiler authority.\", expression.location)\n      }\n      return\n    }\n    if (expression.kind == \"IdentifierExpression\" && parseProtectedEntryName(expression.name) !== null) {\n      fail(\"STDLIB_PROTECTED_BINDING_ACCESS\",\n        `Reference to protected provider entry '${expression.name}' is not portable code.`, expression.location)\n    }\n    if (expression.kind != \"CallExpression\") return\n    if (functions.has(expression.callee)) return\n    let operationName = expression.callee\n    const protectedEntry = parseProtectedEntryName(expression.callee)\n\n    if (protectedEntry !== null) {\n      if (capabilities.length == 0) {\n        fail(\"STDLIB_PROTECTED_BINDING_ACCESS\",\n          `Protected provider entry '${expression.callee}' requires an explicit capability authority.`, expression.location)\n      }\n      if (protectedEntry.target != language) {\n        fail(\"STDLIB_PROTECTED_BINDING_ACCESS\",\n          `Protected provider entry target '${protectedEntry.target}' does not match source language '${language}'.`,\n          expression.location)\n      }\n      operationName = protectedEntry.operation\n    }\n    const match = authorizedOperation(capabilities, operationName)\n\n    if (!match) {\n      if (protectedEntry !== null) {\n        fail(\"STDLIB_PROTECTED_BINDING_ACCESS\",\n          `Protected provider entry for undeclared operation '${operationName}' has no authorized capability operation.`,\n          expression.location)\n      }\n      if (isTask034OperationName(operationName)) {\n        fail(\"MISSING_CAPABILITY_AUTHORITY\", `Operation '${operationName}' requires explicit compiler authority.`, expression.location)\n      }\n      return\n    }\n    if (!normalize) {\n      fail(\"UNDECLARED_EFFECT\", `Caller-authored ordinary call '${expression.callee}' cannot forge a capability operation.`, expression.location)\n    }\n    const {capability, operation} = match\n    const flow = operation.resourceFlow\n\n    if ((flow.kind == \"borrow\" || flow.kind == \"close\") && expression.arguments[flow.parameterIndex]) {\n      const argument = expression.arguments[flow.parameterIndex]\n      if (argument.kind != \"IdentifierExpression\" && argument.kind != \"PrivateFieldRead\" && argument.kind != \"ReceiverExpression\") {\n        fail(\"INVALID_RESOURCE_BORROW\", \"An owned borrow must name one immediate resource place.\", argument.location)\n      }\n      expression.arguments[flow.parameterIndex] = {\n        expression: argument,\n        kind: \"OwnedBorrowExpression\",\n        location: argument.location,\n        mode: flow.kind == \"close\" ? \"exclusive\" : \"shared\",\n        sourceProvenance: argument.sourceProvenance,\n        type: /** @type {import(\"./types.js\").OwnedResourceType | import(\"./types.js\").OwnedReferenceType} */ (\n          operation.parameters[flow.parameterIndex].type\n        )\n      }\n    }\n    const replacement = /** @type {import(\"./types.js\").EffectCallExpression} */ (/** @type {unknown} */ (expression))\n    delete /** @type {{callee?: string}} */ (replacement).callee\n    replacement.kind = \"EffectCallExpression\"\n    replacement.operation = operation.id\n    replacement.resolution = signature(capability, operation)\n  })\n\n  const complete = completeEffectSummaries(module, failureIds, visibleClasses)\n  const summaries = complete.functions\n  const methodSummaries = complete.methods\n  const constructorSummaries = complete.constructors\n\n  for (const declaration of module.classes ?? []) {\n    applyDeclarationSummary(declaration.constructor,\n      constructorSummaries.get(/** @type {string} */ (declaration.constructor.id)), normalize, fail)\n    for (const method of declaration.methods) {\n      applyDeclarationSummary(method, methodSummaries.get(/** @type {string} */ (method.id)), normalize, fail)\n    }\n  }\n  let site = 0\n\n  forEachExpression(module, (expression) => {\n    if (expression.kind == \"EffectCallExpression\") {\n      if (normalize) expression.effectSiteId = `effect:${site}`\n      else validateSite(expression, site, fail)\n      site += 1\n      return\n    }\n    if (expression.kind == \"CallExpression\") {\n      const summary = summaries.get(expression.callee)\n      if (!summary?.host) {\n        if (normalize) {\n          delete expression.effectSiteId\n          delete expression.effects\n          delete expression.failureIds\n        }\n        if (!normalize && Array.isArray(expression.failureIds) && expression.failureIds.length > 0) {\n          fail(\"UNDECLARED_FAILURE\", \"UNDECLARED_FAILURE: Pure call carries a forged typed failure boundary.\", expression.location)\n        }\n        if (!normalize && (expression.effectSiteId !== undefined || expression.effects !== undefined || expression.failureIds !== undefined)) {\n          fail(\"UNDECLARED_EFFECT\", \"Pure call carries forged effect metadata.\", expression.location)\n        }\n        return\n      }\n      if (normalize) {\n        expression.effectSiteId = `effect:${site}`\n        expression.effects = [\"host\"]\n        expression.failureIds = [...summary.failureIds]\n      } else {\n        validateSite(expression, site, fail)\n        if (!Array.isArray(expression.failureIds) || expression.failureIds.join(\",\") != [...summary.failureIds].join(\",\")) {\n          fail(\"UNDECLARED_FAILURE\", \"UNDECLARED_FAILURE: Call failure boundary does not match its resolved function.\", expression.location)\n        }\n        if (expression.effects?.length != 1 || expression.effects[0] != \"host\") {\n          fail(\"UNDECLARED_EFFECT\", \"Call effect summary does not match its resolved function.\", expression.location)\n        }\n      }\n      site += 1\n      return\n    }\n    if (expression.kind == \"MethodCallExpression\" || expression.kind == \"ReferenceConstruction\") {\n      const summary = expression.kind == \"MethodCallExpression\"\n        ? methodSummaries.get(expression.method)\n        : constructorSummaries.get(expression.resolution?.declarationId ?? `${expression.reference.declarationId}:constructor`)\n      const label = expression.kind == \"MethodCallExpression\" ? \"method call\" : \"construction\"\n      if (!summary?.host) {\n        if (normalize) {\n          delete expression.effectSiteId\n          delete expression.effects\n          delete expression.failureIds\n        }\n        if (!normalize && Array.isArray(expression.failureIds) && expression.failureIds.length > 0) {\n          fail(\"UNDECLARED_FAILURE\", `UNDECLARED_FAILURE: Pure ${label} carries a forged typed failure boundary.`, expression.location)\n        }\n        if (!normalize && (expression.effectSiteId !== undefined || expression.effects !== undefined || expression.failureIds !== undefined)) {\n          fail(\"UNDECLARED_EFFECT\", `Pure ${label} carries forged effect metadata.`, expression.location)\n        }\n        return\n      }\n      if (normalize) {\n        expression.effectSiteId = `effect:${site}`\n        expression.effects = [\"host\"]\n        expression.failureIds = [...summary.failureIds]\n      } else {\n        validateSite(expression, site, fail)\n        if (!Array.isArray(expression.failureIds) || expression.failureIds.join(\",\") != [...summary.failureIds].join(\",\")) {\n          fail(\"UNDECLARED_FAILURE\", `UNDECLARED_FAILURE: ${label} failure boundary does not match its resolved declaration.`, expression.location)\n        }\n        if (expression.effects?.length != 1 || expression.effects[0] != \"host\") {\n          fail(\"UNDECLARED_EFFECT\", `${label} effect summary does not match its resolved declaration.`, expression.location)\n        }\n      }\n      site += 1\n    }\n  }, true)\n}\n\n/**\n * Computes the joint finite fixed point across functions and resolved receiver methods.\n * @param {import(\"./types.js\").SemanticModule} module - Resolved module.\n * @param {Set<string>} capabilityFailureIds - Declared capability failures.\n * @param {Map<string, import(\"./types.js\").ClassDeclaration>} visibleClasses - Resolved reference classes.\n * @returns {{constructors: Map<string, EffectSummary>, functions: Map<string, EffectSummary>, methods: Map<string, EffectSummary>}} Complete summaries.\n */\nfunction completeEffectSummaries(module, capabilityFailureIds, visibleClasses) {\n  const importedMethods = declaredClassSummaries(visibleClasses, \"methods\")\n  let functions = effectSummaries(module.functions, new Map(), capabilityFailureIds)\n  let methods = directMethodSummaries(module, functions, importedMethods, capabilityFailureIds, importedMethods)\n\n  while (true) {\n    const nextFunctions = effectSummaries(module.functions, methods, capabilityFailureIds)\n    const nextMethods = directMethodSummaries(module, nextFunctions, methods, capabilityFailureIds, importedMethods)\n\n    if (sameSummaries(functions, nextFunctions) && sameSummaries(methods, nextMethods)) {\n      return {constructors: directConstructorSummaries(module, nextFunctions, nextMethods, capabilityFailureIds,\n        declaredClassSummaries(visibleClasses, \"constructors\")), functions: nextFunctions, methods: nextMethods}\n    }\n    functions = nextFunctions\n    methods = nextMethods\n  }\n}\n\n/**\n * Compares stable host/failure summary maps.\n * @param {Map<string, EffectSummary>} left - Previous summaries.\n * @param {Map<string, EffectSummary>} right - Next summaries.\n * @returns {boolean} Whether the summaries are identical.\n */\nfunction sameSummaries(left, right) {\n  if (left.size != right.size) return false\n  for (const [name, summary] of left) {\n    const candidate = right.get(name)\n\n    if (!candidate || summary.host != candidate.host || summary.failureIds.size != candidate.failureIds.size ||\n      [...summary.failureIds].some((id) => !candidate.failureIds.has(id))) return false\n  }\n  return true\n}\n\n/**\n * Builds the complete immutable resolution recorded at an effect call site.\n * @param {import(\"./types.js\").EffectCapabilityDeclaration} capability - Declaring capability.\n * @param {import(\"./types.js\").EffectOperationDeclaration} operation - Resolved operation.\n * @returns {import(\"./types.js\").ResolvedEffectOperationSignature} Complete resolution.\n */\nfunction signature(capability, operation) {\n  return {\n    capabilityId: capability.id,\n    effects: /** @type {const} */ ([\"host\"]),\n    failureIds: [...operation.failureIds],\n    kind: /** @type {const} */ (\"ResolvedEffectOperationSignature\"),\n    operationId: operation.id,\n    parameterTypes: operation.parameters.map(({type}) => /** @type {import(\"./types.js\").SemanticTypeIdentity} */ (typeIdentity(type))),\n    resourceFlow: structuredClone(operation.resourceFlow),\n    returnType: typeIdentity(operation.returnType)\n  }\n}\n\n/**\n * Removes locations and provenance from one resolved type.\n * @param {import(\"./types.js\").SemanticFunctionReturnType} type - Semantic type.\n * @returns {import(\"./types.js\").FunctionReturnTypeIdentity} Stable type identity.\n */\nfunction typeIdentity(type) {\n  if (type.kind == \"TypeReference\") return type.name\n  if (type.kind == \"OwnedResourceType\") return {kind: type.kind, resourceId: type.resourceId}\n  if (type.kind == \"OwnedReferenceType\") return {declarationId: type.declarationId, kind: type.kind}\n  if (type.kind == \"OptionalType\") return {kind: type.kind,\n    valueType: /** @type {import(\"./types.js\").SemanticTypeIdentity} */ (typeIdentity(type.valueType))}\n  if (type.kind == \"ListType\") return {\n    elementType: /** @type {import(\"./types.js\").SemanticTypeIdentity} */ (typeIdentity(type.elementType)), kind: type.kind}\n  if (type.kind == \"MapType\" || type.kind == \"OrderedMapType\") {\n    const keyType = /** @type {import(\"./types.js\").SemanticTypeIdentity} */ (typeIdentity(type.keyType))\n    const valueType = /** @type {import(\"./types.js\").SemanticTypeIdentity} */ (typeIdentity(type.valueType))\n\n    return type.kind == \"OrderedMapType\" ? {keyType, kind: type.kind, order: \"insertion\", valueType} :\n      {keyType, kind: type.kind, valueType}\n  }\n  if (type.kind == \"RecordType\") return {arguments: type.arguments?.map((argument) =>\n    /** @type {import(\"./types.js\").SemanticTypeIdentity} */ (typeIdentity(argument))), declarationId: type.declarationId, kind: type.kind}\n  if (type.kind == \"ReferenceType\") return {declarationId: type.declarationId, kind: type.kind}\n  return {kind: type.kind, parameterId: type.parameterId}\n}\n\n/**\n * Computes the fixed-point host-effect summary for ordinary functions.\n * @param {import(\"./types.js\").FunctionDeclaration[]} functions - Module functions.\n * @param {Map<string, EffectSummary>} [methodSummaries] - Receiver-call summaries from the current fixed-point round.\n * @param {Set<string>} [capabilityFailureIds] - Capability failures eligible for call-site propagation.\n * @returns {Map<string, EffectSummary>} Summaries by source function name.\n */\nfunction effectSummaries(functions, methodSummaries = new Map(), capabilityFailureIds = new Set()) {\n  const summaries = new Map(functions.map(({name}) => /** @type {[string, EffectSummary]} */ (\n    [name, {failureIds: new Set(), host: false}]\n  )))\n  let changed = true\n\n  while (changed) {\n    changed = false\n    for (const declaration of functions) {\n      const summary = summaries.get(declaration.name)\n      if (!summary) continue\n      forEachBlockExpression(declaration.body, (expression) => {\n        if (expression.kind == \"EffectCallExpression\") {\n          if (!summary.host) { summary.host = true; changed = true }\n        } else if (expression.kind == \"CallExpression\") {\n          const called = summaries.get(expression.callee)\n          if (called?.host && !summary.host) { summary.host = true; changed = true }\n        } else if (expression.kind == \"MethodCallExpression\") {\n          const called = methodSummaries.get(expression.method)\n          if (called?.host && !summary.host) { summary.host = true; changed = true }\n        }\n      }, false)\n      const escaping = escapingBlockFailures(declaration.body, summaries, methodSummaries, capabilityFailureIds)\n\n      for (const id of escaping) if (!summary.failureIds.has(id)) { summary.failureIds.add(id); changed = true }\n    }\n  }\n  return summaries\n}\n\n/**\n * Computes the capability failures escaping one structured block.\n * @param {import(\"./types.js\").Block} block - Function body.\n * @param {Map<string, EffectSummary>} functionSummaries - Current function fixed point.\n * @param {Map<string, EffectSummary>} methodSummaries - Resolved method summaries.\n * @param {Set<string>} capabilityFailureIds - Declared capability failures.\n * @returns {Set<string>} Escaping failure identities.\n */\nfunction escapingBlockFailures(block, functionSummaries, methodSummaries, capabilityFailureIds) {\n  const result = new Set()\n\n  for (const statement of block.statements) {\n    if (statement.kind == \"TryStatement\") {\n      const body = escapingBlockFailures(statement.body, functionSummaries, methodSummaries, capabilityFailureIds)\n\n      if (body.delete(statement.catchType.declarationId)) {\n        addFailures(result, escapingBlockFailures(statement.catchBody, functionSummaries, methodSummaries, capabilityFailureIds))\n      }\n      addFailures(result, body)\n      continue\n    }\n    for (const expression of statementExpressions(statement)) {\n      addExpressionFailures(result, expression, functionSummaries, methodSummaries)\n    }\n    if (statement.kind == \"RaiseStatement\" && capabilityFailureIds.has(statement.error.error.declarationId)) {\n      result.add(statement.error.error.declarationId)\n    }\n    for (const child of statementBlocks(statement)) {\n      addFailures(result, escapingBlockFailures(child, functionSummaries, methodSummaries, capabilityFailureIds))\n    }\n  }\n  return result\n}\n\n/**\n * Adds failures evaluated by one expression subtree.\n * @param {Set<string>} target - Destination identities.\n * @param {import(\"./types.js\").Expression} expression - Expression root.\n * @param {Map<string, EffectSummary>} functionSummaries - Function summaries.\n * @param {Map<string, EffectSummary>} methodSummaries - Method summaries.\n * @returns {void}\n */\nfunction addExpressionFailures(target, expression, functionSummaries, methodSummaries) {\n  if (expression.kind == \"EffectCallExpression\") addFailures(target, expression.resolution.failureIds)\n  else if (expression.kind == \"CallExpression\") addFailures(target, functionSummaries.get(expression.callee)?.failureIds ?? [])\n  else if (expression.kind == \"MethodCallExpression\") addFailures(target, methodSummaries.get(expression.method)?.failureIds ?? [])\n  for (const child of expressionChildren(expression)) addExpressionFailures(target, child, functionSummaries, methodSummaries)\n}\n\n/**\n * Returns directly evaluated expressions for one statement.\n * @param {import(\"./types.js\").Statement} statement - Statement.\n * @returns {import(\"./types.js\").Expression[]} Expression roots.\n */\nfunction statementExpressions(statement) {\n  if (statement.kind == \"LocalDeclaration\") return [statement.initializer]\n  if (statement.kind == \"AssignmentStatement\" || statement.kind == \"PrivateFieldWriteStatement\" ||\n    statement.kind == \"ExpressionStatement\" || statement.kind == \"PrintStatement\") return [statement.expression]\n  if (statement.kind == \"ReturnStatement\") return statement.expression ? [statement.expression] : []\n  if (statement.kind == \"RaiseStatement\") return [statement.error.message]\n  if (statement.kind == \"IfStatement\" || statement.kind == \"WhileStatement\") return [statement.condition]\n  if (statement.kind == \"ForEachStatement\") return [statement.list]\n  if (statement.kind == \"ForEachMapStatement\") return [statement.map]\n  return []\n}\n\n/**\n * Returns nested blocks whose failures propagate through one statement.\n * @param {import(\"./types.js\").Statement} statement - Statement.\n * @returns {import(\"./types.js\").Block[]} Child blocks.\n */\nfunction statementBlocks(statement) {\n  if (statement.kind == \"IfStatement\") return [statement.consequent, ...(statement.alternate ? [statement.alternate] : [])]\n  if (statement.kind == \"WhileStatement\" || statement.kind == \"ForEachStatement\" || statement.kind == \"ForEachMapStatement\") {\n    return [statement.body]\n  }\n  return []\n}\n\n/**\n * Adds an iterable of failure identities to a set.\n * @param {Set<string>} target - Destination.\n * @param {Iterable<string>} source - Source identities.\n * @returns {void}\n */\nfunction addFailures(target, source) {\n  for (const id of source) target.add(id)\n}\n\n/**\n * Computes bounded direct summaries for class methods.\n * @param {import(\"./types.js\").SemanticModule} module - Resolved module.\n * @param {Map<string, EffectSummary>} functionSummaries - Ordinary function summaries.\n * @param {Map<string, EffectSummary>} priorMethodSummaries - Receiver summaries from the previous fixed-point round.\n * @param {Set<string>} capabilityFailureIds - Declared capability failures.\n * @param {Map<string, EffectSummary>} baseSummaries - Imported receiver summaries.\n * @returns {Map<string, EffectSummary>} Summaries by resolved method identity.\n */\nfunction directMethodSummaries(module, functionSummaries, priorMethodSummaries, capabilityFailureIds, baseSummaries = new Map()) {\n  /** @type {Map<string, EffectSummary>} */\n  const summaries = new Map(baseSummaries)\n\n  for (const declaration of module.classes ?? []) {\n    for (const method of declaration.methods) {\n      /** @type {EffectSummary} */\n      const summary = {failureIds: escapingBlockFailures(method.body, functionSummaries, priorMethodSummaries, capabilityFailureIds), host: false}\n\n      forEachBlockExpression(method.body, (expression) => {\n        if (expression.kind == \"EffectCallExpression\") {\n          summary.host = true\n          const flow = expression.resolution.resourceFlow\n          const argument = flow.kind == \"borrow\" || flow.kind == \"close\" ? expression.arguments[flow.parameterIndex] : undefined\n          const borrowedParameterName = argument?.kind == \"OwnedBorrowExpression\" && argument.expression.kind == \"IdentifierExpression\"\n            ? argument.expression.name : undefined\n          const knownOpenBorrow = declaration.ownership?.kind == \"ownedResource\" && argument?.kind == \"OwnedBorrowExpression\" && (\n            argument.expression.kind == \"PrivateFieldRead\" && argument.expression.field == declaration.ownership.fieldId ||\n            borrowedParameterName !== undefined && method.parameters.some((parameter) =>\n              parameter.name == borrowedParameterName &&\n              (parameter.type.kind == \"OwnedResourceType\" || parameter.type.kind == \"OwnedReferenceType\"))\n          )\n          const terminalFailureId = knownOpenBorrow\n            ? flow.kind == \"borrow\" || flow.kind == \"close\" ? flow.terminalFailureId : undefined\n            : undefined\n\n          if (terminalFailureId) summary.failureIds.delete(terminalFailureId)\n        } else if (expression.kind == \"CallExpression\") {\n          const called = functionSummaries.get(expression.callee)\n          if (called?.host) summary.host = true\n        } else if (expression.kind == \"MethodCallExpression\") {\n          const called = priorMethodSummaries.get(expression.method)\n          if (called?.host) summary.host = true\n        }\n      }, false)\n      summaries.set(/** @type {string} */ (method.id), summary)\n    }\n  }\n  return summaries\n}\n\n/**\n * Reads checked summaries already proved on imported class declarations.\n * @param {Map<string, import(\"./types.js\").ClassDeclaration>} classes - Visible classes.\n * @param {\"constructors\" | \"methods\"} kind - Declaration cohort.\n * @returns {Map<string, EffectSummary>} Imported summaries by declaration identity.\n */\nfunction declaredClassSummaries(classes, kind) {\n  /** @type {Map<string, EffectSummary>} */\n  const summaries = new Map()\n\n  for (const declaration of classes.values()) {\n    const members = kind == \"constructors\" ? [declaration.constructor] : declaration.methods\n\n    for (const member of members) {\n      if (member.effects?.length == 1 && member.effects[0] == \"host\" && Array.isArray(member.failureIds)) {\n        summaries.set(/** @type {string} */ (member.id), {failureIds: new Set(member.failureIds), host: true})\n      }\n    }\n  }\n  return summaries\n}\n\n/**\n * Computes direct constructor effects after function and method fixed points stabilize.\n * @param {import(\"./types.js\").SemanticModule} module - Resolved module.\n * @param {Map<string, EffectSummary>} functionSummaries - Stable function summaries.\n * @param {Map<string, EffectSummary>} methodSummaries - Stable method summaries.\n * @param {Set<string>} capabilityFailureIds - Declared capability failures.\n * @param {Map<string, EffectSummary>} baseSummaries - Imported constructor summaries.\n * @returns {Map<string, EffectSummary>} Constructor summaries by identity.\n */\nfunction directConstructorSummaries(module, functionSummaries, methodSummaries, capabilityFailureIds, baseSummaries) {\n  const summaries = new Map(baseSummaries)\n\n  for (const declaration of module.classes ?? []) {\n    const constructor = declaration.constructor\n    /** @type {EffectSummary} */\n    const summary = {\n      failureIds: escapingBlockFailures(constructor.body, functionSummaries, methodSummaries, capabilityFailureIds),\n      host: false\n    }\n\n    forEachBlockExpression(constructor.body, (expression) => {\n      if (expression.kind == \"EffectCallExpression\") summary.host = true\n      else if (expression.kind == \"CallExpression\" && functionSummaries.get(expression.callee)?.host) summary.host = true\n      else if (expression.kind == \"MethodCallExpression\" && methodSummaries.get(expression.method)?.host) summary.host = true\n    }, false)\n    summaries.set(/** @type {string} */ (constructor.id), summary)\n  }\n  return summaries\n}\n\n/**\n * Records or verifies one checked class-member summary.\n * @param {import(\"./types.js\").ConstructorDeclaration | import(\"./types.js\").MethodDeclaration} declaration - Class member.\n * @param {EffectSummary | undefined} summary - Computed summary.\n * @param {boolean} normalize - Whether metadata may be written.\n * @param {(code: string, detail: string, location: import(\"./types.js\").SourceLocation) => never} fail - Located failure.\n * @returns {void}\n */\nfunction applyDeclarationSummary(declaration, summary, normalize, fail) {\n  if (!summary?.host) {\n    if (normalize) {\n      delete declaration.effects\n      delete declaration.failureIds\n    } else if (declaration.effects !== undefined || declaration.failureIds !== undefined) {\n      fail(\"UNDECLARED_EFFECT\", \"Pure class member carries forged effect metadata.\", declaration.location)\n    }\n    return\n  }\n  const failureIds = [...summary.failureIds]\n\n  if (normalize) {\n    declaration.effects = [\"host\"]\n    declaration.failureIds = failureIds\n  } else if (declaration.effects?.length != 1 || declaration.effects[0] != \"host\" ||\n    !Array.isArray(declaration.failureIds) || declaration.failureIds.join(\",\") != failureIds.join(\",\")) {\n    fail(\"UNDECLARED_EFFECT\", \"Class member effect summary does not match its body.\", declaration.location)\n  }\n}\n\n/**\n * Validates one deterministic effect-site identity.\n * @param {import(\"./types.js\").CallExpression | import(\"./types.js\").EffectCallExpression | import(\"./types.js\").MethodCallExpression | import(\"./types.js\").ReferenceConstruction} expression - Effectful call.\n * @param {number} site - Expected traversal index.\n * @param {(code: string, detail: string, location: import(\"./types.js\").SourceLocation) => never} fail - Located failure.\n * @returns {void}\n */\nfunction validateSite(expression, site, fail) {\n  if (expression.effectSiteId != `effect:${site}`) {\n    fail(\"INVALID_EFFECT_ORDER\", `Effect site '${String(expression.effectSiteId)}' is not expected site 'effect:${site}'.`, expression.location)\n  }\n}\n\n/**\n * Visits every expression in deterministic declaration and evaluation order.\n * @param {import(\"./types.js\").SemanticModule} module - Module to traverse.\n * @param {ExpressionVisitor} visitor - Expression visitor.\n * @param {boolean} [postorder] - Visit children before parents.\n * @returns {void}\n */\nfunction forEachExpression(module, visitor, postorder = false) {\n  for (const declaration of module.classes ?? []) {\n    forEachBlockExpression(declaration.constructor.body, visitor, postorder)\n    for (const method of declaration.methods) forEachBlockExpression(method.body, visitor, postorder)\n  }\n  for (const declaration of module.functions) forEachBlockExpression(declaration.body, visitor, postorder)\n  forEachBlockExpression(module.entryPoint.body, visitor, postorder)\n}\n\n/**\n * Visits expressions in one structured block.\n * @param {import(\"./types.js\").Block} block - Block to traverse.\n * @param {ExpressionVisitor} visitor - Expression visitor.\n * @param {boolean} postorder - Visit children before parents.\n * @returns {void}\n */\nfunction forEachBlockExpression(block, visitor, postorder) {\n  for (const statement of block.statements) {\n    if (statement.kind == \"LocalDeclaration\") visit(statement.initializer)\n    else if (statement.kind == \"AssignmentStatement\" || statement.kind == \"PrivateFieldWriteStatement\") visit(statement.expression)\n    else if (statement.kind == \"ReturnStatement\" && statement.expression) visit(statement.expression)\n    else if (statement.kind == \"ExpressionStatement\" || statement.kind == \"PrintStatement\") visit(statement.expression)\n    else if (statement.kind == \"IfStatement\") {\n      visit(statement.condition); forEachBlockExpression(statement.consequent, visitor, postorder)\n      if (statement.alternate) forEachBlockExpression(statement.alternate, visitor, postorder)\n    } else if (statement.kind == \"ForEachStatement\") {\n      visit(statement.list); forEachBlockExpression(statement.body, visitor, postorder)\n    } else if (statement.kind == \"ForEachMapStatement\") {\n      visit(statement.map); forEachBlockExpression(statement.body, visitor, postorder)\n    } else if (statement.kind == \"WhileStatement\") {\n      visit(statement.condition); forEachBlockExpression(statement.body, visitor, postorder)\n    } else if (statement.kind == \"RaiseStatement\") visit(statement.error.message)\n    else if (statement.kind == \"TryStatement\") {\n      forEachBlockExpression(statement.body, visitor, postorder); forEachBlockExpression(statement.catchBody, visitor, postorder)\n    }\n  }\n\n  /**\n   * Visits one expression subtree.\n   * @param {import(\"./types.js\").Expression} expression - Expression root.\n   * @returns {void}\n   */\n  function visit(expression) {\n    if (!postorder) visitor(expression)\n    for (const child of expressionChildren(expression)) visit(child)\n    if (postorder) visitor(expression)\n  }\n}\n\n/**\n * Reports whether one semantic block references a reserved protected provider entry.\n * @param {import(\"./types.js\").Block} block - Semantic block.\n * @returns {boolean} Whether a protected entry name is referenced.\n */\nexport function blockReferencesProtectedEntry(block) {\n  return block.statements.some(statementReferencesProtectedEntry)\n}\n\n/**\n * Reports whether one semantic statement references a reserved protected provider entry.\n * @param {import(\"./types.js\").Statement} statement - Semantic statement.\n * @returns {boolean} Whether a protected entry name is referenced.\n */\nfunction statementReferencesProtectedEntry(statement) {\n  switch (statement.kind) {\n    case \"LocalDeclaration\":\n      return expressionReferencesProtectedEntry(statement.initializer)\n    case \"AssignmentStatement\":\n    case \"PrivateFieldWriteStatement\":\n      return expressionReferencesProtectedEntry(statement.expression)\n    case \"ReturnStatement\":\n      return statement.expression ? expressionReferencesProtectedEntry(statement.expression) : false\n    case \"ExpressionStatement\":\n    case \"PrintStatement\":\n      return expressionReferencesProtectedEntry(statement.expression)\n    case \"IfStatement\":\n      return expressionReferencesProtectedEntry(statement.condition) ||\n        blockReferencesProtectedEntry(statement.consequent) ||\n        (statement.alternate ? blockReferencesProtectedEntry(statement.alternate) : false)\n    case \"ForEachStatement\":\n      return expressionReferencesProtectedEntry(statement.list) || blockReferencesProtectedEntry(statement.body)\n    case \"ForEachMapStatement\":\n      return expressionReferencesProtectedEntry(statement.map) || blockReferencesProtectedEntry(statement.body)\n    case \"WhileStatement\":\n      return expressionReferencesProtectedEntry(statement.condition) || blockReferencesProtectedEntry(statement.body)\n    case \"RaiseStatement\":\n      return expressionReferencesProtectedEntry(statement.error.message)\n    case \"TryStatement\":\n      return blockReferencesProtectedEntry(statement.body) || blockReferencesProtectedEntry(statement.catchBody)\n    default:\n      return false\n  }\n}\n\n/**\n * Reports whether one semantic expression references a reserved protected provider entry.\n * @param {import(\"./types.js\").Expression} expression - Semantic expression.\n * @returns {boolean} Whether a protected entry name is referenced.\n */\nfunction expressionReferencesProtectedEntry(expression) {\n  if (expression.kind == \"IdentifierExpression\" && parseProtectedEntryName(expression.name) !== null) return true\n  if (expression.kind == \"CallExpression\" && parseProtectedEntryName(expression.callee) !== null) return true\n  return expressionChildren(expression).some(expressionReferencesProtectedEntry)\n}\n\n/**\n * Returns semantic child expressions in evaluation order.\n * @param {import(\"./types.js\").Expression} expression - Parent expression.\n * @returns {import(\"./types.js\").Expression[]} Children.\n */\nfunction expressionChildren(expression) {\n  if (expression.kind == \"CallExpression\" || expression.kind == \"EffectCallExpression\" || expression.kind == \"ReferenceConstruction\" ||\n    expression.kind == \"RecordConstruction\") return expression.arguments\n  if (expression.kind == \"MethodCallExpression\") return [expression.receiver, ...expression.arguments]\n  if (expression.kind == \"OwnedBorrowExpression\" || expression.kind == \"OwnedMoveExpression\") return [expression.expression]\n  if (expression.kind == \"BinaryExpression\") return [expression.left, expression.right]\n  if (expression.kind == \"UnaryExpression\") return [expression.operand]\n  if (expression.kind == \"OptionalSome\") return [expression.value]\n  if (expression.kind == \"OptionalIsPresent\" || expression.kind == \"OptionalUnwrap\") return [expression.operand]\n  if (expression.kind == \"ListLiteral\") return expression.elements\n  if (expression.kind == \"MapLiteral\" || expression.kind == \"OrderedMapLiteral\") return expression.entries.map(({value}) => value)\n  if (expression.kind == \"ListIndexExpression\") return [expression.collection, expression.index]\n  if (expression.kind == \"MapLookupExpression\") return [expression.collection, expression.key]\n  if (expression.kind == \"CollectionSizeExpression\") return [expression.collection]\n  if (expression.kind == \"MemberRead\") return [expression.receiver]\n  if (expression.kind == \"PrivateFieldRead\") return [expression.receiver]\n  if (expression.kind == \"ErrorMessageRead\") return [expression.receiver]\n  return []\n}\n"]}