semantifold 0.3.0 → 0.5.0

package/build/src/backends/effects.js

@@ -0,0 +1,746 @@
+// @ts-check
+import { unsupportedCapability } from "../diagnostic.js";
+import { isTask034ResourceProbe } from "../semantic/capabilities.js";
+const adoptedTargets = new Set(["php", "ruby", "javascript", "typescript", "java"]);
+const task037Authorities = new Set([
+    "semantifold.output", "semantifold.resource", "semantifold.socket-client", "semantifold.text-stream"
+]);
+const protectedSupportNames = new Set([
+    "ProbeOperationFailure", "ProbeAcquireFailure", "ProbeReadFailure", "ProbeCloseFailure", "ProbeResourceClosed", "ProbeResource",
+    "probeEffect", "probeAcquire", "probeRead", "probeClose", "probeTrace"
+]);
+/** @typedef {{expression: import("../semantic/types.js").Expression, path: string}} ExpressionPath */
+/** @typedef {{detail: string, location: import("../semantic/types.js").SourceLocation}} ExcludedEffect */
+/**
+ * Validates Task 034 target support before a SourceWriter is allocated.
+ * @param {import("../semantic/types.js").SemanticModule} module - Candidate module.
+ * @param {import("../semantic/types.js").BackendLanguage} language - Requested target.
+ * @param {{usedOperations?: readonly string[]}} [options] - Program-wide used canonical
+ *   operations for a linked stdlib provider; restricts the reserved support surface to the
+ *   operations actually materialized in the provider artifact.
+ * @returns {void}
+ */
+export function preflightEffectCapabilities(module, language, options = {}) {
+    const capabilities = module?.capabilities;
+    if (capabilities === undefined) {
+        const unauthorized = findTask034Node(module);
+        if (unauthorized) {
+            unsupportedCapability(language, "MISSING_CAPABILITY_AUTHORITY: Task 034 IR requires its compiler authority graph", 
+            /** @type {import("../semantic/types.js").SourceLocation | undefined} */ (Reflect.get(unauthorized, "location") ?? module?.location));
+        }
+        return;
+    }
+    if (!Array.isArray(capabilities) || capabilities.length == 0) {
+        unsupportedCapability(language, "malformed or empty Task 034 capability graph", module?.location);
+    }
+    if (!adoptedTargets.has(language)) {
+        unsupportedCapability(language, "Task 034 effectful capabilities and owned resources", module.location);
+    }
+    const task037 = language == "php" && capabilities.every((capability) => task037Authorities.has(capability.authorityId));
+    if (!isTask034ResourceProbe(capabilities) && !task037) {
+        unsupportedCapability(language, "unbound Task 034 capability authority", module.location);
+    }
+    if (!Array.isArray(module.functions) || !module.entryPoint || typeof module.entryPoint != "object" ||
+        !module.entryPoint.body || !Array.isArray(module.entryPoint.body.statements) ||
+        [module.records, module.classes, module.errors].some((declarations) => declarations !== undefined && !Array.isArray(declarations))) {
+        unsupportedCapability(language, "malformed Task 034 semantic module", module.location);
+    }
+    const collision = moduleNeedsEffectSupport(module) ? findSupportCollision(module, language, options.usedOperations) : undefined;
+    if (collision)
+        unsupportedCapability(language, `protected Task 034 support name '${collision.name}'`, collision.location);
+    const excluded = findExcludedEffectContext(module);
+    if (excluded)
+        unsupportedCapability(language, excluded.detail, excluded.location);
+}
+/**
+ * Finds compiler-authorized Task 034 IR that has been detached from its authority graph.
+ * @param {unknown} value - Candidate semantic graph.
+ * @param {Set<object>} [seen] - Cycle protection.
+ * @returns {object | undefined} First unauthorized Task 034 node.
+ */
+function findTask034Node(value, seen = new Set()) {
+    if (!value || typeof value != "object" || seen.has(value))
+        return undefined;
+    seen.add(value);
+    if (!Array.isArray(value)) {
+        const kind = Reflect.get(value, "kind");
+        if (["EffectCallExpression", "OwnedBorrowExpression", "OwnedMoveExpression", "OwnedReferenceType", "OwnedResourceType"].includes(String(kind)) ||
+            kind == "ErrorType" && /^capability:[0-9]+\/failure:[0-9]+$/u.test(String(Reflect.get(value, "declarationId"))))
+            return value;
+    }
+    for (const [key, child] of Object.entries(value)) {
+        if (["location", "sourceProvenance"].includes(key))
+            continue;
+        const found = findTask034Node(child, seen);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+/**
+ * Finds one user declaration that would collide with the protected support surface.
+ * @param {import("../semantic/types.js").SemanticModule} module - Validated semantic graph.
+ * @param {import("../semantic/types.js").BackendLanguage} language - Target language.
+ * @param {readonly string[]} [usedOperations] - Linked provider operations; omitted for the full inlined surface.
+ * @returns {{name: string, location: import("../semantic/types.js").SourceLocation} | undefined} First collision.
+ */
+function findSupportCollision(module, language, usedOperations) {
+    const reserved = new Set();
+    if (usedOperations === undefined) {
+        for (const name of protectedSupportNames)
+            reserved.add(supportNameKey(name, language));
+        if (language == "javascript" || language == "typescript") {
+            reserved.add("__semantifoldTask034Fs");
+            reserved.add("__semantifoldTask034Trace");
+        }
+        else if (language == "php")
+            reserved.add("__semantifold_task034_trace");
+    }
+    else {
+        const used = new Set(usedOperations);
+        for (const name of used)
+            reserved.add(supportNameKey(name, language));
+        if (used.has("probeEffect"))
+            reserved.add(supportNameKey("ProbeOperationFailure", language));
+        if (used.has("probeAcquire"))
+            reserved.add(supportNameKey("ProbeAcquireFailure", language));
+        if (used.has("probeRead"))
+            reserved.add(supportNameKey("ProbeReadFailure", language));
+        if (used.has("probeClose"))
+            reserved.add(supportNameKey("ProbeCloseFailure", language));
+        if (used.has("probeRead") || used.has("probeClose"))
+            reserved.add(supportNameKey("ProbeResourceClosed", language));
+        if (used.has("probeAcquire") || used.has("probeRead") || used.has("probeClose")) {
+            reserved.add(supportNameKey("ProbeResource", language));
+        }
+        if (used.size > 0) {
+            if (language == "javascript" || language == "typescript") {
+                reserved.add("__semantifoldTask034Trace");
+                if (used.has("probeAcquire"))
+                    reserved.add("__semantifoldTask034Fs");
+            }
+            else if (language == "php")
+                reserved.add("__semantifold_task034_trace");
+        }
+    }
+    const declarations = [...module.records ?? [], ...module.classes ?? [], ...module.errors ?? [], ...module.functions];
+    for (const declaration of declarations) {
+        if (!declaration || typeof declaration != "object")
+            continue;
+        if (reserved.has(supportNameKey(declaration.name, language)))
+            return { location: declaration.location, name: declaration.name };
+    }
+    if (language == "javascript" || language == "typescript" || language == "php") {
+        for (const statement of module.entryPoint.body.statements) {
+            if (!statement || typeof statement != "object")
+                continue;
+            if (statement.kind == "LocalDeclaration" && reserved.has(supportNameKey(statement.name, language))) {
+                return { location: statement.location, name: statement.name };
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Applies target namespace casing to a protected support name.
+ * @param {string} name - Source name.
+ * @param {import("../semantic/types.js").BackendLanguage} language - Target language.
+ * @returns {string} Comparable name.
+ */
+function supportNameKey(name, language) {
+    return language == "php" ? name.toLowerCase() : name;
+}
+/**
+ * Emits fixed target-private Task 034 conformance support.
+ * @param {import("./writer.js").SourceWriter} writer - Destination writer.
+ * @param {import("../semantic/types.js").SemanticModule} module - Authorized module.
+ * @param {"php" | "ruby" | "javascript" | "typescript" | "java"} language - Adopted target.
+ * @param {"top" | "members"} [placement] - Java support placement.
+ * @returns {void}
+ */
+export function emitEffectSupport(writer, module, language, placement = "top") {
+    const linked = writer.stdlibProviderEntries !== undefined;
+    if (language == "java" && linked) {
+        if (placement != "members" || writer.stdlibProviderShims === undefined)
+            return;
+    }
+    else if (linked || !module.capabilities || !moduleNeedsEffectSupport(module)) {
+        return;
+    }
+    const content = language == "php" ? phpSupport : language == "ruby" ? rubySupport : language == "javascript" ? javascriptSupport :
+        language == "typescript" ? typescriptSupport :
+            writer.stdlibProviderShims !== undefined ? javaProgramNestedSupport + javaMemberSupport :
+                placement == "top" ? javaTopSupport : javaMemberSupport;
+    writer.synthetic(content, "semantifold-task034-support", [module]);
+}
+/**
+ * Emits the public static provider shims for the program-wide used operations on the Java owner module.
+ * @param {import("./writer.js").SourceWriter} writer - Destination writer.
+ * @param {import("../semantic/types.js").SemanticModule} module - Owner module.
+ * @returns {void}
+ */
+export function emitEffectProviderEntries(writer, module) {
+    const operations = writer.stdlibProviderShims ?? [];
+    if (operations.length == 0)
+        return;
+    const lines = operations.map((operation) => `  ${javaProviderShims[operation]}`);
+    writer.synthetic(`${lines.join("\n")}\n\n`, "semantifold-stdlib-provider-entries", [module]);
+}
+/**
+ * Recognizes only the byte-exact protected support emitted by this backend.
+ * Frontends use this in addition to parser-shape checks during generated-source reparse.
+ * @param {string} source - Complete candidate source.
+ * @param {"php" | "ruby" | "javascript" | "typescript" | "java"} language - Adopted target.
+ * @param {"top" | "members"} [placement] - Java support placement.
+ * @returns {boolean} Whether the exact protected segment is present.
+ */
+export function hasExactEffectSupport(source, language, placement = "top") {
+    const content = language == "php" ? phpSupport : language == "ruby" ? rubySupport : language == "javascript" ? javascriptSupport :
+        language == "typescript" ? typescriptSupport : placement == "top" ? javaTopSupport : javaMemberSupport;
+    return source.includes(content);
+}
+/**
+ * Materializes nested effect sites before their enclosing eager expression.
+ * The installed replacements remain active until the next statement begins.
+ * @param {import("./writer.js").SourceWriter} writer - Destination writer.
+ * @param {import("../semantic/types.js").Statement} statement - Current statement.
+ * @param {string} indent - Current target indentation.
+ * @param {string} path - Exact statement path.
+ * @param {"php" | "ruby" | "javascript" | "typescript" | "java"} language - Adopted target.
+ * @param {(expression: import("../semantic/types.js").Expression, path: string) => void} emit - Target expression emitter.
+ * @returns {void}
+ */
+export function emitEffectPrefixes(writer, statement, indent, path, language, emit) {
+    /** @type {ExpressionPath[]} */
+    const planned = [];
+    for (const root of statementExpressionRoots(statement, path))
+        collectNestedEffects(root.expression, root.path, root.expression, planned);
+    writer.planEffectReplacements(planned.map(({ expression }) => expression));
+    for (const { expression, path: expressionPath } of planned) {
+        const name = writer.effectTemporaryName(expression);
+        const type = effectExpressionType(writer, expression);
+        const typeName = emittedTypeName(writer, type, language);
+        const declaration = language == "php"
+            ? `/**\n${indent} * @var ${typeName} $${name}\n${indent} * @semantifold-immutable\n${indent} */\n${indent}$${name} = `
+            : language == "ruby"
+                ? `# @type [${typeName}]\n${indent}# @semantifold-immutable\n${indent}${name} = `
+                : language == "javascript" ? `/** @type {${typeName}} */\n${indent}const ${name} = `
+                    : language == "typescript" ? `const ${name}: ${typeName} = ` : `final ${typeName} ${name} = `;
+        writer.synthetic(`${indent}${declaration}`, "exactly-once effect temporary", [expression], [expressionPath]);
+        writer.emitEffectDefinition(expression, () => emit(expression, expressionPath));
+        writer.synthetic(language == "ruby" ? "\n" : ";\n", "exactly-once effect temporary terminator", [expression], [expressionPath]);
+    }
+}
+/**
+ * Resolves the result type needed for an effect temporary.
+ * @param {import("./writer.js").SourceWriter} writer - Active writer.
+ * @param {import("../semantic/types.js").Expression} expression - Effectful expression.
+ * @returns {import("../semantic/types.js").SemanticFunctionReturnType | undefined} Result type.
+ */
+function effectExpressionType(writer, expression) {
+    if (expression.kind == "EffectCallExpression")
+        return writer.effectOperationForId(expression.operation).returnType;
+    if (expression.kind == "MethodCallExpression" || expression.kind == "CallExpression") {
+        return expression.resolution ? semanticTypeForIdentity(expression.resolution.returnType) : undefined;
+    }
+    return undefined;
+}
+/**
+ * Rehydrates a resolved call result for target-local temporary spelling.
+ * @param {import("../semantic/types.js").FunctionReturnTypeIdentity} identity - Exact resolved result identity.
+ * @returns {import("../semantic/types.js").SemanticFunctionReturnType} Detached semantic type.
+ */
+function semanticTypeForIdentity(identity) {
+    if (typeof identity == "string") {
+        return { kind: "TypeReference", name: /** @type {import("../semantic/types.js").FunctionReturnTypeName} */ (identity) };
+    }
+    if (identity.kind == "ListType")
+        return { elementType: semanticTypeForValueIdentity(identity.elementType), kind: "ListType" };
+    if (identity.kind == "MapType")
+        return { keyType: /** @type {import("../semantic/types.js").TypeReference} */ (semanticTypeForValueIdentity(identity.keyType)), kind: "MapType",
+            valueType: semanticTypeForValueIdentity(identity.valueType) };
+    if (identity.kind == "OrderedMapType")
+        return { keyType: /** @type {import("../semantic/types.js").TypeReference} */ (semanticTypeForValueIdentity(identity.keyType)), kind: "OrderedMapType",
+            order: "insertion", valueType: semanticTypeForValueIdentity(identity.valueType) };
+    if (identity.kind == "OptionalType")
+        return { kind: "OptionalType", valueType: semanticTypeForValueIdentity(identity.valueType) };
+    if (identity.kind == "RecordType")
+        return { arguments: identity.arguments?.map(semanticTypeForValueIdentity),
+            declarationId: identity.declarationId, kind: "RecordType" };
+    if (identity.kind == "ReferenceType")
+        return { declarationId: identity.declarationId, kind: "ReferenceType" };
+    if (identity.kind == "OwnedResourceType")
+        return { kind: "OwnedResourceType", resourceId: identity.resourceId };
+    if (identity.kind == "OwnedReferenceType")
+        return { declarationId: identity.declarationId, kind: "OwnedReferenceType" };
+    return { kind: "TypeVariableReference", location: /** @type {never} */ (undefined), parameterId: identity.parameterId };
+}
+/**
+ * Rehydrates one non-void resolved type identity.
+ * @param {import("../semantic/types.js").SemanticTypeIdentity} identity - Exact type identity.
+ * @returns {import("../semantic/types.js").SemanticValueType} Detached semantic type.
+ */
+function semanticTypeForValueIdentity(identity) {
+    return /** @type {import("../semantic/types.js").SemanticValueType} */ (semanticTypeForIdentity(identity));
+}
+/**
+ * Renders the subset of semantic types admitted for synthetic temporaries.
+ * @param {import("./writer.js").SourceWriter} writer - Active writer.
+ * @param {import("../semantic/types.js").SemanticFunctionReturnType | undefined} type - Semantic type.
+ * @param {"php" | "ruby" | "javascript" | "typescript" | "java"} language - Target.
+ * @param {boolean} [nested] - Whether Java requires a boxed scalar.
+ * @returns {string} Target type spelling.
+ */
+function emittedTypeName(writer, type, language, nested = false) {
+    if (!type || type.kind == "TypeReference" && type.name == "void")
+        return language == "java" ? "Object" : "unknown";
+    if (type.kind == "TypeReference") {
+        if (language == "php")
+            return type.name == "integer" ? "int" : type.name == "boolean" ? "bool" : "string";
+        if (language == "ruby")
+            return type.name == "integer" ? "Integer" : type.name == "boolean" ? "Boolean" : "String";
+        if (language == "java")
+            return type.name == "integer" ? nested ? "Integer" : "int" :
+                type.name == "boolean" ? nested ? "Boolean" : "boolean" : "String";
+        return type.name == "integer" ? "number" : type.name;
+    }
+    if (type.kind == "OwnedResourceType")
+        return writer.resourceForId(type.resourceId).name;
+    if (type.kind == "ReferenceType" || type.kind == "OwnedReferenceType")
+        return writer.classNameForId(type.declarationId);
+    if (type.kind == "TypeVariableReference")
+        return writer.typeParameterForId(type.parameterId).name;
+    if (type.kind == "RecordType") {
+        const name = writer.recordNameForId(type.declarationId);
+        const arguments_ = type.arguments?.map((argument) => emittedTypeName(writer, argument, language, true)) ?? [];
+        return arguments_.length == 0 ? name : language == "ruby" ? `${name}[${arguments_.join(",")}]` : `${name}<${arguments_.join(",")}>`;
+    }
+    if (type.kind == "OptionalType") {
+        const value = emittedTypeName(writer, type.valueType, language, true);
+        return language == "php" ? `?${value}` : language == "ruby" ? `${value}?` :
+            language == "java" ? `java.util.Optional<${value}>` : `${value} | null`;
+    }
+    if (type.kind == "ListType") {
+        const value = emittedTypeName(writer, type.elementType, language, true);
+        return language == "php" ? `list<${value}>` : language == "ruby" ? `Array<${value}>` :
+            language == "java" ? `java.util.List<${value}>` : `readonly ${value}[]`;
+    }
+    if (type.kind == "MapType" || type.kind == "OrderedMapType") {
+        const key = emittedTypeName(writer, type.keyType, language, true);
+        const value = emittedTypeName(writer, type.valueType, language, true);
+        if (language == "php")
+            return `array<${key},${value}>`;
+        if (language == "ruby")
+            return `Hash[${key},${value}]`;
+        if (language == "java")
+            return `${type.kind == "OrderedMapType" ? "java.util.SequencedMap" : "java.util.Map"}<${key},${value}>`;
+        return `ReadonlyMap<${key}, ${value}>`;
+    }
+    return language == "java" ? "Object" : "unknown";
+}
+/**
+ * Returns the expression roots evaluated by one statement.
+ * @param {import("../semantic/types.js").Statement} statement - Statement.
+ * @param {string} path - Stable statement path.
+ * @returns {ExpressionPath[]} Expression roots.
+ */
+function statementExpressionRoots(statement, path) {
+    if (statement.kind == "LocalDeclaration")
+        return [{ expression: statement.initializer, path: `${path}/initializer` }];
+    if (statement.kind == "AssignmentStatement" || statement.kind == "ExpressionStatement" || statement.kind == "PrintStatement") {
+        return [{ expression: statement.expression, path: `${path}/expression` }];
+    }
+    if (statement.kind == "ReturnStatement")
+        return statement.expression ? [{ expression: statement.expression, path: `${path}/expression` }] : [];
+    if (statement.kind == "PrivateFieldWriteStatement")
+        return [{ expression: statement.expression, path: `${path}/expression` }];
+    if (statement.kind == "IfStatement" || statement.kind == "WhileStatement")
+        return [{ expression: statement.condition, path: `${path}/condition` }];
+    if (statement.kind == "ForEachStatement")
+        return [{ expression: statement.list, path: `${path}/list` }];
+    if (statement.kind == "ForEachMapStatement")
+        return [{ expression: statement.map, path: `${path}/map` }];
+    if (statement.kind == "RaiseStatement")
+        return [{ expression: statement.error.message, path: `${path}/error/message` }];
+    return [];
+}
+/**
+ * Collects nested effect sites in postorder so children are materialized first.
+ * @param {import("../semantic/types.js").Expression} expression - Current expression.
+ * @param {string} path - Current occurrence path.
+ * @param {import("../semantic/types.js").Expression} root - Statement expression root.
+ * @param {ExpressionPath[]} output - Ordered plan receiving nested sites.
+ * @returns {void}
+ */
+function collectNestedEffects(expression, path, root, output) {
+    for (const child of expressionChildren(expression, path))
+        collectNestedEffects(child.expression, child.path, root, output);
+    if (expression !== root && (expression.kind == "EffectCallExpression" || typeof Reflect.get(expression, "effectSiteId") == "string")) {
+        output.push({ expression, path });
+    }
+}
+/**
+ * Returns path-bearing expression children in evaluation order.
+ * @param {import("../semantic/types.js").Expression} expression - Parent expression.
+ * @param {string} path - Parent path.
+ * @returns {ExpressionPath[]} Children.
+ */
+function expressionChildren(expression, path) {
+    if (expression.kind == "CallExpression" || expression.kind == "EffectCallExpression" || expression.kind == "ReferenceConstruction" ||
+        expression.kind == "RecordConstruction")
+        return expression.arguments.map((child, index) => ({ expression: child, path: `${path}/arguments/${index}` }));
+    if (expression.kind == "MethodCallExpression")
+        return [
+            { expression: expression.receiver, path: `${path}/receiver` },
+            ...expression.arguments.map((child, index) => ({ expression: child, path: `${path}/arguments/${index}` }))
+        ];
+    if (expression.kind == "OwnedMoveExpression" || expression.kind == "OwnedBorrowExpression") {
+        return [{ expression: expression.expression, path: `${path}/expression` }];
+    }
+    if (expression.kind == "BinaryExpression")
+        return [
+            { expression: expression.left, path: `${path}/left` }, { expression: expression.right, path: `${path}/right` }
+        ];
+    if (expression.kind == "UnaryExpression")
+        return [{ expression: expression.operand, path: `${path}/operand` }];
+    if (expression.kind == "OptionalSome")
+        return [{ expression: expression.value, path: `${path}/value` }];
+    if (expression.kind == "OptionalIsPresent" || expression.kind == "OptionalUnwrap") {
+        return [{ expression: expression.operand, path: `${path}/operand` }];
+    }
+    if (expression.kind == "ListLiteral")
+        return expression.elements.map((child, index) => ({ expression: child, path: `${path}/elements/${index}` }));
+    if (expression.kind == "MapLiteral" || expression.kind == "OrderedMapLiteral")
+        return expression.entries.flatMap((entry, index) => [
+            { expression: entry.key, path: `${path}/entries/${index}/key` }, { expression: entry.value, path: `${path}/entries/${index}/value` }
+        ]);
+    if (expression.kind == "ListIndexExpression")
+        return [
+            { expression: expression.collection, path: `${path}/collection` }, { expression: expression.index, path: `${path}/index` }
+        ];
+    if (expression.kind == "MapLookupExpression")
+        return [
+            { expression: expression.collection, path: `${path}/collection` }, { expression: expression.key, path: `${path}/key` }
+        ];
+    if (expression.kind == "CollectionSizeExpression")
+        return [{ expression: expression.collection, path: `${path}/collection` }];
+    if (expression.kind == "MemberRead")
+        return [{ expression: expression.receiver, path: `${path}/receiver` }];
+    return [];
+}
+/**
+ * Checks whether generated support is required by a semantic capability node or type.
+ * @param {import("../semantic/types.js").SemanticModule} module - Semantic module.
+ * @returns {boolean} Whether the protected binding is required.
+ */
+function moduleNeedsEffectSupport(module) {
+    /** @type {unknown[]} */
+    const pending = [module.entryPoint, ...module.functions, ...module.records ?? [], ...module.errors ?? [], ...module.classes ?? []];
+    const seen = new Set();
+    while (pending.length > 0) {
+        const value = pending.pop();
+        if (!value || typeof value != "object" || seen.has(value))
+            continue;
+        seen.add(value);
+        const kind = Reflect.get(value, "kind");
+        if (kind == "EffectCallExpression" || kind == "OwnedResourceType" || kind == "OwnedReferenceType" ||
+            kind == "ErrorType" && /^capability:[0-9]+\/failure:[0-9]+$/u.test(String(Reflect.get(value, "declarationId"))))
+            return true;
+        for (const [key, child] of Object.entries(value)) {
+            if (["location", "sourceProvenance"].includes(key))
+                continue;
+            if (Array.isArray(child))
+                pending.push(...child);
+            else if (child && typeof child == "object")
+                pending.push(child);
+        }
+    }
+    return false;
+}
+/**
+ * Finds a context excluded from bounded eager lowering.
+ * @param {import("../semantic/types.js").SemanticModule} module - Semantic module.
+ * @returns {ExcludedEffect | undefined} First deterministic exclusion.
+ */
+function findExcludedEffectContext(module) {
+    /** @type {object[]} */
+    const owners = [...module.functions.filter((owner) => owner && typeof owner == "object"), module.entryPoint];
+    for (const declaration of module.classes ?? []) {
+        if (!declaration || typeof declaration != "object")
+            continue;
+        if (declaration.constructor && typeof declaration.constructor == "object")
+            owners.push(declaration.constructor);
+        if (Array.isArray(declaration.methods))
+            owners.push(...declaration.methods.filter((owner) => owner && typeof owner == "object"));
+    }
+    for (const owner of owners) {
+        const body = Reflect.get(owner, "body");
+        if (!body || typeof body != "object")
+            continue;
+        const found = blockExcluded(/** @type {import("../semantic/types.js").Block} */ (body));
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+/**
+ * Finds an excluded context in one structured block.
+ * @param {import("../semantic/types.js").Block} block - Semantic block.
+ * @returns {ExcludedEffect | undefined} First deterministic exclusion.
+ */
+function blockExcluded(block) {
+    if (!block || typeof block != "object" || !Array.isArray(block.statements))
+        return undefined;
+    for (const statement of block.statements) {
+        if (!statement || typeof statement != "object")
+            continue;
+        if (statement.kind == "WhileStatement" && containsEffect(statement.condition)) {
+            return { detail: "effectful condition-controlled loop condition", location: statement.condition.location };
+        }
+        const expressions = statement.kind == "LocalDeclaration" ? [statement.initializer] :
+            statement.kind == "AssignmentStatement" || statement.kind == "ExpressionStatement" || statement.kind == "PrintStatement" ? [statement.expression] :
+                statement.kind == "ReturnStatement" ? statement.expression ? [statement.expression] : [] :
+                    statement.kind == "IfStatement" ? [statement.condition] : statement.kind == "ForEachStatement" ? [statement.list] :
+                        statement.kind == "ForEachMapStatement" ? [statement.map] : statement.kind == "PrivateFieldWriteStatement" ? [statement.expression] :
+                            statement.kind == "RaiseStatement" ? [statement.error.message] : [];
+        for (const expression of expressions) {
+            const conditional = findConditionalEffect(expression);
+            if (conditional)
+                return { detail: "effectful short-circuit BooleanAnd/BooleanOr expression", location: conditional.location };
+        }
+        const nested = statement.kind == "IfStatement" ? [statement.consequent, ...(statement.alternate ? [statement.alternate] : [])] :
+            statement.kind == "ForEachStatement" || statement.kind == "ForEachMapStatement" || statement.kind == "WhileStatement" ? [statement.body] :
+                statement.kind == "TryStatement" ? [statement.body, statement.catchBody] : [];
+        for (const child of nested) {
+            const found = blockExcluded(child);
+            if (found)
+                return found;
+        }
+    }
+    return undefined;
+}
+/**
+ * Finds an effect below a short-circuit operator.
+ * @param {import("../semantic/types.js").Expression} expression - Expression root.
+ * @returns {import("../semantic/types.js").Expression | undefined} Invalid conditional effect.
+ */
+function findConditionalEffect(expression) {
+    if (!expression || typeof expression != "object")
+        return undefined;
+    if (expression.kind == "BinaryExpression" && ["BooleanAnd", "BooleanOr"].includes(expression.operation) &&
+        (containsEffect(expression.left) || containsEffect(expression.right)))
+        return expression;
+    for (const child of children(expression)) {
+        const found = findConditionalEffect(child);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+/**
+ * Checks whether an expression evaluates an effect.
+ * @param {import("../semantic/types.js").Expression} expression - Expression root.
+ * @returns {boolean} Whether an effect is reachable.
+ */
+function containsEffect(expression) {
+    if (!expression || typeof expression != "object")
+        return false;
+    return expression.kind == "EffectCallExpression" || Boolean(Reflect.get(expression, "effectSiteId")) || children(expression).some(containsEffect);
+}
+/**
+ * Returns child expressions in evaluation order.
+ * @param {import("../semantic/types.js").Expression} expression - Parent expression.
+ * @returns {import("../semantic/types.js").Expression[]} Children.
+ */
+function children(expression) {
+    if (!expression || typeof expression != "object")
+        return [];
+    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 == "OwnedMoveExpression" || expression.kind == "OwnedBorrowExpression")
+        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.flatMap(({ key, value }) => [key, 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];
+    return [];
+}
+const phpSupport = `/* semantifold-task034-support */
+final class ProbeOperationFailure extends RuntimeException {}
+final class ProbeAcquireFailure extends RuntimeException {}
+final class ProbeReadFailure extends RuntimeException {}
+final class ProbeCloseFailure extends RuntimeException {}
+final class ProbeResourceClosed extends RuntimeException {}
+final class ProbeResource {
+    public bool $closed = false;
+    public function __construct(public mixed $handle) {}
+}
+$GLOBALS['__semantifold_task034_trace'] = [];
+function probeEffect(string $label, int $value, bool $fail): int {
+    $GLOBALS['__semantifold_task034_trace'][] = 'effect:' . $label;
+    if ($fail) throw new ProbeOperationFailure('ProbeOperationFailure');
+    return $value;
+}
+function probeAcquire(bool $fail): ProbeResource {
+    $GLOBALS['__semantifold_task034_trace'][] = 'acquire';
+    if ($fail) throw new ProbeAcquireFailure('ProbeAcquireFailure');
+    try { $handle = @fopen((string) getenv('SEMANTIFOLD_TASK034_PROBE_PATH'), 'rb'); }
+    catch (Throwable) { throw new ProbeAcquireFailure('ProbeAcquireFailure'); }
+    if ($handle === false) throw new ProbeAcquireFailure('ProbeAcquireFailure');
+    return new ProbeResource($handle);
+}
+function probeRead(ProbeResource $resource, bool $fail): ?string {
+    if ($resource->closed) throw new ProbeResourceClosed('ProbeResourceClosed');
+    $GLOBALS['__semantifold_task034_trace'][] = 'read';
+    if ($fail) throw new ProbeReadFailure('ProbeReadFailure');
+    try { $line = @fgets($resource->handle); }
+    catch (Throwable) { throw new ProbeReadFailure('ProbeReadFailure'); }
+    if ($line === false) {
+        if (feof($resource->handle)) return null;
+        throw new ProbeReadFailure('ProbeReadFailure');
+    }
+    return rtrim($line, "\\r\\n");
+}
+function probeClose(ProbeResource $resource, bool $fail): void {
+    if ($resource->closed) throw new ProbeResourceClosed('ProbeResourceClosed');
+    $GLOBALS['__semantifold_task034_trace'][] = 'close';
+    try { $closed = @fclose($resource->handle); }
+    catch (Throwable) { $resource->closed = true; throw new ProbeCloseFailure('ProbeCloseFailure'); }
+    $resource->closed = true;
+    if ($fail || !$closed) throw new ProbeCloseFailure('ProbeCloseFailure');
+}
+function probeTrace(): string { return implode(',', $GLOBALS['__semantifold_task034_trace']); }
+/* semantifold-task034-support-end */
+
+`;
+const rubySupport = `# semantifold-task034-support
+class ProbeOperationFailure < StandardError; end
+class ProbeAcquireFailure < StandardError; end
+class ProbeReadFailure < StandardError; end
+class ProbeCloseFailure < StandardError; end
+class ProbeResourceClosed < StandardError; end
+class ProbeResource
+  attr_accessor :handle, :closed
+  def initialize(handle); @handle = handle; @closed = false; end
+end
+$__semantifold_task034_trace = []
+def probeEffect(label, value, fail_value)
+  $__semantifold_task034_trace << "effect:#{label}"
+  raise ProbeOperationFailure, "ProbeOperationFailure" if fail_value
+  value
+end
+def probeAcquire(fail_value)
+  $__semantifold_task034_trace << "acquire"
+  raise ProbeAcquireFailure, "ProbeAcquireFailure" if fail_value
+  begin; ProbeResource.new(File.open(ENV.fetch("SEMANTIFOLD_TASK034_PROBE_PATH"), "r")); rescue ProbeAcquireFailure; raise; rescue StandardError; raise ProbeAcquireFailure, "ProbeAcquireFailure"; end
+end
+def probeRead(resource, fail_value)
+  raise ProbeResourceClosed, "ProbeResourceClosed" if resource.closed
+  $__semantifold_task034_trace << "read"
+  raise ProbeReadFailure, "ProbeReadFailure" if fail_value
+  begin; value = resource.handle.gets; value.nil? ? nil : value.chomp; rescue ProbeReadFailure; raise; rescue StandardError; raise ProbeReadFailure, "ProbeReadFailure"; end
+end
+def probeClose(resource, fail_value)
+  raise ProbeResourceClosed, "ProbeResourceClosed" if resource.closed
+  $__semantifold_task034_trace << "close"
+  begin; resource.handle.close; rescue StandardError; resource.closed = true; raise ProbeCloseFailure, "ProbeCloseFailure"; end
+  resource.closed = true
+  raise ProbeCloseFailure, "ProbeCloseFailure" if fail_value
+  nil
+end
+def probeTrace; $__semantifold_task034_trace.join(","); end
+# semantifold-task034-support-end
+
+`;
+const javascriptSupport = `/* semantifold-task034-support */
+const __semantifoldTask034Fs = process.getBuiltinModule("node:fs")
+class ProbeOperationFailure extends Error {}
+class ProbeAcquireFailure extends Error {}
+class ProbeReadFailure extends Error {}
+class ProbeCloseFailure extends Error {}
+class ProbeResourceClosed extends Error {}
+class ProbeResource { constructor(handle) { this.handle = handle; this.closed = false; this.position = 0 } }
+const __semantifoldTask034Trace = []
+function probeEffect(label, value, fail) { __semantifoldTask034Trace.push(\`effect:\${label}\`); if (fail) throw new ProbeOperationFailure("ProbeOperationFailure"); return value }
+function probeAcquire(fail) { __semantifoldTask034Trace.push("acquire"); if (fail) throw new ProbeAcquireFailure("ProbeAcquireFailure"); try { return new ProbeResource(__semantifoldTask034Fs.openSync(process.env.SEMANTIFOLD_TASK034_PROBE_PATH, "r")) } catch { throw new ProbeAcquireFailure("ProbeAcquireFailure") } }
+function probeRead(resource, fail) { if (resource.closed) throw new ProbeResourceClosed("ProbeResourceClosed"); __semantifoldTask034Trace.push("read"); if (fail) throw new ProbeReadFailure("ProbeReadFailure"); try { const bytes = []; const buffer = Buffer.alloc(1); while (true) { const count = __semantifoldTask034Fs.readSync(resource.handle, buffer, 0, 1, resource.position++); if (count === 0) return bytes.length === 0 ? null : Buffer.from(bytes).toString("utf8"); if (buffer[0] === 10) return Buffer.from(bytes).toString("utf8").replace(/\\r$/u, ""); bytes.push(buffer[0]) } } catch { throw new ProbeReadFailure("ProbeReadFailure") } }
+function probeClose(resource, fail) { if (resource.closed) throw new ProbeResourceClosed("ProbeResourceClosed"); __semantifoldTask034Trace.push("close"); try { __semantifoldTask034Fs.closeSync(resource.handle) } catch { resource.closed = true; throw new ProbeCloseFailure("ProbeCloseFailure") } resource.closed = true; if (fail) throw new ProbeCloseFailure("ProbeCloseFailure") }
+function probeTrace() { return __semantifoldTask034Trace.join(",") }
+/* semantifold-task034-support-end */
+
+`;
+const typescriptSupport = `/* semantifold-task034-support */
+const __semantifoldTask034Fs = process.getBuiltinModule("node:fs")
+class ProbeOperationFailure extends Error {}
+class ProbeAcquireFailure extends Error {}
+class ProbeReadFailure extends Error {}
+class ProbeCloseFailure extends Error {}
+class ProbeResourceClosed extends Error {}
+class ProbeResource { closed = false; position = 0; constructor(readonly handle: number) {} }
+const __semantifoldTask034Trace: string[] = []
+function probeEffect(label: string, value: number, fail: boolean): number { __semantifoldTask034Trace.push(\`effect:\${label}\`); if (fail) throw new ProbeOperationFailure("ProbeOperationFailure"); return value }
+function probeAcquire(fail: boolean): ProbeResource { __semantifoldTask034Trace.push("acquire"); if (fail) throw new ProbeAcquireFailure("ProbeAcquireFailure"); try { return new ProbeResource(__semantifoldTask034Fs.openSync(process.env.SEMANTIFOLD_TASK034_PROBE_PATH as string, "r")) } catch { throw new ProbeAcquireFailure("ProbeAcquireFailure") } }
+function probeRead(resource: ProbeResource, fail: boolean): string | null { if (resource.closed) throw new ProbeResourceClosed("ProbeResourceClosed"); __semantifoldTask034Trace.push("read"); if (fail) throw new ProbeReadFailure("ProbeReadFailure"); try { const bytes: number[] = []; const buffer = Buffer.alloc(1); while (true) { const count = __semantifoldTask034Fs.readSync(resource.handle, buffer, 0, 1, resource.position++); if (count === 0) return bytes.length === 0 ? null : Buffer.from(bytes).toString("utf8"); if (buffer[0] === 10) return Buffer.from(bytes).toString("utf8").replace(/\\r$/u, ""); bytes.push(buffer[0]) } } catch { throw new ProbeReadFailure("ProbeReadFailure") } }
+function probeClose(resource: ProbeResource, fail: boolean): void { if (resource.closed) throw new ProbeResourceClosed("ProbeResourceClosed"); __semantifoldTask034Trace.push("close"); try { __semantifoldTask034Fs.closeSync(resource.handle) } catch { resource.closed = true; throw new ProbeCloseFailure("ProbeCloseFailure") } resource.closed = true; if (fail) throw new ProbeCloseFailure("ProbeCloseFailure") }
+function probeTrace(): string { return __semantifoldTask034Trace.join(",") }
+/* semantifold-task034-support-end */
+
+`;
+const javaTopSupport = `// semantifold-task034-support
+final class ProbeOperationFailure extends RuntimeException { ProbeOperationFailure() { super("ProbeOperationFailure"); } }
+final class ProbeAcquireFailure extends RuntimeException { ProbeAcquireFailure() { super("ProbeAcquireFailure"); } }
+final class ProbeReadFailure extends RuntimeException { ProbeReadFailure() { super("ProbeReadFailure"); } }
+final class ProbeCloseFailure extends RuntimeException { ProbeCloseFailure() { super("ProbeCloseFailure"); } }
+final class ProbeResourceClosed extends RuntimeException { ProbeResourceClosed() { super("ProbeResourceClosed"); } }
+final class ProbeResource { final java.nio.channels.FileChannel handle; boolean closed = false; ProbeResource(java.nio.channels.FileChannel handle) { this.handle = handle; } }
+// semantifold-task034-support-top-end
+
+`;
+const javaMemberSupport = `  // semantifold-task034-support-members
+  private static final java.util.ArrayList<String> __semantifoldTask034Trace = new java.util.ArrayList<>();
+  static int probeEffect(String label, int value, boolean fail) { __semantifoldTask034Trace.add("effect:" + label); if (fail) throw new ProbeOperationFailure(); return value; }
+  static ProbeResource probeAcquire(boolean fail) { __semantifoldTask034Trace.add("acquire"); if (fail) throw new ProbeAcquireFailure(); try { return new ProbeResource(java.nio.channels.FileChannel.open(java.nio.file.Path.of(System.getenv("SEMANTIFOLD_TASK034_PROBE_PATH")))); } catch (RuntimeException | java.io.IOException exception) { throw new ProbeAcquireFailure(); } }
+  static java.util.Optional<String> probeRead(ProbeResource resource, boolean fail) { if (resource.closed) throw new ProbeResourceClosed(); __semantifoldTask034Trace.add("read"); if (fail) throw new ProbeReadFailure(); try { java.io.ByteArrayOutputStream bytes = new java.io.ByteArrayOutputStream(); java.nio.ByteBuffer buffer = java.nio.ByteBuffer.allocate(1); while (true) { buffer.clear(); int count = resource.handle.read(buffer); if (count < 0) return bytes.size() == 0 ? java.util.Optional.empty() : java.util.Optional.of(bytes.toString(java.nio.charset.StandardCharsets.UTF_8)); buffer.flip(); byte value = buffer.get(); if (value == 10) return java.util.Optional.of(bytes.toString(java.nio.charset.StandardCharsets.UTF_8).replaceFirst("\\r$", "")); bytes.write(value); } } catch (java.io.IOException exception) { throw new ProbeReadFailure(); } }
+  static void probeClose(ProbeResource resource, boolean fail) { if (resource.closed) throw new ProbeResourceClosed(); __semantifoldTask034Trace.add("close"); try { resource.handle.close(); } catch (java.io.IOException exception) { resource.closed = true; throw new ProbeCloseFailure(); } resource.closed = true; if (fail) throw new ProbeCloseFailure(); }
+  static String probeTrace() { return String.join(",", __semantifoldTask034Trace); }
+  // semantifold-task034-support-members-end
+
+`;
+const javaProgramNestedSupport = `  // semantifold-task034-support-program
+  public static final class ProbeOperationFailure extends RuntimeException { ProbeOperationFailure() { super("ProbeOperationFailure"); } }
+  public static final class ProbeAcquireFailure extends RuntimeException { ProbeAcquireFailure() { super("ProbeAcquireFailure"); } }
+  public static final class ProbeReadFailure extends RuntimeException { ProbeReadFailure() { super("ProbeReadFailure"); } }
+  public static final class ProbeCloseFailure extends RuntimeException { ProbeCloseFailure() { super("ProbeCloseFailure"); } }
+  public static final class ProbeResourceClosed extends RuntimeException { ProbeResourceClosed() { super("ProbeResourceClosed"); } }
+  public static final class ProbeResource { final java.nio.channels.FileChannel handle; boolean closed = false; ProbeResource(java.nio.channels.FileChannel handle) { this.handle = handle; } }
+  // semantifold-task034-support-program-end
+
+`;
+/** @type {Record<string, string>} */
+const javaProviderShims = {
+    probeAcquire: "public static ProbeResource __semantifold_provider_java_probeAcquire(boolean fail) { return probeAcquire(fail); }",
+    probeClose: "public static void __semantifold_provider_java_probeClose(ProbeResource resource, boolean fail) { probeClose(resource, fail); }",
+    probeEffect: "public static int __semantifold_provider_java_probeEffect(String label, int value, boolean fail) { return probeEffect(label, value, fail); }",
+    probeRead: "public static java.util.Optional<String> __semantifold_provider_java_probeRead(ProbeResource resource, boolean fail) { return probeRead(resource, fail); }",
+    probeTrace: "public static String __semantifold_provider_java_probeTrace() { return probeTrace(); }"
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"effects.js","sourceRoot":"","sources":["../../../src/backends/effects.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {unsupportedCapability} from \"../diagnostic.js\"\nimport {isTask034ResourceProbe} from \"../semantic/capabilities.js\"\n\nconst adoptedTargets = new Set([\"php\", \"ruby\", \"javascript\", \"typescript\", \"java\"])\nconst task037Authorities = new Set([\n  \"semantifold.output\", \"semantifold.resource\", \"semantifold.socket-client\", \"semantifold.text-stream\"\n])\nconst protectedSupportNames = new Set([\n  \"ProbeOperationFailure\", \"ProbeAcquireFailure\", \"ProbeReadFailure\", \"ProbeCloseFailure\", \"ProbeResourceClosed\", \"ProbeResource\",\n  \"probeEffect\", \"probeAcquire\", \"probeRead\", \"probeClose\", \"probeTrace\"\n])\n\n/** @typedef {{expression: import(\"../semantic/types.js\").Expression, path: string}} ExpressionPath */\n/** @typedef {{detail: string, location: import(\"../semantic/types.js\").SourceLocation}} ExcludedEffect */\n\n/**\n * Validates Task 034 target support before a SourceWriter is allocated.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Candidate module.\n * @param {import(\"../semantic/types.js\").BackendLanguage} language - Requested target.\n * @param {{usedOperations?: readonly string[]}} [options] - Program-wide used canonical\n *   operations for a linked stdlib provider; restricts the reserved support surface to the\n *   operations actually materialized in the provider artifact.\n * @returns {void}\n */\nexport function preflightEffectCapabilities(module, language, options = {}) {\n  const capabilities = module?.capabilities\n\n  if (capabilities === undefined) {\n    const unauthorized = findTask034Node(module)\n\n    if (unauthorized) {\n      unsupportedCapability(language, \"MISSING_CAPABILITY_AUTHORITY: Task 034 IR requires its compiler authority graph\",\n        /** @type {import(\"../semantic/types.js\").SourceLocation | undefined} */ (Reflect.get(unauthorized, \"location\") ?? module?.location))\n    }\n    return\n  }\n  if (!Array.isArray(capabilities) || capabilities.length == 0) {\n    unsupportedCapability(language, \"malformed or empty Task 034 capability graph\", module?.location)\n  }\n  if (!adoptedTargets.has(language)) {\n    unsupportedCapability(language, \"Task 034 effectful capabilities and owned resources\", module.location)\n  }\n  const task037 = language == \"php\" && capabilities.every((capability) => task037Authorities.has(capability.authorityId))\n\n  if (!isTask034ResourceProbe(capabilities) && !task037) {\n    unsupportedCapability(language, \"unbound Task 034 capability authority\", module.location)\n  }\n  if (!Array.isArray(module.functions) || !module.entryPoint || typeof module.entryPoint != \"object\" ||\n    !module.entryPoint.body || !Array.isArray(module.entryPoint.body.statements) ||\n    [module.records, module.classes, module.errors].some((declarations) => declarations !== undefined && !Array.isArray(declarations))) {\n    unsupportedCapability(language, \"malformed Task 034 semantic module\", module.location)\n  }\n  const collision = moduleNeedsEffectSupport(module) ? findSupportCollision(module, language, options.usedOperations) : undefined\n\n  if (collision) unsupportedCapability(language, `protected Task 034 support name '${collision.name}'`, collision.location)\n  const excluded = findExcludedEffectContext(module)\n  if (excluded) unsupportedCapability(language, excluded.detail, excluded.location)\n}\n\n/**\n * Finds compiler-authorized Task 034 IR that has been detached from its authority graph.\n * @param {unknown} value - Candidate semantic graph.\n * @param {Set<object>} [seen] - Cycle protection.\n * @returns {object | undefined} First unauthorized Task 034 node.\n */\nfunction findTask034Node(value, seen = new Set()) {\n  if (!value || typeof value != \"object\" || seen.has(value)) return undefined\n  seen.add(value)\n  if (!Array.isArray(value)) {\n    const kind = Reflect.get(value, \"kind\")\n\n    if ([\"EffectCallExpression\", \"OwnedBorrowExpression\", \"OwnedMoveExpression\", \"OwnedReferenceType\", \"OwnedResourceType\"].includes(String(kind)) ||\n      kind == \"ErrorType\" && /^capability:[0-9]+\\/failure:[0-9]+$/u.test(String(Reflect.get(value, \"declarationId\")))) return value\n  }\n  for (const [key, child] of Object.entries(value)) {\n    if ([\"location\", \"sourceProvenance\"].includes(key)) continue\n    const found = findTask034Node(child, seen)\n    if (found) return found\n  }\n  return undefined\n}\n\n/**\n * Finds one user declaration that would collide with the protected support surface.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Validated semantic graph.\n * @param {import(\"../semantic/types.js\").BackendLanguage} language - Target language.\n * @param {readonly string[]} [usedOperations] - Linked provider operations; omitted for the full inlined surface.\n * @returns {{name: string, location: import(\"../semantic/types.js\").SourceLocation} | undefined} First collision.\n */\nfunction findSupportCollision(module, language, usedOperations) {\n  const reserved = new Set()\n\n  if (usedOperations === undefined) {\n    for (const name of protectedSupportNames) reserved.add(supportNameKey(name, language))\n    if (language == \"javascript\" || language == \"typescript\") {\n      reserved.add(\"__semantifoldTask034Fs\")\n      reserved.add(\"__semantifoldTask034Trace\")\n    } else if (language == \"php\") reserved.add(\"__semantifold_task034_trace\")\n  } else {\n    const used = new Set(usedOperations)\n\n    for (const name of used) reserved.add(supportNameKey(name, language))\n    if (used.has(\"probeEffect\")) reserved.add(supportNameKey(\"ProbeOperationFailure\", language))\n    if (used.has(\"probeAcquire\")) reserved.add(supportNameKey(\"ProbeAcquireFailure\", language))\n    if (used.has(\"probeRead\")) reserved.add(supportNameKey(\"ProbeReadFailure\", language))\n    if (used.has(\"probeClose\")) reserved.add(supportNameKey(\"ProbeCloseFailure\", language))\n    if (used.has(\"probeRead\") || used.has(\"probeClose\")) reserved.add(supportNameKey(\"ProbeResourceClosed\", language))\n    if (used.has(\"probeAcquire\") || used.has(\"probeRead\") || used.has(\"probeClose\")) {\n      reserved.add(supportNameKey(\"ProbeResource\", language))\n    }\n    if (used.size > 0) {\n      if (language == \"javascript\" || language == \"typescript\") {\n        reserved.add(\"__semantifoldTask034Trace\")\n        if (used.has(\"probeAcquire\")) reserved.add(\"__semantifoldTask034Fs\")\n      } else if (language == \"php\") reserved.add(\"__semantifold_task034_trace\")\n    }\n  }\n  const declarations = [...module.records ?? [], ...module.classes ?? [], ...module.errors ?? [], ...module.functions]\n\n  for (const declaration of declarations) {\n    if (!declaration || typeof declaration != \"object\") continue\n    if (reserved.has(supportNameKey(declaration.name, language))) return {location: declaration.location, name: declaration.name}\n  }\n  if (language == \"javascript\" || language == \"typescript\" || language == \"php\") {\n    for (const statement of module.entryPoint.body.statements) {\n      if (!statement || typeof statement != \"object\") continue\n      if (statement.kind == \"LocalDeclaration\" && reserved.has(supportNameKey(statement.name, language))) {\n        return {location: statement.location, name: statement.name}\n      }\n    }\n  }\n  return undefined\n}\n\n/**\n * Applies target namespace casing to a protected support name.\n * @param {string} name - Source name.\n * @param {import(\"../semantic/types.js\").BackendLanguage} language - Target language.\n * @returns {string} Comparable name.\n */\nfunction supportNameKey(name, language) {\n  return language == \"php\" ? name.toLowerCase() : name\n}\n\n/**\n * Emits fixed target-private Task 034 conformance support.\n * @param {import(\"./writer.js\").SourceWriter} writer - Destination writer.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Authorized module.\n * @param {\"php\" | \"ruby\" | \"javascript\" | \"typescript\" | \"java\"} language - Adopted target.\n * @param {\"top\" | \"members\"} [placement] - Java support placement.\n * @returns {void}\n */\nexport function emitEffectSupport(writer, module, language, placement = \"top\") {\n  const linked = writer.stdlibProviderEntries !== undefined\n\n  if (language == \"java\" && linked) {\n    if (placement != \"members\" || writer.stdlibProviderShims === undefined) return\n  } else if (linked || !module.capabilities || !moduleNeedsEffectSupport(module)) {\n    return\n  }\n  const content = language == \"php\" ? phpSupport : language == \"ruby\" ? rubySupport : language == \"javascript\" ? javascriptSupport :\n    language == \"typescript\" ? typescriptSupport :\n    writer.stdlibProviderShims !== undefined ? javaProgramNestedSupport + javaMemberSupport :\n    placement == \"top\" ? javaTopSupport : javaMemberSupport\n\n  writer.synthetic(content, \"semantifold-task034-support\", [module])\n}\n\n/**\n * Emits the public static provider shims for the program-wide used operations on the Java owner module.\n * @param {import(\"./writer.js\").SourceWriter} writer - Destination writer.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Owner module.\n * @returns {void}\n */\nexport function emitEffectProviderEntries(writer, module) {\n  const operations = writer.stdlibProviderShims ?? []\n\n  if (operations.length == 0) return\n  const lines = operations.map((operation) => `  ${javaProviderShims[operation]}`)\n\n  writer.synthetic(`${lines.join(\"\\n\")}\\n\\n`, \"semantifold-stdlib-provider-entries\", [module])\n}\n\n/**\n * Recognizes only the byte-exact protected support emitted by this backend.\n * Frontends use this in addition to parser-shape checks during generated-source reparse.\n * @param {string} source - Complete candidate source.\n * @param {\"php\" | \"ruby\" | \"javascript\" | \"typescript\" | \"java\"} language - Adopted target.\n * @param {\"top\" | \"members\"} [placement] - Java support placement.\n * @returns {boolean} Whether the exact protected segment is present.\n */\nexport function hasExactEffectSupport(source, language, placement = \"top\") {\n  const content = language == \"php\" ? phpSupport : language == \"ruby\" ? rubySupport : language == \"javascript\" ? javascriptSupport :\n    language == \"typescript\" ? typescriptSupport : placement == \"top\" ? javaTopSupport : javaMemberSupport\n\n  return source.includes(content)\n}\n\n/**\n * Materializes nested effect sites before their enclosing eager expression.\n * The installed replacements remain active until the next statement begins.\n * @param {import(\"./writer.js\").SourceWriter} writer - Destination writer.\n * @param {import(\"../semantic/types.js\").Statement} statement - Current statement.\n * @param {string} indent - Current target indentation.\n * @param {string} path - Exact statement path.\n * @param {\"php\" | \"ruby\" | \"javascript\" | \"typescript\" | \"java\"} language - Adopted target.\n * @param {(expression: import(\"../semantic/types.js\").Expression, path: string) => void} emit - Target expression emitter.\n * @returns {void}\n */\nexport function emitEffectPrefixes(writer, statement, indent, path, language, emit) {\n  /** @type {ExpressionPath[]} */\n  const planned = []\n\n  for (const root of statementExpressionRoots(statement, path)) collectNestedEffects(root.expression, root.path, root.expression, planned)\n  writer.planEffectReplacements(planned.map(({expression}) => expression))\n  for (const {expression, path: expressionPath} of planned) {\n    const name = writer.effectTemporaryName(expression)\n    const type = effectExpressionType(writer, expression)\n    const typeName = emittedTypeName(writer, type, language)\n    const declaration = language == \"php\"\n      ? `/**\\n${indent} * @var ${typeName} $${name}\\n${indent} * @semantifold-immutable\\n${indent} */\\n${indent}$${name} = `\n      : language == \"ruby\"\n        ? `# @type [${typeName}]\\n${indent}# @semantifold-immutable\\n${indent}${name} = `\n        : language == \"javascript\" ? `/** @type {${typeName}} */\\n${indent}const ${name} = `\n          : language == \"typescript\" ? `const ${name}: ${typeName} = ` : `final ${typeName} ${name} = `\n\n    writer.synthetic(`${indent}${declaration}`, \"exactly-once effect temporary\", [expression], [expressionPath])\n    writer.emitEffectDefinition(expression, () => emit(expression, expressionPath))\n    writer.synthetic(language == \"ruby\" ? \"\\n\" : \";\\n\", \"exactly-once effect temporary terminator\", [expression], [expressionPath])\n  }\n}\n\n/**\n * Resolves the result type needed for an effect temporary.\n * @param {import(\"./writer.js\").SourceWriter} writer - Active writer.\n * @param {import(\"../semantic/types.js\").Expression} expression - Effectful expression.\n * @returns {import(\"../semantic/types.js\").SemanticFunctionReturnType | undefined} Result type.\n */\nfunction effectExpressionType(writer, expression) {\n  if (expression.kind == \"EffectCallExpression\") return writer.effectOperationForId(expression.operation).returnType\n  if (expression.kind == \"MethodCallExpression\" || expression.kind == \"CallExpression\") {\n    return expression.resolution ? semanticTypeForIdentity(expression.resolution.returnType) : undefined\n  }\n  return undefined\n}\n\n/**\n * Rehydrates a resolved call result for target-local temporary spelling.\n * @param {import(\"../semantic/types.js\").FunctionReturnTypeIdentity} identity - Exact resolved result identity.\n * @returns {import(\"../semantic/types.js\").SemanticFunctionReturnType} Detached semantic type.\n */\nfunction semanticTypeForIdentity(identity) {\n  if (typeof identity == \"string\") {\n    return {kind: \"TypeReference\", name: /** @type {import(\"../semantic/types.js\").FunctionReturnTypeName} */ (identity)}\n  }\n  if (identity.kind == \"ListType\") return {elementType: semanticTypeForValueIdentity(identity.elementType), kind: \"ListType\"}\n  if (identity.kind == \"MapType\") return {keyType: /** @type {import(\"../semantic/types.js\").TypeReference} */ (\n    semanticTypeForValueIdentity(identity.keyType)), kind: \"MapType\",\n    valueType: semanticTypeForValueIdentity(identity.valueType)}\n  if (identity.kind == \"OrderedMapType\") return {keyType: /** @type {import(\"../semantic/types.js\").TypeReference} */ (\n    semanticTypeForValueIdentity(identity.keyType)), kind: \"OrderedMapType\",\n    order: \"insertion\", valueType: semanticTypeForValueIdentity(identity.valueType)}\n  if (identity.kind == \"OptionalType\") return {kind: \"OptionalType\", valueType: semanticTypeForValueIdentity(identity.valueType)}\n  if (identity.kind == \"RecordType\") return {arguments: identity.arguments?.map(semanticTypeForValueIdentity),\n    declarationId: identity.declarationId, kind: \"RecordType\"}\n  if (identity.kind == \"ReferenceType\") return {declarationId: identity.declarationId, kind: \"ReferenceType\"}\n  if (identity.kind == \"OwnedResourceType\") return {kind: \"OwnedResourceType\", resourceId: identity.resourceId}\n  if (identity.kind == \"OwnedReferenceType\") return {declarationId: identity.declarationId, kind: \"OwnedReferenceType\"}\n  return {kind: \"TypeVariableReference\", location: /** @type {never} */ (undefined), parameterId: identity.parameterId}\n}\n\n/**\n * Rehydrates one non-void resolved type identity.\n * @param {import(\"../semantic/types.js\").SemanticTypeIdentity} identity - Exact type identity.\n * @returns {import(\"../semantic/types.js\").SemanticValueType} Detached semantic type.\n */\nfunction semanticTypeForValueIdentity(identity) {\n  return /** @type {import(\"../semantic/types.js\").SemanticValueType} */ (semanticTypeForIdentity(identity))\n}\n\n/**\n * Renders the subset of semantic types admitted for synthetic temporaries.\n * @param {import(\"./writer.js\").SourceWriter} writer - Active writer.\n * @param {import(\"../semantic/types.js\").SemanticFunctionReturnType | undefined} type - Semantic type.\n * @param {\"php\" | \"ruby\" | \"javascript\" | \"typescript\" | \"java\"} language - Target.\n * @param {boolean} [nested] - Whether Java requires a boxed scalar.\n * @returns {string} Target type spelling.\n */\nfunction emittedTypeName(writer, type, language, nested = false) {\n  if (!type || type.kind == \"TypeReference\" && type.name == \"void\") return language == \"java\" ? \"Object\" : \"unknown\"\n  if (type.kind == \"TypeReference\") {\n    if (language == \"php\") return type.name == \"integer\" ? \"int\" : type.name == \"boolean\" ? \"bool\" : \"string\"\n    if (language == \"ruby\") return type.name == \"integer\" ? \"Integer\" : type.name == \"boolean\" ? \"Boolean\" : \"String\"\n    if (language == \"java\") return type.name == \"integer\" ? nested ? \"Integer\" : \"int\" :\n      type.name == \"boolean\" ? nested ? \"Boolean\" : \"boolean\" : \"String\"\n    return type.name == \"integer\" ? \"number\" : type.name\n  }\n  if (type.kind == \"OwnedResourceType\") return writer.resourceForId(type.resourceId).name\n  if (type.kind == \"ReferenceType\" || type.kind == \"OwnedReferenceType\") return writer.classNameForId(type.declarationId)\n  if (type.kind == \"TypeVariableReference\") return writer.typeParameterForId(type.parameterId).name\n  if (type.kind == \"RecordType\") {\n    const name = writer.recordNameForId(type.declarationId)\n    const arguments_ = type.arguments?.map((argument) => emittedTypeName(writer, argument, language, true)) ?? []\n\n    return arguments_.length == 0 ? name : language == \"ruby\" ? `${name}[${arguments_.join(\",\")}]` : `${name}<${arguments_.join(\",\")}>`\n  }\n  if (type.kind == \"OptionalType\") {\n    const value = emittedTypeName(writer, type.valueType, language, true)\n    return language == \"php\" ? `?${value}` : language == \"ruby\" ? `${value}?` :\n      language == \"java\" ? `java.util.Optional<${value}>` : `${value} | null`\n  }\n  if (type.kind == \"ListType\") {\n    const value = emittedTypeName(writer, type.elementType, language, true)\n    return language == \"php\" ? `list<${value}>` : language == \"ruby\" ? `Array<${value}>` :\n      language == \"java\" ? `java.util.List<${value}>` : `readonly ${value}[]`\n  }\n  if (type.kind == \"MapType\" || type.kind == \"OrderedMapType\") {\n    const key = emittedTypeName(writer, type.keyType, language, true)\n    const value = emittedTypeName(writer, type.valueType, language, true)\n\n    if (language == \"php\") return `array<${key},${value}>`\n    if (language == \"ruby\") return `Hash[${key},${value}]`\n    if (language == \"java\") return `${type.kind == \"OrderedMapType\" ? \"java.util.SequencedMap\" : \"java.util.Map\"}<${key},${value}>`\n    return `ReadonlyMap<${key}, ${value}>`\n  }\n  return language == \"java\" ? \"Object\" : \"unknown\"\n}\n\n/**\n * Returns the expression roots evaluated by one statement.\n * @param {import(\"../semantic/types.js\").Statement} statement - Statement.\n * @param {string} path - Stable statement path.\n * @returns {ExpressionPath[]} Expression roots.\n */\nfunction statementExpressionRoots(statement, path) {\n  if (statement.kind == \"LocalDeclaration\") return [{expression: statement.initializer, path: `${path}/initializer`}]\n  if (statement.kind == \"AssignmentStatement\" || statement.kind == \"ExpressionStatement\" || statement.kind == \"PrintStatement\") {\n    return [{expression: statement.expression, path: `${path}/expression`}]\n  }\n  if (statement.kind == \"ReturnStatement\") return statement.expression ? [{expression: statement.expression, path: `${path}/expression`}] : []\n  if (statement.kind == \"PrivateFieldWriteStatement\") return [{expression: statement.expression, path: `${path}/expression`}]\n  if (statement.kind == \"IfStatement\" || statement.kind == \"WhileStatement\") return [{expression: statement.condition, path: `${path}/condition`}]\n  if (statement.kind == \"ForEachStatement\") return [{expression: statement.list, path: `${path}/list`}]\n  if (statement.kind == \"ForEachMapStatement\") return [{expression: statement.map, path: `${path}/map`}]\n  if (statement.kind == \"RaiseStatement\") return [{expression: statement.error.message, path: `${path}/error/message`}]\n  return []\n}\n\n/**\n * Collects nested effect sites in postorder so children are materialized first.\n * @param {import(\"../semantic/types.js\").Expression} expression - Current expression.\n * @param {string} path - Current occurrence path.\n * @param {import(\"../semantic/types.js\").Expression} root - Statement expression root.\n * @param {ExpressionPath[]} output - Ordered plan receiving nested sites.\n * @returns {void}\n */\nfunction collectNestedEffects(expression, path, root, output) {\n  for (const child of expressionChildren(expression, path)) collectNestedEffects(child.expression, child.path, root, output)\n  if (expression !== root && (expression.kind == \"EffectCallExpression\" || typeof Reflect.get(expression, \"effectSiteId\") == \"string\")) {\n    output.push({expression, path})\n  }\n}\n\n/**\n * Returns path-bearing expression children in evaluation order.\n * @param {import(\"../semantic/types.js\").Expression} expression - Parent expression.\n * @param {string} path - Parent path.\n * @returns {ExpressionPath[]} Children.\n */\nfunction expressionChildren(expression, path) {\n  if (expression.kind == \"CallExpression\" || expression.kind == \"EffectCallExpression\" || expression.kind == \"ReferenceConstruction\" ||\n    expression.kind == \"RecordConstruction\") return expression.arguments.map((child, index) => ({expression: child, path: `${path}/arguments/${index}`}))\n  if (expression.kind == \"MethodCallExpression\") return [\n    {expression: expression.receiver, path: `${path}/receiver`},\n    ...expression.arguments.map((child, index) => ({expression: child, path: `${path}/arguments/${index}`}))\n  ]\n  if (expression.kind == \"OwnedMoveExpression\" || expression.kind == \"OwnedBorrowExpression\") {\n    return [{expression: expression.expression, path: `${path}/expression`}]\n  }\n  if (expression.kind == \"BinaryExpression\") return [\n    {expression: expression.left, path: `${path}/left`}, {expression: expression.right, path: `${path}/right`}\n  ]\n  if (expression.kind == \"UnaryExpression\") return [{expression: expression.operand, path: `${path}/operand`}]\n  if (expression.kind == \"OptionalSome\") return [{expression: expression.value, path: `${path}/value`}]\n  if (expression.kind == \"OptionalIsPresent\" || expression.kind == \"OptionalUnwrap\") {\n    return [{expression: expression.operand, path: `${path}/operand`}]\n  }\n  if (expression.kind == \"ListLiteral\") return expression.elements.map((child, index) => ({expression: child, path: `${path}/elements/${index}`}))\n  if (expression.kind == \"MapLiteral\" || expression.kind == \"OrderedMapLiteral\") return expression.entries.flatMap((entry, index) => [\n    {expression: entry.key, path: `${path}/entries/${index}/key`}, {expression: entry.value, path: `${path}/entries/${index}/value`}\n  ])\n  if (expression.kind == \"ListIndexExpression\") return [\n    {expression: expression.collection, path: `${path}/collection`}, {expression: expression.index, path: `${path}/index`}\n  ]\n  if (expression.kind == \"MapLookupExpression\") return [\n    {expression: expression.collection, path: `${path}/collection`}, {expression: expression.key, path: `${path}/key`}\n  ]\n  if (expression.kind == \"CollectionSizeExpression\") return [{expression: expression.collection, path: `${path}/collection`}]\n  if (expression.kind == \"MemberRead\") return [{expression: expression.receiver, path: `${path}/receiver`}]\n  return []\n}\n\n/**\n * Checks whether generated support is required by a semantic capability node or type.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Semantic module.\n * @returns {boolean} Whether the protected binding is required.\n */\nfunction moduleNeedsEffectSupport(module) {\n  /** @type {unknown[]} */\n  const pending = [module.entryPoint, ...module.functions, ...module.records ?? [], ...module.errors ?? [], ...module.classes ?? []]\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    const kind = Reflect.get(value, \"kind\")\n\n    if (kind == \"EffectCallExpression\" || kind == \"OwnedResourceType\" || kind == \"OwnedReferenceType\" ||\n      kind == \"ErrorType\" && /^capability:[0-9]+\\/failure:[0-9]+$/u.test(String(Reflect.get(value, \"declarationId\")))) return true\n    for (const [key, child] of Object.entries(value)) {\n      if ([\"location\", \"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 false\n}\n\n/**\n * Finds a context excluded from bounded eager lowering.\n * @param {import(\"../semantic/types.js\").SemanticModule} module - Semantic module.\n * @returns {ExcludedEffect | undefined} First deterministic exclusion.\n */\nfunction findExcludedEffectContext(module) {\n  /** @type {object[]} */\n  const owners = [...module.functions.filter((owner) => owner && typeof owner == \"object\"), module.entryPoint]\n\n  for (const declaration of module.classes ?? []) {\n    if (!declaration || typeof declaration != \"object\") continue\n    if (declaration.constructor && typeof declaration.constructor == \"object\") owners.push(declaration.constructor)\n    if (Array.isArray(declaration.methods)) owners.push(...declaration.methods.filter((owner) => owner && typeof owner == \"object\"))\n  }\n  for (const owner of owners) {\n    const body = Reflect.get(owner, \"body\")\n\n    if (!body || typeof body != \"object\") continue\n    const found = blockExcluded(/** @type {import(\"../semantic/types.js\").Block} */ (body))\n    if (found) return found\n  }\n  return undefined\n}\n\n/**\n * Finds an excluded context in one structured block.\n * @param {import(\"../semantic/types.js\").Block} block - Semantic block.\n * @returns {ExcludedEffect | undefined} First deterministic exclusion.\n */\nfunction blockExcluded(block) {\n  if (!block || typeof block != \"object\" || !Array.isArray(block.statements)) return undefined\n  for (const statement of block.statements) {\n    if (!statement || typeof statement != \"object\") continue\n    if (statement.kind == \"WhileStatement\" && containsEffect(statement.condition)) {\n      return {detail: \"effectful condition-controlled loop condition\", location: statement.condition.location}\n    }\n    const expressions = statement.kind == \"LocalDeclaration\" ? [statement.initializer] :\n      statement.kind == \"AssignmentStatement\" || statement.kind == \"ExpressionStatement\" || statement.kind == \"PrintStatement\" ? [statement.expression] :\n        statement.kind == \"ReturnStatement\" ? statement.expression ? [statement.expression] : [] :\n          statement.kind == \"IfStatement\" ? [statement.condition] : statement.kind == \"ForEachStatement\" ? [statement.list] :\n            statement.kind == \"ForEachMapStatement\" ? [statement.map] : statement.kind == \"PrivateFieldWriteStatement\" ? [statement.expression] :\n              statement.kind == \"RaiseStatement\" ? [statement.error.message] : []\n    for (const expression of expressions) {\n      const conditional = findConditionalEffect(expression)\n      if (conditional) return {detail: \"effectful short-circuit BooleanAnd/BooleanOr expression\", location: conditional.location}\n    }\n    const nested = statement.kind == \"IfStatement\" ? [statement.consequent, ...(statement.alternate ? [statement.alternate] : [])] :\n      statement.kind == \"ForEachStatement\" || statement.kind == \"ForEachMapStatement\" || statement.kind == \"WhileStatement\" ? [statement.body] :\n        statement.kind == \"TryStatement\" ? [statement.body, statement.catchBody] : []\n    for (const child of nested) {\n      const found = blockExcluded(child)\n      if (found) return found\n    }\n  }\n  return undefined\n}\n\n/**\n * Finds an effect below a short-circuit operator.\n * @param {import(\"../semantic/types.js\").Expression} expression - Expression root.\n * @returns {import(\"../semantic/types.js\").Expression | undefined} Invalid conditional effect.\n */\nfunction findConditionalEffect(expression) {\n  if (!expression || typeof expression != \"object\") return undefined\n  if (expression.kind == \"BinaryExpression\" && [\"BooleanAnd\", \"BooleanOr\"].includes(expression.operation) &&\n    (containsEffect(expression.left) || containsEffect(expression.right))) return expression\n  for (const child of children(expression)) {\n    const found = findConditionalEffect(child)\n    if (found) return found\n  }\n  return undefined\n}\n\n/**\n * Checks whether an expression evaluates an effect.\n * @param {import(\"../semantic/types.js\").Expression} expression - Expression root.\n * @returns {boolean} Whether an effect is reachable.\n */\nfunction containsEffect(expression) {\n  if (!expression || typeof expression != \"object\") return false\n  return expression.kind == \"EffectCallExpression\" || Boolean(Reflect.get(expression, \"effectSiteId\")) || children(expression).some(containsEffect)\n}\n\n/**\n * Returns child expressions in evaluation order.\n * @param {import(\"../semantic/types.js\").Expression} expression - Parent expression.\n * @returns {import(\"../semantic/types.js\").Expression[]} Children.\n */\nfunction children(expression) {\n  if (!expression || typeof expression != \"object\") return []\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 == \"OwnedMoveExpression\" || expression.kind == \"OwnedBorrowExpression\") 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.flatMap(({key, value}) => [key, 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  return []\n}\n\nconst phpSupport = `/* semantifold-task034-support */\nfinal class ProbeOperationFailure extends RuntimeException {}\nfinal class ProbeAcquireFailure extends RuntimeException {}\nfinal class ProbeReadFailure extends RuntimeException {}\nfinal class ProbeCloseFailure extends RuntimeException {}\nfinal class ProbeResourceClosed extends RuntimeException {}\nfinal class ProbeResource {\n    public bool $closed = false;\n    public function __construct(public mixed $handle) {}\n}\n$GLOBALS['__semantifold_task034_trace'] = [];\nfunction probeEffect(string $label, int $value, bool $fail): int {\n    $GLOBALS['__semantifold_task034_trace'][] = 'effect:' . $label;\n    if ($fail) throw new ProbeOperationFailure('ProbeOperationFailure');\n    return $value;\n}\nfunction probeAcquire(bool $fail): ProbeResource {\n    $GLOBALS['__semantifold_task034_trace'][] = 'acquire';\n    if ($fail) throw new ProbeAcquireFailure('ProbeAcquireFailure');\n    try { $handle = @fopen((string) getenv('SEMANTIFOLD_TASK034_PROBE_PATH'), 'rb'); }\n    catch (Throwable) { throw new ProbeAcquireFailure('ProbeAcquireFailure'); }\n    if ($handle === false) throw new ProbeAcquireFailure('ProbeAcquireFailure');\n    return new ProbeResource($handle);\n}\nfunction probeRead(ProbeResource $resource, bool $fail): ?string {\n    if ($resource->closed) throw new ProbeResourceClosed('ProbeResourceClosed');\n    $GLOBALS['__semantifold_task034_trace'][] = 'read';\n    if ($fail) throw new ProbeReadFailure('ProbeReadFailure');\n    try { $line = @fgets($resource->handle); }\n    catch (Throwable) { throw new ProbeReadFailure('ProbeReadFailure'); }\n    if ($line === false) {\n        if (feof($resource->handle)) return null;\n        throw new ProbeReadFailure('ProbeReadFailure');\n    }\n    return rtrim($line, \"\\\\r\\\\n\");\n}\nfunction probeClose(ProbeResource $resource, bool $fail): void {\n    if ($resource->closed) throw new ProbeResourceClosed('ProbeResourceClosed');\n    $GLOBALS['__semantifold_task034_trace'][] = 'close';\n    try { $closed = @fclose($resource->handle); }\n    catch (Throwable) { $resource->closed = true; throw new ProbeCloseFailure('ProbeCloseFailure'); }\n    $resource->closed = true;\n    if ($fail || !$closed) throw new ProbeCloseFailure('ProbeCloseFailure');\n}\nfunction probeTrace(): string { return implode(',', $GLOBALS['__semantifold_task034_trace']); }\n/* semantifold-task034-support-end */\n\n`\n\nconst rubySupport = `# semantifold-task034-support\nclass ProbeOperationFailure < StandardError; end\nclass ProbeAcquireFailure < StandardError; end\nclass ProbeReadFailure < StandardError; end\nclass ProbeCloseFailure < StandardError; end\nclass ProbeResourceClosed < StandardError; end\nclass ProbeResource\n  attr_accessor :handle, :closed\n  def initialize(handle); @handle = handle; @closed = false; end\nend\n$__semantifold_task034_trace = []\ndef probeEffect(label, value, fail_value)\n  $__semantifold_task034_trace << \"effect:#{label}\"\n  raise ProbeOperationFailure, \"ProbeOperationFailure\" if fail_value\n  value\nend\ndef probeAcquire(fail_value)\n  $__semantifold_task034_trace << \"acquire\"\n  raise ProbeAcquireFailure, \"ProbeAcquireFailure\" if fail_value\n  begin; ProbeResource.new(File.open(ENV.fetch(\"SEMANTIFOLD_TASK034_PROBE_PATH\"), \"r\")); rescue ProbeAcquireFailure; raise; rescue StandardError; raise ProbeAcquireFailure, \"ProbeAcquireFailure\"; end\nend\ndef probeRead(resource, fail_value)\n  raise ProbeResourceClosed, \"ProbeResourceClosed\" if resource.closed\n  $__semantifold_task034_trace << \"read\"\n  raise ProbeReadFailure, \"ProbeReadFailure\" if fail_value\n  begin; value = resource.handle.gets; value.nil? ? nil : value.chomp; rescue ProbeReadFailure; raise; rescue StandardError; raise ProbeReadFailure, \"ProbeReadFailure\"; end\nend\ndef probeClose(resource, fail_value)\n  raise ProbeResourceClosed, \"ProbeResourceClosed\" if resource.closed\n  $__semantifold_task034_trace << \"close\"\n  begin; resource.handle.close; rescue StandardError; resource.closed = true; raise ProbeCloseFailure, \"ProbeCloseFailure\"; end\n  resource.closed = true\n  raise ProbeCloseFailure, \"ProbeCloseFailure\" if fail_value\n  nil\nend\ndef probeTrace; $__semantifold_task034_trace.join(\",\"); end\n# semantifold-task034-support-end\n\n`\n\nconst javascriptSupport = `/* semantifold-task034-support */\nconst __semantifoldTask034Fs = process.getBuiltinModule(\"node:fs\")\nclass ProbeOperationFailure extends Error {}\nclass ProbeAcquireFailure extends Error {}\nclass ProbeReadFailure extends Error {}\nclass ProbeCloseFailure extends Error {}\nclass ProbeResourceClosed extends Error {}\nclass ProbeResource { constructor(handle) { this.handle = handle; this.closed = false; this.position = 0 } }\nconst __semantifoldTask034Trace = []\nfunction probeEffect(label, value, fail) { __semantifoldTask034Trace.push(\\`effect:\\${label}\\`); if (fail) throw new ProbeOperationFailure(\"ProbeOperationFailure\"); return value }\nfunction probeAcquire(fail) { __semantifoldTask034Trace.push(\"acquire\"); if (fail) throw new ProbeAcquireFailure(\"ProbeAcquireFailure\"); try { return new ProbeResource(__semantifoldTask034Fs.openSync(process.env.SEMANTIFOLD_TASK034_PROBE_PATH, \"r\")) } catch { throw new ProbeAcquireFailure(\"ProbeAcquireFailure\") } }\nfunction probeRead(resource, fail) { if (resource.closed) throw new ProbeResourceClosed(\"ProbeResourceClosed\"); __semantifoldTask034Trace.push(\"read\"); if (fail) throw new ProbeReadFailure(\"ProbeReadFailure\"); try { const bytes = []; const buffer = Buffer.alloc(1); while (true) { const count = __semantifoldTask034Fs.readSync(resource.handle, buffer, 0, 1, resource.position++); if (count === 0) return bytes.length === 0 ? null : Buffer.from(bytes).toString(\"utf8\"); if (buffer[0] === 10) return Buffer.from(bytes).toString(\"utf8\").replace(/\\\\r$/u, \"\"); bytes.push(buffer[0]) } } catch { throw new ProbeReadFailure(\"ProbeReadFailure\") } }\nfunction probeClose(resource, fail) { if (resource.closed) throw new ProbeResourceClosed(\"ProbeResourceClosed\"); __semantifoldTask034Trace.push(\"close\"); try { __semantifoldTask034Fs.closeSync(resource.handle) } catch { resource.closed = true; throw new ProbeCloseFailure(\"ProbeCloseFailure\") } resource.closed = true; if (fail) throw new ProbeCloseFailure(\"ProbeCloseFailure\") }\nfunction probeTrace() { return __semantifoldTask034Trace.join(\",\") }\n/* semantifold-task034-support-end */\n\n`\n\nconst typescriptSupport = `/* semantifold-task034-support */\nconst __semantifoldTask034Fs = process.getBuiltinModule(\"node:fs\")\nclass ProbeOperationFailure extends Error {}\nclass ProbeAcquireFailure extends Error {}\nclass ProbeReadFailure extends Error {}\nclass ProbeCloseFailure extends Error {}\nclass ProbeResourceClosed extends Error {}\nclass ProbeResource { closed = false; position = 0; constructor(readonly handle: number) {} }\nconst __semantifoldTask034Trace: string[] = []\nfunction probeEffect(label: string, value: number, fail: boolean): number { __semantifoldTask034Trace.push(\\`effect:\\${label}\\`); if (fail) throw new ProbeOperationFailure(\"ProbeOperationFailure\"); return value }\nfunction probeAcquire(fail: boolean): ProbeResource { __semantifoldTask034Trace.push(\"acquire\"); if (fail) throw new ProbeAcquireFailure(\"ProbeAcquireFailure\"); try { return new ProbeResource(__semantifoldTask034Fs.openSync(process.env.SEMANTIFOLD_TASK034_PROBE_PATH as string, \"r\")) } catch { throw new ProbeAcquireFailure(\"ProbeAcquireFailure\") } }\nfunction probeRead(resource: ProbeResource, fail: boolean): string | null { if (resource.closed) throw new ProbeResourceClosed(\"ProbeResourceClosed\"); __semantifoldTask034Trace.push(\"read\"); if (fail) throw new ProbeReadFailure(\"ProbeReadFailure\"); try { const bytes: number[] = []; const buffer = Buffer.alloc(1); while (true) { const count = __semantifoldTask034Fs.readSync(resource.handle, buffer, 0, 1, resource.position++); if (count === 0) return bytes.length === 0 ? null : Buffer.from(bytes).toString(\"utf8\"); if (buffer[0] === 10) return Buffer.from(bytes).toString(\"utf8\").replace(/\\\\r$/u, \"\"); bytes.push(buffer[0]) } } catch { throw new ProbeReadFailure(\"ProbeReadFailure\") } }\nfunction probeClose(resource: ProbeResource, fail: boolean): void { if (resource.closed) throw new ProbeResourceClosed(\"ProbeResourceClosed\"); __semantifoldTask034Trace.push(\"close\"); try { __semantifoldTask034Fs.closeSync(resource.handle) } catch { resource.closed = true; throw new ProbeCloseFailure(\"ProbeCloseFailure\") } resource.closed = true; if (fail) throw new ProbeCloseFailure(\"ProbeCloseFailure\") }\nfunction probeTrace(): string { return __semantifoldTask034Trace.join(\",\") }\n/* semantifold-task034-support-end */\n\n`\n\nconst javaTopSupport = `// semantifold-task034-support\nfinal class ProbeOperationFailure extends RuntimeException { ProbeOperationFailure() { super(\"ProbeOperationFailure\"); } }\nfinal class ProbeAcquireFailure extends RuntimeException { ProbeAcquireFailure() { super(\"ProbeAcquireFailure\"); } }\nfinal class ProbeReadFailure extends RuntimeException { ProbeReadFailure() { super(\"ProbeReadFailure\"); } }\nfinal class ProbeCloseFailure extends RuntimeException { ProbeCloseFailure() { super(\"ProbeCloseFailure\"); } }\nfinal class ProbeResourceClosed extends RuntimeException { ProbeResourceClosed() { super(\"ProbeResourceClosed\"); } }\nfinal class ProbeResource { final java.nio.channels.FileChannel handle; boolean closed = false; ProbeResource(java.nio.channels.FileChannel handle) { this.handle = handle; } }\n// semantifold-task034-support-top-end\n\n`\n\nconst javaMemberSupport = `  // semantifold-task034-support-members\n  private static final java.util.ArrayList<String> __semantifoldTask034Trace = new java.util.ArrayList<>();\n  static int probeEffect(String label, int value, boolean fail) { __semantifoldTask034Trace.add(\"effect:\" + label); if (fail) throw new ProbeOperationFailure(); return value; }\n  static ProbeResource probeAcquire(boolean fail) { __semantifoldTask034Trace.add(\"acquire\"); if (fail) throw new ProbeAcquireFailure(); try { return new ProbeResource(java.nio.channels.FileChannel.open(java.nio.file.Path.of(System.getenv(\"SEMANTIFOLD_TASK034_PROBE_PATH\")))); } catch (RuntimeException | java.io.IOException exception) { throw new ProbeAcquireFailure(); } }\n  static java.util.Optional<String> probeRead(ProbeResource resource, boolean fail) { if (resource.closed) throw new ProbeResourceClosed(); __semantifoldTask034Trace.add(\"read\"); if (fail) throw new ProbeReadFailure(); try { java.io.ByteArrayOutputStream bytes = new java.io.ByteArrayOutputStream(); java.nio.ByteBuffer buffer = java.nio.ByteBuffer.allocate(1); while (true) { buffer.clear(); int count = resource.handle.read(buffer); if (count < 0) return bytes.size() == 0 ? java.util.Optional.empty() : java.util.Optional.of(bytes.toString(java.nio.charset.StandardCharsets.UTF_8)); buffer.flip(); byte value = buffer.get(); if (value == 10) return java.util.Optional.of(bytes.toString(java.nio.charset.StandardCharsets.UTF_8).replaceFirst(\"\\\\r$\", \"\")); bytes.write(value); } } catch (java.io.IOException exception) { throw new ProbeReadFailure(); } }\n  static void probeClose(ProbeResource resource, boolean fail) { if (resource.closed) throw new ProbeResourceClosed(); __semantifoldTask034Trace.add(\"close\"); try { resource.handle.close(); } catch (java.io.IOException exception) { resource.closed = true; throw new ProbeCloseFailure(); } resource.closed = true; if (fail) throw new ProbeCloseFailure(); }\n  static String probeTrace() { return String.join(\",\", __semantifoldTask034Trace); }\n  // semantifold-task034-support-members-end\n\n`\n\nconst javaProgramNestedSupport = `  // semantifold-task034-support-program\n  public static final class ProbeOperationFailure extends RuntimeException { ProbeOperationFailure() { super(\"ProbeOperationFailure\"); } }\n  public static final class ProbeAcquireFailure extends RuntimeException { ProbeAcquireFailure() { super(\"ProbeAcquireFailure\"); } }\n  public static final class ProbeReadFailure extends RuntimeException { ProbeReadFailure() { super(\"ProbeReadFailure\"); } }\n  public static final class ProbeCloseFailure extends RuntimeException { ProbeCloseFailure() { super(\"ProbeCloseFailure\"); } }\n  public static final class ProbeResourceClosed extends RuntimeException { ProbeResourceClosed() { super(\"ProbeResourceClosed\"); } }\n  public static final class ProbeResource { final java.nio.channels.FileChannel handle; boolean closed = false; ProbeResource(java.nio.channels.FileChannel handle) { this.handle = handle; } }\n  // semantifold-task034-support-program-end\n\n`\n\n/** @type {Record<string, string>} */\nconst javaProviderShims = {\n  probeAcquire: \"public static ProbeResource __semantifold_provider_java_probeAcquire(boolean fail) { return probeAcquire(fail); }\",\n  probeClose: \"public static void __semantifold_provider_java_probeClose(ProbeResource resource, boolean fail) { probeClose(resource, fail); }\",\n  probeEffect: \"public static int __semantifold_provider_java_probeEffect(String label, int value, boolean fail) { return probeEffect(label, value, fail); }\",\n  probeRead: \"public static java.util.Optional<String> __semantifold_provider_java_probeRead(ProbeResource resource, boolean fail) { return probeRead(resource, fail); }\",\n  probeTrace: \"public static String __semantifold_provider_java_probeTrace() { return probeTrace(); }\"\n}\n"]}