@openprose/reactor-cradle 0.1.0-rc.1

package/dist/replay/model-gateway.d.ts

@@ -0,0 +1,25 @@
+import type { ReactorModelGatewayAdapterV0, ReactorModelGatewayRequestV0, ReactorModelGatewayResponseV0 } from "@openprose/reactor/sdk";
+import type { ContentHashV0 } from "@openprose/reactor/receipt";
+export declare const MODEL_GATEWAY_CASSETTE_SCHEMA_V0: "openprose.reactor.model-gateway-cassette";
+export declare const MODEL_GATEWAY_CASSETTE_VERSION_V0: 0;
+export interface RecordedModelGatewayExchangeV0 {
+    readonly request: ReactorModelGatewayRequestV0;
+    readonly request_canonical: string;
+    readonly request_hash: ContentHashV0;
+    readonly response: ReactorModelGatewayResponseV0;
+    readonly response_canonical: string;
+    readonly response_hash: ContentHashV0;
+}
+export interface ModelGatewayCassetteV0 {
+    readonly schema: typeof MODEL_GATEWAY_CASSETTE_SCHEMA_V0;
+    readonly v: typeof MODEL_GATEWAY_CASSETTE_VERSION_V0;
+    readonly exchanges: readonly RecordedModelGatewayExchangeV0[];
+}
+export type ModelGatewayHandlerV0 = (request: ReactorModelGatewayRequestV0) => ReactorModelGatewayResponseV0;
+export interface RecordingModelGatewayV0 {
+    readonly adapter: ReactorModelGatewayAdapterV0;
+    readonly cassette: ModelGatewayCassetteV0;
+}
+export declare function createRecordingModelGatewayV0(handler: ModelGatewayHandlerV0): RecordingModelGatewayV0;
+export declare function createReplayModelGatewayV0(cassette: ModelGatewayCassetteV0): ReactorModelGatewayAdapterV0;
+//# sourceMappingURL=model-gateway.d.ts.map

package/dist/replay/model-gateway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-gateway.d.ts","sourceRoot":"","sources":["../../src/replay/model-gateway.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,4BAA4B,EAC5B,4BAA4B,EAC5B,6BAA6B,EAC9B,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAEhE,eAAO,MAAM,gCAAgC,EAC3C,0CAAmD,CAAC;AACtD,eAAO,MAAM,iCAAiC,EAAG,CAAU,CAAC;AAE5D,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,OAAO,EAAE,4BAA4B,CAAC;IAC/C,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;IACnC,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,6BAA6B,CAAC;IACjD,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC;CACvC;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,EAAE,OAAO,gCAAgC,CAAC;IACzD,QAAQ,CAAC,CAAC,EAAE,OAAO,iCAAiC,CAAC;IACrD,QAAQ,CAAC,SAAS,EAAE,SAAS,8BAA8B,EAAE,CAAC;CAC/D;AAED,MAAM,MAAM,qBAAqB,GAAG,CAClC,OAAO,EAAE,4BAA4B,KAClC,6BAA6B,CAAC;AAEnC,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,OAAO,EAAE,4BAA4B,CAAC;IAC/C,QAAQ,CAAC,QAAQ,EAAE,sBAAsB,CAAC;CAC3C;AAQD,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,qBAAqB,GAC7B,uBAAuB,CAqCzB;AAED,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,sBAAsB,GAC/B,4BAA4B,CA4B9B"}

package/dist/replay/model-gateway.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODEL_GATEWAY_CASSETTE_VERSION_V0 = exports.MODEL_GATEWAY_CASSETTE_SCHEMA_V0 = void 0;
+exports.createRecordingModelGatewayV0 = createRecordingModelGatewayV0;
+exports.createReplayModelGatewayV0 = createReplayModelGatewayV0;
+const node_crypto_1 = require("node:crypto");
+exports.MODEL_GATEWAY_CASSETTE_SCHEMA_V0 = "openprose.reactor.model-gateway-cassette";
+exports.MODEL_GATEWAY_CASSETTE_VERSION_V0 = 0;
+function createRecordingModelGatewayV0(handler) {
+    const exchanges = [];
+    const adapter = {
+        invoke(request) {
+            const requestSnapshot = createCanonicalSnapshot(request, "model gateway request");
+            const response = handler(cloneFromCanonical(requestSnapshot));
+            const responseSnapshot = createCanonicalSnapshot(response, "model gateway response");
+            exchanges.push({
+                request: requestSnapshot.value,
+                request_canonical: requestSnapshot.canonical,
+                request_hash: requestSnapshot.hash,
+                response: responseSnapshot.value,
+                response_canonical: responseSnapshot.canonical,
+                response_hash: responseSnapshot.hash,
+            });
+            return cloneFromCanonical(responseSnapshot);
+        },
+    };
+    return {
+        adapter,
+        get cassette() {
+            return cloneCassette({
+                schema: exports.MODEL_GATEWAY_CASSETTE_SCHEMA_V0,
+                v: exports.MODEL_GATEWAY_CASSETTE_VERSION_V0,
+                exchanges,
+            });
+        },
+    };
+}
+function createReplayModelGatewayV0(cassette) {
+    const replayCassette = cloneCassette(cassette);
+    let cursor = 0;
+    return {
+        invoke(request) {
+            const expected = replayCassette.exchanges[cursor];
+            if (expected === undefined) {
+                throw new Error(`model gateway replay exhausted at exchange ${cursor}; cassette has ${replayCassette.exchanges.length} exchanges`);
+            }
+            const actual = createCanonicalSnapshot(request, "model gateway request");
+            if (actual.canonical !== expected.request_canonical) {
+                throw new Error(`unexpected model gateway request at exchange ${cursor}: expected ${expected.request_hash}, received ${actual.hash}`);
+            }
+            cursor += 1;
+            return cloneFromCanonical({
+                value: expected.response,
+                canonical: expected.response_canonical,
+                hash: expected.response_hash,
+            });
+        },
+    };
+}
+function cloneCassette(cassette) {
+    if (cassette.schema !== exports.MODEL_GATEWAY_CASSETTE_SCHEMA_V0) {
+        throw new Error("model gateway cassette schema must be openprose.reactor.model-gateway-cassette");
+    }
+    if (cassette.v !== exports.MODEL_GATEWAY_CASSETTE_VERSION_V0) {
+        throw new Error("model gateway cassette version must be 0");
+    }
+    if (!Array.isArray(cassette.exchanges)) {
+        throw new Error("model gateway cassette exchanges must be an array");
+    }
+    return {
+        schema: exports.MODEL_GATEWAY_CASSETTE_SCHEMA_V0,
+        v: exports.MODEL_GATEWAY_CASSETTE_VERSION_V0,
+        exchanges: cassette.exchanges.map((exchange, index) => cloneExchange(exchange, index)),
+    };
+}
+function cloneExchange(exchange, index) {
+    const request = createCanonicalSnapshot(exchange.request, `model gateway cassette exchange ${index} request`);
+    const response = createCanonicalSnapshot(exchange.response, `model gateway cassette exchange ${index} response`);
+    assertStoredCanonical(exchange.request_canonical, request.canonical, `model gateway cassette exchange ${index} request_canonical`);
+    assertStoredHash(exchange.request_hash, request.hash, `model gateway cassette exchange ${index} request_hash`);
+    assertStoredCanonical(exchange.response_canonical, response.canonical, `model gateway cassette exchange ${index} response_canonical`);
+    assertStoredHash(exchange.response_hash, response.hash, `model gateway cassette exchange ${index} response_hash`);
+    return {
+        request: request.value,
+        request_canonical: request.canonical,
+        request_hash: request.hash,
+        response: response.value,
+        response_canonical: response.canonical,
+        response_hash: response.hash,
+    };
+}
+function createCanonicalSnapshot(value, label) {
+    try {
+        const canonical = renderCanonical(value);
+        return {
+            value: JSON.parse(canonical),
+            canonical,
+            hash: hashCanonical(canonical),
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "canonicalization failed";
+        throw new Error(`${label} must be canonical JSON: ${message}`);
+    }
+}
+function cloneFromCanonical(snapshot) {
+    return JSON.parse(snapshot.canonical);
+}
+function assertStoredCanonical(stored, actual, label) {
+    if (stored !== actual) {
+        throw new Error(`${label} does not match canonical payload`);
+    }
+}
+function assertStoredHash(stored, actual, label) {
+    if (stored !== actual) {
+        throw new Error(`${label} does not match canonical payload hash`);
+    }
+}
+function hashCanonical(canonical) {
+    return `sha256:${(0, node_crypto_1.createHash)("sha256").update(canonical).digest("hex")}`;
+}
+function renderCanonical(value) {
+    if (value === null) {
+        return "null";
+    }
+    switch (typeof value) {
+        case "boolean":
+            return value ? "true" : "false";
+        case "number":
+            if (!Number.isFinite(value)) {
+                throw new TypeError("Cannot canonicalize non-finite numbers");
+            }
+            return JSON.stringify(value);
+        case "string":
+            return JSON.stringify(value);
+        case "object":
+            if (Array.isArray(value)) {
+                return `[${value.map((item) => renderCanonical(item)).join(",")}]`;
+            }
+            if (!isPlainRecord(value)) {
+                throw new TypeError("Cannot canonicalize non-plain objects");
+            }
+            return renderCanonicalObject(value);
+        case "undefined":
+        case "bigint":
+        case "function":
+        case "symbol":
+            throw new TypeError(`Cannot canonicalize ${typeof value}`);
+    }
+    throw new TypeError("Cannot canonicalize unknown value");
+}
+function renderCanonicalObject(value) {
+    const fields = [];
+    for (const key of Object.keys(value).sort()) {
+        const item = value[key];
+        if (item === undefined) {
+            throw new TypeError(`Cannot canonicalize undefined field ${key}`);
+        }
+        fields.push(`${JSON.stringify(key)}:${renderCanonical(item)}`);
+    }
+    return `{${fields.join(",")}}`;
+}
+function isPlainRecord(value) {
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/dist/replay/parity.d.ts

@@ -0,0 +1,110 @@
+import type { ContentHashV0 } from "@openprose/reactor/receipt";
+export declare const REPLAY_COMPARABLE_OUTPUT_SCHEMA_V0: "openprose.reactor-cradle.replay-comparable-output";
+export declare const REPLAY_COMPARABLE_OUTPUT_VERSION_V0: 0;
+export declare const REPLAY_PARITY_MATRIX_SCHEMA_V0: "openprose.reactor-cradle.replay-parity-matrix";
+export declare const REPLAY_PARITY_MATRIX_VERSION_V0: 0;
+export type ReplayComparableJsonValueV0 = null | boolean | number | string | readonly ReplayComparableJsonValueV0[] | {
+    readonly [key: string]: ReplayComparableJsonValueV0;
+};
+export interface ReplayComparableScenarioOutputInputV0 {
+    readonly scenario_id: string;
+    readonly world_profile: string;
+    readonly cassette_path: string;
+    readonly initial_instant: string;
+    readonly final_instant: string;
+    readonly trace: unknown;
+    readonly receipt_log: unknown;
+    readonly expected_relationships?: unknown;
+    readonly decisions?: unknown;
+    readonly registry?: unknown;
+}
+export interface ReplayComparableScenarioOutputV0 {
+    readonly schema: typeof REPLAY_COMPARABLE_OUTPUT_SCHEMA_V0;
+    readonly v: typeof REPLAY_COMPARABLE_OUTPUT_VERSION_V0;
+    readonly scenario_id: string;
+    readonly world_profile: string;
+    readonly cassette_path: string;
+    readonly initial_instant: string;
+    readonly final_instant: string;
+    readonly trace: ReplayComparableJsonValueV0;
+    readonly receipt_log: ReplayComparableJsonValueV0;
+    readonly expected_relationships: ReplayComparableJsonValueV0;
+    readonly decisions?: ReplayComparableJsonValueV0;
+    readonly registry?: ReplayComparableJsonValueV0;
+}
+export interface ReplayComparableSnapshotV0 {
+    readonly output: ReplayComparableScenarioOutputV0;
+    readonly bytes: string;
+    readonly content_hash: ContentHashV0;
+    readonly byte_length: number;
+}
+export type ReplayByteIdenticalCheckV0 = ReplayByteIdenticalPassV0 | ReplayByteIdenticalFailV0;
+export interface ReplayByteIdenticalPassV0 {
+    readonly ok: true;
+    readonly relationship: "replay-byte-identical";
+    readonly expected_hash: ContentHashV0;
+    readonly actual_hash: ContentHashV0;
+    readonly byte_length: number;
+    readonly evidence_path: "$";
+}
+export interface ReplayByteIdenticalFailV0 {
+    readonly ok: false;
+    readonly relationship: "replay-byte-identical";
+    readonly expected_hash: ContentHashV0;
+    readonly actual_hash: ContentHashV0;
+    readonly expected_bytes: string;
+    readonly actual_bytes: string;
+    readonly evidence_path: "$";
+    readonly reason: string;
+}
+export type ReplayParityAdapterNameV0 = "deterministic-in-memory" | "filesystem" | "postgres";
+export type ReplayParityStorageAdapterV0 = "memory" | "fs" | "pg";
+export type ReplayParityAdapterStatusV0 = "ready" | "future";
+export interface ReplayParityAdapterRowV0 {
+    readonly name: ReplayParityAdapterNameV0;
+    readonly storage_adapter: ReplayParityStorageAdapterV0;
+    readonly status: ReplayParityAdapterStatusV0;
+    readonly reason: string;
+}
+export declare const REPLAY_PARITY_MATRIX_ROWS_V0: readonly ReplayParityAdapterRowV0[];
+export interface ReplayParityMatrixInputV0 {
+    readonly baseline: ReplayComparableScenarioOutputInputV0;
+    readonly rows?: readonly ReplayParityAdapterRowV0[];
+    readonly runAdapter: (row: ReplayParityAdapterRowV0) => ReplayComparableScenarioOutputInputV0;
+}
+export interface ReplayParityMatrixResultV0 {
+    readonly schema: typeof REPLAY_PARITY_MATRIX_SCHEMA_V0;
+    readonly v: typeof REPLAY_PARITY_MATRIX_VERSION_V0;
+    readonly relationship: "cross-adapter-parity";
+    readonly ok: boolean;
+    readonly ready_rows_run: number;
+    readonly future_rows: number;
+    readonly rows: readonly ReplayParityRowResultV0[];
+}
+export type ReplayParityRowResultV0 = ReplayParityReadyPassV0 | ReplayParityReadyFailV0 | ReplayParityFutureRowV0;
+export interface ReplayParityReadyPassV0 {
+    readonly adapter_name: ReplayParityAdapterNameV0;
+    readonly storage_adapter: ReplayParityStorageAdapterV0;
+    readonly status: "passed";
+    readonly check: ReplayByteIdenticalPassV0;
+}
+export interface ReplayParityReadyFailV0 {
+    readonly adapter_name: ReplayParityAdapterNameV0;
+    readonly storage_adapter: ReplayParityStorageAdapterV0;
+    readonly status: "failed";
+    readonly reason: string;
+    readonly check?: ReplayByteIdenticalFailV0;
+}
+export interface ReplayParityFutureRowV0 {
+    readonly adapter_name: ReplayParityAdapterNameV0;
+    readonly storage_adapter: ReplayParityStorageAdapterV0;
+    readonly status: "future";
+    readonly reason: string;
+}
+export declare function createReplayComparableOutputV0(input: ReplayComparableScenarioOutputInputV0): ReplayComparableScenarioOutputV0;
+export declare function snapshotReplayComparableOutputV0(input: ReplayComparableScenarioOutputInputV0): ReplayComparableSnapshotV0;
+export declare function compareReplayByteIdenticalV0(expected: ReplayComparableScenarioOutputInputV0, actual: ReplayComparableScenarioOutputInputV0): ReplayByteIdenticalCheckV0;
+export declare function assertReplayByteIdenticalV0(expected: ReplayComparableScenarioOutputInputV0, actual: ReplayComparableScenarioOutputInputV0): ReplayByteIdenticalPassV0;
+export declare function runReplayParityMatrixV0(input: ReplayParityMatrixInputV0): ReplayParityMatrixResultV0;
+export declare function assertReplayParityMatrixV0(input: ReplayParityMatrixInputV0): ReplayParityMatrixResultV0;
+//# sourceMappingURL=parity.d.ts.map

package/dist/replay/parity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parity.d.ts","sourceRoot":"","sources":["../../src/replay/parity.ts"],"names":[],"mappings":"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"}

package/dist/replay/parity.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REPLAY_PARITY_MATRIX_ROWS_V0 = exports.REPLAY_PARITY_MATRIX_VERSION_V0 = exports.REPLAY_PARITY_MATRIX_SCHEMA_V0 = exports.REPLAY_COMPARABLE_OUTPUT_VERSION_V0 = exports.REPLAY_COMPARABLE_OUTPUT_SCHEMA_V0 = void 0;
+exports.createReplayComparableOutputV0 = createReplayComparableOutputV0;
+exports.snapshotReplayComparableOutputV0 = snapshotReplayComparableOutputV0;
+exports.compareReplayByteIdenticalV0 = compareReplayByteIdenticalV0;
+exports.assertReplayByteIdenticalV0 = assertReplayByteIdenticalV0;
+exports.runReplayParityMatrixV0 = runReplayParityMatrixV0;
+exports.assertReplayParityMatrixV0 = assertReplayParityMatrixV0;
+const node_crypto_1 = require("node:crypto");
+exports.REPLAY_COMPARABLE_OUTPUT_SCHEMA_V0 = "openprose.reactor-cradle.replay-comparable-output";
+exports.REPLAY_COMPARABLE_OUTPUT_VERSION_V0 = 0;
+exports.REPLAY_PARITY_MATRIX_SCHEMA_V0 = "openprose.reactor-cradle.replay-parity-matrix";
+exports.REPLAY_PARITY_MATRIX_VERSION_V0 = 0;
+exports.REPLAY_PARITY_MATRIX_ROWS_V0 = Object.freeze([
+    Object.freeze({
+        name: "deterministic-in-memory",
+        storage_adapter: "memory",
+        status: "ready",
+        reason: "C3 deterministic row backed by in-memory doubles",
+    }),
+    Object.freeze({
+        name: "filesystem",
+        storage_adapter: "fs",
+        status: "ready",
+        reason: "durable filesystem adapter row backed by deterministic JSON files",
+    }),
+    Object.freeze({
+        name: "postgres",
+        storage_adapter: "pg",
+        status: "future",
+        reason: "future Postgres adapter parity row; not implemented in C3",
+    }),
+]);
+function createReplayComparableOutputV0(input) {
+    assertNonEmptyString(input.scenario_id, "scenario_id");
+    assertNonEmptyString(input.world_profile, "world_profile");
+    assertNonEmptyString(input.cassette_path, "cassette_path");
+    assertNonEmptyString(input.initial_instant, "initial_instant");
+    assertNonEmptyString(input.final_instant, "final_instant");
+    const base = {
+        schema: exports.REPLAY_COMPARABLE_OUTPUT_SCHEMA_V0,
+        v: exports.REPLAY_COMPARABLE_OUTPUT_VERSION_V0,
+        scenario_id: input.scenario_id,
+        world_profile: input.world_profile,
+        cassette_path: input.cassette_path,
+        initial_instant: input.initial_instant,
+        final_instant: input.final_instant,
+        trace: toComparableJsonValue(input.trace, "trace"),
+        receipt_log: toComparableJsonValue(input.receipt_log, "receipt_log"),
+        expected_relationships: toComparableJsonValue(input.expected_relationships ?? [], "expected_relationships"),
+    };
+    return {
+        ...base,
+        ...(input.decisions === undefined
+            ? {}
+            : { decisions: toComparableJsonValue(input.decisions, "decisions") }),
+        ...(input.registry === undefined
+            ? {}
+            : { registry: toComparableJsonValue(input.registry, "registry") }),
+    };
+}
+function snapshotReplayComparableOutputV0(input) {
+    const output = createReplayComparableOutputV0(input);
+    const bytes = renderCanonical(output);
+    return {
+        output,
+        bytes,
+        content_hash: hashCanonical(bytes),
+        byte_length: Buffer.byteLength(bytes, "utf8"),
+    };
+}
+function compareReplayByteIdenticalV0(expected, actual) {
+    const expectedSnapshot = snapshotReplayComparableOutputV0(expected);
+    const actualSnapshot = snapshotReplayComparableOutputV0(actual);
+    if (expectedSnapshot.bytes === actualSnapshot.bytes) {
+        return {
+            ok: true,
+            relationship: "replay-byte-identical",
+            expected_hash: expectedSnapshot.content_hash,
+            actual_hash: actualSnapshot.content_hash,
+            byte_length: expectedSnapshot.byte_length,
+            evidence_path: "$",
+        };
+    }
+    return {
+        ok: false,
+        relationship: "replay-byte-identical",
+        expected_hash: expectedSnapshot.content_hash,
+        actual_hash: actualSnapshot.content_hash,
+        expected_bytes: expectedSnapshot.bytes,
+        actual_bytes: actualSnapshot.bytes,
+        evidence_path: "$",
+        reason: "comparable scenario output bytes differ",
+    };
+}
+function assertReplayByteIdenticalV0(expected, actual) {
+    const check = compareReplayByteIdenticalV0(expected, actual);
+    if (!check.ok) {
+        throw new Error(`replay-byte-identical failed: expected ${check.expected_hash}, received ${check.actual_hash}`);
+    }
+    return check;
+}
+function runReplayParityMatrixV0(input) {
+    const rows = input.rows ?? exports.REPLAY_PARITY_MATRIX_ROWS_V0;
+    const results = rows.map((row) => runParityRow(row, input));
+    const readyRowsRun = results.filter((result) => result.status === "passed" || result.status === "failed").length;
+    const futureRows = results.filter((result) => result.status === "future").length;
+    const failedRows = results.filter((result) => result.status === "failed");
+    return {
+        schema: exports.REPLAY_PARITY_MATRIX_SCHEMA_V0,
+        v: exports.REPLAY_PARITY_MATRIX_VERSION_V0,
+        relationship: "cross-adapter-parity",
+        ok: readyRowsRun > 0 && failedRows.length === 0,
+        ready_rows_run: readyRowsRun,
+        future_rows: futureRows,
+        rows: Object.freeze(results),
+    };
+}
+function assertReplayParityMatrixV0(input) {
+    const result = runReplayParityMatrixV0(input);
+    if (!result.ok) {
+        throw new Error("cross-adapter-parity failed");
+    }
+    return result;
+}
+function runParityRow(row, input) {
+    if (row.status === "future") {
+        return {
+            adapter_name: row.name,
+            storage_adapter: row.storage_adapter,
+            status: "future",
+            reason: row.reason,
+        };
+    }
+    try {
+        const check = compareReplayByteIdenticalV0(input.baseline, input.runAdapter(row));
+        if (check.ok) {
+            return {
+                adapter_name: row.name,
+                storage_adapter: row.storage_adapter,
+                status: "passed",
+                check,
+            };
+        }
+        return {
+            adapter_name: row.name,
+            storage_adapter: row.storage_adapter,
+            status: "failed",
+            reason: check.reason,
+            check,
+        };
+    }
+    catch (error) {
+        return {
+            adapter_name: row.name,
+            storage_adapter: row.storage_adapter,
+            status: "failed",
+            reason: error instanceof Error ? error.message : "adapter row failed",
+        };
+    }
+}
+function toComparableJsonValue(value, label) {
+    return createCanonicalSnapshot(value, label).value;
+}
+function createCanonicalSnapshot(value, label) {
+    try {
+        const canonical = renderCanonical(value);
+        return {
+            value: JSON.parse(canonical),
+            canonical,
+            hash: hashCanonical(canonical),
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "canonicalization failed";
+        throw new Error(`${label} must be comparable canonical JSON: ${message}`);
+    }
+}
+function hashCanonical(canonical) {
+    return `sha256:${(0, node_crypto_1.createHash)("sha256").update(canonical).digest("hex")}`;
+}
+function renderCanonical(value) {
+    if (value === null) {
+        return "null";
+    }
+    switch (typeof value) {
+        case "boolean":
+            return value ? "true" : "false";
+        case "number":
+            if (!Number.isFinite(value)) {
+                throw new TypeError("Cannot canonicalize non-finite numbers");
+            }
+            return JSON.stringify(value);
+        case "string":
+            return JSON.stringify(value);
+        case "object":
+            if (Array.isArray(value)) {
+                return `[${value.map((item) => renderCanonical(item)).join(",")}]`;
+            }
+            if (!isPlainRecord(value)) {
+                throw new TypeError("Cannot canonicalize non-plain objects");
+            }
+            return renderCanonicalObject(value);
+        case "undefined":
+        case "bigint":
+        case "function":
+        case "symbol":
+            throw new TypeError(`Cannot canonicalize ${typeof value}`);
+    }
+    throw new TypeError("Cannot canonicalize unknown value");
+}
+function renderCanonicalObject(value) {
+    const fields = [];
+    for (const key of Object.keys(value).sort()) {
+        const item = value[key];
+        if (item === undefined) {
+            throw new TypeError(`Cannot canonicalize undefined field ${key}`);
+        }
+        fields.push(`${JSON.stringify(key)}:${renderCanonical(item)}`);
+    }
+    return `{${fields.join(",")}}`;
+}
+function assertNonEmptyString(value, label) {
+    if (value.length === 0) {
+        throw new Error(`${label} must be non-empty`);
+    }
+}
+function isPlainRecord(value) {
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/dist/rollback/index.d.ts

@@ -0,0 +1,106 @@
+import type { CompiledEvidencePlan, DeepRoamDiscovery, DeepRoamReconciliation, ShallowEvidencePlanResult } from "@openprose/reactor/evidence-plan";
+import type { AuthoredPolicyArtifactV0 } from "@openprose/reactor/policy";
+import type { ContentHashV0, ReceiptV0 } from "@openprose/reactor/receipt";
+import { type NormalizedPolicyRecompileDecisionV0, type PlanPolicyRecompileV0 } from "../recompile";
+export declare const POLICY_ROLLBACK_D2_SCENARIO_SCHEMA_V0: "openprose.reactor-cradle.rollback-d2-scenario";
+export declare const POLICY_ROLLBACK_D2_SCENARIO_VERSION_V0: 0;
+export declare const PLAN_INCOMPLETE_D2_SCENARIO_SCHEMA_V0: "openprose.reactor-cradle.plan-incomplete-d2-scenario";
+export declare const PLAN_INCOMPLETE_D2_SCENARIO_VERSION_V0: 0;
+export declare const ROLLBACK_D2_RESPONSIBILITY_ID: "incident-channel-current-briefing";
+export declare const PLAN_INCOMPLETE_D2_MISSING_SOURCE_ID: "crm-owner-map";
+export declare const PLAN_INCOMPLETE_D2_BACKSTOP_FACT: "kernel.deep_shallow_contradiction_count_7d";
+export type PolicyRollbackDecisionOutcomeV0 = "rollback" | "keep-current" | "no-last-known-good";
+export type PlanPolicyRollbackV0 = (input: PolicyRollbackPlanInputV0) => Promise<unknown> | unknown;
+export interface RecordedPolicyTripSummaryV0 {
+    readonly policy_revision: string;
+    readonly judged_activations_before_trip: number;
+    readonly activated_at: string;
+    readonly first_trip_at: string;
+}
+export interface RecordedPolicyRollbackD2ScenarioV0 {
+    readonly schema: typeof POLICY_ROLLBACK_D2_SCENARIO_SCHEMA_V0;
+    readonly v: typeof POLICY_ROLLBACK_D2_SCENARIO_VERSION_V0;
+    readonly responsibility_id: string;
+    readonly contract_revision: ContentHashV0;
+    readonly as_of: string;
+    readonly fresh_policy: RecordedPolicyTripSummaryV0;
+    readonly last_known_good_policy: RecordedPolicyTripSummaryV0;
+}
+export interface PolicyRollbackPlanInputV0 {
+    readonly responsibility_id: string;
+    readonly contract_revision: ContentHashV0;
+    readonly as_of: string;
+    readonly fresh_policy_revision: string;
+    readonly fresh_policy_judged_activations_before_trip: number;
+    readonly last_known_good_revision?: string;
+    readonly last_known_good_judged_activations_before_trip?: number;
+    readonly policy_trip_history: readonly RecordedPolicyTripSummaryV0[];
+}
+export interface NormalizedPolicyRollbackDecisionV0 {
+    readonly outcome: PolicyRollbackDecisionOutcomeV0;
+    readonly fresh_policy_revision: string;
+    readonly fresh_policy_judged_activations_before_trip: number;
+    readonly last_known_good_revision?: string;
+    readonly last_known_good_judged_activations_before_trip?: number;
+    readonly target_policy_revision?: string;
+    readonly raw: unknown;
+}
+export interface RecordedPolicyRollbackD2ProofV0 {
+    readonly scenario: RecordedPolicyRollbackD2ScenarioV0;
+    readonly decision: NormalizedPolicyRollbackDecisionV0;
+    readonly gateway_invocations: {
+        readonly agent_launch_count: 0;
+        readonly model_gateway_invocation_count: 0;
+    };
+}
+export interface RunRecordedPolicyRollbackD2ProofInputV0 {
+    readonly planPolicyRollbackV0: PlanPolicyRollbackV0;
+    readonly scenario?: RecordedPolicyRollbackD2ScenarioV0;
+}
+export interface RecordedPlanIncompleteD2ScenarioV0 {
+    readonly schema: typeof PLAN_INCOMPLETE_D2_SCENARIO_SCHEMA_V0;
+    readonly v: typeof PLAN_INCOMPLETE_D2_SCENARIO_VERSION_V0;
+    readonly responsibility_id: string;
+    readonly contract_revision: ContentHashV0;
+    readonly as_of: string;
+    readonly last_recompile_at: string;
+    readonly last_policy_revalidated_at: string;
+    readonly last_unforced_deep_at: string;
+    readonly incomplete_plan: CompiledEvidencePlan;
+    readonly planned_receipt: ReceiptV0;
+    readonly plan_age_receipt: ReceiptV0;
+    readonly missing_dependency_receipt: ReceiptV0;
+    readonly plan_incomplete_receipt: ReceiptV0;
+    readonly deep_roam_discovery: DeepRoamDiscovery;
+    readonly policy_artifact: AuthoredPolicyArtifactV0;
+    readonly policy_artifact_bytes: string;
+    readonly policy_artifact_content_hash: ContentHashV0;
+    readonly receipt_history_after_discovery: readonly ReceiptV0[];
+}
+export interface RecordedPlanIncompleteD2ProofV0 {
+    readonly scenario: RecordedPlanIncompleteD2ScenarioV0;
+    readonly shallow: Extract<ShallowEvidencePlanResult, {
+        outcome: "ready";
+    }>;
+    readonly deep_roam: Extract<DeepRoamReconciliation, {
+        outcome: "force-recompile";
+    }>;
+    readonly recompile_request: NormalizedPolicyRecompileDecisionV0;
+    readonly gateway_invocations: {
+        readonly agent_launch_count: 0;
+        readonly model_gateway_invocation_count: 0;
+    };
+}
+export interface RunRecordedPlanIncompleteD2ProofInputV0 {
+    readonly planPolicyRecompileV0: PlanPolicyRecompileV0;
+    readonly scenario?: RecordedPlanIncompleteD2ScenarioV0;
+}
+export declare function makeRecordedPolicyRollbackD2ScenarioV0(): RecordedPolicyRollbackD2ScenarioV0;
+export declare function assertRecordedPolicyRollbackD2ScenarioV0(scenario: RecordedPolicyRollbackD2ScenarioV0): void;
+export declare function runRecordedPolicyRollbackD2ProofV0(input: RunRecordedPolicyRollbackD2ProofInputV0): Promise<RecordedPolicyRollbackD2ProofV0>;
+export declare function createRecordedPolicyRollbackPlannerDoubleV0(): PlanPolicyRollbackV0;
+export declare function normalizePolicyRollbackDecisionV0(result: unknown): NormalizedPolicyRollbackDecisionV0;
+export declare function makeRecordedPlanIncompleteD2ScenarioV0(): RecordedPlanIncompleteD2ScenarioV0;
+export declare function assertRecordedPlanIncompleteD2ScenarioV0(scenario: RecordedPlanIncompleteD2ScenarioV0): void;
+export declare function runRecordedPlanIncompleteD2ProofV0(input: RunRecordedPlanIncompleteD2ProofInputV0): Promise<RecordedPlanIncompleteD2ProofV0>;
+//# sourceMappingURL=index.d.ts.map

package/dist/rollback/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rollback/index.ts"],"names":[],"mappings":"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"}