rea-agents 6.0.0 → 6.2.0

package/dist/domain/javascript/javascriptSemanticMemberMutations.js

@@ -2,10 +2,17 @@ import * as t from "@babel/types";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { evaluateSemanticBinding } from "./javascriptSemanticValues.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
-import { semanticStaticPropertyKey, semanticStaticPropertyName, } from "./javascriptAstValues.js";
+import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
 /** Keep explicit property mutations outside the initializer-only value lattice. */
 export const collectSemanticMemberMutations = (program, state) => {
-    const markValue = (node, path, bindings) => {
+    const parents = new WeakMap();
+    traverseJavaScriptAst(program, {
+        enter: (node, parent) => {
+            if (parent !== null)
+                parents.set(node, parent);
+        },
+    });
+    const markValue = (node, path, bindings, mutation) => {
         if (t.isIdentifier(node)) {
             const binding = resolveSemanticBindingState(state, node, node.name);
             if (binding === undefined || bindings.has(binding.bindingId))
@@ -15,8 +22,8 @@ export const collectSemanticMemberMutations = (program, state) => {
                 return;
             binding.mutatedPaths.push(path);
             const nested = new Set([...bindings, binding.bindingId]);
-            for (const initializer of binding.initializers)
-                markValue(initializer.node, [...initializer.projection, ...path], nested);
+            for (const initializer of mutationInitializers(binding, mutation, parents))
+                markValue(initializer.node, [...initializer.projection, ...path], nested, mutation);
             return;
         }
         if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
@@ -27,42 +34,92 @@ export const collectSemanticMemberMutations = (program, state) => {
                 members.push(semanticStaticPropertyKey(current.property, current.computed));
                 current = current.object;
             }
-            markValue(current, [...members.reverse(), ...path], bindings);
+            markValue(current, [...members.reverse(), ...path], bindings, mutation);
             return;
         }
         for (const value of referencedValues(node, path))
-            markValue(value.node, value.path, bindings);
+            markValue(value.node, value.path, bindings, mutation);
     };
-    const markTarget = (node) => {
+    const markTarget = (node, mutation) => {
         if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node))
-            markValue(node.object, [semanticStaticPropertyKey(node.property, node.computed)], new Set());
+            markValue(node.object, [semanticStaticPropertyKey(node.property, node.computed)], new Set(), mutation);
         else if (t.isRestElement(node))
-            markTarget(node.argument);
+            markTarget(node.argument, mutation);
         else if (t.isAssignmentPattern(node))
-            markTarget(node.left);
+            markTarget(node.left, mutation);
         else if (t.isArrayPattern(node)) {
             for (const element of node.elements)
                 if (element !== null)
-                    markTarget(element);
+                    markTarget(element, mutation);
         }
         else if (t.isObjectPattern(node)) {
             for (const property of node.properties)
-                markTarget(t.isRestElement(property) ? property.argument : property.value);
+                markTarget(t.isRestElement(property) ? property.argument : property.value, mutation);
         }
     };
     traverseJavaScriptAst(program, {
         enter: (node) => {
             if (t.isAssignmentExpression(node))
-                markTarget(node.left);
+                markTarget(node.left, node);
             else if (t.isUpdateExpression(node))
-                markTarget(node.argument);
+                markTarget(node.argument, node);
             else if (t.isUnaryExpression(node, { operator: "delete" }))
-                markTarget(node.argument);
+                markTarget(node.argument, node);
             else if (t.isForOfStatement(node) || t.isForInStatement(node))
-                markTarget(node.left);
+                markTarget(node.left, node);
         },
     });
 };
+const statementPosition = (statement, parents) => {
+    const parent = parents.get(statement);
+    if (!t.isProgram(parent) && !t.isBlockStatement(parent))
+        return null;
+    const index = parent.body.indexOf(statement);
+    return index < 0 ? null : { body: parent.body, index };
+};
+const directInitializerPosition = (node, parents) => {
+    const parent = parents.get(node);
+    if (t.isVariableDeclarator(parent) && parent.init === node) {
+        const declaration = parents.get(parent);
+        return t.isVariableDeclaration(declaration)
+            ? statementPosition(declaration, parents)
+            : null;
+    }
+    if (t.isAssignmentExpression(parent) &&
+        parent.operator === "=" &&
+        parent.right === node &&
+        t.isIdentifier(parent.left)) {
+        const statement = parents.get(parent);
+        return t.isExpressionStatement(statement) && statement.expression === parent
+            ? statementPosition(statement, parents)
+            : null;
+    }
+    return null;
+};
+const directMutationPosition = (node, parents) => {
+    if (!t.isAssignmentExpression(node) &&
+        !t.isUpdateExpression(node) &&
+        !t.isUnaryExpression(node, { operator: "delete" }))
+        return null;
+    const statement = parents.get(node);
+    return t.isExpressionStatement(statement) && statement.expression === node
+        ? statementPosition(statement, parents)
+        : null;
+};
+const mutationInitializers = (binding, mutation, parents) => {
+    if (binding.initializers.length < 2)
+        return binding.initializers;
+    const mutationPosition = directMutationPosition(mutation, parents);
+    if (mutationPosition === null)
+        return binding.initializers;
+    const positions = binding.initializers.map(({ node }) => directInitializerPosition(node, parents));
+    if (positions.some((position) => position === null ||
+        position.body !== mutationPosition.body ||
+        position.index >= mutationPosition.index))
+        return binding.initializers;
+    const latestIndex = positions.reduce((latest, position) => Math.max(latest, position?.index ?? -1), -1);
+    return binding.initializers.filter((_, index) => positions[index]?.index === latestIndex);
+};
 const referencedValues = (node, path) => {
     const [key, ...remaining] = path;
     // An initializer owns its slots; only deeper writes can affect shared children.
@@ -74,10 +131,8 @@ const referencedValues = (node, path) => {
                     return [{ node: property.argument, path }];
                 if (!t.isObjectProperty(property))
                     return [];
-                const name = semanticStaticPropertyName(property.key, property.computed);
-                return key === null ||
-                    (name === "" && !t.isStringLiteral(property.key, { value: "" })) ||
-                    String(key) === name
+                const name = semanticStaticPropertyKey(property.key, property.computed);
+                return key === null || name === null || String(key) === name
                     ? [{ node: property.value, path: remaining }]
                     : [];
             });
@@ -112,5 +167,7 @@ const referencedValues = (node, path) => {
             { node: node.left, path },
             { node: node.right, path },
         ];
+    if (t.isAssignmentExpression(node, { operator: "&&=" }))
+        return [{ node: node.right, path }];
     return [];
 };

package/dist/domain/javascript/javascriptSemanticMutationValues.js

@@ -13,41 +13,35 @@ export const invalidateSemanticMutationPath = (value, path) => {
         const properties = value.properties.map((property) => property.name === name
             ? {
                 ...property,
+                ...(remaining.length === 0
+                    ? { presence: "unknown-coverage" }
+                    : {}),
                 value: invalidateSemanticMutationPath(property.value, remaining),
             }
             : property);
-        return value.unknownProperties || !observed
-            ? {
-                status: "object",
-                properties,
-                unknownProperties: true,
-                omittedProperties: observed ? value.omittedProperties : null,
-            }
-            : {
-                status: "object",
-                properties,
-                unknownProperties: false,
-                omittedProperties: 0,
-            };
+        if (!observed)
+            properties.push({ name, value: unknown, presence: "unknown-coverage" });
+        return { ...value, properties };
     }
     if (value.status === "array") {
-        const index = typeof key === "number" ? key : Number(key);
-        if (!Number.isSafeInteger(index) ||
-            index < 0 ||
-            String(index) !== String(key))
+        const name = String(key);
+        // Array length writes can remove every index; ordinary named properties
+        // and sparse indices affect only their own slot.
+        if (name === "length")
             return unknown;
-        const observed = value.items[index] !== undefined;
-        const items = value.items.map((item, position) => position === index
-            ? invalidateSemanticMutationPath(item, remaining)
-            : item);
-        return value.unknownItems || !observed
+        const observed = value.items.some((item) => item.name === name);
+        const items = value.items.map((item) => item.name === name
             ? {
-                status: "array",
-                items,
-                unknownItems: true,
-                omittedItems: observed ? value.omittedItems : null,
+                ...item,
+                presence: remaining.length === 0
+                    ? "unknown-coverage"
+                    : item.presence,
+                value: invalidateSemanticMutationPath(item.value, remaining),
             }
-            : { status: "array", items, unknownItems: false, omittedItems: 0 };
+            : item);
+        if (!observed)
+            items.push({ name, presence: "unknown-coverage", value: unknown });
+        return { ...value, items };
     }
     return unknown;
 };

package/dist/domain/javascript/javascriptSemanticObjects.js

@@ -1,5 +1,6 @@
 import * as t from "@babel/types";
-import { semanticCallableIdForNode, semanticReadsBeforeWrite, semanticStaticPropertyKey, } from "./javascriptSemanticProjection.js";
+import { semanticCallableIdForNode, semanticReadsBeforeWrite, } from "./javascriptSemanticProjection.js";
+import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
@@ -19,16 +20,19 @@ export const collectJavaScriptSemanticObjects = (program, state, callables) => {
                 collectMember(node, parent, ownerCallableId, context);
             else if (t.isSpreadElement(node) &&
                 parent !== null &&
-                t.isObjectExpression(parent))
+                t.isObjectExpression(parent)) {
+                const identity = expressionObjectIdentity(node.argument, state);
                 addObjectOperation({
                     node,
                     kind: "spread",
                     ownerCallableId,
-                    objectBindingId: expressionBindingId(node.argument, state),
+                    objectBindingId: identity.bindingId,
                     targetBindingId: null,
-                    propertyName: null,
+                    propertyPath: identity.path,
                 }, state, output);
-            else if (t.isVariableDeclarator(node) && t.isObjectPattern(node.id))
+            }
+            else if (t.isVariableDeclarator(node) &&
+                (t.isObjectPattern(node.id) || t.isArrayPattern(node.id)))
                 collectDestructuring(node, ownerCallableId, state, output);
         },
         exit: (node) => {
@@ -41,9 +45,12 @@ export const collectJavaScriptSemanticObjects = (program, state, callables) => {
 };
 const collectMember = (node, parent, ownerCallableId, context) => {
     const { state, output } = context;
-    const name = semanticStaticPropertyKey(node.property, node.computed);
-    if (name === null)
+    // A chain is one property access; retaining every prefix duplicates work and
+    // would make full paths quadratic in deeply nested producer expressions.
+    if ((t.isMemberExpression(parent) || t.isOptionalMemberExpression(parent)) &&
+        parent.object === node)
         return;
+    const identity = expressionObjectIdentity(node, state);
     const write = (t.isAssignmentExpression(parent) && parent.left === node) ||
         (t.isUpdateExpression(parent) && parent.argument === node);
     const readsBeforeWrite = write && semanticReadsBeforeWrite(node, parent);
@@ -52,42 +59,53 @@ const collectMember = (node, parent, ownerCallableId, context) => {
             node,
             kind: "read",
             ownerCallableId,
-            objectBindingId: expressionBindingId(node.object, state),
+            objectBindingId: identity.bindingId,
             targetBindingId: null,
-            propertyName: name,
+            propertyPath: identity.path,
         }, state, output);
     addObjectOperation({
         node,
         kind: write ? "write" : "read",
         ownerCallableId,
-        objectBindingId: expressionBindingId(node.object, state),
+        objectBindingId: identity.bindingId,
         targetBindingId: null,
-        propertyName: name,
+        propertyPath: identity.path,
     }, state, output);
 };
 const collectDestructuring = (node, ownerCallableId, state, output) => {
-    if (!t.isObjectPattern(node.id))
-        return;
-    const objectBindingId = expressionBindingId(node.init, state);
-    for (const property of node.id.properties) {
-        if (!t.isObjectProperty(property))
-            continue;
-        const name = semanticStaticPropertyKey(property.key, property.computed);
-        if (name === null)
-            continue;
-        const target = bindingIdentifier(property.value);
+    const source = expressionObjectIdentity(node.init, state);
+    const visit = (pattern, path) => {
+        if (t.isObjectPattern(pattern)) {
+            for (const property of pattern.properties) {
+                if (!t.isObjectProperty(property))
+                    continue;
+                const name = semanticStaticPropertyKey(property.key, property.computed);
+                if (name !== null)
+                    visit(property.value, [...path, name]);
+            }
+            return;
+        }
+        if (t.isArrayPattern(pattern)) {
+            pattern.elements.forEach((element, index) => {
+                if (element !== null && !t.isRestElement(element))
+                    visit(element, [...path, String(index)]);
+            });
+            return;
+        }
+        const target = bindingIdentifier(pattern);
+        if (target === null)
+            return;
         addObjectOperation({
-            node: property,
+            node: pattern,
             kind: "destructure",
             ownerCallableId,
-            objectBindingId,
-            targetBindingId: target === null
-                ? null
-                : (resolveSemanticBindingState(state, target, target.name)
-                    ?.bindingId ?? null),
-            propertyName: name,
+            objectBindingId: source.bindingId,
+            targetBindingId: resolveSemanticBindingState(state, target, target.name)?.bindingId ??
+                null,
+            propertyPath: source.path === null ? null : [...source.path, ...path],
         }, state, output);
-    }
+    };
+    visit(node.id, []);
 };
 const addObjectOperation = (input, state, output) => {
     output.push({
@@ -97,21 +115,44 @@ const addObjectOperation = (input, state, output) => {
         ownerCallableId: input.ownerCallableId,
         objectBindingId: input.objectBindingId,
         targetBindingId: input.targetBindingId,
-        propertyName: input.propertyName,
-        resolution: input.kind === "spread"
-            ? input.objectBindingId === null
-                ? "partial"
-                : "complete"
-            : input.objectBindingId === null ||
-                input.propertyName === null ||
-                (input.kind === "destructure" && input.targetBindingId === null)
-                ? "partial"
-                : "complete",
+        propertyPath: input.propertyPath,
+        resolution: input.objectBindingId === null ||
+            input.propertyPath === null ||
+            (input.kind === "destructure" && input.targetBindingId === null)
+            ? "partial"
+            : "complete",
     });
 };
-const expressionBindingId = (node, state) => t.isIdentifier(node)
-    ? (resolveSemanticBindingState(state, node, node.name)?.bindingId ?? null)
-    : null;
+const expressionObjectIdentity = (node, state) => {
+    const path = [];
+    let current = node;
+    let staticPath = true;
+    while (current !== null && current !== undefined) {
+        if (t.isMemberExpression(current) ||
+            t.isOptionalMemberExpression(current)) {
+            const name = semanticStaticPropertyKey(current.property, current.computed);
+            if (name === null)
+                staticPath = false;
+            else
+                path.push(name);
+            current = current.object;
+        }
+        else if (t.isTSAsExpression(current) ||
+            t.isTSTypeAssertion(current) ||
+            t.isTSNonNullExpression(current) ||
+            t.isTSSatisfiesExpression(current))
+            current = current.expression;
+        else
+            break;
+    }
+    return {
+        bindingId: t.isIdentifier(current)
+            ? (resolveSemanticBindingState(state, current, current.name)?.bindingId ??
+                null)
+            : null,
+        path: staticPath ? path.reverse() : null,
+    };
+};
 const bindingIdentifier = (node) => {
     if (t.isIdentifier(node))
         return node;

package/dist/domain/javascript/javascriptSemanticPrimitives.js

@@ -1,16 +1,25 @@
-import * as t from "@babel/types";
 import { compareCodePoints } from "../canonicalOrdering.js";
 import { semanticPrimitiveKey } from "./javascriptSemanticProvenance.js";
+import { SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT, exceedsSemanticPrimitiveStringByteBudget, semanticResourceLimitUnknown, } from "./javascriptSemanticResourceLimits.js";
 /** Normalize one bounded collection of possible primitive values. */
 export const semanticPrimitiveSet = (values) => {
-    if (values.some((value) => typeof value === "number" && !Number.isFinite(value)))
-        return {
-            status: "unknown",
-            reason: "Nonfinite numbers are outside the JSON primitive lattice.",
-        };
-    const unique = [
-        ...new Map(values.map((value) => [semanticPrimitiveKey(value), value])).values(),
-    ].sort((left, right) => compareCodePoints(semanticPrimitiveKey(left), semanticPrimitiveKey(right)));
+    const uniqueValues = new Set();
+    for (const value of values) {
+        if (typeof value === "number" && !Number.isFinite(value))
+            return {
+                status: "unknown",
+                reason: "Nonfinite numbers are outside the JSON primitive lattice.",
+            };
+        uniqueValues.add(value);
+        if (uniqueValues.size > SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT)
+            return semanticResourceLimitUnknown("primitive-candidates");
+    }
+    if (exceedsSemanticPrimitiveStringByteBudget([...uniqueValues].flatMap((value) => typeof value === "string" ? [value] : [])))
+        return semanticResourceLimitUnknown("primitive-bytes");
+    const unique = [...uniqueValues]
+        .map((value) => ({ key: semanticPrimitiveKey(value), value }))
+        .sort((left, right) => compareCodePoints(left.key, right.key))
+        .map(({ value }) => value);
     const only = unique[0];
     return unique.length === 1 && only !== undefined
         ? { status: "literal", value: only }
@@ -22,15 +31,3 @@ export const semanticPrimitiveCandidates = (value) => value.status === "literal"
     : value.status === "union"
         ? value.values
         : null;
-/** Parse one Babel primitive literal without evaluating code. */
-export const semanticPrimitiveValue = (node) => {
-    if (t.isStringLiteral(node))
-        return { found: true, value: node.value };
-    if (t.isNumericLiteral(node) && Number.isFinite(node.value))
-        return { found: true, value: node.value };
-    if (t.isBooleanLiteral(node))
-        return { found: true, value: node.value };
-    if (t.isNullLiteral(node))
-        return { found: true, value: null };
-    return { found: false };
-};

package/dist/domain/javascript/javascriptSemanticProjection.js

@@ -4,8 +4,8 @@ import { semanticRequireOrigin } from "./javascriptSemanticRequireOrigin.js";
 import { compareCodePoints } from "../canonicalOrdering.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { evaluateSemanticBinding, evaluateSemanticProvenance, } from "./javascriptSemanticValues.js";
-import { propertyName, range, stringValue, } from "./javascriptStaticAnalysisHelpers.js";
-import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
+import { range, stringValue } from "./javascriptStaticAnalysisHelpers.js";
+import { propertyName, semanticStaticPropertyKey, } from "./javascriptAstValues.js";
 /** Retain callable identity without polluting lexical bindings. */
 export const collectSemanticCallable = (input) => {
     const { node, parent, containerScope, bodyScope, state } = input;
@@ -136,7 +136,6 @@ export const immutableSemanticBindings = (state) => [...state.bindingsById.value
     provenance: evaluateSemanticProvenance(binding, state),
 }))
     .sort((left, right) => compareCodePoints(left.bindingId, right.bindingId));
-export { semanticStaticPropertyKey, semanticStaticPropertyName, } from "./javascriptAstValues.js";
 const callableKind = (node) => {
     if (t.isClassMethod(node) ||
         t.isClassPrivateMethod(node) ||

package/dist/domain/javascript/javascriptSemanticPromises.js

@@ -1,5 +1,6 @@
 import * as t from "@babel/types";
-import { semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
+import { semanticStaticPropertyName } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
 import { compareCodePoints } from "../canonicalOrdering.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";

package/dist/domain/javascript/javascriptSemanticQuerySchemas.js

@@ -4,12 +4,16 @@ import { jsonValueSchema } from "../jsonValue.js";
 import { digestSchema } from "../digests.js";
 import { prefixedDigestSchema } from "../digests.js";
 const semanticNodeIdSchema = prefixedDigestSchema("jsrg_node");
+const literalValueSchema = jsonValueSchema.refine((value) => value === null ||
+    typeof value === "string" ||
+    typeof value === "number" ||
+    typeof value === "boolean", "Literal seeds accept only JSON primitive values");
+// Zod derivations drop the shared schema's JSON Schema projection override;
+// re-apply it so MCP catalog generation keeps projecting `{}`.
+literalValueSchema._zod.toJSONSchema = () => ({});
 const literalSeedSchema = z.strictObject({
     kind: z.literal("literal"),
-    value: jsonValueSchema.refine((value) => value === null ||
-        typeof value === "string" ||
-        typeof value === "number" ||
-        typeof value === "boolean", "Literal seeds accept only JSON primitive values"),
+    value: literalValueSchema,
 });
 /** Authenticated starting points accepted by semantic tracing. */
 export const javaScriptSemanticQuerySeedSchema = z.discriminatedUnion("kind", [

package/dist/domain/javascript/javascriptSemanticResourceLimits.js

@@ -0,0 +1,77 @@
+/** Maximum distinct alternatives retained in one normalized primitive value. */
+export const SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT = 256;
+/** Maximum active expression nesting during inert semantic evaluation. */
+export const SEMANTIC_EXPRESSION_DEPTH_LIMIT = 256;
+/** Bound normalized strings and transient keys independently of transport limits. */
+export const SEMANTIC_PRIMITIVE_JSON_BYTES_LIMIT = 1_048_576;
+const RESOURCE_LIMIT_REASON = {
+    "primitive-candidates": "Primitive candidate budget exceeded (maximum 256 alternatives).",
+    "primitive-bytes": "Primitive string-byte budget exceeded (maximum 1048576 estimated JSON bytes).",
+    "expression-depth": "Semantic expression depth budget exceeded (maximum 256 nested expressions).",
+};
+/** Check UTF-16 length against worst-case JSON escaping without flattening. */
+const jsonStringBytesFromLength = (codeUnits) => codeUnits * 6 + 2;
+/** Bound string payload before JSON key serialization or candidate creation. */
+export const exceedsSemanticPrimitiveStringByteBudget = (strings) => {
+    let total = 0;
+    for (const value of strings) {
+        total += jsonStringBytesFromLength(value.length);
+        if (total > SEMANTIC_PRIMITIVE_JSON_BYTES_LIMIT)
+            return true;
+    }
+    return false;
+};
+/** Bound all outputs of a primitive addition before concatenating any. */
+export const exceedsSemanticPrimitiveAdditionByteBudget = (left, right) => {
+    let total = 0;
+    for (const leftValue of left) {
+        for (const rightValue of right) {
+            if (typeof leftValue !== "string" && typeof rightValue !== "string")
+                continue;
+            const length = String(leftValue).length + String(rightValue).length;
+            total += jsonStringBytesFromLength(length);
+            if (total > SEMANTIC_PRIMITIVE_JSON_BYTES_LIMIT)
+                return true;
+        }
+    }
+    return false;
+};
+/** Bound template interpolation outputs before creating concatenated strings. */
+export const exceedsSemanticTemplateByteBudget = (prefixes, suffixes) => {
+    let total = 0;
+    for (const prefix of prefixes) {
+        for (const suffix of suffixes) {
+            total += jsonStringBytesFromLength(prefix.length + suffix.length);
+            if (total > SEMANTIC_PRIMITIVE_JSON_BYTES_LIMIT)
+                return true;
+        }
+    }
+    return false;
+};
+/** Make an explicit unknown value tagged with the semantic resource bound. */
+export const semanticResourceLimitUnknown = (resourceLimit) => ({
+    status: "unknown",
+    reason: RESOURCE_LIMIT_REASON[resourceLimit],
+    resourceLimit,
+});
+/** Collect resource-limit classifications from nested semantic values. */
+export const semanticResourceLimitsIn = (values) => {
+    const found = new Set();
+    const pending = [...values];
+    while (pending.length > 0) {
+        const value = pending.pop();
+        if (value === undefined)
+            continue;
+        if (value.status === "unknown" && value.resourceLimit !== undefined)
+            found.add(value.resourceLimit);
+        else if (value.status === "object")
+            for (const property of value.properties)
+                pending.push(property.value);
+        else if (value.status === "array")
+            for (const item of value.items)
+                pending.push(item.value);
+    }
+    return [...found].sort();
+};
+/** Display label for one stable resource classification. */
+export const semanticResourceLimitReason = (resourceLimit) => RESOURCE_LIMIT_REASON[resourceLimit];

package/dist/domain/javascript/javascriptSemanticResources.js

@@ -1,6 +1,6 @@
 import * as t from "@babel/types";
 import { semanticBuiltinNamespacePath } from "./javascriptSemanticProvenance.js";
-import { semanticStaticPropertyName } from "./javascriptSemanticProjection.js";
+import { semanticStaticPropertyName } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, } from "./javascriptSemanticState.js";
 import { dataEffectMemberCallee, outerDataEffectBinding, traverseDataEffects, } from "./javascriptSemanticDataEffectHelpers.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";