rea-agents 6.3.0 → 6.4.0

package/dist/domain/javascript/javascriptSemanticGraph.js

@@ -5,8 +5,9 @@ import { uniqueSorted } from "../canonicalOrdering.js";
 import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
 import { canonicalJsonDigestSteps } from "../canonicalJsonDigestSteps.js";
 import { freezeOwnedJsonSnapshotSteps } from "../immutableJson.js";
+import { arrayContainerSchema, parseElementSteps, } from "../zodCollectionSteps.js";
 import { applicationGraphEvidenceSchema } from "./javascriptApplicationEvidenceSchemas.js";
-import { JAVASCRIPT_SEMANTIC_RELATION_FAMILIES, JAVASCRIPT_SEMANTIC_RELATION_FAMILY, javaScriptSemanticFingerprintInputSchema, javaScriptSemanticFingerprintSchema, javaScriptSemanticGraphInputSchema, javaScriptSemanticGraphRecordSchema, javaScriptSemanticNodeInputSchema, javaScriptSemanticNodeSchema, javaScriptSemanticRelationInputSchema, javaScriptSemanticRelationSchema, javaScriptSemanticUnknownInputSchema, javaScriptSemanticUnknownSchema, } from "./javascriptSemanticGraphSchemas.js";
+import { JAVASCRIPT_SEMANTIC_RELATION_FAMILIES, JAVASCRIPT_SEMANTIC_RELATION_FAMILY, javaScriptSemanticFingerprintInputSchema, javaScriptSemanticEvidenceContextSchema, javaScriptSemanticGraphInputSchema, javaScriptSemanticGraphRecordSchema, javaScriptSemanticNodeInputSchema, javaScriptSemanticRelationInputSchema, javaScriptSemanticUnknownInputSchema, } from "./javascriptSemanticGraphSchemas.js";
 const normalizeEvidence = (evidence) => ({
     ...evidence,
     coverage: {
@@ -20,18 +21,24 @@ const evidenceContextId = (context) => `jsrg_evidence_${digestCanonicalValue(con
 /** Graph-scoped owner for canonical provenance shared by semantic facts. */
 export class JavaScriptSemanticEvidenceContextRegistry {
     #contexts = new Map();
+    // Facts share a few contexts, so key them by canonical text and hash each
+    // distinct context once instead of on every fact.
+    #idsByCanonicalContext = new Map();
     /** Intern normalized non-location provenance at fact construction. */
     intern(evidence) {
         const normalized = normalizeEvidence(evidence);
         const { location, ...context } = normalized;
+        const canonicalContext = canonicalJson(context, "JavaScript semantic graph");
+        const internedId = this.#idsByCanonicalContext.get(canonicalContext);
+        if (internedId !== undefined)
+            return { context_id: internedId, location };
         const contextId = evidenceContextId(context);
-        const row = { ...context, context_id: contextId };
-        const existing = this.#contexts.get(contextId);
-        if (existing !== undefined &&
-            canonicalJson(existing, "JavaScript semantic graph") !==
-                canonicalJson(row, "JavaScript semantic graph"))
+        // This canonical context is new, so a row already stored under its
+        // digest holds different provenance.
+        if (this.#contexts.has(contextId))
             throw new TypeError("JavaScript semantic evidence context digest collision");
-        this.#contexts.set(contextId, row);
+        this.#contexts.set(contextId, { ...context, context_id: contextId });
+        this.#idsByCanonicalContext.set(canonicalContext, contextId);
         return { context_id: contextId, location };
     }
     /** Resolve one already interned fact reference for derived evidence. */
@@ -49,6 +56,24 @@ export class JavaScriptSemanticEvidenceContextRegistry {
     /** Release interned contexts after the owning graph is finalized. */
     clear() {
         this.#contexts.clear();
+        this.#idsByCanonicalContext.clear();
+    }
+    /** Validate and intern provenance decoded in this realm from an analysis worker. */
+    adopt(input) {
+        const context = javaScriptSemanticEvidenceContextSchema.parse(input);
+        const { context_id: identifier, ...value } = context;
+        if (identifier !== evidenceContextId(value))
+            throw new TypeError("Transferred semantic evidence context identifier is stale");
+        const canonical = canonicalJson(value, "JavaScript semantic evidence context");
+        const existing = this.#contexts.get(identifier);
+        if (existing !== undefined) {
+            const { context_id: _existingIdentifier, ...existingValue } = existing;
+            if (canonical !==
+                canonicalJson(existingValue, "JavaScript semantic evidence context"))
+                throw new TypeError("Transferred semantic evidence context digest collision");
+        }
+        this.#contexts.set(identifier, context);
+        this.#idsByCanonicalContext.set(canonical, identifier);
     }
 }
 /** Derive a semantic node ID from its kind and exact artifact identity. */
@@ -60,15 +85,11 @@ export const createJavaScriptSemanticGraphNode = (input, evidenceContexts) => {
         ...parsed,
         application_node_ids: uniqueSorted(parsed.application_node_ids),
         evidence: evidenceContexts.intern(parsed.evidence),
-        identifier_strategy: {
-            strategy: "semantic-content-sha256",
-            stability: "artifact-version",
-        },
     };
-    return javaScriptSemanticNodeSchema.parse({
+    return {
         ...semantic,
         node_id: javaScriptSemanticNodeId(semantic),
-    });
+    };
 };
 /** Normalize one semantic relationship and derive its exact identifier. */
 export const createJavaScriptSemanticGraphRelation = (input, evidenceContexts) => {
@@ -76,15 +97,11 @@ export const createJavaScriptSemanticGraphRelation = (input, evidenceContexts) =
     const semantic = {
         ...parsed,
         evidence: evidenceContexts.intern(parsed.evidence),
-        identifier_strategy: {
-            strategy: "semantic-content-sha256",
-            stability: "relationship-exact",
-        },
     };
-    return javaScriptSemanticRelationSchema.parse({
+    return {
         ...semantic,
         relation_id: `jsrg_relation_${digestCanonicalValue(semantic, "JavaScript semantic graph")}`,
-    });
+    };
 };
 /** Normalize one unresolved semantic frontier and derive its identifier. */
 export const createJavaScriptSemanticGraphUnknown = (input, evidenceContexts) => {
@@ -95,10 +112,10 @@ export const createJavaScriptSemanticGraphUnknown = (input, evidenceContexts) =>
         candidate_node_ids: uniqueSorted(parsed.candidate_node_ids),
         evidence: evidenceContexts.intern(parsed.evidence),
     };
-    return javaScriptSemanticUnknownSchema.parse({
+    return {
         ...semantic,
         unknown_id: `jsrg_unknown_${digestCanonicalValue(semantic, "JavaScript semantic graph")}`,
-    });
+    };
 };
 /** Normalize one function fingerprint and derive its component commitment. */
 export const createJavaScriptSemanticFingerprint = (input, evidenceContexts) => {
@@ -113,7 +130,7 @@ export const createJavaScriptSemanticFingerprint = (input, evidenceContexts) =>
         evidence: evidenceContexts.intern(parsed.evidence),
     };
     const fingerprintSha256 = digestCanonicalValue(semantic.components, "JavaScript semantic graph");
-    return javaScriptSemanticFingerprintSchema.parse({
+    return {
         ...semantic,
         fingerprint_sha256: fingerprintSha256,
         fingerprint_id: `jsrg_fingerprint_${digestCanonicalValue({
@@ -121,7 +138,7 @@ export const createJavaScriptSemanticFingerprint = (input, evidenceContexts) =>
             algorithm: semantic.algorithm,
             fingerprint_sha256: fingerprintSha256,
         }, "JavaScript semantic graph")}`,
-    });
+    };
 };
 const sortedUniqueIssue = (values, path, label, context) => {
     for (let index = 1; index < values.length; index += 1) {
@@ -504,8 +521,37 @@ export const createJavaScriptSemanticGraph = (input) => {
     return record;
 };
 const validatedImmutableSemanticGraphs = new WeakSet();
+const semanticGraphShape = javaScriptSemanticGraphInputSchema.shape;
+const semanticGraphContainerSchema = javaScriptSemanticGraphInputSchema.extend({
+    evidence_contexts: arrayContainerSchema(semanticGraphShape.evidence_contexts),
+    nodes: arrayContainerSchema(semanticGraphShape.nodes),
+    relations: arrayContainerSchema(semanticGraphShape.relations),
+    fingerprints: arrayContainerSchema(semanticGraphShape.fingerprints),
+    unknowns: arrayContainerSchema(semanticGraphShape.unknowns),
+});
 /** Clone input synchronously; commit, check and seal the owned graph in steps. */
 export const createImmutableJavaScriptSemanticGraphSteps = (input) => validateAndSealSemanticGraphSteps(normalizeGraphInput(javaScriptSemanticGraphInputSchema.parse(input)));
+/**
+ * Seal a graph whose input the caller transfers: the caller neither retains nor
+ * mutates any part of it afterwards. Only the graph's own fields are validated
+ * synchronously; collection elements are validated and cloned in steps, because
+ * a whole-graph parse of a large application held the event loop for seconds.
+ */
+export const sealTransferredJavaScriptSemanticGraphSteps = (input) => parseAndSealSemanticGraphSteps(semanticGraphContainerSchema.parse(input));
+function* parseAndSealSemanticGraphSteps(container) {
+    const issues = [];
+    const parsed = {
+        ...container,
+        evidence_contexts: yield* parseElementSteps(semanticGraphShape.evidence_contexts.element, container.evidence_contexts, ["evidence_contexts"], issues),
+        nodes: yield* parseElementSteps(semanticGraphShape.nodes.element, container.nodes, ["nodes"], issues),
+        relations: yield* parseElementSteps(semanticGraphShape.relations.element, container.relations, ["relations"], issues),
+        fingerprints: yield* parseElementSteps(semanticGraphShape.fingerprints.element, container.fingerprints, ["fingerprints"], issues),
+        unknowns: yield* parseElementSteps(semanticGraphShape.unknowns.element, container.unknowns, ["unknowns"], issues),
+    };
+    if (issues.length > 0)
+        throw new z.ZodError(issues);
+    return yield* validateAndSealSemanticGraphSteps(normalizeGraphInput(parsed));
+}
 function* validateAndSealSemanticGraphSteps(semantic) {
     const graph = {
         ...semantic,

package/dist/domain/javascript/javascriptSemanticGraphSchemas.js

@@ -201,11 +201,7 @@ export const javaScriptSemanticNodeInputSchema = z.strictObject({
 /** One exact, artifact-version semantic entity. */
 export const javaScriptSemanticNodeSchema = javaScriptSemanticNodeInputSchema.extend({
     evidence: javaScriptSemanticEvidenceReferenceSchema,
-    node_id: semanticNodeIdSchema,
-    identifier_strategy: z.strictObject({
-        strategy: z.literal("semantic-content-sha256"),
-        stability: z.literal("artifact-version"),
-    }),
+    node_id: semanticNodeIdSchema.describe("SHA-256 of the node kind and identity; stable for one artifact version."),
 });
 /** One directed semantic relationship before its ID is derived. */
 export const javaScriptSemanticRelationInputSchema = z.strictObject({
@@ -219,11 +215,7 @@ export const javaScriptSemanticRelationInputSchema = z.strictObject({
 /** One canonical directed semantic relationship. */
 export const javaScriptSemanticRelationSchema = javaScriptSemanticRelationInputSchema.extend({
     evidence: javaScriptSemanticEvidenceReferenceSchema,
-    relation_id: semanticRelationIdSchema,
-    identifier_strategy: z.strictObject({
-        strategy: z.literal("semantic-content-sha256"),
-        stability: z.literal("relationship-exact"),
-    }),
+    relation_id: semanticRelationIdSchema.describe("SHA-256 of the exact relation content, including its evidence reference."),
 });
 /** Reasons semantic analysis can leave an explicit frontier. */
 export const JAVASCRIPT_SEMANTIC_UNKNOWN_REASONS = [

package/dist/domain/javascript/javascriptSemanticIterationSources.js

@@ -1,8 +1,10 @@
 import * as t from "@babel/types";
-import { semanticStaticPropertyKey } from "./javascriptAstValues.js";
-import { semanticArrayIndex } from "./javascriptSemanticPropertyPaths.js";
-const add = (sources, source, mutation, guards) => {
+import { semanticObjectPatternKeys, semanticStaticPropertyKey, } from "./javascriptAstValues.js";
+import { semanticArrayIndex, } from "./javascriptSemanticPropertyPaths.js";
+import { compareUnicodeCodePoints } from "../unicodeCodePointOrder.js";
+const add = (sources, source, mutation, guards, kind = "iteration") => {
     sources.push({
+        kind,
         node: source.node,
         projection: source.projection,
         mutation,
@@ -25,6 +27,21 @@ const project = (source, key) => {
 };
 const visit = (context, pattern, source, guards = {}) => {
     const { sources, mutation } = context;
+    if (t.isMemberExpression(pattern)) {
+        // Property stores have no lexical alias binding. Preserve the selected
+        // reference's escape rather than claiming later writes cannot reach it.
+        if (source !== undefined)
+            add(sources, source.restStartIndex === undefined
+                ? source
+                : {
+                    node: source.node,
+                    projection: [
+                        ...source.projection,
+                        { excludedKeys: [], startIndex: source.restStartIndex },
+                    ],
+                }, mutation, guards, "reference-store");
+        return;
+    }
     if (t.isTSParameterProperty(pattern)) {
         visit(context, pattern.parameter, source, guards);
         return;
@@ -48,9 +65,24 @@ const visit = (context, pattern, source, guards = {}) => {
     }
     if (t.isObjectPattern(pattern)) {
         for (const property of pattern.properties) {
-            // Object rest creates a fresh object and has no iterable binding pattern.
-            if (t.isRestElement(property))
+            if (t.isRestElement(property)) {
+                // A rest copy owns its scalar slots; only selected child references
+                // escape when that fresh copy is stored through a member target.
+                visit(context, property.argument, source === undefined
+                    ? undefined
+                    : {
+                        node: source.node,
+                        projection: [
+                            ...source.projection,
+                            {
+                                excludedKeys: [
+                                    ...new Set(semanticObjectPatternKeys(pattern)),
+                                ].sort(compareUnicodeCodePoints),
+                            },
+                        ],
+                    }, guards);
                 continue;
+            }
             visit(context, property.value, project(source, semanticStaticPropertyKey(property.key, property.computed)), guards);
         }
         return;
@@ -77,13 +109,14 @@ const visit = (context, pattern, source, guards = {}) => {
     if (t.isRestElement(pattern))
         visit(context, pattern.argument, undefined, guards);
 };
-/** Describe implicit iteration sources without deciding their runtime values. */
+/** Describe iterator receivers and property reference stores without evaluation. */
 export const semanticIterationSources = (node, parent) => {
     const sources = [];
     const context = { sources, mutation: node };
     if (t.isVariableDeclarator(node) && node.init != null)
         visit(context, node.id, { node: node.init, projection: [] });
-    else if (t.isAssignmentExpression(node) && node.operator === "=")
+    else if (t.isAssignmentExpression(node) &&
+        ["=", "||=", "&&=", "??="].includes(node.operator))
         visit(context, node.left, { node: node.right, projection: [] });
     else if (t.isForOfStatement(node)) {
         add(sources, { node: node.right, projection: [] }, node, {});