rea-agents 3.0.0 → 3.1.0

package/dist/domain/reconstructionReadinessSchemas.js

@@ -197,7 +197,21 @@ export const reconstructionReadinessInputSchema = z.strictObject({
     closure_history: z.array(closureObservationSchema).min(2).max(1_000),
     delegation_checks: z.array(delegationCheckSchema).min(1).max(1_000),
     replay: replaySchema,
-    stages: z.array(stageSchema).max(20),
+    stages: z
+        .array(stageSchema)
+        .length(9)
+        .superRefine((stages, context) => {
+        const seen = new Set();
+        stages.forEach((stage, index) => {
+            if (seen.has(stage.stage_id))
+                context.addIssue({
+                    code: "custom",
+                    path: [index, "stage_id"],
+                    message: "Readiness stage IDs must be unique",
+                });
+            seen.add(stage.stage_id);
+        });
+    }),
 });
 const findingSchema = z.strictObject({
     code: stableIdSchema,
@@ -233,7 +247,21 @@ export const reconstructionReadinessReportSchema = z.strictObject({
         cleanup_leak_count: z.number().int().min(0),
         nondeterministic_replay_count: z.number().int().min(0),
     }),
-    stages: z.array(stageSchema).max(20),
+    stages: z
+        .array(stageSchema)
+        .length(9)
+        .superRefine((stages, context) => {
+        const seen = new Set();
+        stages.forEach((stage, index) => {
+            if (seen.has(stage.stage_id))
+                context.addIssue({
+                    code: "custom",
+                    path: [index, "stage_id"],
+                    message: "Readiness stage IDs must be unique",
+                });
+            seen.add(stage.stage_id);
+        });
+    }),
     findings: z.array(findingSchema).max(10_000),
     evidence_links: z.array(evidenceIdSchema).max(100_000),
     snapshot: reconstructionReadinessInputSchema,

package/dist/domain/referenceSourceImportParsing.js

@@ -199,11 +199,11 @@ const parseWithBabel = (path, source, language) => {
         });
         return { ast, parseState: "parsed" };
     }
-    catch (error) {
+    catch (cause) {
         return {
             ast: undefined,
             parseState: "unknown",
-            reason: error instanceof Error ? error.message : "Parse failed",
+            reason: cause instanceof Error ? cause.message : "Parse failed",
         };
     }
 };

package/dist/domain/replayMachineRuntime.js

@@ -20,7 +20,7 @@ const replayEventHeadersSchema = z
         });
 });
 const replayEventFields = {
-    at_ms: z.number().int().nonnegative().safe(),
+    at_ms: z.number().int().safe().nonnegative(),
     path: z.string().startsWith("/").max(8_192),
     headers: replayEventHeadersSchema,
     body: z.string().max(1_000_000),
@@ -51,7 +51,8 @@ export const replayMachineEventSchema = z.discriminatedUnion("protocol", [
 ]);
 const parseJson = (value) => {
     try {
-        return JSON.parse(value);
+        const parsed = JSON.parse(value);
+        return parsed;
     }
     catch {
         return undefined;
@@ -70,7 +71,8 @@ const atPath = (value, path) => {
             current === null ||
             !Object.hasOwn(current, segment))
             return undefined;
-        current = current[segment];
+        const next = Reflect.get(current, segment);
+        current = next;
     }
     return current;
 };

package/dist/domain/sourceToBundleComparison.js

@@ -135,8 +135,8 @@ const comparisonCoverage = (projection, mappings, factors) => ({
 const scoringModel = () => ({
     algorithm: "rea-source-to-bundle-signals/v1",
     minimum_candidate_score: 20,
-    weights: Object.entries(SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS).map(([signal, weight]) => ({
-        signal: signal,
+    weights: SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS.map(([signal, weight]) => ({
+        signal,
         weight,
     })),
 });

package/dist/domain/sourceToBundleComparisonSchemas.js

@@ -6,14 +6,14 @@ const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
 const nodeIdSchema = z.string().regex(/^jag_node_[a-f0-9]{64}$/u);
 const boundedTextSchema = z.string().min(1).max(4_096);
-export const SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS = {
-    "exact-source-digest": 100,
-    "source-map-original-path": 70,
-    "current-path-exact": 60,
-    "current-path-suffix": 40,
-    "basename-match": 20,
-    "language-extension": 5,
-};
+export const SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS = [
+    ["exact-source-digest", 100],
+    ["source-map-original-path", 70],
+    ["current-path-exact", 60],
+    ["current-path-suffix", 40],
+    ["basename-match", 20],
+    ["language-extension", 5],
+];
 const sourceToBundleSignalKindSchema = z.enum([
     "exact-source-digest",
     "source-map-original-path",

package/dist/domain/sourceToBundleSignals.js

@@ -14,6 +14,12 @@ const PATH_PROPERTIES = [
     "declared_path",
 ];
 const MAX_PATH_SUFFIXES = 128;
+const signalWeight = (kind) => {
+    const entry = SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS.find(([signal]) => signal === kind);
+    if (entry === undefined)
+        throw new TypeError(`Missing source-to-bundle signal weight: ${kind}`);
+    return entry[1];
+};
 /** Keep source-bearing application nodes in stable identifier order. */
 export const sourceBearingNodes = (nodes) => nodes
     .filter(({ kind }) => RELEVANT_NODE_KINDS.has(kind))
@@ -145,7 +151,7 @@ const candidateSignals = (source, current) => {
 };
 const signal = (kind, sourceValue, currentValues) => ({
     kind,
-    weight: SOURCE_TO_BUNDLE_SIGNAL_WEIGHTS[kind],
+    weight: signalWeight(kind),
     source_value: sourceValue,
     current_values: [...new Set(currentValues)].sort(compareText).slice(0, 64),
 });

package/dist/domain/staticRuntimeCorrelation.js

@@ -242,11 +242,12 @@ const selectStatic = (evidence, selector) => {
             throw new TypeError("Function selector requires function comparison Evidence");
         const result = functionComparisonResultSchema.parse(evidence.normalized_result);
         const matches = result.dimensions.filter(({ dimension }) => dimension === selector.dimension);
-        if (matches.length !== 1)
+        const match = matches.at(0);
+        if (matches.length !== 1 || match === undefined)
             throw new TypeError("Function selector must resolve exactly once");
         return {
-            status: matches[0].status,
-            conclusion_kind: matches[0].conclusion_kind,
+            status: match.status,
+            conclusion_kind: match.conclusion_kind,
         };
     }
     if (evidence.operation !== "compare_artifacts")
@@ -257,9 +258,10 @@ const selectStatic = (evidence, selector) => {
         result.changes.items.length !== result.changes.total)
         throw new TypeError("Static/runtime correlation requires complete artifact comparison pagination");
     const matches = result.changes.items.filter(({ logical_path: path }) => path === selector.logical_path);
-    if (matches.length !== 1)
+    const match = matches.at(0);
+    if (matches.length !== 1 || match === undefined)
         throw new TypeError("Artifact selector must resolve exactly one reported delta");
-    const status = matches[0].classification;
+    const status = match.classification;
     return {
         status,
         conclusion_kind: status === "contradiction"

package/dist/domain/webBundleAnalysis.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { inspectWebPageInputSchema } from "./browserObservation.js";
+import { inspectWebPageWithSourceInputSchema } from "./browserObservation.js";
 import { webTextArtifactSchema } from "./webContentArtifact.js";
 const webBundleLimitsSchema = z.object({
     max_findings: z.number().int().min(1).max(10_000).default(1_000),
@@ -21,12 +21,7 @@ const webBundleLimitsSchema = z.object({
     max_original_sources: z.number().int().min(1).max(20_000).default(2_000),
 });
 /** Capture-and-analyze input with separate source and source-map approvals. */
-export const analyzeWebBundleInputSchema = inspectWebPageInputSchema
-    .safeExtend({
-    include_script_sources: z.literal(true).default(true),
-    source_capture_approved: z.literal(true),
-    fetch_source_maps: z.boolean().default(false),
-    source_map_fetch_approved: z.boolean().default(false),
+const analyzeWebBundleFactsSchema = inspectWebPageWithSourceInputSchema.safeExtend({
     analysis_limits: webBundleLimitsSchema.default({
         max_findings: 1_000,
         max_ast_nodes: 250_000,
@@ -36,14 +31,19 @@ export const analyzeWebBundleInputSchema = inspectWebPageInputSchema
         max_source_map_mappings: 10_000,
         max_original_sources: 2_000,
     }),
-})
+});
+export const analyzeWebBundleInputSchema = z
+    .union([
+    analyzeWebBundleFactsSchema.safeExtend({
+        fetch_source_maps: z.literal(false).default(false),
+        source_map_fetch_approved: z.literal(false).default(false),
+    }),
+    analyzeWebBundleFactsSchema.safeExtend({
+        fetch_source_maps: z.literal(true),
+        source_map_fetch_approved: z.literal(true),
+    }),
+])
     .superRefine((input, context) => {
-    if (input.fetch_source_maps && !input.source_map_fetch_approved)
-        context.addIssue({
-            code: "custom",
-            path: ["source_map_fetch_approved"],
-            message: "Source-map network fetch requires separate approval",
-        });
     if (input.analysis_limits.max_source_map_bytes >
         input.analysis_limits.max_total_source_map_bytes)
         context.addIssue({

package/dist/domain/webCaptureDiff.js

@@ -228,20 +228,23 @@ const accessibilityComparable = (inspection) => {
     return { text, nodes, complete };
 };
 const accessibilityProjection = (accessibility, includeText, includeNodes) => {
-    const result = {
-        total_nodes: accessibility.total_nodes,
-    };
     if (!includeNodes)
-        return result;
+        return { total_nodes: accessibility.total_nodes };
     const nodeIndexes = new Map(accessibility.nodes.map((node, index) => [node.node_id, index]));
-    result.nodes = accessibility.nodes.map((node) => ({
-        parent_index: node.parent_id === null ? null : (nodeIndexes.get(node.parent_id) ?? -1),
-        role: node.role,
-        ignored: node.ignored,
-        states: node.states,
-        ...(includeText ? { name: node.name, description: node.description } : {}),
-    }));
-    return result;
+    return {
+        total_nodes: accessibility.total_nodes,
+        nodes: accessibility.nodes.map((node) => ({
+            parent_index: node.parent_id === null
+                ? null
+                : (nodeIndexes.get(node.parent_id) ?? -1),
+            role: node.role,
+            ignored: node.ignored,
+            states: node.states,
+            ...(includeText
+                ? { name: node.name, description: node.description }
+                : {}),
+        })),
+    };
 };
 const storageKeysComparable = (inspection) => sectionsComplete(inspection, ["storage_keys"]);
 const storageComparable = (before, after, keysComplete, usageComplete) => keysComplete &&

package/dist/dotnet/ManagedNativeBoundaryInspector.js

@@ -59,8 +59,7 @@ const emptyInspection = (target, bytes, classification, issues = []) => managedN
         "Static inspection does not load or execute target code, so native export resolution is not performed.",
     ],
 });
-const readBoundaryInventory = (bytes, pe, limits) => {
-    const cli = pe.cli;
+const readBoundaryInventory = (bytes, pe, cli, limits) => {
     const metadataOffset = pe.rvaToOffset(cli.metadata.rva, cli.metadata.size, "cli.metadata");
     const layout = readManagedMetadataLayout(bytes, metadataOffset, cli.metadata.size, limits.maxTableRows);
     const resourceDirectory = {
@@ -104,7 +103,7 @@ export const inspectManagedNativeBoundariesBytes = (bytes, target, limits) => {
     let layout;
     let inventory;
     try {
-        ({ layout, inventory } = readBoundaryInventory(bytes, pe, limits));
+        ({ layout, inventory } = readBoundaryInventory(bytes, pe, pe.cli, limits));
     }
     catch (cause) {
         if (!(cause instanceof ManagedReaderFailure))