rea-agents 3.0.0 → 3.1.0

package/dist/domain/javascriptRuntimeReconciliationMatching.js

@@ -20,14 +20,16 @@ const reconcileEntity = (entity, index, layers) => {
         const content = index.byCategoryDigest.get(categoryDigestKey(entity.staticKind, entity.sourceSha256)) ?? [];
         const locatedKeys = new Set(locations.map(({ candidate }) => candidateKey(candidate)));
         const combined = content.filter((candidate) => locatedKeys.has(candidateKey(candidate)));
-        if (combined.length === 1)
-            return matched(entity, combined[0], {
+        const combinedCandidate = combined.at(0);
+        if (combined.length === 1 && combinedCandidate !== undefined)
+            return matched(entity, combinedCandidate, {
                 basis: "content-and-location",
                 confidence: "high",
                 reason: "content-and-location-match",
             });
-        if (content.length === 1) {
-            const candidate = content[0];
+        const contentCandidate = content.at(0);
+        if (content.length === 1 && contentCandidate !== undefined) {
+            const candidate = contentCandidate;
             const digestBasis = candidate.digests.find(({ sha256 }) => sha256 === entity.sourceSha256)?.basis;
             return matched(entity, candidate, {
                 basis: digestBasis ?? "content-sha256",
@@ -59,8 +61,9 @@ const reconcileEntity = (entity, index, layers) => {
             candidates: [],
         });
     }
-    if (locations.length === 1) {
-        const located = locations[0];
+    const location = locations.at(0);
+    if (locations.length === 1 && location !== undefined) {
+        const located = location;
         return matched(entity, located.candidate, {
             basis: located.mapping.basis,
             confidence: "medium",
@@ -174,50 +177,55 @@ const createItem = (entity, input) => {
         ...semantic,
     };
 };
-const reconciliationEvidence = (entity, layer, basis, confidence) => ({
-    authority: "cross-layer-reconciliation",
-    state: "inferred",
-    confidence: confidence === "medium" ? "medium" : "high",
-    artifact: entity.sourceSha256 === null
-        ? {
-            available: false,
-            reason: "not-observed",
-            detail: "Runtime source bytes were not captured for this mapping.",
-        }
-        : {
-            available: true,
-            artifact_id: `art_${entity.sourceSha256}`,
-            sha256: entity.sourceSha256,
-        },
-    location: entity.node.observations[0].evidence.location,
-    extractor: {
-        name: "rea-javascript-runtime-reconciliation",
-        version: "1",
-        operation: "reconcile_javascript_runtime",
-        executable_sha256: null,
-    },
-    coverage: layer.graph.coverage.status === "complete" &&
-        entity.capture.scriptsCompleteWithinScope
-        ? { status: "complete", truncated: false, omitted_count: 0, limits: [] }
-        : {
-            status: "partial",
-            truncated: false,
-            omitted_count: null,
-            limits: [],
+const reconciliationEvidence = (entity, layer, basis, confidence) => {
+    const observation = entity.node.observations.at(0);
+    if (observation === undefined)
+        throw new TypeError("Runtime reconciliation entity has no observation");
+    return {
+        authority: "cross-layer-reconciliation",
+        state: "inferred",
+        confidence: confidence === "medium" ? "medium" : "high",
+        artifact: entity.sourceSha256 === null
+            ? {
+                available: false,
+                reason: "not-observed",
+                detail: "Runtime source bytes were not captured for this mapping.",
+            }
+            : {
+                available: true,
+                artifact_id: `art_${entity.sourceSha256}`,
+                sha256: entity.sourceSha256,
+            },
+        location: observation.evidence.location,
+        extractor: {
+            name: "rea-javascript-runtime-reconciliation",
+            version: "1",
+            operation: "reconcile_javascript_runtime",
+            executable_sha256: null,
         },
-    limitations: [
-        basis === "content-sha256" ||
-            basis === "module-source-sha256" ||
-            basis === "content-and-location"
-            ? "Equal content digests establish byte identity, not execution causality."
-            : "Location correspondence is inferred from an artifact root or caller-declared mapping.",
-        "Passive script parsing or target presence does not prove feature execution.",
-    ],
-    evidence_ids: [
-        layer.evidence.evidence_id,
-        entity.capture.evidence.evidence_id,
-    ].sort(),
-});
+        coverage: layer.graph.coverage.status === "complete" &&
+            entity.capture.scriptsCompleteWithinScope
+            ? { status: "complete", truncated: false, omitted_count: 0, limits: [] }
+            : {
+                status: "partial",
+                truncated: false,
+                omitted_count: null,
+                limits: [],
+            },
+        limitations: [
+            basis === "content-sha256" ||
+                basis === "module-source-sha256" ||
+                basis === "content-and-location"
+                ? "Equal content digests establish byte identity, not execution causality."
+                : "Location correspondence is inferred from an artifact root or caller-declared mapping.",
+            "Passive script parsing or target presence does not prove feature execution.",
+        ],
+        evidence_ids: [
+            layer.evidence.evidence_id,
+            entity.capture.evidence.evidence_id,
+        ].sort(),
+    };
+};
 const strongestLocationBasis = (values) => {
     const bases = new Set(values.map(({ mapping }) => mapping.basis));
     if (bases.has("artifact-path"))

package/dist/domain/javascriptRuntimeReconciliationParsing.js

@@ -9,6 +9,7 @@ import { javascriptRuntimeObservationSchema, javascriptRuntimeKindSchema, } from
 import { parseEvidence } from "./evidence.js";
 import { javascriptApplicationAnalysisResultSchema, } from "./javascriptApplicationAnalysis.js";
 import { compareCodePoints, } from "./javascriptApplicationGraph.js";
+import { parseActiveElectronCapture } from "./javascriptRuntimeReconciliationActive.js";
 /** Parse and semantically bind every static analysis Evidence layer. */
 export const parseStaticLayers = (layers) => layers
     .map((layer) => parseStaticLayer(layer))
@@ -133,7 +134,10 @@ const parseRuntimeCapture = (input) => {
             scriptsCompleteWithinScope: false,
         };
     }
-    throw new TypeError("Runtime reconciliation requires inspect_web_page, inspect_electron_page, or observe_javascript_runtime Evidence");
+    if (evidence.operation === "capture_electron_scenario") {
+        return parseActiveElectronCapture(evidence);
+    }
+    throw new TypeError("Runtime reconciliation requires inspect_web_page, inspect_electron_page, observe_javascript_runtime, or capture_electron_scenario Evidence");
 };
 const assertV8RuntimeParameters = (evidence, result) => {
     const parameters = z

package/dist/domain/javascriptRuntimeReconciliationResult.js

@@ -78,27 +78,34 @@ const sourceMapAuthority = (input) => ({
     limitation: "Source-map declarations and approved original-source reads retain separate static authority and are not used as primary runtime byte matches.",
 });
 const reconciliationCoverage = (input, completion) => ({
-    status: completion.outputTruncated || completion.inputTruncated
+    status: completion.outputTruncated || completion.inputStatus === "truncated"
         ? "truncated"
-        : completion.inputPartial
+        : completion.inputStatus === "partial"
             ? "partial"
             : "complete-within-inputs",
-    truncated: completion.outputTruncated || completion.inputTruncated,
+    truncated: completion.outputTruncated || completion.inputStatus === "truncated",
     omitted_runtime_entities: input.runtime.omittedEntities,
     omitted_reconciliation_items: input.matching.omittedItems,
     omitted_static_load_states: input.loadStates.omittedStates,
     omitted_graph_items: input.omittedGraphItems,
 });
-const completionFlags = (input) => ({
-    outputTruncated: input.runtime.omittedEntities > 0 ||
-        input.matching.omittedItems > 0 ||
-        input.loadStates.omittedStates > 0 ||
-        input.omittedGraphItems > 0,
-    inputTruncated: input.layers.some(({ graph }) => graph.coverage.truncated) ||
-        input.captures.some(({ inspection }) => inspection.completeness.conditions.includes("truncated")),
-    inputPartial: input.layers.some(({ graph }) => graph.coverage.status !== "complete") ||
-        input.captures.some(({ inspection }) => inspection.completeness.status !== "complete_within_window"),
-});
+const completionFlags = (input) => {
+    const inputTruncated = input.layers.some(({ graph }) => graph.coverage.truncated) ||
+        input.captures.some(({ inspection }) => inspection.completeness.conditions.includes("truncated"));
+    const inputPartial = input.layers.some(({ graph }) => graph.coverage.status !== "complete") ||
+        input.captures.some(({ inspection }) => inspection.completeness.status !== "complete_within_window");
+    return {
+        outputTruncated: input.runtime.omittedEntities > 0 ||
+            input.matching.omittedItems > 0 ||
+            input.loadStates.omittedStates > 0 ||
+            input.omittedGraphItems > 0,
+        inputStatus: inputTruncated
+            ? "truncated"
+            : inputPartial
+                ? "partial"
+                : "complete",
+    };
+};
 const reconciliationLimitations = (completion) => uniqueSorted([
     "Only caller-supplied, semantically verified Evidence records were reconciled.",
     "Digest equality establishes byte identity but not code reachability, module initialization, or feature execution.",
@@ -106,7 +113,7 @@ const reconciliationLimitations = (completion) => uniqueSorted([
     "Not-observed means absent from the bounded captures in scope, never globally unloaded.",
     "Caller-declared file and URL mappings are inference inputs and do not expand CDP origin or filesystem-root authority.",
     "Source-map authority remains separate from passive runtime authority.",
-    ...(completion.inputPartial
+    ...(completion.inputStatus !== "complete"
         ? ["One or more static graphs or passive captures were incomplete."]
         : []),
     ...(completion.outputTruncated

package/dist/domain/javascriptRuntimeReconciliationSchemas.js

@@ -133,7 +133,7 @@ const layerSummarySchema = z.strictObject({
 const captureSummarySchema = z.strictObject({
     evidence_id: evidenceIdSchema,
     capture_sha256: digestSchema,
-    kind: z.enum(["browser", "electron", "v8-inspector"]),
+    kind: z.enum(["browser", "electron", "v8-inspector", "electron-active"]),
     target_node_id: nodeIdSchema,
     target_key: boundedTextSchema,
     target_location: boundedTextSchema,

package/dist/domain/knownPageCoverage.js

@@ -11,11 +11,19 @@ export const assessKnownPageCoverage = (page, includedCount = page.items.length)
         page.returned === page.total &&
         sourceOmittedCount === 0;
     const omittedCount = Math.max(0, page.total - retainedCount);
-    return {
-        complete: sourceComplete && omittedCount === 0,
-        sourceComplete,
-        includedCount: retainedCount,
-        omittedCount,
-        sourceOmittedCount,
-    };
+    return sourceComplete && omittedCount === 0
+        ? {
+            complete: true,
+            sourceComplete: true,
+            includedCount: retainedCount,
+            omittedCount: 0,
+            sourceOmittedCount: 0,
+        }
+        : {
+            complete: false,
+            sourceComplete,
+            includedCount: retainedCount,
+            omittedCount,
+            sourceOmittedCount,
+        };
 };

package/dist/domain/nativeApiBoundary.js

@@ -13,9 +13,7 @@ const inferenceEvidenceSchema = z
     detail: z.string().min(1),
 })
     .strict();
-const inferredBoundaryTypeSchema = z
-    .object({
-    role: z.enum(["return", "parameter"]),
+const inferredBoundaryTypeFacts = {
     ordinal: z.number().int().min(0).nullable(),
     name: z.string().min(1).nullable(),
     data_type: z.string().min(1),
@@ -28,8 +26,18 @@ const inferredBoundaryTypeSchema = z
         "register-or-stack-storage",
         "compiler-generated-variable",
     ])),
-})
-    .strict();
+};
+const inferredReturnTypeSchema = z.strictObject({
+    ...inferredBoundaryTypeFacts,
+    role: z.literal("return"),
+    ordinal: z.null(),
+    name: z.null(),
+});
+const inferredParameterTypeSchema = z.strictObject({
+    ...inferredBoundaryTypeFacts,
+    role: z.literal("parameter"),
+    ordinal: z.number().int().min(0),
+});
 const jumpTableDataSourceSchema = z
     .object({
     address: z.string().min(1),
@@ -68,8 +76,8 @@ const availableNativeApiBoundarySchema = z
     provenance: z.string().min(1),
     signature_source: z.string().min(1),
     calling_convention: z.string().min(1),
-    return_type: inferredBoundaryTypeSchema,
-    parameters: z.array(inferredBoundaryTypeSchema),
+    return_type: inferredReturnTypeSchema,
+    parameters: z.array(inferredParameterTypeSchema),
     parameters_truncated: z.boolean(),
     jump_tables: z.array(inferredJumpTableSchema),
     jump_tables_truncated: z.boolean(),

package/dist/domain/nodeRuntimeCharacterization.js

@@ -1,24 +1,25 @@
 import { z } from "zod";
-import { controlledReplayInputSchema, controlledReplayOutputSchema, } from "./javascriptReplay.js";
+import { controlledReplayExecutionOutputSchema, controlledReplayPlanInputSchema, controlledReplayPlanOutputSchema, } from "./javascriptReplay.js";
 import { javascriptExportInstrumentationInputSchema, javascriptExportTransformationManifestSchema, } from "./javascriptExportInstrumentation.js";
 import { runtimeCharacterizationPlanSchema } from "./runtimeCharacterization.js";
 import { evidenceRecordSchema } from "./evidence.js";
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
+const nodeCharacterizationExpectedEffectSchema = z.enum([
+    "pure",
+    "observation-only",
+]);
+const nodeRuntimeCharacterizationPlanSchema = runtimeCharacterizationPlanSchema.extend({
+    expected_effect: nodeCharacterizationExpectedEffectSchema,
+});
 export const nodeCharacterizationPreparationInputSchema = z
     .strictObject({
     preparation_approved: z.literal(true),
     selected_alias: z.string().min(1).max(200),
-    expected_effect: z.enum(["pure", "observation-only"]),
+    expected_effect: nodeCharacterizationExpectedEffectSchema,
     instrumentation: javascriptExportInstrumentationInputSchema,
-    replay: controlledReplayInputSchema,
+    replay: controlledReplayPlanInputSchema,
 })
     .superRefine((input, context) => {
-    if (input.replay.mode !== "plan")
-        context.addIssue({
-            code: "custom",
-            path: ["replay", "mode"],
-            message: "Characterization preparation requires replay plan mode",
-        });
     const selected = input.replay.left.modules.filter(({ alias }) => alias === input.selected_alias);
     if (selected.length !== 1 ||
         selected[0]?.path !== input.instrumentation.artifact_path ||
@@ -50,17 +51,17 @@ export const nodeCharacterizationExecutionInputSchema = z.strictObject({
 export const nodeCharacterizationPreparationOutputSchema = z.strictObject({
     schema_version: z.literal(1),
     phase: z.literal("preparation"),
-    plan: runtimeCharacterizationPlanSchema,
+    plan: nodeRuntimeCharacterizationPlanSchema,
     transformation: javascriptExportTransformationManifestSchema,
     transformation_evidence: evidenceRecordSchema,
-    replay: controlledReplayOutputSchema,
+    replay: controlledReplayPlanOutputSchema,
 });
 export const nodeCharacterizationExecutionOutputSchema = z.strictObject({
     schema_version: z.literal(1),
     phase: z.literal("execution"),
-    plan: runtimeCharacterizationPlanSchema,
+    plan: nodeRuntimeCharacterizationPlanSchema,
     transformation: javascriptExportTransformationManifestSchema,
     transformation_evidence: evidenceRecordSchema,
     evidence: evidenceRecordSchema,
-    replay: controlledReplayOutputSchema,
+    replay: controlledReplayExecutionOutputSchema,
 });

package/dist/domain/processCaptureReactiveValidation.js

@@ -118,6 +118,8 @@ const replayTransitions = (scenario, run, observations, require) => {
         while ((run.controls[controlIndex]?.after_capture_order ??
             Number.MAX_SAFE_INTEGER) < observation.capture_order) {
             const control = run.controls[controlIndex];
+            if (control === undefined)
+                break;
             advanceControl(control, controlIndex);
             controlIndex += 1;
         }
@@ -125,6 +127,8 @@ const replayTransitions = (scenario, run, observations, require) => {
     }
     for (; controlIndex < run.controls.length; controlIndex += 1) {
         const control = run.controls[controlIndex];
+        if (control === undefined)
+            break;
         advanceControl(control, controlIndex);
     }
     require(transitionIndex ===
@@ -141,10 +145,11 @@ const validateControls = (run, observations, require) => {
         require(control.sequence ===
             index, `reactive_run.controls[${String(index)}].sequence`, "reactive control sequence must be contiguous");
         require(admittedOrders.has(control.after_capture_order), `reactive_run.controls[${String(index)}].after_capture_order`, "reactive control cutoff must identify the last admitted observation");
+        const previous = run.controls.at(index - 1);
         require(index === 0 ||
-            control.after_capture_order >=
-                run.controls[index - 1]
-                    .after_capture_order, `reactive_run.controls[${String(index)}].after_capture_order`, "reactive control cutoffs must be ordered");
+            (previous !== undefined &&
+                control.after_capture_order >=
+                    previous.after_capture_order), `reactive_run.controls[${String(index)}].after_capture_order`, "reactive control cutoffs must be ordered");
     }
 };
 /** Validate one capture's reactive journal by replaying the production reducer. */

package/dist/domain/processCaptureValidation.js

@@ -1,7 +1,11 @@
 import { validateProcessCaptureReactiveRun } from "./processCaptureReactiveValidation.js";
 import { replayMachineSchema } from "./replayMachine.js";
 import { digestProcessCommitment } from "./processScenario.js";
-const orderedTimestamps = (values) => values.every((value, index) => index === 0 || value.at_ms >= values[index - 1].at_ms);
+const orderedTimestamps = (values) => values.every((value, index) => {
+    const previous = values[index - 1];
+    return previous === undefined || value.at_ms >= previous.at_ms;
+});
+const transitionsAreContiguous = (previous, current) => previous !== undefined && previous.state_after === current.state_before;
 const validateCommitments = (capture, require) => {
     const { manifest } = capture;
     require(manifest.scenario.executable_sha256 ===
@@ -192,9 +196,9 @@ const validateReplayEvents = (capture, require) => {
         if (index === 0)
             require(transition.state_before ===
                 machine?.initial_state, "replay_transitions", "first replay transition does not start at the declared initial state");
+        const previous = capture.replay_transitions[index - 1];
         if (index > 0)
-            require(capture.replay_transitions[index - 1].state_after ===
-                transition.state_before, "replay_transitions", "replay transition states are not contiguous");
+            require(transitionsAreContiguous(previous, transition), "replay_transitions", "replay transition states are not contiguous");
     }
 };
 /** Recompute v4 commitments and cross-field invariants without side effects. */

package/dist/domain/processComparison.js

@@ -1,3 +1,4 @@
+import canonicalize from "canonicalize";
 import { z } from "zod";
 import { validateProcessCapture } from "./processCapture.js";
 import { jsonValueSchema } from "./jsonValue.js";
@@ -97,6 +98,10 @@ const filesystemObservations = (capture) => [
         effects: capture.filesystem_effects,
     },
 ];
+const sameJsonValue = (left, right) => {
+    const encodedLeft = canonicalize(left);
+    return encodedLeft !== undefined && encodedLeft === canonicalize(right);
+};
 /** Canonical observations for one process-comparison dimension. */
 export const processDimensionObservations = (capture, dimension) => {
     switch (dimension) {
@@ -117,7 +122,7 @@ export const processDimensionObservations = (capture, dimension) => {
     }
 };
 const classifyCollection = (left, right) => {
-    if (JSON.stringify(left) === JSON.stringify(right))
+    if (sameJsonValue(left, right))
         return "unchanged";
     if (left.length === 0)
         return "added";
@@ -141,7 +146,7 @@ const firstCollectionDivergence = (dimension, left, right) => {
     for (let index = 0; index < length; index += 1) {
         const leftValue = left[index] ?? null;
         const rightValue = right[index] ?? null;
-        if (JSON.stringify(leftValue) === JSON.stringify(rightValue))
+        if (sameJsonValue(leftValue, rightValue))
             continue;
         return {
             status: "found",
@@ -168,8 +173,9 @@ const assertComparable = (left, right, options) => {
         ...validateProcessCapture(left),
         ...validateProcessCapture(right),
     ];
-    if (invalid.length > 0)
-        throw new TypeError(`Invalid Process Capture v4: ${invalid[0].path}`);
+    const firstInvalid = invalid.at(0);
+    if (firstInvalid !== undefined)
+        throw new TypeError(`Invalid Process Capture v4: ${firstInvalid.path}`);
     if (left.schema_version !== right.schema_version ||
         left.manifest.comparison_contract_sha256 !==
             right.manifest.comparison_contract_sha256)
@@ -239,8 +245,7 @@ const compareDimensions = (left, right, sameNormalization) => {
         interaction: classify("interaction", left.interaction_events, right.interaction_events),
         exit: hasUnknown(left, "exit") || hasUnknown(right, "exit")
             ? "unknown"
-            : JSON.stringify({ exit: left.exit, settlement: left.settlement }) ===
-                JSON.stringify({ exit: right.exit, settlement: right.settlement })
+            : sameJsonValue({ exit: left.exit, settlement: left.settlement }, { exit: right.exit, settlement: right.settlement })
                 ? "unchanged"
                 : "changed",
         filesystem: classify("filesystem", filesystemObservations(left), filesystemObservations(right)),
@@ -266,7 +271,7 @@ export const compareProcessCaptures = (left, right, options = {}) => {
                 trace: compareProcessTraces(left, right, options.traceSpecification),
             };
     }
-    const sameNormalization = JSON.stringify(left.normalization) === JSON.stringify(right.normalization);
+    const sameNormalization = sameJsonValue(left.normalization, right.normalization);
     const exactDimensions = compareDimensions(left, right, sameNormalization);
     const trace = options.traceSpecification === undefined
         ? undefined

package/dist/domain/processObservation.js

@@ -52,14 +52,13 @@ export const createProcessObservation = (input) => ({
 const atMilliseconds = (value) => {
     if (typeof value !== "object" || value === null)
         return null;
-    for (const name of ["at_ms", "dispatched_at_ms"])
-        if (name in value) {
-            const candidate = value[name];
-            if (typeof candidate === "number" && Number.isSafeInteger(candidate))
-                return candidate;
-        }
+    if ("at_ms" in value && isSafeMillisecond(value.at_ms))
+        return value.at_ms;
+    if ("dispatched_at_ms" in value && isSafeMillisecond(value.dispatched_at_ms))
+        return value.dispatched_at_ms;
     return null;
 };
+const isSafeMillisecond = (value) => typeof value === "number" && Number.isSafeInteger(value);
 /** Derive the stable capture-local identity for one normalized observation. */
 export const processObservationSubject = (source, value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value))

package/dist/domain/processReactiveMatching.js

@@ -125,13 +125,20 @@ const matchTerminalText = (trigger, context) => {
         overflow: false,
     };
 };
-const mergeMatches = (matches) => ({
-    matched: matches.every(({ matched }) => matched),
-    eventIds: [...new Set(matches.flatMap(({ eventIds }) => eventIds))],
-    consumeIds: [...new Set(matches.flatMap(({ consumeIds }) => consumeIds))],
-    lastOrder: Math.max(-1, ...matches.map(({ lastOrder }) => lastOrder)),
-    overflow: matches.some(({ overflow }) => overflow),
-});
+const mergeMatches = (matches) => {
+    const base = {
+        eventIds: [...new Set(matches.flatMap(({ eventIds }) => eventIds))],
+        consumeIds: [...new Set(matches.flatMap(({ consumeIds }) => consumeIds))],
+        lastOrder: Math.max(-1, ...matches.map(({ lastOrder }) => lastOrder)),
+    };
+    return matches.every(({ matched }) => matched)
+        ? { ...base, matched: true, overflow: false }
+        : {
+            ...base,
+            matched: false,
+            overflow: matches.some(({ overflow }) => overflow),
+        };
+};
 const matchEarliestPrefix = (trigger, context) => {
     for (const observation of context.snapshot.observations) {
         if (observation.capture_order <= context.afterOrder)

package/dist/domain/processReactiveTransition.js

@@ -11,6 +11,8 @@ const incrementCounter = (counters, id) => {
 };
 /** Commit one uniquely selected transition after its declarative effects succeed. */
 const applyProcessReactiveTransition = (input) => {
+    if (input.effectResults.length !== input.transition.actions.length)
+        throw new TypeError("Reactive transition effects do not match the admitted actions");
     const outcome = input.transition.target.kind === "finish"
         ? input.transition.target.outcome
         : null;
@@ -31,13 +33,17 @@ const applyProcessReactiveTransition = (input) => {
     for (const eventId of input.consumeEventIds)
         consumed.add(eventId);
     const checkpoints = [...input.snapshot.checkpoints];
-    for (const [index, action] of input.transition.actions.entries())
+    for (const [index, action] of input.transition.actions.entries()) {
+        const effect = input.effectResults[index];
+        if (effect === undefined)
+            throw new TypeError("Reactive transition effect is missing");
         if (action.type === "checkpoint")
             checkpoints.push({
                 name: action.name,
-                event_id: input.effectResults[index].observation.event_id,
-                capture_order: input.effectResults[index].observation.capture_order,
+                event_id: effect.observation.event_id,
+                capture_order: effect.observation.capture_order,
             });
+    }
     const completedCaptureOrder = Math.max(input.observation.capture_order, ...input.effectResults.map(({ observation }) => observation.capture_order));
     let next = {
         ...input.snapshot,

package/dist/domain/processScenario.js

@@ -283,7 +283,9 @@ export const processScenarioSchema = z
     .strict()
     .superRefine((scenario, context) => {
     for (let index = 1; index < scenario.events.length; index += 1) {
-        if (scenario.events[index].at_ms < scenario.events[index - 1].at_ms) {
+        const event = scenario.events[index];
+        const previous = scenario.events[index - 1];
+        if (eventsOutOfOrder(event, previous)) {
             context.addIssue({
                 code: "custom",
                 message: "events must be ordered by at_ms",
@@ -361,15 +363,16 @@ export const processScenarioSchema = z
             path: ["replay"],
         });
 });
+const eventsOutOfOrder = (event, previous) => event !== undefined && previous !== undefined && event.at_ms < previous.at_ms;
 /** Parse untrusted process scenario input and apply safe default budgets. */
 export const parseProcessScenario = (input) => processScenarioSchema.parse(input);
 const isWithin = (candidate, root) => resolve(candidate) === resolve(root) ||
     resolve(candidate).startsWith(`${resolve(root)}${resolve(root).endsWith("/") ? "" : "/"}`);
 /** Evaluate scenario authority before any process or filesystem side effect occurs. */
 export const authorizeProcessScenario = (scenario, policy) => {
-    if (!policy.enabled)
+    if (policy.status === "disabled")
         return { allowed: false, reason: "process capture is disabled" };
-    if (scenario.network_access === "host" && !policy.allowExternalNetwork)
+    if (scenario.network_access === "host" && policy.networkAccess === "none")
         return {
             allowed: false,
             reason: "host network access is not approved by operator policy",

package/dist/domain/processTraceComparison.js

@@ -9,8 +9,9 @@ export const compareProcessTraces = (left, right, specificationInput) => {
         ...validateProcessCapture(left),
         ...validateProcessCapture(right),
     ];
-    if (captureIssues.length > 0)
-        throw new TypeError(`Invalid Process Capture v4: ${captureIssues[0].path}`);
+    const firstCaptureIssue = captureIssues.at(0);
+    if (firstCaptureIssue !== undefined)
+        throw new TypeError(`Invalid Process Capture v4: ${firstCaptureIssue.path}`);
     const specification = processTraceSpecificationSchema.parse(specificationInput);
     const leftEvaluation = evaluateProcessTraceSide(left, specification);
     const rightEvaluation = evaluateProcessTraceSide(right, specification);

package/dist/domain/protocolCapture.js

@@ -109,7 +109,7 @@ export function looksLikeCredential(path) {
 /** Decode a JSON-RPC message from raw payload bytes. */
 export function decodeJsonRpc(rawPayload) {
     const text = new TextDecoder().decode(rawPayload);
-    const parsed = JSON.parse(text);
+    const parsed = jsonValueSchema.parse(JSON.parse(text));
     const fields = [];
     if (typeof parsed === "object" && parsed !== null) {
         for (const [key, value] of Object.entries(parsed)) {
@@ -125,7 +125,7 @@ export function decodeJsonRpc(rawPayload) {
                 fields.push({
                     path: key,
                     wire_type: "json",
-                    value: value,
+                    value,
                     inferred: false,
                 });
             }
@@ -141,6 +141,8 @@ export function decodeMessagePack(rawPayload) {
         return { decoded_fields: [], truncated: false };
     }
     const tag = rawPayload[0];
+    if (tag === undefined)
+        return { decoded_fields: [], truncated: false };
     // Map type: 0x80-0x8f (fixmap), 0xde (map16), 0xdf (map32)
     if ((tag >= 0x80 && tag <= 0x8f) || tag === 0xde || tag === 0xdf) {
         fields.push({
@@ -189,10 +191,10 @@ export function decodeGrpcFrame(rawPayload) {
         };
     }
     const compressed = rawPayload[0] !== 0;
-    const length = (rawPayload[1] << 24) |
-        (rawPayload[2] << 16) |
-        (rawPayload[3] << 8) |
-        rawPayload[4];
+    const length = ((rawPayload[1] ?? 0) << 24) |
+        ((rawPayload[2] ?? 0) << 16) |
+        ((rawPayload[3] ?? 0) << 8) |
+        (rawPayload[4] ?? 0);
     return {
         decoded_fields: [
             {