rea-agents 3.1.0 → 3.2.1

package/dist/application/LoopbackReplay.js

@@ -1,7 +1,7 @@
 import { createServer, } from "node:http";
 import { WebSocketServer } from "ws";
 import {} from "../domain/replayMachineRuntime.js";
-import { closeReplayServer, listenOnLoopback, recordMachineEvent, readReplayRequestBody, ReplayRecorder, requestHeaders, waitForReplayDelay, } from "./LoopbackReplayRecorder.js";
+import { closeReplayServer, listenOnLoopback, recordMachineEvent, readReplayRequestBody, ReplayRecorder, ReplayDelayScheduler, requestHeaders, } from "./LoopbackReplayRecorder.js";
 const recordHttpResponse = (recorder, request, data, outcome) => recorder.record({
     at_ms: recorder.atMs(),
     protocol: "http",
@@ -11,7 +11,7 @@ const recordHttpResponse = (recorder, request, data, outcome) => recorder.record
     data,
     outcome,
 });
-const handleMachineHttp = async (recorder, request) => {
+const handleMachineHttp = async (recorder, request, delays) => {
     const machine = recorder.machine;
     if (machine === undefined)
         return;
@@ -40,7 +40,7 @@ const handleMachineHttp = async (recorder, request) => {
     }
     for (const action of decision.actions) {
         if (action.type === "delay")
-            await waitForReplayDelay(action.duration_ms);
+            await delays.wait(action.duration_ms);
         else if (action.type === "disconnect") {
             request.response.destroy();
             recordHttpResponse(recorder, request, "", "disconnected");
@@ -55,7 +55,7 @@ const handleMachineHttp = async (recorder, request) => {
         }
     }
 };
-const handleStaticHttp = async (recorder, request, calls) => {
+const handleStaticHttp = async (recorder, request, calls, delays) => {
     const index = recorder.scenario.replay.http.findIndex((route) => route.method !== request.method || route.path !== request.path
         ? false
         : (route.request_body === undefined ||
@@ -84,7 +84,7 @@ const handleStaticHttp = async (recorder, request, calls) => {
     }
     calls.set(index, used + 1);
     if (route.delay_ms > 0)
-        await waitForReplayDelay(route.delay_ms);
+        await delays.wait(route.delay_ms);
     if (route.disconnect) {
         request.response.destroy();
         recordHttpResponse(recorder, request, "", "disconnected");
@@ -96,7 +96,7 @@ const handleStaticHttp = async (recorder, request, calls) => {
     request.response.end(route.body);
     recordHttpResponse(recorder, request, route.body, "matched");
 };
-const handleHttpRequest = async (recorder, request, response, calls) => {
+const handleHttpRequest = async (recorder, request, response, calls, delays) => {
     const body = await readReplayRequestBody(request, recorder.scenario.limits.protocol_body_bytes);
     const method = request.method ?? "GET";
     const path = new URL(request.url ?? "/", "http://127.0.0.1").pathname;
@@ -125,13 +125,13 @@ const handleHttpRequest = async (recorder, request, response, calls) => {
         recordedAtMs: recorder.atMs(),
     };
     await (recorder.machine === undefined
-        ? handleStaticHttp(recorder, replayRequest, calls)
-        : recorder.enqueueMachine(() => handleMachineHttp(recorder, replayRequest)));
+        ? handleStaticHttp(recorder, replayRequest, calls, delays)
+        : recorder.enqueueMachine(() => handleMachineHttp(recorder, replayRequest, delays)));
 };
-const createHttpHandler = (recorder) => {
+const createHttpHandler = (recorder, delays) => {
     const calls = new Map();
     return (request, response) => {
-        void handleHttpRequest(recorder, request, response, calls).catch(() => {
+        void handleHttpRequest(recorder, request, response, calls, delays).catch(() => {
             recorder.truncated = true;
             if (response.headersSent)
                 response.destroy();
@@ -142,7 +142,7 @@ const createHttpHandler = (recorder) => {
         });
     };
 };
-const sendWebSocketScript = async (client, connection, recorder) => {
+const sendWebSocketScript = async (client, connection, recorder, delays) => {
     const scripts = recorder.scenario.replay.websocket_connections;
     const script = scripts[connection - 1];
     if (scripts.length > 0 && script === undefined) {
@@ -165,7 +165,7 @@ const sendWebSocketScript = async (client, connection, recorder) => {
         }));
     for (const message of messages) {
         if (message.delay_ms > 0)
-            await new Promise((resolveDelay) => setTimeout(resolveDelay, message.delay_ms));
+            await delays.wait(message.delay_ms);
         if (client.readyState !== 1)
             return;
         client.send(message.data);
@@ -192,10 +192,10 @@ const sendWebSocketScript = async (client, connection, recorder) => {
         });
     }
 };
-const runWebSocketActions = async (client, recorder, decision, path) => {
+const runWebSocketActions = async (client, recorder, decision, path, delays) => {
     for (const action of decision.actions) {
         if (action.type === "delay") {
-            await waitForReplayDelay(action.duration_ms);
+            await delays.wait(action.duration_ms);
             continue;
         }
         if (action.type === "disconnect") {
@@ -225,7 +225,7 @@ const runWebSocketActions = async (client, recorder, decision, path) => {
         }
     }
 };
-const handleStaticWebSocket = (client, recorder, connection, path) => {
+const handleStaticWebSocket = (client, recorder, connection, path, delays) => {
     client.on("message", (value) => recorder.record({
         at_ms: recorder.atMs(),
         protocol: "websocket",
@@ -235,10 +235,10 @@ const handleStaticWebSocket = (client, recorder, connection, path) => {
         data: value.toString(),
         outcome: "matched",
     }));
-    void sendWebSocketScript(client, connection, recorder);
+    void sendWebSocketScript(client, connection, recorder, delays);
 };
 const handleMachineWebSocket = (options) => {
-    const { client, request, recorder, connection, path } = options;
+    const { client, request, recorder, connection, path, delays } = options;
     const machine = recorder.machine;
     if (machine === undefined)
         return;
@@ -264,7 +264,7 @@ const handleMachineWebSocket = (options) => {
             data: "",
         }, connectionDecision);
         if (connectionDecision.outcome === "matched")
-            await runWebSocketActions(client, recorder, connectionDecision, path);
+            await runWebSocketActions(client, recorder, connectionDecision, path, delays);
         else
             client.close();
     })
@@ -297,7 +297,7 @@ const handleMachineWebSocket = (options) => {
                 data: body,
             }, decision);
             if (decision.outcome === "matched")
-                await runWebSocketActions(client, recorder, decision, path);
+                await runWebSocketActions(client, recorder, decision, path, delays);
         })
             .catch(() => {
             recorder.truncated = true;
@@ -305,7 +305,7 @@ const handleMachineWebSocket = (options) => {
         });
     });
 };
-const createWebSocketReplay = (server, recorder) => {
+const createWebSocketReplay = (server, recorder, delays) => {
     let connections = 0;
     const websocket = new WebSocketServer({
         noServer: true,
@@ -330,7 +330,7 @@ const createWebSocketReplay = (server, recorder) => {
         client.on("error", () => undefined);
         const path = new URL(request.url ?? "/", "http://127.0.0.1").pathname;
         if (recorder.machine === undefined)
-            handleStaticWebSocket(client, recorder, connections, path);
+            handleStaticWebSocket(client, recorder, connections, path, delays);
         else
             handleMachineWebSocket({
                 client,
@@ -338,6 +338,7 @@ const createWebSocketReplay = (server, recorder) => {
                 recorder,
                 connection: connections,
                 path,
+                delays,
             });
     });
     return websocket;
@@ -345,8 +346,9 @@ const createWebSocketReplay = (server, recorder) => {
 /** Start bounded HTTP and WebSocket replay endpoints on IPv4 loopback only. */
 export const startLoopbackReplay = async (scenario, recordEvent = () => undefined) => {
     const recorder = new ReplayRecorder(scenario, recordEvent);
-    const server = createServer(createHttpHandler(recorder));
-    const websocket = createWebSocketReplay(server, recorder);
+    const delays = new ReplayDelayScheduler();
+    const server = createServer(createHttpHandler(recorder, delays));
+    const websocket = createWebSocketReplay(server, recorder, delays);
     let closePromise;
     let port;
     try {
@@ -373,6 +375,7 @@ export const startLoopbackReplay = async (scenario, recordEvent = () => undefine
         },
         async close() {
             closePromise ??= (async () => {
+                delays.close();
                 recorder.stopMachineAdmission();
                 await recorder.drainMachine();
                 for (const client of websocket.clients)

package/dist/application/LoopbackReplayRecorder.js

@@ -1,4 +1,5 @@
 import { ReplayMachineRuntime, } from "../domain/replayMachineRuntime.js";
+import { scheduleProcessDelay } from "./ProcessTimer.js";
 /** Bounded protocol and replay-machine observations for one process run. */
 export class ReplayRecorder {
     scenario;
@@ -82,7 +83,34 @@ export const recordMachineEvent = (recorder, event, decision) => {
     });
     recorder.recordTransition(decision);
 };
-export const waitForReplayDelay = (durationMs) => new Promise((resolveDelay) => setTimeout(resolveDelay, durationMs));
+/** Owns replay delays so endpoint shutdown can release every waiting handler. */
+export class ReplayDelayScheduler {
+    #pending = new Map();
+    #closed = false;
+    wait(durationMs) {
+        if (this.#closed)
+            return Promise.resolve();
+        return new Promise((resolveDelay) => {
+            let timer;
+            const finish = () => {
+                this.#pending.delete(timer);
+                resolveDelay();
+            };
+            timer = scheduleProcessDelay(durationMs, finish);
+            this.#pending.set(timer, finish);
+        });
+    }
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        for (const [timer, finish] of this.#pending) {
+            timer.cancel();
+            finish();
+        }
+        this.#pending.clear();
+    }
+}
 export const listenOnLoopback = async (server) => {
     await new Promise((resolveListen, rejectListen) => {
         server.once("error", rejectListen);

package/dist/application/ManagedApplicationGraphService.js

@@ -22,13 +22,12 @@ export const projectManagedApplicationGraphEvidence = (rawInput) => {
     }
 };
 const createManagedApplicationGraphEvidence = (input, result) => createEvidence(subjectTarget(input), MANAGED_WORKFLOW_PROVIDER, {
-    predicateType: "rea.managed-application-graph/v1",
+    predicateType: "rea.managed-application-graph",
     operation: OPERATION,
     parameters: {
         managed_artifact_evidence_id: input.managed_artifact?.evidence_id ?? null,
         managed_members_evidence_id: input.managed_members?.evidence_id ?? null,
         managed_native_boundaries_evidence_id: input.managed_native_boundaries?.evidence_id ?? null,
-        limits: jsonValueSchema.parse(input.limits),
     },
     result: jsonValueSchema.parse(managedApplicationGraphResultSchema.parse(result)),
     rawResult: null,

package/dist/application/ManagedMemberComparisonService.js

@@ -1,21 +1,20 @@
-import { readFile, stat } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { z } from "zod";
 import { compareManagedMembers, managedMemberComparisonResultSchema, parseManagedMemberEvidence, } from "../domain/managedMemberComparison.js";
 import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { parseBinaryTarget } from "../domain/binaryTarget.js";
+import { parseBinaryTarget } from "./BinaryTargetResolver.js";
 import { err, ok } from "../domain/result.js";
 import { inspectManagedMembersBytes } from "../dotnet/ManagedMemberInspector.js";
-import { MANAGED_STATIC_PROVIDER } from "./InvestigationProviders.js";
-import { MANAGED_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
+import { MANAGED_STATIC_PROVIDER, MANAGED_WORKFLOW_PROVIDER, } from "./InvestigationProviders.js";
 /** Compare managed members from input parsed by a trusted adapter. */
 export const compareManagedMembersEvidenceValidated = (input) => {
     const operation = "compare_managed_members";
     try {
         const left = parseManagedMemberEvidence(input.left);
         const right = parseManagedMemberEvidence(input.right);
-        const result = compareManagedMembers({ evidenceId: left.evidenceId, result: left.result }, { evidenceId: right.evidenceId, result: right.result }, input.limits);
+        const result = compareManagedMembers({ evidenceId: left.evidenceId, result: left.result }, { evidenceId: right.evidenceId, result: right.result });
         return ok(createManagedMemberComparisonEvidence(input, result));
     }
     catch (cause) {
@@ -34,24 +33,15 @@ export const compareManagedMemberPaths = async (input) => {
             return err(new AnalysisInputError(operation, { cause: leftTarget.error }));
         if (!rightTarget.ok)
             return err(new AnalysisInputError(operation, { cause: rightTarget.error }));
-        const [leftStat, rightStat] = await Promise.all([
-            stat(leftTarget.value.path),
-            stat(rightTarget.value.path),
-        ]);
-        if (leftStat.size > input.memberLimits.maxFileBytes ||
-            rightStat.size > input.memberLimits.maxFileBytes)
-            return err(new AnalysisInputError(operation, {
-                cause: new RangeError(`Managed comparison input exceeds max_file_bytes ${String(input.memberLimits.maxFileBytes)}`),
-            }));
         const [leftBytes, rightBytes] = await Promise.all([
             readFile(leftTarget.value.path),
             readFile(rightTarget.value.path),
         ]);
-        const leftInspection = inspectManagedMembersBytes(leftBytes, leftTarget.value, input.memberLimits);
-        const rightInspection = inspectManagedMembersBytes(rightBytes, rightTarget.value, input.memberLimits);
+        const leftInspection = inspectManagedMembersBytes(leftBytes, leftTarget.value);
+        const rightInspection = inspectManagedMembersBytes(rightBytes, rightTarget.value);
         const leftEvidence = createEvidence(leftTarget.value, MANAGED_STATIC_PROVIDER, {
             operation: "inspect_managed_members",
-            parameters: memberLimitParameters(input.memberLimits),
+            parameters: {},
             result: jsonValueSchema.parse(leftInspection),
             rawResult: null,
             limitations: leftInspection.limitations,
@@ -59,7 +49,7 @@ export const compareManagedMemberPaths = async (input) => {
         });
         const rightEvidence = createEvidence(rightTarget.value, MANAGED_STATIC_PROVIDER, {
             operation: "inspect_managed_members",
-            parameters: memberLimitParameters(input.memberLimits),
+            parameters: {},
             result: jsonValueSchema.parse(rightInspection),
             rawResult: null,
             limitations: rightInspection.limitations,
@@ -71,24 +61,23 @@ export const compareManagedMemberPaths = async (input) => {
         }, {
             evidenceId: rightEvidence.evidence_id,
             result: rightInspection,
-        }, input.comparisonLimits);
+        });
         return ok(createManagedMemberComparisonEvidence({
             left: leftEvidence,
             right: rightEvidence,
-            limits: input.comparisonLimits,
         }, result));
     }
     catch (cause) {
         return workflowFailure(operation, cause);
     }
 };
+/** ECMA-335 representable limits for path-based member comparison. */
 const createManagedMemberComparisonEvidence = (parameters, result) => createEvidence(undefined, MANAGED_WORKFLOW_PROVIDER, {
-    predicateType: "rea.managed-member-comparison/v1",
+    predicateType: "rea.managed-member-comparison",
     operation: "compare_managed_members",
     parameters: {
         left_evidence_id: parameters.left.evidence_id,
         right_evidence_id: parameters.right.evidence_id,
-        limits: jsonValueSchema.parse(parameters.limits),
     },
     result: jsonValueSchema.parse(result),
     rawResult: null,
@@ -98,25 +87,6 @@ const createManagedMemberComparisonEvidence = (parameters, result) => createEvid
     limitations: result.limitations,
     evidenceLinks: result.evidence_links,
 });
-const memberLimitParameters = (limits) => ({
-    type_offset: limits.typeOffset,
-    type_limit: limits.typeLimit,
-    method_offset: limits.methodOffset,
-    method_limit: limits.methodLimit,
-    field_offset: limits.fieldOffset,
-    field_limit: limits.fieldLimit,
-    member_ref_offset: limits.memberRefOffset,
-    member_ref_limit: limits.memberRefLimit,
-    edge_offset: limits.edgeOffset,
-    edge_limit: limits.edgeLimit,
-    instruction_anchor_limit: limits.instructionAnchorLimit,
-    max_file_bytes: limits.maxFileBytes,
-    max_metadata_bytes: limits.maxMetadataBytes,
-    max_table_rows: limits.maxTableRows,
-    max_heap_item_bytes: limits.maxHeapItemBytes,
-    max_method_body_bytes: limits.maxMethodBodyBytes,
-    max_method_instructions: limits.maxMethodInstructions,
-});
 const workflowFailure = (operation, cause) => err(cause instanceof z.ZodError || cause instanceof TypeError
     ? new AnalysisInputError(operation, { cause })
     : new AnalysisProtocolError("Managed member comparison produced an invalid result", { cause }));

package/dist/application/ManagedNativeVerificationService.js

@@ -22,12 +22,11 @@ export const verifyManagedNativeBoundariesEvidence = (rawInput) => {
     }
 };
 const createManagedNativeVerificationEvidence = (input, result) => createEvidence(undefined, MANAGED_WORKFLOW_PROVIDER, {
-    predicateType: "rea.managed-native-verification/v1",
+    predicateType: "rea.managed-native-verification",
     operation: OPERATION,
     parameters: {
         managed_boundaries_evidence_id: input.managed_boundaries.evidence_id,
         native_evidence_ids: jsonValueSchema.parse(input.native_observations.map(({ evidence_id: id }) => id)),
-        limits: jsonValueSchema.parse(input.limits),
     },
     result: jsonValueSchema.parse(result),
     rawResult: null,

package/dist/application/ManagedReconstructionService.js

@@ -30,7 +30,7 @@ const createManagedReconstructionEvidence = (input, result) => createEvidence({
     sha256: result.static_observation.artifact_sha256,
     format: "pe",
 }, MANAGED_WORKFLOW_PROVIDER, {
-    predicateType: "rea.managed-reconstruction-import/v1",
+    predicateType: "rea.managed-reconstruction-import",
     operation: OPERATION,
     parameters: {
         static_members_evidence_id: input.static_members.evidence_id,

package/dist/application/ManagedRuntimeCorrelationService.js

@@ -1,4 +1,5 @@
-import { AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisProtocolError, PermissionRequiredError, } from "../domain/errors.js";
+import { projectPermissionFailure } from "./PermissionFailure.js";
+import { AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
 import { createEvidence, parseEvidence, } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { managedRuntimeCorrelationInputSchema, planManagedRuntimeCorrelation, } from "../domain/managedRuntimeCorrelation.js";
@@ -40,13 +41,9 @@ export const planManagedRuntimeCorrelationEvidenceValidated = async (dependencie
         network: "none",
         mount: false,
         operation_identity: operationIdentity(input, staticEvidence),
-    }, "read", { restartRequired: true });
+    }, "read", { remediation: "restart" });
     if (!authorized.ok)
-        return err(authorized.error instanceof PermissionRequiredError
-            ? authorized.error
-            : new AnalysisProtocolError(authorized.error.message, {
-                cause: authorized.error,
-            }));
+        return err(projectPermissionFailure(authorized.error));
     try {
         const result = planManagedRuntimeCorrelation(input, policy.executablePath, authorized.value.grant_id);
         return ok(createEvidence({
@@ -54,7 +51,7 @@ export const planManagedRuntimeCorrelationEvidenceValidated = async (dependencie
             sha256: result.static_observation.artifact_sha256,
             format: "pe",
         }, MANAGED_WORKFLOW_PROVIDER, {
-            predicateType: "rea.managed-runtime-correlation-plan/v1",
+            predicateType: "rea.managed-runtime-correlation-plan",
             operation: OPERATION,
             parameters: {
                 static_members_evidence_id: staticEvidence.evidence_id,

package/dist/application/NativeApiInspection.js

@@ -17,7 +17,6 @@ export const projectNativeApiInspection = (dossier) => {
         ? availableResidualUnknowns(boundary)
         : boundary.residual_unknowns;
     return nativeApiInspectionResultSchema.parse({
-        schema_version: 1,
         procedure: {
             address: dossier.procedure.address,
             name: dossier.procedure.name,
@@ -58,13 +57,9 @@ export const projectNativeApiInspection = (dossier) => {
 };
 const availableResidualUnknowns = (boundary) => {
     const unknowns = [];
-    if (boundary.parameters_truncated)
-        unknowns.push("Which additional parameters were omitted by the native API boundary limit?");
-    if (boundary.jump_tables_truncated)
-        unknowns.push("Which additional jump tables were omitted by the native API boundary limit?");
     for (const table of boundary.jump_tables) {
-        if (table.data_sources_truncated || table.mappings_truncated)
-            unknowns.push(`Which additional data sources or targets were omitted for the jump table dispatched at ${table.dispatch_address}?`);
+        if (table.mappings.length === 0)
+            unknowns.push(`Which case values and targets belong to the dispatch at ${table.dispatch_address}?`);
         if (table.data_sources.length === 0)
             unknowns.push(`What backing data address produced the jump table dispatched at ${table.dispatch_address}?`);
         if (table.data_sources.some(({ entry_count: count, entry_size_bytes: size }) => count === null || size === null))