rea-agents 6.0.0 → 6.2.0

package/dist/domain/javascript/javascriptSemanticAnalysis.js

@@ -1,13 +1,16 @@
 import * as t from "@babel/types";
 import { failedJavaScriptSemanticIr, } from "./javascriptSemanticIr.js";
-import { collectSemanticModuleLink, collectSemanticCallable, collectSemanticReferences, immutableSemanticBindings, immutableSemanticScopes, semanticStaticPropertyKey, } from "./javascriptSemanticProjection.js";
-import { currentSemanticScope, resolveSemanticBindingFromScope, semanticScopeId, semanticVariableScope, } from "./javascriptSemanticState.js";
+import { collectSemanticModuleLink, collectSemanticCallable, collectSemanticReferences, immutableSemanticBindings, immutableSemanticScopes, } from "./javascriptSemanticProjection.js";
+import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
+import { currentSemanticScope, resolveSemanticBindingState, semanticResolutionBlocked, resolveSemanticBindingFromScope, semanticScopeId, semanticVariableScope, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { collectSemanticMemberMutations } from "./javascriptSemanticMemberMutations.js";
 import { collectSemanticReturns, resolveSemanticModuleCallables, } from "./javascriptSemanticReturns.js";
 import { collectJavaScriptDerivedSemantics } from "./javascriptSemanticDerivedAnalysis.js";
-import { propertyName, range } from "./javascriptStaticAnalysisHelpers.js";
+import { range } from "./javascriptStaticAnalysisHelpers.js";
+import { propertyName } from "./javascriptAstValues.js";
 import { semanticCoverage } from "./javascriptSemanticCoverage.js";
+import { semanticResourceLimitsIn } from "./javascriptSemanticResourceLimits.js";
 import { parseJavaScriptSource, } from "./javascriptSourceParser.js";
 /** Recover lexical bindings, aliases, constants, and module links. */
 export const analyzeJavaScriptSemantics = (source) => {
@@ -44,7 +47,10 @@ export const analyzeParsedJavaScriptSemantics = (file) => {
         references,
         moduleLinks,
         ...derived,
-        coverage: semanticCoverage(parserPartial),
+        coverage: semanticCoverage(parserPartial, semanticResourceLimitsIn([
+            ...bindings.map(({ value }) => value),
+            ...callables.flatMap((callable) => callable.returnSites.map(({ value }) => value)),
+        ])),
         limitations: [
             ...(parserPartial
                 ? [
@@ -59,6 +65,97 @@ export const analyzeParsedJavaScriptSemantics = (file) => {
         ],
     };
 };
+/**
+ * Resolve only the lexical receiver identity needed to distinguish browser
+ * `window.open` from XHR and global storage `.open` calls. This deliberately
+ * builds definitions without running semantic value or provenance analysis.
+ */
+export const classifyParsedJavaScriptOpenReceivers = (file) => {
+    const state = createState(file.program);
+    collectDefinitions(file.program, state);
+    const facts = new Map();
+    traverseJavaScriptAst(file.program, {
+        enter: (node) => {
+            if ((!t.isCallExpression(node) && !t.isOptionalCallExpression(node)) ||
+                (!t.isMemberExpression(node.callee) &&
+                    !t.isOptionalMemberExpression(node.callee)) ||
+                semanticStaticPropertyKey(node.callee.property, node.callee.computed) !== "open" ||
+                !t.isIdentifier(node.callee.object))
+                return;
+            const receiver = node.callee.object.name;
+            const binding = resolveSemanticBindingState(state, node, receiver);
+            if (binding === undefined) {
+                if (semanticResolutionBlocked(state, node, receiver))
+                    return;
+                const fact = openGlobalFact(receiver);
+                if (fact !== undefined)
+                    facts.set(node.start ?? -1, fact);
+                return;
+            }
+            // A lexically bound receiver overrides ambient browser globals. Mark an
+            // otherwise unresolved local as local so name-based window.open
+            // heuristics do not hide its XHR-like overloads.
+            facts.set(node.start ?? -1, "local");
+            if (receiver === "indexedDB" || receiver === "caches") {
+                facts.set(node.start ?? -1, receiver === "indexedDB" ? "local-indexed-db" : "local-cache-storage");
+                return;
+            }
+            if (binding.mutable || binding.initializers.length !== 1)
+                return;
+            const initializer = binding.initializers[0]?.node;
+            if (!t.isIdentifier(initializer))
+                return;
+            const initializerBinding = resolveSemanticBindingState(state, initializer, initializer.name);
+            if (initializerBinding !== undefined) {
+                if (initializer.name === "indexedDB" || initializer.name === "caches") {
+                    const localFact = initializer.name === "indexedDB"
+                        ? "local-indexed-db"
+                        : "local-cache-storage";
+                    facts.set(node.start ?? -1, localFact);
+                    if (initializerBinding.mutable ||
+                        initializerBinding.initializers.length !== 1)
+                        return;
+                    const nested = initializerBinding.initializers[0]?.node;
+                    if (t.isIdentifier(nested)) {
+                        const nestedFact = resolveGlobalAliasFact(state, initializer, nested.name);
+                        if (nestedFact !== undefined)
+                            facts.set(node.start ?? -1, nestedFact);
+                    }
+                }
+                else if (initializer.name === "window") {
+                    facts.set(node.start ?? -1, "local");
+                }
+                return;
+            }
+            const aliasFact = resolveGlobalAliasFact(state, initializer, initializer.name);
+            if (aliasFact !== undefined)
+                facts.set(node.start ?? -1, aliasFact);
+        },
+    });
+    return facts;
+};
+const openGlobalFact = (name) => {
+    if (name === "window" ||
+        name === "self" ||
+        name === "globalThis" ||
+        name === "top" ||
+        name === "parent" ||
+        name === "opener" ||
+        name === "frames" ||
+        name === "document")
+        return "window";
+    if (name === "indexedDB")
+        return "indexed-db";
+    if (name === "caches")
+        return "cache-storage";
+    return undefined;
+};
+const resolveGlobalAliasFact = (state, node, name) => {
+    if (resolveSemanticBindingState(state, node, name) !== undefined ||
+        semanticResolutionBlocked(state, node, name))
+        return undefined;
+    return openGlobalFact(name);
+};
 const createState = (program) => {
     const root = {
         scopeId: semanticScopeId("program", program),
@@ -184,7 +281,11 @@ const bindInnerDeclaration = (node, parent, scope, state) => {
         });
     else if (t.isAssignmentExpression(node)) {
         if (t.isIdentifier(node.left))
-            addAssignment(node.left, node.right, scope, state);
+            addAssignment(node.left, node.operator === "=" ||
+                node.operator === "||=" ||
+                node.operator === "??="
+                ? node.right
+                : node, scope, state);
         else
             for (const identifier of assignedPatternIdentifiers(node.left))
                 addAssignment(identifier, node, scope, state);

package/dist/domain/javascript/javascriptSemanticAsyncEffects.js

@@ -1,6 +1,7 @@
 import * as t from "@babel/types";
 import { semanticBuiltinNamespacePath } from "./javascriptSemanticProvenance.js";
-import { semanticCallableIdForNode, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
+import { semanticStaticPropertyName } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";

package/dist/domain/javascript/javascriptSemanticCalls.js

@@ -1,5 +1,6 @@
 import * as t from "@babel/types";
-import { semanticCallableIdForNode, semanticReferenceRole, semanticStaticPropertyKey, } from "./javascriptSemanticProjection.js";
+import { semanticCallableIdForNode, semanticReferenceRole, } from "./javascriptSemanticProjection.js";
+import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, isUnshadowedGlobal, } from "./javascriptSemanticState.js";
 import { parameterBindings, resolveLocalCallables, } from "./javascriptSemanticCallResolution.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";

package/dist/domain/javascript/javascriptSemanticChildProcesses.js

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

package/dist/domain/javascript/javascriptSemanticCoverage.js

@@ -1,8 +1,9 @@
-/** Classify whole-file semantic coverage from parser recovery. */
-export const semanticCoverage = (parserPartial) => ({
-    status: parserPartial ? "partial" : "complete",
-    omittedCount: 0,
-});
+/** Classify whole-file semantic coverage from parsing and value bounds. */
+export const semanticCoverage = (parserPartial, resourceLimits = []) => resourceLimits.length > 0
+    ? { status: "partial", omittedCount: null, resourceLimits }
+    : { status: parserPartial ? "partial" : "complete", omittedCount: 0 };
+/** Read typed resource-limit classifications from any coverage state. */
+export const semanticCoverageResourceLimits = (coverage) => coverage.resourceLimits ?? [];
 /** Classify one callable's direct-return coverage. */
 export const semanticReturnCoverage = (retainedCount, parserPartial) => ({
     status: parserPartial ? "partial" : "complete",

package/dist/domain/javascript/javascriptSemanticDataEffectHelpers.js

@@ -3,7 +3,7 @@ import { semanticBuiltinNamespacePath } from "./javascriptSemanticProvenance.js"
 import { semanticCallableIdForNode } from "./javascriptSemanticProjection.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
-import { semanticStaticPropertyKey, semanticStaticPropertyName, } from "./javascriptAstValues.js";
+import { readExactJavaScriptLiteral, semanticStaticPropertyKey, semanticStaticPropertyName, } from "./javascriptAstValues.js";
 /** Resolve bindings written by the nearest variable or assignment owner. */
 export const assignedSemanticResultBindings = (node, ancestors, state) => {
     for (let index = ancestors.length - 1; index >= 0; index -= 1) {
@@ -164,11 +164,14 @@ export const dataEffectPrimitive = (node) => {
 };
 /** Read one static string or expression-free template. */
 export const dataEffectLiteralString = (node) => {
-    if (t.isStringLiteral(node))
-        return node.value;
-    if (t.isTemplateLiteral(node) && node.expressions.length === 0)
-        return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? null;
-    return null;
+    if (node === undefined)
+        return null;
+    const literal = readExactJavaScriptLiteral(node);
+    if (literal.found && typeof literal.value === "string")
+        return literal.value;
+    return t.isTemplateLiteral(node) && node.expressions.length === 0
+        ? (node.quasis[0]?.value.raw ?? null)
+        : null;
 };
 /** Read a member callee from call or construction syntax. */
 export const dataEffectMemberCallee = (node) => t.isMemberExpression(node.callee) || t.isOptionalMemberExpression(node.callee)
@@ -179,14 +182,3 @@ export const dataEffectMemberObject = (node) => node !== null &&
     (t.isMemberExpression(node) || t.isOptionalMemberExpression(node))
     ? node.object
     : null;
-/** Compare Babel source offsets for exact containment. */
-export const containsSemanticNode = (outer, inner) => outer.start !== null &&
-    outer.start !== undefined &&
-    outer.end !== null &&
-    outer.end !== undefined &&
-    inner.start !== null &&
-    inner.start !== undefined &&
-    inner.end !== null &&
-    inner.end !== undefined &&
-    outer.start <= inner.start &&
-    outer.end >= inner.end;

package/dist/domain/javascript/javascriptSemanticDataEffects.js

@@ -1,9 +1,9 @@
 import * as t from "@babel/types";
 import { semanticBuiltinNamespacePath } from "./javascriptSemanticProvenance.js";
 import { compareCodePoints } from "../canonicalOrdering.js";
-import { semanticStaticPropertyKey, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { semanticStaticPropertyKey, semanticStaticPropertyName, } from "./javascriptAstValues.js";
 import { resolveSemanticBindingState, semanticResolutionBlocked, } from "./javascriptSemanticState.js";
-import { builtinDataEffectMethod as builtinMethod, containsSemanticNode as containsNode, dataEffectArgumentBindingId as argumentBindingId, dataEffectLiteralString as literalString, dataEffectMemberCallee as memberCallee, dataEffectMemberObject as memberObject, dataEffectPrimitive as primitiveValue, isSemanticProcessObject as isProcessObject, outerDataEffectBinding as outerAssignedBinding, assignedSemanticResultBindings, semanticProjectedBindingFacts, traverseDataEffects as traverseWithContext, } from "./javascriptSemanticDataEffectHelpers.js";
+import { builtinDataEffectMethod as builtinMethod, dataEffectArgumentBindingId as argumentBindingId, dataEffectLiteralString as literalString, dataEffectMemberCallee as memberCallee, dataEffectMemberObject as memberObject, dataEffectPrimitive as primitiveValue, isSemanticProcessObject as isProcessObject, outerDataEffectBinding as outerAssignedBinding, assignedSemanticResultBindings, semanticProjectedBindingFacts, traverseDataEffects as traverseWithContext, } from "./javascriptSemanticDataEffectHelpers.js";
 import { range } from "./javascriptStaticAnalysisHelpers.js";
 /** Recover configuration, request, and boundary candidates from inert syntax. */
 export const collectJavaScriptSemanticDataEffects = (program, state, callables) => {
@@ -80,20 +80,37 @@ const processConfigurationMember = (node, state) => {
         return null;
     // `process.env[""]` names an exact (empty) key; only a dynamic key is unknown.
     const key = semanticStaticPropertyKey(node.property, node.computed);
+    if (family === "argv" && key !== null && !isArrayIndexKey(key))
+        return null;
     return {
         kind: family === "env" ? "environment" : "argv",
         key,
         resolution: key === null ? "partial" : "complete",
     };
 };
+const isArrayIndexKey = (key) => {
+    if (!/^(?:0|[1-9][0-9]*)$/u.test(key))
+        return false;
+    const index = Number(key);
+    return Number.isSafeInteger(index) && index < 2 ** 32 - 1;
+};
 const collectDefaults = (program, context, configurations) => {
     const output = [];
+    const configurationsByNode = new Map(configurations.map((candidate) => [candidate.node, candidate]));
     traverseWithContext(program, context, (node) => {
         if (!t.isLogicalExpression(node) ||
             (node.operator !== "??" && node.operator !== "||"))
             return;
-        const sources = configurations.filter(({ node: source }) => containsNode(node.left, source));
-        if (sources.length !== 1 || sources[0] === undefined)
+        let source = node.left;
+        while (t.isParenthesizedExpression(source) ||
+            t.isTSAsExpression(source) ||
+            t.isTSTypeAssertion(source) ||
+            t.isTypeCastExpression(source) ||
+            t.isTSSatisfiesExpression(source) ||
+            t.isTSNonNullExpression(source))
+            source = source.expression;
+        const candidate = configurationsByNode.get(source);
+        if (candidate === undefined)
             return;
         output.push({
             configId: `config:default:${String(node.start ?? -1)}:${String(node.end ?? -1)}`,
@@ -101,8 +118,8 @@ const collectDefaults = (program, context, configurations) => {
             location: range(node.right),
             ownerCallableId: context.callableStack.at(-1) ?? null,
             resultBindingId: outerAssignedBinding(node, context),
-            key: sources[0].operation.key,
-            sourceConfigId: sources[0].operation.configId,
+            key: candidate.operation.key,
+            sourceConfigId: candidate.operation.configId,
             value: primitiveValue(node.right),
             resolution: primitiveValue(node.right) === null ? "partial" : "complete",
         });

package/dist/domain/javascript/javascriptSemanticGraph.js

@@ -1,6 +1,8 @@
 import { z } from "zod";
 import { canonicalDigest, canonicalJson } from "../comparisonSemantics.js";
 import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
+import { canonicalJsonDigestSteps } from "../canonicalJsonDigestSteps.js";
+import { freezeOwnedJsonSnapshotSteps } from "../immutableJson.js";
 import { JAVASCRIPT_SEMANTIC_RELATION_FAMILIES, JAVASCRIPT_SEMANTIC_RELATION_FAMILY, javaScriptSemanticFingerprintInputSchema, javaScriptSemanticFingerprintSchema, javaScriptSemanticGraphInputSchema, javaScriptSemanticGraphRecordSchema, javaScriptSemanticNodeInputSchema, javaScriptSemanticNodeSchema, javaScriptSemanticRelationInputSchema, javaScriptSemanticRelationSchema, javaScriptSemanticUnknownInputSchema, javaScriptSemanticUnknownSchema, } from "./javascriptSemanticGraphSchemas.js";
 const normalizeEvidence = (evidence) => ({
     ...evidence,
@@ -95,7 +97,7 @@ const sortedUniqueIssue = (values, path, label, context) => {
         return;
     }
 };
-const checkCoverage = (graph, context) => {
+function* checkCoverageSteps(graph, context) {
     const families = graph.coverage.families.map(({ family }) => family);
     if (canonicalJson(families, "JavaScript semantic graph") !==
         canonicalJson(JAVASCRIPT_SEMANTIC_RELATION_FAMILIES, "JavaScript semantic graph"))
@@ -121,11 +123,18 @@ const checkCoverage = (graph, context) => {
             message: "Truncated graph coverage must identify an effective limit",
         });
     const relationsByFamily = new Map(JAVASCRIPT_SEMANTIC_RELATION_FAMILIES.map((family) => [family, 0]));
-    for (const relation of graph.relations) {
+    for (const [index, relation] of graph.relations.entries()) {
+        if (index % 256 === 0)
+            yield;
         const family = JAVASCRIPT_SEMANTIC_RELATION_FAMILY[relation.relation];
         relationsByFamily.set(family, (relationsByFamily.get(family) ?? 0) + 1);
     }
-    const unknownsById = new Map(graph.unknowns.map((unknown) => [unknown.unknown_id, unknown]));
+    const unknownsById = new Map();
+    for (const [index, unknown] of graph.unknowns.entries()) {
+        if (index % 256 === 0)
+            yield;
+        unknownsById.set(unknown.unknown_id, unknown);
+    }
     for (const [index, family] of graph.coverage.families.entries()) {
         if (family.retained_relations !== relationsByFamily.get(family.family))
             context.addIssue({
@@ -147,7 +156,7 @@ const checkCoverage = (graph, context) => {
                 message: "Complete family coverage cannot omit or retain unknown facts",
             });
     }
-};
+}
 const checkCanonicalOrder = (graph, context) => {
     sortedUniqueIssue(graph.root_node_ids, ["root_node_ids"], "Root nodes", context);
     sortedUniqueIssue(graph.nodes.map(({ node_id }) => node_id), ["nodes"], "Nodes", context);
@@ -156,8 +165,10 @@ const checkCanonicalOrder = (graph, context) => {
     sortedUniqueIssue(graph.unknowns.map(({ unknown_id }) => unknown_id), ["unknowns"], "Unknown frontiers", context);
     sortedUniqueIssue(graph.limitations, ["limitations"], "Limitations", context);
 };
-const checkNodes = (graph, nodes, context) => {
+function* checkNodesSteps(graph, nodes, context) {
     for (const [index, node] of graph.nodes.entries()) {
+        if (index % 256 === 0)
+            yield;
         if (node.node_id !== javaScriptSemanticNodeId(node))
             context.addIssue({
                 code: "custom",
@@ -172,18 +183,23 @@ const checkNodes = (graph, nodes, context) => {
                 message: "Function owner must name a function node",
             });
     }
-};
-const checkRoots = (graph, nodes, context) => {
-    for (const root of graph.root_node_ids)
+}
+function* checkRootsSteps(graph, nodes, context) {
+    for (const [index, root] of graph.root_node_ids.entries()) {
+        if (index % 256 === 0)
+            yield;
         if (!nodes.has(root))
             context.addIssue({
                 code: "custom",
                 path: ["root_node_ids"],
                 message: "Root identifier must name a semantic node",
             });
-};
-const checkRelations = (graph, nodes, context) => {
+    }
+}
+function* checkRelationsSteps(graph, nodes, context) {
     for (const [index, relation] of graph.relations.entries()) {
+        if (index % 256 === 0)
+            yield;
         const { relation_id: identifier, ...semantic } = relation;
         if (identifier !==
             "jsrg_relation_" + canonicalDigest(semantic, "JavaScript semantic graph"))
@@ -213,9 +229,11 @@ const checkRelations = (graph, nodes, context) => {
                 message: "Candidate relations cannot claim observed resolution",
             });
     }
-};
-const checkUnknowns = (graph, nodes, context) => {
+}
+function* checkUnknownsSteps(graph, nodes, context) {
     for (const [index, unknown] of graph.unknowns.entries()) {
+        if (index % 256 === 0)
+            yield;
         const { unknown_id: identifier, ...semantic } = unknown;
         if (identifier !==
             "jsrg_unknown_" + canonicalDigest(semantic, "JavaScript semantic graph"))
@@ -249,7 +267,7 @@ const checkUnknowns = (graph, nodes, context) => {
                 message: "Unknown frontiers require unknown or unavailable evidence",
             });
     }
-};
+}
 const checkUnknownReferences = (graph, context) => {
     const unknownIds = new Set(graph.unknowns.map(({ unknown_id }) => unknown_id));
     for (const [index, family] of graph.coverage.families.entries())
@@ -260,8 +278,10 @@ const checkUnknownReferences = (graph, context) => {
                 message: "Family coverage references an absent unknown frontier",
             });
 };
-const checkFingerprints = (graph, nodes, context) => {
+function* checkFingerprintsSteps(graph, nodes, context) {
     for (const [index, fingerprint] of graph.fingerprints.entries()) {
+        if (index % 256 === 0)
+            yield;
         if (nodes.get(fingerprint.function_node_id)?.kind !== "function")
             context.addIssue({
                 code: "custom",
@@ -295,23 +315,34 @@ const checkFingerprints = (graph, nodes, context) => {
                 message: "Incomplete fingerprints require a limitation",
             });
     }
-};
-const checkGraphContent = (graph, context) => {
+}
+function* checkGraphContentSteps(graph, context) {
     checkCanonicalOrder(graph, context);
-    const nodes = new Map(graph.nodes.map((node) => [node.node_id, node]));
-    checkNodes(graph, nodes, context);
-    checkRoots(graph, nodes, context);
-    checkRelations(graph, nodes, context);
-    checkUnknowns(graph, nodes, context);
+    const nodes = new Map();
+    for (const [index, node] of graph.nodes.entries()) {
+        if (index % 256 === 0)
+            yield;
+        nodes.set(node.node_id, node);
+    }
+    yield* checkNodesSteps(graph, nodes, context);
+    yield* checkRootsSteps(graph, nodes, context);
+    yield* checkRelationsSteps(graph, nodes, context);
+    yield* checkUnknownsSteps(graph, nodes, context);
     checkUnknownReferences(graph, context);
-    checkFingerprints(graph, nodes, context);
-    checkCoverage(graph, context);
+    yield* checkFingerprintsSteps(graph, nodes, context);
+    yield* checkCoverageSteps(graph, context);
     if (graph.coverage.status !== "complete" && graph.limitations.length === 0)
         context.addIssue({
             code: "custom",
             path: ["limitations"],
             message: "Non-complete graph coverage requires a limitation",
         });
+}
+const checkGraphContent = (graph, context) => {
+    const steps = checkGraphContentSteps(graph, context);
+    while (!steps.next().done) {
+        // Synchronous callers apply the same integrity checks without scheduling.
+    }
 };
 const checkGraph = (graph, context) => {
     checkGraphContent(graph, context);
@@ -326,28 +357,28 @@ const checkGraph = (graph, context) => {
 };
 /** Strict semantic graph schema with verified canonical commitments. */
 export const javaScriptSemanticGraphSchema = javaScriptSemanticGraphRecordSchema.superRefine(checkGraph);
+const normalizeGraphInput = (parsed) => ({
+    ...parsed,
+    root_node_ids: uniqueSorted(parsed.root_node_ids),
+    nodes: [...parsed.nodes].sort((left, right) => compareCodePoints(left.node_id, right.node_id)),
+    relations: [...parsed.relations].sort((left, right) => compareCodePoints(left.relation_id, right.relation_id)),
+    fingerprints: [...parsed.fingerprints].sort((left, right) => compareCodePoints(left.fingerprint_id, right.fingerprint_id)),
+    unknowns: [...parsed.unknowns].sort((left, right) => compareCodePoints(left.unknown_id, right.unknown_id)),
+    coverage: {
+        ...parsed.coverage,
+        limits: [...parsed.coverage.limits].sort((left, right) => compareCodePoints(canonicalJson(left, "JavaScript semantic graph"), canonicalJson(right, "JavaScript semantic graph"))),
+        families: [...parsed.coverage.families]
+            .map((family) => ({
+            ...family,
+            unknown_ids: uniqueSorted(family.unknown_ids),
+        }))
+            .sort((left, right) => compareCodePoints(left.family, right.family)),
+    },
+    limitations: uniqueSorted(parsed.limitations),
+});
 /** Normalize a complete companion graph and derive its graph ID. */
 export const createJavaScriptSemanticGraph = (input) => {
-    const parsed = javaScriptSemanticGraphInputSchema.parse(input);
-    const semantic = {
-        ...parsed,
-        root_node_ids: uniqueSorted(parsed.root_node_ids),
-        nodes: [...parsed.nodes].sort((left, right) => compareCodePoints(left.node_id, right.node_id)),
-        relations: [...parsed.relations].sort((left, right) => compareCodePoints(left.relation_id, right.relation_id)),
-        fingerprints: [...parsed.fingerprints].sort((left, right) => compareCodePoints(left.fingerprint_id, right.fingerprint_id)),
-        unknowns: [...parsed.unknowns].sort((left, right) => compareCodePoints(left.unknown_id, right.unknown_id)),
-        coverage: {
-            ...parsed.coverage,
-            limits: [...parsed.coverage.limits].sort((left, right) => compareCodePoints(canonicalJson(left, "JavaScript semantic graph"), canonicalJson(right, "JavaScript semantic graph"))),
-            families: [...parsed.coverage.families]
-                .map((family) => ({
-                ...family,
-                unknown_ids: uniqueSorted(family.unknown_ids),
-            }))
-                .sort((left, right) => compareCodePoints(left.family, right.family)),
-        },
-        limitations: uniqueSorted(parsed.limitations),
-    };
+    const semantic = normalizeGraphInput(javaScriptSemanticGraphInputSchema.parse(input));
     // The input schema already cloned and validated every field. Validate the
     // normalized relationships in place, then derive the only added field. The
     // public schema still verifies arbitrary records and their commitments.
@@ -365,3 +396,27 @@ export const createJavaScriptSemanticGraph = (input) => {
         throw new z.ZodError(issues);
     return record;
 };
+const validatedImmutableSemanticGraphs = new WeakSet();
+/** Clone input synchronously; commit, check and seal the owned graph in steps. */
+export const createImmutableJavaScriptSemanticGraphSteps = (input) => validateAndSealSemanticGraphSteps(normalizeGraphInput(javaScriptSemanticGraphInputSchema.parse(input)));
+function* validateAndSealSemanticGraphSteps(semantic) {
+    const graph = {
+        ...semantic,
+        graph_id: `jsrg_${yield* canonicalJsonDigestSteps(semantic)}`,
+    };
+    const issues = [];
+    yield* checkGraphContentSteps(graph, {
+        addIssue: (issue) => {
+            issues.push(issue);
+        },
+    });
+    if (issues.length > 0)
+        throw new z.ZodError(issues);
+    yield* freezeOwnedJsonSnapshotSteps(graph);
+    validatedImmutableSemanticGraphs.add(graph);
+    return graph;
+}
+/** Recognize the exact completely sealed graph produced by the owned factory. */
+export const isValidatedImmutableJavaScriptSemanticGraph = (value) => typeof value === "object" &&
+    value !== null &&
+    validatedImmutableSemanticGraphs.has(value);

package/dist/domain/javascript/javascriptSemanticGraphSchemas.js

@@ -221,6 +221,7 @@ export const JAVASCRIPT_SEMANTIC_UNKNOWN_REASONS = [
     "eval-or-generated-code",
     "incomplete-module",
     "missing-source",
+    "resource-limit",
     "unsupported-syntax",
 ];
 /** One unresolved semantic frontier before its ID is derived. */