rea-agents 6.4.0 → 6.7.0

package/dist/domain/javascript/javascriptAstValues.js

@@ -1,10 +1,15 @@
 import * as t from "@babel/types";
+import { SEMANTIC_EXPRESSION_DEPTH_LIMIT } from "./javascriptSemanticResourceLimits.js";
+/** TypeScript receiver annotations occupy no positional runtime parameter slot. */
+export const runtimeFunctionParameters = (node) => t.isIdentifier(node.params[0], { name: "this" })
+    ? node.params.slice(1)
+    : node.params;
 /**
  * Remove wrappers that affect TypeScript or Flow checking but not runtime
  * expression identity. The returned depth lets bounded evaluators account for
  * syntax that normalization would otherwise skip.
  */
-export const unwrapJavaScriptExpression = (node) => {
+export const unwrapJavaScriptExpression = (node, options) => {
     let current = node;
     let depth = 0;
     while (t.isParenthesizedExpression(current) ||
@@ -14,6 +19,12 @@ export const unwrapJavaScriptExpression = (node) => {
         t.isTSSatisfiesExpression(current) ||
         t.isTSInstantiationExpression(current) ||
         t.isTypeCastExpression(current)) {
+        // Optional-chain grouping affects execution even when expression identity
+        // is transparent. Keep every grouping boundary available to that consumer.
+        if (options?.stopAtParentheses === true &&
+            (t.isParenthesizedExpression(current) ||
+                current.extra?.parenthesized === true))
+            break;
         current = current.expression;
         depth += 1;
     }
@@ -53,10 +64,92 @@ export const semanticStaticPropertyName = (property, computed) => semanticStatic
 /** Read an exact property key, preserving the legal empty-string key. */
 export const semanticStaticPropertyKey = (property, computed) => {
     property = unwrapJavaScriptExpression(property).node;
-    if (t.isStringLiteral(property) || t.isNumericLiteral(property))
+    if (t.isStringLiteral(property) ||
+        t.isNumericLiteral(property) ||
+        t.isBooleanLiteral(property))
+        return String(property.value);
+    if (t.isNullLiteral(property))
+        return "null";
+    if (t.isBigIntLiteral(property))
         return String(property.value);
+    if (t.isUnaryExpression(property, { operator: "void" }))
+        return "undefined";
+    if (t.isUnaryExpression(property, { operator: "+" })) {
+        const argument = unwrapJavaScriptExpression(property.argument).node;
+        if (t.isNumericLiteral(argument))
+            return String(argument.value);
+    }
+    if (t.isUnaryExpression(property, { operator: "-" })) {
+        const argument = unwrapJavaScriptExpression(property.argument).node;
+        if (t.isNumericLiteral(argument))
+            return String(-argument.value);
+        if (t.isBigIntLiteral(argument))
+            return String(-BigInt(argument.value));
+    }
+    if (t.isTemplateLiteral(property) &&
+        property.expressions.length === 0 &&
+        property.quasis.length === 1) {
+        const cooked = property.quasis[0]?.value.cooked;
+        return cooked === null || cooked === undefined ? null : cooked;
+    }
     return !computed && t.isIdentifier(property) ? property.name : null;
 };
+/** Syntax whose value cannot contribute own properties to an object spread. */
+export const isNullishJavaScriptSyntax = (node) => {
+    node = unwrapJavaScriptExpression(node).node;
+    return (t.isNullLiteral(node) || t.isUnaryExpression(node, { operator: "void" }));
+};
+/** Find the effective explicit property, preserving unresolved overrides. */
+export const staticObjectProperty = (object, name, isNullish) => {
+    if (object === undefined)
+        return { status: "missing" };
+    if (!t.isObjectExpression(object))
+        return { status: "dynamic" };
+    const lookup = (current, depth) => {
+        for (const property of current.properties.toReversed()) {
+            if (t.isSpreadElement(property)) {
+                const { node: spread, depth: wrappers } = unwrapJavaScriptExpression(property.argument);
+                if (t.isObjectExpression(spread)) {
+                    const nextDepth = depth + wrappers + 1;
+                    // Copying a getter can run code that changes another source key.
+                    if (nextDepth > SEMANTIC_EXPRESSION_DEPTH_LIMIT ||
+                        spread.properties.some((entry) => t.isObjectMethod(entry, { kind: "get" })))
+                        return { status: "dynamic" };
+                    const found = lookup(spread, nextDepth);
+                    if (found.status === "missing")
+                        continue;
+                    return found;
+                }
+                // These primitive boxes have no own keys; strings can own index keys.
+                if (t.isBooleanLiteral(spread) ||
+                    t.isNumericLiteral(spread) ||
+                    t.isBigIntLiteral(spread) ||
+                    isNullish?.(property.argument) === true)
+                    continue;
+                return { status: "dynamic" };
+            }
+            const key = semanticStaticPropertyKey(property.key, property.computed);
+            if (key === null)
+                return { status: "dynamic" };
+            if (key !== name)
+                continue;
+            return t.isObjectProperty(property)
+                ? { status: "explicit", property }
+                : { status: "dynamic" };
+        }
+        return { status: "missing" };
+    };
+    return lookup(object, 0);
+};
+/** Later properties own a key; an intervening dynamic write leaves it unknown. */
+export const semanticFinalObjectProperty = (node, key) => {
+    const property = staticObjectProperty(node, key);
+    return property.status === "explicit" ? property.property.value : undefined;
+};
+export const semanticFinalObjectStringProperty = (node, key) => {
+    const value = semanticFinalObjectProperty(node, key);
+    return t.isStringLiteral(value) ? value.value : undefined;
+};
 /** Read exact consumed object-pattern keys, leaving dynamic keys unknown. */
 export const semanticObjectPatternKeys = (pattern) => pattern.properties.flatMap((property) => {
     if (t.isRestElement(property))
@@ -64,15 +157,49 @@ export const semanticObjectPatternKeys = (pattern) => pattern.properties.flatMap
     const key = semanticStaticPropertyKey(property.key, property.computed);
     return key === null ? [] : [key];
 });
-/** Visit member write targets in direct and destructuring assignment forms. */
-export function* semanticMemberWriteTargets(root) {
+/** Return the syntactic node whose target this construct writes. */
+export const semanticWriteSiteTarget = (node) => {
+    if (t.isAssignmentExpression(node))
+        return node.left;
+    if (t.isUpdateExpression(node))
+        return node.argument;
+    if (t.isUnaryExpression(node, { operator: "delete" }))
+        return node.argument;
+    if (t.isForOfStatement(node) || t.isForInStatement(node))
+        return node.left;
+    return null;
+};
+/** Whether a write site reads the previous target value before writing. */
+export const semanticWriteSiteReadsFirst = (site) => (t.isAssignmentExpression(site) && site.operator !== "=") ||
+    t.isUpdateExpression(site);
+/** Find the owning write site through inert TypeScript and parenthesis wrappers. */
+export const semanticWrappedWriteSite = (node, parent, ancestors) => {
+    const chain = ancestors.at(-1) === parent ? ancestors : [...ancestors, parent];
+    for (let index = chain.length - 1; index >= 0; index -= 1) {
+        const candidate = chain[index];
+        if (candidate === undefined)
+            return null;
+        const target = semanticWriteSiteTarget(candidate);
+        if (target !== null)
+            return unwrapJavaScriptExpression(target).node === node
+                ? candidate
+                : null;
+        if (unwrapJavaScriptExpression(candidate).depth === 0)
+            return null;
+    }
+    return null;
+};
+/** Visit binding and member leaves in direct and destructuring write targets. */
+export function* semanticWriteTargets(root) {
     const pending = [root];
     while (pending.length > 0) {
         const next = pending.pop();
         if (next === undefined)
             break;
         const node = unwrapJavaScriptExpression(next).node;
-        if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node))
+        if (t.isIdentifier(node) ||
+            t.isMemberExpression(node) ||
+            t.isOptionalMemberExpression(node))
             yield node;
         else if (t.isRestElement(node))
             pending.push(node.argument);

package/dist/domain/javascript/javascriptBootstrap.js

@@ -0,0 +1,94 @@
+import * as t from "@babel/types";
+import { semanticStaticPropertyKey, runtimeFunctionParameters, } from "./javascriptAstValues.js";
+import { moduleFactory } from "./javascriptStaticAnalysisHelpers.js";
+import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
+import { resolveSemanticBindingState, semanticStableInitializer, } from "./javascriptSemanticState.js";
+/** Recognize syntax, never invoke a bootstrap or infer it from variable names. */
+export const javascriptBootstrapAt = (call, state) => {
+    if ((!t.isFunctionExpression(call.callee) &&
+        !t.isArrowFunctionExpression(call.callee)) ||
+        !t.isBlockStatement(call.callee.body) ||
+        runtimeFunctionParameters(call.callee).length !== 0 ||
+        call.arguments.length !== 0)
+        return undefined;
+    const body = call.callee.body;
+    const tables = new Map();
+    for (const statement of body.body) {
+        if (!t.isVariableDeclaration(statement))
+            continue;
+        for (const declaration of statement.declarations) {
+            if (t.isIdentifier(declaration.id) &&
+                t.isObjectExpression(declaration.init) &&
+                declaration.init.properties.length > 0 &&
+                declaration.init.properties.every((property) => moduleFactory(property) !== undefined)) {
+                const binding = resolveSemanticBindingState(state, declaration.id, declaration.id.name);
+                if (binding !== undefined &&
+                    semanticStableInitializer(binding, state)?.node === declaration.init)
+                    tables.set(binding.bindingId, declaration.init);
+            }
+        }
+    }
+    if (tables.size === 0)
+        return undefined;
+    for (const loader of body.body) {
+        if (!t.isFunctionDeclaration(loader) ||
+            loader.id === null ||
+            loader.id === undefined ||
+            runtimeFunctionParameters(loader).length !== 1)
+            continue;
+        const parameter = runtimeFunctionParameters(loader)[0];
+        if (!t.isIdentifier(parameter))
+            continue;
+        const loaderName = loader.id.name;
+        const loaderBindingId = bindingId(state, loader.id);
+        const parameterBindingId = bindingId(state, parameter);
+        if (loaderBindingId === undefined || parameterBindingId === undefined)
+            continue;
+        let tableBindingId;
+        traverseJavaScriptAst(loader.body, {
+            enter: (node, _parent, ancestors) => {
+                if (!t.isCallExpression(node) ||
+                    ancestors().some((node) => t.isFunction(node)))
+                    return;
+                const candidate = dispatchedTableBinding(node, loaderBindingId, parameterBindingId, state);
+                if (candidate !== undefined && tables.has(candidate))
+                    tableBindingId = candidate;
+            },
+        });
+        const table = tableBindingId === undefined ? undefined : tables.get(tableBindingId);
+        if (table !== undefined && tableBindingId !== undefined)
+            return { body, table, loaderName, loaderBindingId, tableBindingId };
+    }
+    return undefined;
+};
+const dispatchedTableBinding = (call, loaderBindingId, keyBindingId, state) => {
+    const member = call.callee;
+    const viaCall = t.isMemberExpression(member) &&
+        semanticStaticPropertyKey(member.property, member.computed) === "call";
+    const dispatch = viaCall && t.isMemberExpression(member) ? member.object : member;
+    if (!t.isMemberExpression(dispatch) ||
+        !dispatch.computed ||
+        !t.isIdentifier(dispatch.object) ||
+        !t.isIdentifier(dispatch.property) ||
+        bindingId(state, dispatch.property) !== keyBindingId)
+        return undefined;
+    const args = viaCall ? call.arguments.slice(1) : call.arguments;
+    const [module, exports, require] = args;
+    if (args.length !== 3 ||
+        !t.isIdentifier(module) ||
+        bindingId(state, module) === undefined ||
+        !t.isMemberExpression(exports) ||
+        !t.isIdentifier(exports.object) ||
+        bindingId(state, exports.object) !== bindingId(state, module) ||
+        semanticStaticPropertyKey(exports.property, exports.computed) !==
+            "exports" ||
+        !t.isIdentifier(require) ||
+        bindingId(state, require) !== loaderBindingId)
+        return undefined;
+    if (viaCall &&
+        (!t.isNode(call.arguments[0]) ||
+            !t.isNodesEquivalent(call.arguments[0], exports)))
+        return undefined;
+    return bindingId(state, dispatch.object);
+};
+const bindingId = (state, identifier) => resolveSemanticBindingState(state, identifier, identifier.name)?.bindingId;

package/dist/domain/javascript/javascriptBootstrapIntegrity.js

@@ -0,0 +1,372 @@
+import * as t from "@babel/types";
+import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
+import { resolveSemanticBindingState, semanticStableInitializer, } from "./javascriptSemanticState.js";
+import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
+import { argumentValue } from "./javascriptStaticAnalysisHelpers.js";
+/**
+ * Prove that `loader(key)` returns the exports of the factory declared at
+ * `table[key]`: the loader returns only the dispatched module's exports or a
+ * cache entry it created for that module, the table has only literal keys,
+ * and the table and cache are referenced only by the loader or through the
+ * runtime's `loader.m`/`loader.c` exposure. Literal-key writes through that
+ * exposure replace their slot. Returns undefined when any of this is unproven.
+ */
+export const proveJavaScriptBootstrapIntegrity = (call, bootstrap, loaderIds, state) => {
+    if (bootstrap.table.properties.some((property) => t.isSpreadElement(property)
+        ? true
+        : semanticStaticPropertyKey(property.key, property.computed) === null))
+        return undefined;
+    const loader = bootstrap.body.body.find((statement) => t.isFunctionDeclaration(statement) &&
+        statement.id !== null &&
+        statement.id !== undefined &&
+        bindingOf(state, statement.id) === bootstrap.loaderBindingId);
+    const shape = loader === undefined
+        ? undefined
+        : loaderShape(loader, bootstrap.tableBindingId, state);
+    if (shape === undefined)
+        return undefined;
+    return referencesAreContained(call, { bootstrap, shape, loaderIds }, state);
+};
+const loaderShape = (loader, tableId, state) => {
+    const [parameter] = loader.params;
+    const parameterId = t.isIdentifier(parameter)
+        ? bindingOf(state, parameter)
+        : undefined;
+    // A rewritten key would dispatch a different slot than the caller named.
+    if (parameterId === undefined ||
+        state.bindingsById.get(parameterId)?.definitions.length !== 1 ||
+        loader.async ||
+        loader.generator)
+        return undefined;
+    const dispatches = new Set();
+    const calls = [];
+    const modules = new Set();
+    const returns = [];
+    traverseJavaScriptAst(loader.body, {
+        skip: (node) => t.isFunction(node),
+        enter: (node) => {
+            if (t.isReturnStatement(node))
+                returns.push(node.argument);
+            if (!t.isCallExpression(node))
+                return;
+            const dispatch = tableDispatch(node, tableId, parameterId, state);
+            if (dispatch === undefined)
+                return;
+            dispatches.add(dispatch.table);
+            calls.push(node);
+            if (dispatch.moduleId !== undefined)
+                modules.add(dispatch.moduleId);
+        },
+    });
+    const [moduleId] = modules;
+    const [dispatch] = calls;
+    if (calls.length !== 1 ||
+        dispatch === undefined ||
+        modules.size !== 1 ||
+        moduleId === undefined ||
+        !runsUnconditionally(dispatch, loader, state))
+        return undefined;
+    const cache = moduleCache(moduleId, parameterId, state);
+    if (cache === null ||
+        !moduleObjectContained(loader, moduleId, dispatch, state))
+        return undefined;
+    const shape = {
+        parameterId,
+        dispatch,
+        dispatches,
+        moduleId,
+        cacheId: cache?.cacheId,
+        cacheSites: new Set(cache === undefined ? [] : [cache.site]),
+    };
+    return returns.every((argument) => returnsModuleExports(argument, shape, state))
+        ? withCacheReads(loader, shape, state)
+        : undefined;
+};
+/** `table[key](module, ...)` or `table[key].call(thisArg, module, ...)`. */
+const tableDispatch = (call, tableId, parameterId, state) => {
+    const viaCall = t.isMemberExpression(call.callee) &&
+        semanticStaticPropertyKey(call.callee.property, call.callee.computed) ===
+            "call";
+    const slot = viaCall && t.isMemberExpression(call.callee)
+        ? call.callee.object
+        : call.callee;
+    if (!t.isMemberExpression(slot) ||
+        !slot.computed ||
+        !t.isIdentifier(slot.object) ||
+        !t.isIdentifier(slot.property) ||
+        bindingOf(state, slot.object) !== tableId ||
+        bindingOf(state, slot.property) !== parameterId)
+        return undefined;
+    const module = call.arguments[viaCall ? 1 : 0];
+    const moduleId = t.isIdentifier(module)
+        ? bindingOf(state, module)
+        : undefined;
+    return moduleId === undefined
+        ? { table: slot.object }
+        : { table: slot.object, moduleId };
+};
+/**
+ * The module object is a fresh literal, optionally stored as `cache[key]`.
+ * Undefined means no cache; null means the module binding is not proven.
+ */
+const moduleCache = (moduleId, parameterId, state) => {
+    const binding = state.bindingsById.get(moduleId);
+    const initializer = semanticStableInitializer(binding, state);
+    if (binding?.definitions.length !== 1 ||
+        initializer === undefined ||
+        initializer.projection.length !== 0)
+        return null;
+    const value = initializer.node;
+    if (isPlainObject(value))
+        return undefined;
+    if (!t.isAssignmentExpression(value, { operator: "=" }) ||
+        !isPlainObject(value.right))
+        return null;
+    const cacheId = keyedSlot(value.left, parameterId, state);
+    return cacheId !== undefined && startsEmpty(cacheId, state)
+        ? { cacheId, site: value.left }
+        : null;
+};
+/** A pre-populated cache could answer the early return without a dispatch. */
+const startsEmpty = (cacheId, state) => {
+    const binding = state.bindingsById.get(cacheId);
+    const initializer = semanticStableInitializer(binding, state);
+    return (binding?.definitions.length === 1 &&
+        initializer?.projection.length === 0 &&
+        t.isObjectExpression(initializer.node) &&
+        initializer.node.properties.length === 0);
+};
+/** An object literal of ordinary data properties, so `exports` stores plainly. */
+const isPlainObject = (node) => t.isObjectExpression(node) &&
+    node.properties.every((property) => t.isObjectProperty(property) &&
+        !property.computed &&
+        semanticStaticPropertyKey(property.key, false) !== "__proto__");
+/** Every ancestor up to the loader body executes whenever the loader runs. */
+const runsUnconditionally = (dispatch, loader, state) => {
+    let child = dispatch;
+    let parent = state.parentsByNode.get(child);
+    while (parent !== undefined && child !== loader.body) {
+        const ordered = t.isSequenceExpression(parent) ||
+            t.isExpressionStatement(parent) ||
+            t.isReturnStatement(parent) ||
+            t.isBlockStatement(parent) ||
+            (t.isMemberExpression(parent) && parent.object === child) ||
+            (t.isCallExpression(parent) && parent.callee === child) ||
+            (t.isTryStatement(parent) && parent.block === child);
+        if (!ordered)
+            return false;
+        child = parent;
+        parent = state.parentsByNode.get(parent);
+    }
+    return child === loader.body;
+};
+/**
+ * The module object reaches only the dispatch, `.exports` reads after it, and
+ * writes to members other than `exports`, so nothing swaps its exports.
+ */
+const moduleObjectContained = (loader, moduleId, dispatch, state) => {
+    let contained = true;
+    traverseJavaScriptAst(loader.body, {
+        enter: (node, parent, readAncestors) => {
+            if (!contained || !t.isIdentifier(node) || parent === null)
+                return;
+            const ancestors = readAncestors();
+            if (!t.isReferenced(node, parent, ancestors.at(-2)))
+                return;
+            if (bindingOf(state, node) !== moduleId)
+                return;
+            contained =
+                !ancestors.some((ancestor) => t.isFunction(ancestor)) &&
+                    moduleUse(node, [parent, ancestors.at(-2)], dispatch);
+        },
+    });
+    return contained;
+};
+const moduleUse = (node, [parent, grandparent], dispatch) => {
+    if (parent === dispatch)
+        return dispatch.arguments.includes(node);
+    if (!t.isMemberExpression(parent) || parent.object !== node)
+        return false;
+    const key = semanticStaticPropertyKey(parent.property, parent.computed);
+    const written = (t.isAssignmentExpression(grandparent) && grandparent.left === parent) ||
+        t.isUpdateExpression(grandparent) ||
+        t.isUnaryExpression(grandparent, { operator: "delete" });
+    if (written)
+        return key !== null && key !== "exports";
+    if (key !== "exports")
+        return false;
+    // `module.exports` passed to the factory, or read after the dispatch ran.
+    return (grandparent === dispatch ||
+        (parent.start ?? -1) > (dispatch.end ?? Number.POSITIVE_INFINITY));
+};
+/** Record `cache[key]` reads that initialize the loader's early-return binding. */
+const withCacheReads = (loader, shape, state) => {
+    if (shape.cacheId === undefined)
+        return shape;
+    const sites = new Set(shape.cacheSites);
+    let contained = true;
+    traverseJavaScriptAst(loader.body, {
+        skip: (node) => t.isFunction(node),
+        enter: (node, parent) => {
+            if (!t.isMemberExpression(node) ||
+                keyedSlot(node, shape.parameterId, state) !== shape.cacheId)
+                return;
+            const read = t.isVariableDeclarator(parent) && parent.init === node;
+            const deleted = t.isUnaryExpression(parent, { operator: "delete" });
+            if (read || deleted || sites.has(node))
+                sites.add(node);
+            else
+                contained = false;
+        },
+    });
+    return contained ? { ...shape, cacheSites: sites } : undefined;
+};
+/** Accept `module.exports` or `cache[key].exports` read through a stable binding. */
+const returnsModuleExports = (argument, shape, state) => {
+    const value = t.isSequenceExpression(argument)
+        ? argument.expressions.at(-1)
+        : argument;
+    const before = t.isSequenceExpression(argument)
+        ? argument.expressions.slice(0, -1)
+        : [];
+    if (!before.every((expression) => sideEffectBeforeReturn(expression, shape, state)))
+        return false;
+    if (!t.isMemberExpression(value) ||
+        !t.isIdentifier(value.object) ||
+        semanticStaticPropertyKey(value.property, value.computed) !== "exports")
+        return false;
+    const id = bindingOf(state, value.object);
+    if (id === shape.moduleId)
+        return true;
+    if (id === undefined || shape.cacheId === undefined)
+        return false;
+    const binding = state.bindingsById.get(id);
+    const initializer = semanticStableInitializer(binding, state);
+    return (binding?.definitions.length === 1 &&
+        initializer?.projection.length === 0 &&
+        keyedSlot(initializer.node, shape.parameterId, state) === shape.cacheId);
+};
+/** The dispatch itself, or a write to a module member other than `exports`. */
+const sideEffectBeforeReturn = (expression, shape, state) => {
+    if (expression === shape.dispatch)
+        return true;
+    if (!t.isAssignmentExpression(expression) ||
+        !t.isMemberExpression(expression.left) ||
+        !t.isIdentifier(expression.left.object) ||
+        bindingOf(state, expression.left.object) !== shape.moduleId)
+        return false;
+    const key = semanticStaticPropertyKey(expression.left.property, expression.left.computed);
+    return key !== null && key !== "exports";
+};
+/** The binding of `owner` in `owner[key]` when `key` is the loader parameter. */
+const keyedSlot = (node, parameterId, state) => t.isMemberExpression(node) &&
+    node.computed &&
+    t.isIdentifier(node.object) &&
+    t.isIdentifier(node.property) &&
+    bindingOf(state, node.property) === parameterId
+    ? bindingOf(state, node.object)
+    : undefined;
+const referencesAreContained = (call, { bootstrap, shape, loaderIds, }, state) => {
+    const tracked = new Map([
+        [bootstrap.tableBindingId, "table"],
+        ...(shape.cacheId === undefined ? [] : [[shape.cacheId, "cache"]]),
+        ...[...loaderIds].map((id) => [id, "loader"]),
+    ]);
+    const names = new Set([...tracked.keys()].flatMap((id) => state.bindingsById.get(id)?.name ?? []));
+    const replacedKeys = new Set();
+    let contained = true;
+    traverseJavaScriptAst(call, {
+        skip: () => !contained,
+        enter: (node, parent, readAncestors) => {
+            if (!t.isIdentifier(node) || !names.has(node.name) || parent === null)
+                return;
+            const ancestors = readAncestors();
+            if (!t.isReferenced(node, parent, ancestors.at(-2)))
+                return;
+            const id = bindingOf(state, node);
+            const role = id === undefined ? undefined : tracked.get(id);
+            if (role === undefined)
+                return;
+            const use = { node, parent, ancestors, shape, loaderIds, state };
+            if (role !== "loader")
+                contained = containedUse(role, use);
+            else if (exposedTableUse(use) === "escaped")
+                contained = false;
+            else
+                exposedSlotWrite(use, replacedKeys);
+        },
+    });
+    return contained ? { replacedKeys } : undefined;
+};
+/** The table is read only by the dispatch; the cache only by the loader's own slot operations. */
+const containedUse = (role, use) => {
+    if (role === "table" && use.shape.dispatches.has(use.node))
+        return true;
+    if (role === "cache" && use.shape.cacheSites.has(use.parent))
+        return true;
+    return isRuntimeExposure(use, role === "table" ? "m" : "c");
+};
+/** `loader.m = table` or `loader.c = cache`, the runtime's own exposure. */
+const isRuntimeExposure = (use, key) => {
+    const { parent, node, loaderIds, state } = use;
+    return (t.isAssignmentExpression(parent, { operator: "=" }) &&
+        parent.right === node &&
+        t.isMemberExpression(parent.left) &&
+        t.isIdentifier(parent.left.object) &&
+        semanticStaticPropertyKey(parent.left.property, parent.left.computed) ===
+            key &&
+        loaderIds.has(bindingOf(state, parent.left.object) ?? ""));
+};
+/**
+ * `loader.m`/`loader.c` may only be assigned (the exposure) or indexed
+ * directly; any other use, such as `const a = loader.m`, lets later writes
+ * escape this proof. Writing a member of an indexed entry, such as
+ * `loader.c[id].exports = value`, can replace what the loader returns.
+ */
+const exposedTableUse = (use) => {
+    const { parent, ancestors } = use;
+    if (!t.isMemberExpression(parent) ||
+        parent.object !== use.node ||
+        !["m", "c"].includes(semanticStaticPropertyKey(parent.property, parent.computed) ?? ""))
+        return "other";
+    const outer = ancestors.at(-2);
+    const assigned = t.isAssignmentExpression(outer, { operator: "=" }) && outer.left === parent;
+    const indexed = t.isMemberExpression(outer) && outer.object === parent && outer.computed;
+    if (assigned)
+        return "contained";
+    if (!indexed)
+        return "escaped";
+    const member = ancestors.at(-3);
+    const target = ancestors.at(-4);
+    const entryWritten = t.isMemberExpression(member) &&
+        member.object === outer &&
+        ((t.isAssignmentExpression(target) && target.left === member) ||
+            t.isUpdateExpression(target) ||
+            t.isUnaryExpression(target, { operator: "delete" }));
+    return entryWritten ? "escaped" : "contained";
+};
+/**
+ * `loader.m[key] = factory` or `delete loader.c[key]` replaces a literal slot.
+ * Writes with runtime keys are chunk installation, which adds modules under
+ * their own ids; they are not treated as replacing a declared slot.
+ */
+const exposedSlotWrite = (use, replacedKeys) => {
+    const { parent, ancestors } = use;
+    const slot = ancestors.at(-2);
+    const write = ancestors.at(-3);
+    if (!t.isMemberExpression(parent) ||
+        parent.object !== use.node ||
+        !["m", "c"].includes(semanticStaticPropertyKey(parent.property, parent.computed) ?? "") ||
+        !t.isMemberExpression(slot) ||
+        slot.object !== parent ||
+        !((t.isAssignmentExpression(write) && write.left === slot) ||
+            t.isUnaryExpression(write, { operator: "delete" }) ||
+            t.isUpdateExpression(write)))
+        return;
+    const key = slot.computed
+        ? argumentValue(slot.property)
+        : semanticStaticPropertyKey(slot.property, false);
+    if (key !== undefined && key !== null)
+        replacedKeys.add(key);
+};
+const bindingOf = (state, identifier) => resolveSemanticBindingState(state, identifier, identifier.name)?.bindingId;

package/dist/domain/javascript/javascriptBuiltinResourceMethods.js

@@ -0,0 +1,8 @@
+/** Supported native resource receivers, shared by acquisition and validity owners. */
+export const BUILTIN_RESOURCE_METHODS = {
+    fs: ["open", "openSync", "createReadStream", "createWriteStream"],
+    "fs/promises": ["open"],
+    net: ["connect", "createConnection"],
+    tls: ["connect", "createConnection"],
+};
+export const BUILTIN_RESOURCE_SPECIFIERS = Object.keys(BUILTIN_RESOURCE_METHODS);