rea-agents 6.1.0 → 6.2.0

package/dist/domain/javascript/javascriptExportShapeVariants.js

@@ -1,5 +1,9 @@
 import { canonicalExportShapeValue, digestExportShapeValue, } from "./javascriptExportShapeComparisonIdentity.js";
 import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
+const UNKNOWN_COVERAGE_PRESENCE = {
+    left: "unknown-coverage",
+    right: "unknown-coverage",
+};
 /** Pair variants only through reciprocal unique exact literal discriminants. */
 export const pairJavaScriptExportShapeVariants = (left, right) => {
     const leftKeys = discriminantOccurrences(left);
@@ -61,12 +65,41 @@ export const buildJavaScriptExportShapeChanges = (input) => {
     });
     return [...paired, ...unpairedLeft, ...unpairedRight];
 };
+/** List observed property names per retained variant, including unknown values. */
+export const buildJavaScriptExportShapeInventories = (input) => {
+    const leftPairs = new Map(input.pairing.pairs.map((pair) => [pair.leftIndex, pair]));
+    const rightPairs = new Map(input.pairing.pairs.map((pair) => [pair.rightIndex, pair]));
+    return [
+        ...input.leftShapes.map((shape, index) => inventoryFor("left", index, shape, leftPairs.get(index))),
+        ...input.rightShapes.map((shape, index) => inventoryFor("right", index, shape, rightPairs.get(index))),
+    ];
+};
+const inventoryFor = (side, variantIndex, shape, pair) => ({
+    side,
+    variant_index: variantIndex,
+    discriminant: pair?.discriminant ?? null,
+    paired: pair !== undefined,
+    source_range: shape.source_range,
+    properties: uniqueSorted([
+        ...shape.fields
+            .filter((field) => fieldPresence(shape, field, field.path) === "present")
+            .map(({ path }) => path),
+        ...shape.property_coverage.map(({ path }) => path),
+    ]).filter((path) => path !== ""),
+    property_coverage: shape.property_coverage.map(({ path, status }) => ({
+        path,
+        status,
+    })),
+});
 /** Report whether any retained shape lacks complete property coverage. */
-export const hasPartialJavaScriptExportPropertyCoverage = (shapes) => shapes.some((shape) => shape.property_coverage.some(({ status }) => status === "partial"));
+export const hasPartialJavaScriptExportPropertyCoverage = (shapes) => shapes.some((shape) => shape.property_coverage.some(({ status }) => status === "partial") ||
+    shape.fields.some((field) => fieldPresence(shape, field, field.path) === "unknown-coverage"));
 const discriminantOccurrences = (shapes) => {
     const output = new Map();
     shapes.forEach((shape, index) => {
         for (const field of shape.fields) {
+            if (fieldPresence(shape, field, field.path) !== "present")
+                continue;
             const value = literalValue(field);
             if (!value.found)
                 continue;
@@ -111,6 +144,7 @@ const selectionUnknownChange = (input) => changeWithId({
     status: "unknown",
     path: "",
     discriminant: null,
+    presence: UNKNOWN_COVERAGE_PRESENCE,
     left: selectionAvailability(input.leftSelection.selection, "left"),
     right: selectionAvailability(input.rightSelection.selection, "right"),
     left_source_range: null,
@@ -124,6 +158,7 @@ const emptyShapeUnknownChange = (input) => changeWithId({
     status: "unknown",
     path: "",
     discriminant: null,
+    presence: UNKNOWN_COVERAGE_PRESENCE,
     left: emptyShapeAvailability(input.leftShapes, "left"),
     right: emptyShapeAvailability(input.rightShapes, "right"),
     left_source_range: null,
@@ -159,6 +194,10 @@ const diffPair = (left, right, discriminant, evidenceLinks) => {
                 status,
                 path,
                 discriminant,
+                presence: {
+                    left: fieldPresence(left, leftField, path),
+                    right: fieldPresence(right, rightField, path),
+                },
                 left: fieldAvailability(leftField),
                 right: fieldAvailability(rightField),
                 left_source_range: left.source_range,
@@ -181,29 +220,42 @@ const fieldAtPath = (shape, fields, path) => {
         return undefined;
     return {
         path,
+        presence: "present",
         state: "unknown",
         value: null,
         reason: "A static container is retained at this path, but no primitive field value is projected.",
     };
 };
 const fieldChangeStatus = ({ leftShape, rightShape, path, leftField, rightField, }) => {
-    if (leftField !== undefined && rightField !== undefined) {
-        if (canonicalExportShapeValue(leftField) ===
+    const leftPresence = fieldPresence(leftShape, leftField, path);
+    const rightPresence = fieldPresence(rightShape, rightField, path);
+    if (leftField !== undefined &&
+        rightField !== undefined &&
+        canonicalExportShapeValue(leftField) ===
             canonicalExportShapeValue(rightField))
-            return null;
+        return null;
+    if (leftPresence === "absent" && rightPresence === "absent")
+        return null;
+    if (leftPresence === "unknown-coverage" ||
+        rightPresence === "unknown-coverage")
+        return "unknown";
+    if (leftPresence === "absent")
+        return "added";
+    if (rightPresence === "absent")
+        return "removed";
+    if (leftField !== undefined && rightField !== undefined) {
         return leftField.state === "unknown" || rightField.state === "unknown"
             ? "unknown"
             : "changed";
     }
-    const present = leftField ?? rightField;
-    if (present === undefined)
-        return null;
-    const parent = parentPointer(path);
-    const parentsComplete = propertyCoverageComplete(leftShape, parent) &&
-        propertyCoverageComplete(rightShape, parent);
-    if (present.state === "unknown" || !parentsComplete)
-        return "unknown";
-    return leftField === undefined ? "added" : "removed";
+    return null;
+};
+const fieldPresence = (shape, field, path) => {
+    if (field !== undefined)
+        return field.presence;
+    return propertyCoverageComplete(shape, parentPointer(path))
+        ? "absent"
+        : "unknown-coverage";
 };
 const propertyCoverageComplete = (shape, path) => path !== null &&
     shape.property_coverage.some((coverage) => coverage.path === path && coverage.status === "complete");
@@ -214,7 +266,7 @@ const parentPointer = (path) => {
     return separator < 0 ? null : path.slice(0, separator);
 };
 const fieldAvailability = (field) => {
-    if (field === undefined)
+    if (field === undefined || field.presence === "absent")
         return { availability: "absent" };
     if (field.state === "unknown")
         return {
@@ -245,6 +297,7 @@ const unpairedChange = (side, shape, evidenceLinks) => changeWithId({
     status: "unknown",
     path: "",
     discriminant: null,
+    presence: UNKNOWN_COVERAGE_PRESENCE,
     left: {
         availability: "unknown",
         reason: side === "left"

package/dist/domain/javascript/javascriptFeatureSeed.js

@@ -62,6 +62,16 @@ const candidateFields = (node, seedKind) => {
                         value: observation.label,
                     },
                 ]),
+            ...(observation.source_map_reference !== null &&
+                observation.source_map_reference.resolution.kind !== "unresolved"
+                ? [
+                    {
+                        basis: "property",
+                        field: `observations[${String(index)}].source_map_reference.resolution.path`,
+                        value: observation.source_map_reference.resolution.path,
+                    },
+                ]
+                : []),
             ...propertyFields(observation.properties, `observations[${String(index)}].properties`),
         ]),
     ];
@@ -89,6 +99,7 @@ const relevantFields = {
         ".path",
         ".source",
         ".original_source",
+        ".source_root",
         ".exports",
     ],
     "native-export": [".label", ".key", ".requested_members", ".members"],
@@ -104,6 +115,15 @@ const identityFields = (node) => {
                 field: "identity.original_source",
                 value: identity.original_source,
             },
+            ...(identity.source_root === null
+                ? []
+                : [
+                    {
+                        basis: "identity",
+                        field: "identity.source_root",
+                        value: identity.source_root,
+                    },
+                ]),
         ];
     if (identity.strategy === "canonical-path")
         return [

package/dist/domain/javascript/javascriptFeatureTraversal.js

@@ -1,4 +1,3 @@
-import {} from "./javascriptApplicationGraph.js";
 import { compareCodePoints } from "../canonicalOrdering.js";
 /** Traverse a JAG without treating edge inference as observed reachability. */
 export const traverseApplicationFeature = (graph, seedNodeIds, direction) => {

package/dist/domain/javascript/javascriptNativeHandoff.js

@@ -1,5 +1,5 @@
 import { compareCodePoints } from "../canonicalOrdering.js";
-import {} from "./javascriptApplicationGraph.js";
+import {} from "./javascriptApplicationGraphSchemas.js";
 /** Build provider-neutral addon targets and link exact-subject native Evidence. */
 export const buildJavaScriptNativeHandoffs = (nodes, edges, nativeEvidence) => {
     const nodeById = new Map(nodes.map((node) => [node.node_id, node]));

package/dist/domain/javascript/javascriptRuntimeLoadState.js

@@ -1,4 +1,3 @@
-import {} from "./javascriptApplicationGraph.js";
 import { uniqueSorted } from "../canonicalOrdering.js";
 import { createStaticRuntimeScope, mappedRuntimePaths, staticNodeWithinRuntimeScope, } from "./javascriptRuntimeStaticCandidates.js";
 /** Classify static code presence without claiming bundled module execution. */

package/dist/domain/javascript/javascriptRuntimeObservation.js

@@ -77,8 +77,16 @@ const javascriptRuntimeScriptSchema = z.strictObject({
     location: javascriptRuntimeLocationSchema,
     execution_context_key: z.string().nullable(),
     cdp_hash: z.string().nullable(),
-    length: z.number().int().min(0),
-    is_module: z.boolean(),
+    length: z
+        .number()
+        .int()
+        .min(0)
+        .nullable()
+        .describe("Producer-reported script length; null when unavailable."),
+    is_module: z
+        .boolean()
+        .nullable()
+        .describe("Producer-reported module classification; null when unavailable."),
     status: z.literal("observed-loaded"),
 });
 const javascriptRuntimeContextSchema = z.strictObject({

package/dist/domain/javascript/javascriptRuntimeReconciliationMatching.js

@@ -1,4 +1,4 @@
-import { createJavaScriptApplicationEdge, } from "./javascriptApplicationGraph.js";
+import { createJavaScriptApplicationEdge } from "./javascriptApplicationGraph.js";
 import { canonicalDigest } from "../comparisonSemantics.js";
 import { compareCodePoints } from "../canonicalOrdering.js";
 import { mappedRuntimePaths, } from "./javascriptRuntimeStaticCandidates.js";

package/dist/domain/javascript/javascriptRuntimeReconciliationParsing.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { browserAllowedOriginsSchema, browserEndpointSchema, webPageInspectionSchema, } from "../browserObservation.js";
+import { browserAllowedOriginsSchema, browserEndpointSchema, } from "../browserObservation.js";
+import { webPageInspectionSchema, } from "../browserObservationSchemas.js";
 import { classifyBrowserCompleteness, } from "../browserCompleteness.js";
 import { electronPageInspectionSchema, } from "./electronObservation.js";
 import { javascriptRuntimeObservationSchema, javascriptRuntimeKindSchema, } from "./javascriptRuntimeObservation.js";
@@ -160,7 +161,7 @@ const normalizeV8Inspection = (result) => ({
             script_key: script.script_key,
             frame_id: script.execution_context_key,
             ...runtimeLocation(script.location),
-            cdp_hash: script.cdp_hash ?? "",
+            cdp_hash: script.cdp_hash,
             length: script.length,
             is_module: script.is_module,
             language: null,

package/dist/domain/javascript/javascriptRuntimeStaticCandidates.js

@@ -1,5 +1,4 @@
 import { posix, relative, win32 } from "node:path";
-import {} from "./javascriptApplicationGraph.js";
 import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
 /** Index statically reconstructed entities that can receive runtime matches. */
 export const collectStaticRuntimeCandidates = (layers) => layers

package/dist/domain/javascript/javascriptSemanticAnalysis.js

@@ -1,12 +1,14 @@
 import * as t from "@babel/types";
 import { failedJavaScriptSemanticIr, } from "./javascriptSemanticIr.js";
-import { collectSemanticModuleLink, collectSemanticCallable, collectSemanticReferences, immutableSemanticBindings, immutableSemanticScopes, semanticStaticPropertyKey, } from "./javascriptSemanticProjection.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";
@@ -279,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/javascriptSemanticDataEffects.js

@@ -1,7 +1,7 @@
 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, 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";

package/dist/domain/javascript/javascriptSemanticGraph.js

@@ -1,6 +1,7 @@
 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) => ({
@@ -96,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"))
@@ -122,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({
@@ -148,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);
@@ -157,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",
@@ -173,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"))
@@ -214,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"))
@@ -250,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())
@@ -261,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",
@@ -296,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);
@@ -327,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.
@@ -367,9 +397,21 @@ export const createJavaScriptSemanticGraph = (input) => {
     return record;
 };
 const validatedImmutableSemanticGraphs = new WeakSet();
-/** Clone and validate synchronously, then return steps to seal the owned graph. */
-export const createImmutableJavaScriptSemanticGraphSteps = (input) => sealValidatedSemanticGraphSteps(createJavaScriptSemanticGraph(input));
-function* sealValidatedSemanticGraphSteps(graph) {
+/** 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;