rea-agents 3.0.0 → 3.2.0

package/dist/domain/objcSwiftMetadata.js

@@ -51,6 +51,102 @@ export const objcClassSchema = z.strictObject({
     ivar_count: z.number().int().nonnegative().default(0),
     instance_size: z.number().int().nonnegative().nullable(),
 });
+/** Exact location of a decoded native metadata value when the provider knows it. */
+export const nativeMetadataLocationSchema = z.strictObject({
+    address: z.string().nullable(),
+    file_offset: z.number().int().nonnegative().nullable(),
+});
+/** Provider-neutral decode state; absence never silently means unsupported. */
+export const nativeMetadataDecodeSchema = z.strictObject({
+    status: z.enum(["decoded", "partial", "unsupported", "invalid"]),
+    reason: z.string().nullable(),
+});
+/** Evidence attached to one dispatch edge or metadata record. */
+export const nativeMetadataEvidenceSchema = z.strictObject({
+    kind: z.enum([
+        "binary_metadata",
+        "interface_builder_resource",
+        "symbol",
+        "reference",
+        "decompiler",
+    ]),
+    description: z.string().min(1),
+    location: nativeMetadataLocationSchema,
+    artifact_path: z.string().min(1).nullable().default(null),
+    artifact_sha256: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/u)
+        .nullable()
+        .default(null),
+});
+/** Objective-C ivar layout, retaining encoded type and exact storage offset. */
+export const objcIvarSchema = z.strictObject({
+    class_name: z.string().min(1),
+    name: z.string().min(1),
+    type_encoding: z.string().nullable(),
+    offset: z.number().int().nonnegative().nullable(),
+    location: nativeMetadataLocationSchema,
+    decode: nativeMetadataDecodeSchema,
+    evidence: z.array(nativeMetadataEvidenceSchema).min(1),
+});
+/** Selector implementation resolved from a class or metaclass method list. */
+export const objcDispatchImplementationSchema = z.strictObject({
+    class_name: z.string().min(1),
+    selector: z.string().min(1),
+    method_type: z.enum(["instance", "class"]),
+    implementation_address: z.string().nullable(),
+    location: nativeMetadataLocationSchema,
+    decode: nativeMetadataDecodeSchema,
+    evidence: z.array(nativeMetadataEvidenceSchema).min(1),
+});
+/** Swift protocol conformance and its associated witness-table location. */
+export const swiftConformanceSchema = z.strictObject({
+    type_name: z.string().min(1),
+    protocol_name: z.string().min(1),
+    module: z.string().nullable(),
+    witness_table: nativeMetadataLocationSchema,
+    location: nativeMetadataLocationSchema,
+    decode: nativeMetadataDecodeSchema,
+    evidence: z.array(nativeMetadataEvidenceSchema).min(1),
+});
+/** A typed slot in a Swift protocol witness table or class vtable. */
+export const swiftDispatchSlotSchema = z.strictObject({
+    owner: z.string().min(1),
+    table_kind: z.enum(["witness_table", "class_vtable"]),
+    slot_index: z.number().int().nonnegative(),
+    requirement: z.string().nullable(),
+    implementation: z.string().nullable(),
+    implementation_address: z.string().nullable(),
+    thunk_address: z.string().nullable(),
+    location: nativeMetadataLocationSchema,
+    decode: nativeMetadataDecodeSchema,
+    evidence: z.array(nativeMetadataEvidenceSchema).min(1),
+});
+/** Signed-relative pointer as stored in an Apple binary metadata structure. */
+export const relativePointerSchema = z.strictObject({
+    field: nativeMetadataLocationSchema,
+    target: nativeMetadataLocationSchema,
+    displacement: z.number().int(),
+    indirectable: z.boolean(),
+    indirect: z.boolean().nullable(),
+    decode: nativeMetadataDecodeSchema,
+    evidence: z.array(nativeMetadataEvidenceSchema).min(1),
+});
+/** A raw Swift-mangled symbol when a provider has not decoded its metadata. */
+export const swiftSymbolSchema = z.strictObject({
+    mangled_name: z.string().min(1),
+    address: z.string().min(1),
+    decode: nativeMetadataDecodeSchema,
+    evidence: z.array(nativeMetadataEvidenceSchema).min(1),
+});
+/** Per-facet coverage; empty arrays are meaningful only with this record. */
+export const nativeMetadataCoverageSchema = z.strictObject({
+    facet: z.string().min(1),
+    status: z.enum(["complete", "partial", "unsupported", "not_requested"]),
+    reason: z.string().nullable(),
+    examined: z.number().int().nonnegative(),
+    decoded: z.number().int().nonnegative(),
+});
 /** Swift declaration kind. */
 export const swiftDeclKindSchema = z.enum([
     "class",
@@ -107,8 +203,166 @@ export const objcSwiftMetadataSchema = z.strictObject({
     objc_classes: z.array(objcClassSchema).default([]),
     objc_protocols: z.array(objcProtocolSchema).default([]),
     swift_decls: z.array(swiftDeclSchema).default([]),
+    objc_ivars: z.array(objcIvarSchema).default([]),
+    objc_dispatch_implementations: z
+        .array(objcDispatchImplementationSchema)
+        .default([]),
+    swift_conformances: z.array(swiftConformanceSchema).default([]),
+    swift_dispatch_slots: z.array(swiftDispatchSlotSchema).default([]),
+    swift_symbols: z.array(swiftSymbolSchema).default([]),
+    relative_pointers: z.array(relativePointerSchema).default([]),
+    coverage: z.array(nativeMetadataCoverageSchema).default([]),
     db_save_result: dbSaveResultSchema.nullable(),
 });
+/** Provider and target identity for one normalized dispatch-metadata result. */
+export const nativeDispatchMetadataResultSchema = z.strictObject({
+    target_sha256: z
+        .string()
+        .regex(/^[a-f0-9]{64}$/u)
+        .nullable(),
+    provider: z.strictObject({
+        id: z.string().min(1),
+        name: z.string().min(1),
+        version: z.string().nullable(),
+    }),
+    analysis_profile_digest: z.string().min(1).nullable(),
+    result: objcSwiftMetadataSchema,
+});
+/** Decode only facts visible in a provider's existing name inventory. */
+export const inspectNativeDispatchMetadata = (names, maxRecords = 5_000) => {
+    const symbolEvidence = (name, address) => [
+        {
+            kind: "symbol",
+            description: `Provider symbol ${name}`,
+            location: { address, file_offset: null },
+            artifact_path: null,
+            artifact_sha256: null,
+        },
+    ];
+    const classNames = new Set();
+    const implementations = new Map();
+    const swiftSymbols = [];
+    const examinedNames = names.slice(0, maxRecords);
+    for (const entry of examinedNames) {
+        const classMatch = /(?:OBJC_CLASS_|OBJC_METACLASS_)\$_([^\s]+)/u.exec(entry.name);
+        if (classMatch?.[1] !== undefined)
+            classNames.add(classMatch[1]);
+        const methodMatch = /^([+-])\[([^\s\]]+)\s+([^\]]+)\]$/u.exec(entry.name);
+        if (methodMatch?.[1] !== undefined && methodMatch[2] && methodMatch[3]) {
+            const methodType = methodMatch[1] === "+" ? "class" : "instance";
+            const selector = methodMatch[3];
+            implementations.set(`${methodMatch[2]}:${selector}:${methodType}`, {
+                class_name: methodMatch[2],
+                selector,
+                method_type: methodType,
+                implementation_address: entry.address,
+                location: { address: entry.address, file_offset: null },
+                decode: { status: "partial", reason: "symbol_name_only" },
+                evidence: symbolEvidence(entry.name, entry.address),
+            });
+            classNames.add(methodMatch[2]);
+        }
+        if (/^(?:_?\$s|_Tt)/u.test(entry.name))
+            swiftSymbols.push({
+                mangled_name: entry.name,
+                address: entry.address,
+                decode: { status: "partial", reason: "mangled_symbol_not_demangled" },
+                evidence: symbolEvidence(entry.name, entry.address),
+            });
+    }
+    const methodsByClass = new Map();
+    for (const implementation of implementations.values()) {
+        const methods = methodsByClass.get(implementation.class_name) ?? [];
+        methods.push({
+            selector: implementation.selector,
+            method_type: implementation.method_type,
+            address: parseMetadataAddress(implementation.implementation_address),
+            is_required: false,
+            is_optional: false,
+        });
+        methodsByClass.set(implementation.class_name, methods);
+    }
+    const classes = [...classNames].sort().map((name) => ({
+        name,
+        super_class: null,
+        is_meta_class: false,
+        is_root_class: false,
+        methods: methodsByClass.get(name) ?? [],
+        properties: [],
+        protocols: [],
+        ivar_count: 0,
+        instance_size: null,
+    }));
+    const decodedImplementations = [...implementations.values()].sort((left, right) => `${left.class_name}:${left.selector}`.localeCompare(`${right.class_name}:${right.selector}`));
+    const swift = swiftSymbols.length > 0;
+    return objcSwiftMetadataSchema.parse({
+        objc_classes: classes,
+        objc_dispatch_implementations: decodedImplementations,
+        swift_symbols: swiftSymbols,
+        coverage: [
+            {
+                facet: "objc_class_symbols",
+                status: "partial",
+                reason: names.length > examinedNames.length
+                    ? "record_limit_reached_and_symbol_names_are_not_runtime_class_metadata"
+                    : "symbol_names_do_not_recover_all_runtime_class_metadata",
+                examined: examinedNames.length,
+                decoded: classes.length,
+            },
+            {
+                facet: "objc_dispatch_implementations",
+                status: decodedImplementations.length > 0 ? "partial" : "unsupported",
+                reason: names.length > examinedNames.length
+                    ? "record_limit_reached_and_only_symbolized_methods_are_resolved"
+                    : decodedImplementations.length > 0
+                        ? "only_symbolized_methods_are_resolved"
+                        : "provider_name_inventory_has_no_objc_method_symbols",
+                examined: examinedNames.length,
+                decoded: decodedImplementations.length,
+            },
+            {
+                facet: "objc_ivar_layouts",
+                status: "unsupported",
+                reason: "symbol_inventory_does_not_expose_runtime_ivar_layouts",
+                examined: 0,
+                decoded: 0,
+            },
+            {
+                facet: "swift_declarations",
+                status: swift ? "partial" : "unsupported",
+                reason: swift
+                    ? "symbols_are_not_demangled_declarations"
+                    : "no_swift_symbols_observed",
+                examined: swiftSymbols.length,
+                decoded: 0,
+            },
+            {
+                facet: "swift_dispatch_tables",
+                status: "unsupported",
+                reason: "provider_name_inventory_does_not_decode_witness_or_class_vtables",
+                examined: 0,
+                decoded: 0,
+            },
+            {
+                facet: "relative_pointers",
+                status: "unsupported",
+                reason: "provider_name_inventory_does_not_decode_binary_relative_pointers",
+                examined: 0,
+                decoded: 0,
+            },
+        ],
+        db_save_result: null,
+    });
+};
+const parseMetadataAddress = (address) => {
+    if (address === null)
+        return null;
+    const match = /(?:^|:)0x([0-9a-f]+)$/iu.exec(address);
+    if (match?.[1] === undefined)
+        return null;
+    const value = Number.parseInt(match[1], 16);
+    return Number.isSafeInteger(value) ? value : null;
+};
 /** Check if a selector name looks like a getter. */
 export function isGetterSelector(selector) {
     return /^[a-z][a-zA-Z0-9_]*$/u.test(selector) && !selector.includes(":");

package/dist/domain/peInspection.js

@@ -96,7 +96,7 @@ export const peManifestSchema = z.strictObject({
     /** Subsystem version. */
     subsystem_version: z.string().nullable(),
     /** Sections. */
-    sections: z.array(peSectionSchema).min(0).max(96),
+    sections: z.array(peSectionSchema),
     /** Imports. */
     imports: z.array(peImportSchema).default([]),
     /** Exports. */

package/dist/domain/permissionPolicy.js

@@ -1,5 +1,18 @@
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import { err, ok } from "./result.js";
+/** Canonical local capabilities governed by the shared REA permission policy. */
+export const PERMISSION_CAPABILITIES = [
+    "process_capture",
+    "browser_observe",
+    "browser_automate",
+    "electron_observe",
+    "electron_automate",
+    "v8_inspector_observe",
+    "artifact_extract",
+    "native_mount",
+    "javascript_replay",
+    "managed_runtime",
+];
 /** A proposed grant exceeds the administrator-owned maximum authority. */
 export class PermissionGrantError extends Error {
     reason;

package/dist/domain/processCapture.js

@@ -1,7 +1,8 @@
 import { z } from "zod";
 import { jsonValueSchema } from "./jsonValue.js";
-import { LEGACY_PROCESS_CAPTURE_MESSAGE, normalizationSchema, } from "./processScenario.js";
-import { PROCESS_REACTIVE_LIMITS } from "./processReactiveScenario.js";
+import { normalizationSchema } from "./processScenario.js";
+import { processReactiveRunSchema } from "./processCaptureReactiveSchema.js";
+import { collectProcessCaptureIssues } from "./processCaptureValidation.js";
 export * from "./processScenario.js";
 /** Capture collection whose members participate in global observation order. */
 export const PROCESS_CAPTURE_EVENT_COLLECTIONS = [
@@ -15,28 +16,56 @@ export const PROCESS_CAPTURE_EVENT_COLLECTIONS = [
     "protocol_events",
     "replay_transitions",
 ];
-const fileStateSchema = z.object({
+const fileStateShape = {
     path: z.string(),
-    type: z.enum(["file", "directory", "symlink", "other"]),
     mode: z.number().int().nonnegative(),
     size: z.number().int().nonnegative(),
-    sha256: z
-        .string()
-        .regex(/^[a-f0-9]{64}$/u)
-        .nullable(),
-    symlink_target: z.string().nullable(),
-});
-const fileEffectSchema = z.object({
-    path: z.string(),
-    status: z.enum(["created", "modified", "deleted", "unchanged"]),
-    before: fileStateSchema.nullable(),
-    after: fileStateSchema.nullable(),
-});
-/** Exact serialized shape of a bounded process capture. */
-export const processCaptureSchema = z.object({
-    schema_version: z.literal(4, {
-        error: LEGACY_PROCESS_CAPTURE_MESSAGE,
+};
+const fileStateSchema = z.discriminatedUnion("type", [
+    z.object({
+        ...fileStateShape,
+        type: z.literal("file"),
+        sha256: z
+            .string()
+            .regex(/^[a-f0-9]{64}$/u)
+            .nullable(),
+        symlink_target: z.null(),
+    }),
+    z.object({
+        ...fileStateShape,
+        type: z.literal("symlink"),
+        sha256: z.null(),
+        symlink_target: z.string(),
+    }),
+    z.object({
+        ...fileStateShape,
+        type: z.enum(["directory", "other"]),
+        sha256: z.null(),
+        symlink_target: z.null(),
     }),
+]);
+const fileEffectSchema = z.discriminatedUnion("status", [
+    z.object({
+        path: z.string(),
+        status: z.literal("created"),
+        before: z.null(),
+        after: fileStateSchema,
+    }),
+    z.object({
+        path: z.string(),
+        status: z.literal("deleted"),
+        before: fileStateSchema,
+        after: z.null(),
+    }),
+    z.object({
+        path: z.string(),
+        status: z.enum(["modified", "unchanged"]),
+        before: fileStateSchema,
+        after: fileStateSchema,
+    }),
+]);
+/** Exact serialized shape of a process capture. */
+const processCaptureShapeSchema = z.object({
     manifest: z.object({
         rea_version: z.string().min(1),
         provider_version: z.string().min(1),
@@ -86,11 +115,18 @@ export const processCaptureSchema = z.object({
         signal: z.number().int().nullable(),
         reason: z.enum(["exited", "timeout", "idle_timeout"]),
     }),
-    settlement: z.object({
-        state: z.enum(["quiesced", "alive_at_deadline", "unverifiable"]),
-        elapsed_ms: z.number().int().nonnegative(),
-        cleanup_outcome: z.enum(["not_required", "cleaned", "failed"]),
-    }),
+    settlement: z.discriminatedUnion("state", [
+        z.object({
+            state: z.literal("quiesced"),
+            elapsed_ms: z.number().int().nonnegative(),
+            cleanup_outcome: z.literal("not_required"),
+        }),
+        z.object({
+            state: z.enum(["alive_at_deadline", "unverifiable"]),
+            elapsed_ms: z.number().int().nonnegative(),
+            cleanup_outcome: z.enum(["cleaned", "failed"]),
+        }),
+    ]),
     process_samples: z.array(z.object({
         at_ms: z.number().int().nonnegative(),
         pid: z.number().int().positive(),
@@ -140,81 +176,13 @@ export const processCaptureSchema = z.object({
         .array(z.object({
         sequence: z.number().int().nonnegative(),
         at_ms: z.number().int().nonnegative(),
-        transition_id: z.string().min(1).max(64),
-        state_before: z.string().min(1).max(64),
-        state_after: z.string().min(1).max(64),
-        sensitive_aliases: z.array(z.string().min(1).max(64)).max(32),
+        transition_id: z.string().min(1),
+        state_before: z.string().min(1),
+        state_after: z.string().min(1),
+        sensitive_aliases: z.array(z.string().min(1)),
     }))
         .default([]),
-    reactive_run: z
-        .object({
-        status: z.enum(["running", "finished"]),
-        outcome: z
-            .enum([
-            "passed",
-            "predicate_timeout",
-            "scenario_deadline",
-            "ambiguous_match",
-            "action_rejected",
-            "target_lost",
-            "capture_incomplete",
-            "cancelled",
-            "cleanup_failed",
-        ])
-            .nullable(),
-        active_state: z.string().min(1).max(64),
-        controls: z
-            .array(z.object({
-            sequence: z.number().int().nonnegative(),
-            kind: z.enum([
-                "state_deadline",
-                "scenario_deadline",
-                "target_lost",
-                "cancelled",
-                "cleanup_failed",
-            ]),
-            after_capture_order: z.number().int().min(-1),
-        }))
-            .default([]),
-        transitions: z
-            .array(z.object({
-            sequence: z.number().int().nonnegative(),
-            transition_id: z.string().min(1).max(64),
-            state_before: z.string().min(1).max(64),
-            state_after: z.string().min(1).max(64).nullable(),
-            outcome: z
-                .enum([
-                "passed",
-                "predicate_timeout",
-                "scenario_deadline",
-                "ambiguous_match",
-                "action_rejected",
-                "target_lost",
-                "capture_incomplete",
-                "cancelled",
-                "cleanup_failed",
-            ])
-                .nullable(),
-            trigger_event_ids: z
-                .array(z.string().min(1))
-                .max(PROCESS_REACTIVE_LIMITS.predicates),
-            action_event_ids: z
-                .array(z.string().min(1))
-                .max(PROCESS_REACTIVE_LIMITS.actionsPerTransition),
-            action_types: z
-                .array(z.enum([
-                "send_input",
-                "resize",
-                "close_stdin",
-                "send_signal",
-                "checkpoint",
-            ]))
-                .max(PROCESS_REACTIVE_LIMITS.actionsPerTransition),
-        }))
-            .max(PROCESS_REACTIVE_LIMITS.transitions),
-    })
-        .nullable()
-        .default(null),
+    reactive_run: processReactiveRunSchema.nullable().default(null),
     event_journal: z
         .array(z.object({
         capture_order: z.number().int().nonnegative(),
@@ -246,20 +214,15 @@ export const processCaptureSchema = z.object({
         temporary_root: z.literal("removed"),
     }),
 });
-export { validateProcessCapture } from "./processCaptureValidation.js";
-import { validateProcessCapture } from "./processCaptureValidation.js";
-/** Parse unknown input as v4 and reject invalid commitments or semantics. */
-export const parseProcessCapture = (input) => {
-    if (typeof input === "object" &&
-        input !== null &&
-        "schema_version" in input &&
-        input.schema_version === 3)
-        throw new TypeError(LEGACY_PROCESS_CAPTURE_MESSAGE);
-    const capture = processCaptureSchema.parse(input);
-    const issues = validateProcessCapture(capture);
-    if (issues.length > 0)
-        throw new TypeError(`Invalid Process Capture v4: ${issues.map(({ path, message }) => `${path}: ${message}`).join("; ")}`);
-    return capture;
-};
+/** Exact serialized shape plus all process-capture semantic invariants. */
+export const processCaptureSchema = processCaptureShapeSchema.superRefine((capture, context) => {
+    for (const issue of collectProcessCaptureIssues(capture))
+        context.addIssue({
+            code: "custom",
+            path: issue.path.split("."),
+            message: issue.message,
+        });
+});
+export { parseProcessCapture } from "./processCaptureParsing.js";
 export { compareProcessCaptures, comparisonStatusSchema, deriveProcessComparisonStatus, PROCESS_COMPARISON_DIMENSIONS, processCaptureComparisonSchema, } from "./processComparison.js";
 export { compareProcessTraces, processTraceComparisonResultSchema, processTraceSourceSchema, processTraceSpecificationSchema, } from "./processTraceComparison.js";

package/dist/domain/processCaptureExample.js

@@ -0,0 +1,68 @@
+import { digestProcessCommitment } from "./processCapture.js";
+const normalization = {
+    paths: true,
+    pids: true,
+    ports: true,
+    time_bucket_ms: 10,
+    patterns: [],
+};
+const scenario = { executable_sha256: "0".repeat(64) };
+const comparisonContract = {};
+const shimPlan = [];
+const replayPlan = {};
+/** Minimal valid process capture retained as a public contract example. */
+export const EMPTY_PROCESS_CAPTURE_EXAMPLE = {
+    manifest: {
+        rea_version: "1.1.0",
+        provider_version: "3",
+        platform: "fixture",
+        architecture: "fixture",
+        pty_backend: "node-pty",
+        started_at: "2026-01-01T00:00:00.000Z",
+        completed_at: "2026-01-01T00:00:00.001Z",
+        scenario,
+        comparison_contract: comparisonContract,
+        shim_plan: shimPlan,
+        replay_plan: replayPlan,
+        full_scenario_sha256: digestProcessCommitment(scenario),
+        comparison_contract_sha256: digestProcessCommitment(comparisonContract),
+        executable_sha256: "0".repeat(64),
+        normalization_sha256: digestProcessCommitment(normalization),
+        shim_plan_sha256: digestProcessCommitment(shimPlan),
+        replay_plan_sha256: digestProcessCommitment(replayPlan),
+    },
+    normalization,
+    frames: [],
+    rendered_frames: [],
+    interaction_events: [],
+    exit: { code: 0, signal: null, reason: "exited" },
+    settlement: {
+        state: "quiesced",
+        elapsed_ms: 50,
+        cleanup_outcome: "not_required",
+    },
+    process_samples: [],
+    filesystem_checkpoints: [
+        { name: "before", at_ms: 0, files: [], effects: [], truncated: false },
+        {
+            name: "after_settlement",
+            at_ms: 50,
+            files: [],
+            effects: [],
+            truncated: false,
+        },
+    ],
+    shim_events: [],
+    protocol_events: [],
+    replay_transitions: [],
+    files_before: [],
+    files_after: [],
+    filesystem_effects: [],
+    truncated: false,
+    limitations: [],
+    residual_unknowns: [],
+    cleanup: {
+        owned_process_group: "verified",
+        temporary_root: "removed",
+    },
+};

package/dist/domain/processCaptureParsing.js

@@ -0,0 +1,21 @@
+import { processCaptureSchema, } from "./processCapture.js";
+const verifiedCaptures = new WeakSet();
+const isVerifiedCapture = (capture) => verifiedCaptures.has(capture);
+const attachProof = (capture) => {
+    verifiedCaptures.add(capture);
+    if (isVerifiedCapture(capture))
+        return capture;
+    throw new TypeError("Process Capture proof ownership failed");
+};
+/** Parse unknown input and reject invalid commitments or semantics. */
+export const parseProcessCapture = (input) => {
+    const parsed = processCaptureSchema.safeParse(input);
+    if (parsed.success)
+        return attachProof(parsed.data);
+    const issues = parsed.error.issues.flatMap((issue) => issue.code === "custom"
+        ? [{ path: issue.path.join("."), message: issue.message }]
+        : []);
+    if (issues.length > 0)
+        throw new TypeError(`Invalid process capture: ${issues.map(({ path, message }) => `${path}: ${message}`).join("; ")}`);
+    throw parsed.error;
+};

package/dist/domain/processCaptureReactiveSchema.js

@@ -0,0 +1,68 @@
+import { z } from "zod";
+const processReactiveOutcomeSchema = z.enum([
+    "passed",
+    "predicate_timeout",
+    "scenario_deadline",
+    "ambiguous_match",
+    "action_rejected",
+    "target_lost",
+    "capture_incomplete",
+    "cancelled",
+    "cleanup_failed",
+]);
+const processReactiveTransitionShape = {
+    sequence: z.number().int().nonnegative(),
+    transition_id: z.string().min(1),
+    state_before: z.string().min(1),
+    trigger_event_ids: z.array(z.string().min(1)),
+    action_event_ids: z.array(z.string().min(1)),
+    action_types: z.array(z.enum([
+        "send_input",
+        "resize",
+        "close_stdin",
+        "send_signal",
+        "checkpoint",
+    ])),
+};
+const processReactiveTransitionSchema = z.union([
+    z.object({
+        ...processReactiveTransitionShape,
+        state_after: z.string().min(1),
+        outcome: z.null(),
+    }),
+    z.object({
+        ...processReactiveTransitionShape,
+        state_after: z.null(),
+        outcome: z.literal("passed"),
+    }),
+]);
+const processReactiveRunShape = {
+    active_state: z.string().min(1),
+    controls: z
+        .array(z.object({
+        sequence: z.number().int().nonnegative(),
+        kind: z.enum([
+            "state_deadline",
+            "scenario_deadline",
+            "target_lost",
+            "cancelled",
+            "cleanup_failed",
+        ]),
+        after_capture_order: z.number().int().min(-1),
+    }))
+        .default([]),
+    transitions: z.array(processReactiveTransitionSchema),
+};
+/** Serialized reactive reducer state admitted by process capture. */
+export const processReactiveRunSchema = z.discriminatedUnion("status", [
+    z.object({
+        status: z.literal("running"),
+        outcome: z.null(),
+        ...processReactiveRunShape,
+    }),
+    z.object({
+        status: z.literal("finished"),
+        outcome: processReactiveOutcomeSchema,
+        ...processReactiveRunShape,
+    }),
+]);