@openprose/reactor 0.1.0-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 OpenProse
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,231 @@
+# @openprose/reactor
+
+`@openprose/reactor` is the local Reactor Harness runtime spine for OpenProse.
+It models the parts of a responsibility loop that need to survive replay,
+forking, evidence review, and package verification without changing OpenProse
+source syntax.
+
+This README describes the `0.1.0-rc.1` package surface. It is an OSS release
+candidate; the stable `0.1.0` launch waits for provenance publication and
+stranger-run verification.
+
+## v0.1 Status
+
+What v0.1 demonstrates:
+
+- The static-world cost thesis is visible in the package-backed
+  `skills/open-prose/examples/flat-tokens` run: four `createReactor().ingest()` turns
+  produce real Reactor receipts and print `tokens.fresh=46`,
+  `tokens.reused=46`, and `ratio=46:46`.
+- Receipts, owner/subscriber/public projections, and SDK export/import are
+  implemented so the trail can be inspected, redacted for lower-trust readers,
+  and carried as exit material.
+- Composition pins verify consumed receipts against contract revision and
+  acceptable signer posture; Cradle release parity exercises the same package
+  surface across memory and filesystem rows, with Postgres marked future.
+- Local examples are runnable from the package/CLI release surface: the flat
+  tokens example runs from packed tarballs, and the companion OpenProse CLI
+  quickstart compiles, serves, triggers, and projects an incident-briefing
+  responsibility locally.
+
+What is designed and partial:
+
+- The CLI path is local and deterministic. It proves package/CLI integration,
+  receipt production, and projection, not production ingress or hosted
+  fulfillment quality.
+- Provider parity is recorded, not a live runtime matrix. Cradle carries
+  deterministic provider parity doubles and one live-recorded K1 cassette, but
+  this package does not perform runtime variable-depth ensemble judging.
+- The tagged publish gate is wired for provenance publication, but no npm
+  publication has been run for this worktree.
+
+Deferred to v0.2 or external gates:
+
+- Actual npm publication and provenance until a release tag and npm auth or
+  trusted publishing are available.
+- The stranger run that verifies both local demos outside the authoring team.
+- Production ingress, fulfillment, and oracle layers.
+- Runtime variable-depth ensemble judging, Postgres parity, and a non-null
+  signer adapter.
+
+The runtime package currently provides:
+
+- `openprose.receipt v0` creation, verification, canonical hashing, and proof
+  inspection.
+- Token-truth and surprise-attribution checks for flat-spend reasoning.
+- Deterministic kernel policy evaluation, backstops, rollback comparison, and
+  safety receipts.
+- Compiled evidence-plan, memo-key, forecast, policy recompile/rollback, and
+  graph-composition helpers.
+- An adapter-injected SDK with receipt ingest, registry reads, and exit-bundle
+  export/import.
+- Owner/subscriber/public receipt projections for privacy-preserving evidence
+  reports.
+
+## Public Subpaths
+
+The packed artifact exposes these CommonJS entrypoints:
+
+- `@openprose/reactor`
+- `@openprose/reactor/receipt`
+- `@openprose/reactor/cost`
+- `@openprose/reactor/kernel`
+- `@openprose/reactor/evidence-plan`
+- `@openprose/reactor/memo`
+- `@openprose/reactor/forecast`
+- `@openprose/reactor/sdk`
+- `@openprose/reactor/policy`
+- `@openprose/reactor/composition`
+- `@openprose/reactor/projection`
+
+## Quickstart
+
+These TypeScript examples use the package's public subpaths. Verify a receipt
+and derive a proof summary that avoids private payload fields:
+
+```ts
+import {
+  inspectReceiptProofV0,
+  verifyReceiptV0,
+  type ReceiptV0,
+} from "@openprose/reactor/receipt";
+
+export function inspectStoredReceipt(receipt: ReceiptV0) {
+  const verification = verifyReceiptV0(receipt);
+  if (!verification.ok) {
+    throw new Error(verification.errors.join("; "));
+  }
+
+  return inspectReceiptProofV0(receipt);
+}
+```
+
+Project a proof for a lower-trust audience:
+
+```ts
+import { projectReceiptProofV0 } from "@openprose/reactor/projection";
+import type { ReceiptProofInspectionV0 } from "@openprose/reactor/receipt";
+
+export function publicReceiptEvidence(proof: ReceiptProofInspectionV0) {
+  const result = projectReceiptProofV0({ tier: "public", proof });
+  if (!result.ok) {
+    throw new Error(result.errors.join("; "));
+  }
+
+  return result.projection;
+}
+```
+
+Create an SDK instance with explicit adapters. The SDK does not install hidden
+network, model, agent, sandbox, or storage defaults. In v0.1, omitting `signer`
+is represented explicitly as the null signer state
+`{ scheme: "none", null_reason: "no-signer-adapter-configured" }`; real signing
+adapters are deferred:
+
+```ts
+import { createReactor, type ReactorAdaptersV0 } from "@openprose/reactor/sdk";
+
+const adapters: ReactorAdaptersV0 = {
+  clock: { now: () => "2026-05-19T00:00:00Z" },
+  storage: {
+    appendReceipt: () => undefined,
+    listReceipts: () => [],
+    readRegistry: () => ({
+      contract_revision:
+        "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      policy_artifact_id: "policy.incident-briefing",
+      policy_artifact_identity: "incident-briefing",
+      policy_artifact_namespace: "policy.static",
+      policy_artifact_revision: "policy-revision-1",
+      policy_artifact_validation_state: "validated",
+    }),
+  },
+  modelGateway: { invoke: (request) => ({ payload: request.payload }) },
+  agentSdk: { launch: (request) => ({ payload: request.payload }) },
+  sandbox: { run: () => ({ exit_code: 0, stdout: "", stderr: "" }) },
+  connectors: { read: () => ({ payload: null }) },
+  eventSink: { emit: () => undefined },
+};
+
+const reactor = createReactor({
+  responsibility_id: "responsibility.incident-briefing",
+  adapters,
+});
+
+reactor.ingest({ kind: "tick" });
+const exitBundle = reactor.export();
+```
+
+Evaluate a validated policy artifact before running B3 backstops:
+
+```ts
+import {
+  evaluateBackstops,
+  judgedActivations,
+  validateKernelPolicyArtifact,
+} from "@openprose/reactor/kernel";
+
+const validation = validateKernelPolicyArtifact({
+  no_anchor: true,
+  falsification_predicate: {
+    kind: "equals",
+    fact: "material_status",
+    value: "stale",
+  },
+  backstop_divergence_predicate: {
+    kind: "greater-than-or-equal",
+    fact: "observed_divergence_multiplier",
+    value: 2,
+  },
+  live_observables: ["material_status", "observed_divergence_multiplier"],
+});
+
+if (!validation.ok) {
+  throw new Error(validation.errors.join("; "));
+}
+
+const backstops = evaluateBackstops({
+  token: validation.token,
+  as_of: "2026-05-19T00:00:00Z",
+  last_policy_revalidated_at: "2026-05-01T00:00:00Z",
+  last_recompile_at: "2026-05-18T00:00:00Z",
+  recompile_requested: false,
+  policy_warmup_judged_activations: judgedActivations(1),
+});
+```
+
+## Local Package Evidence
+
+The current build has local evidence for the package shape:
+
+```sh
+pnpm --filter @openprose/reactor test
+pnpm --dir packages/reactor pack --pack-destination /tmp/openprose-reactor-pack
+node .github/scripts/verify-reactor-pin.mjs \
+  --tarball /tmp/openprose-reactor-pack/openprose-reactor-0.1.0-rc.1.tgz
+node .github/scripts/smoke-reactor-tarball-import.mjs \
+  --tarball /tmp/openprose-reactor-pack/openprose-reactor-0.1.0-rc.1.tgz
+pnpm --dir packages/reactor-cradle pack --pack-destination /tmp/openprose-reactor-pack
+node .github/scripts/smoke-reactor-flat-tokens-example.mjs \
+  --reactorTarball /tmp/openprose-reactor-pack/openprose-reactor-0.1.0-rc.1.tgz \
+  --cradleTarball /tmp/openprose-reactor-pack/openprose-reactor-cradle-0.1.0-rc.1.tgz \
+  --exampleDir skills/open-prose/examples/flat-tokens
+```
+
+The verifier checks the packed tree against the Cradle pin, and the import
+smoke imports every public Reactor entrypoint from the tarball in a temporary
+offline consumer. The flat-tokens smoke installs packed Reactor and Cradle
+artifacts into a temporary offline consumer and expects `tokens.fresh=46`,
+`tokens.reused=46`, and `ratio=46:46`.
+
+## Current Boundaries
+
+- This README describes the release-candidate package surface; the stable npm
+  release waits for registry-visible provenance and stranger-run evidence.
+- GitHub Actions contain a tagged publish gate that relies on npm trusted
+  publishing/OIDC and rejects tag/package-version mismatches.
+- The package does not include the CLI implementation; local CLI
+  `serve/status` evidence lives in the companion OpenProse CLI worktree.
+- Postgres parity, production adapter release, live provider/model matrix, and
+  deployment checks are still outside this package surface.
+- `cost.provider_norm` remains the deferred receipt v0 normalization field.

package/dist/adapters/agent-sdk-passthrough/index.d.ts

@@ -0,0 +1,8 @@
+import type { ReactorAgentRequestV0, ReactorAgentResponseV0, ReactorAgentSdkAdapterV0 } from "../../sdk";
+export type ReactorAgentSdkLaunchHandlerV0 = (request: ReactorAgentRequestV0) => ReactorAgentResponseV0;
+export interface RecordingAgentSdkAdapterV0 extends ReactorAgentSdkAdapterV0 {
+    readonly launches: () => readonly ReactorAgentRequestV0[];
+}
+export declare function createPassthroughAgentSdkAdapterV0(handler?: ReactorAgentSdkLaunchHandlerV0): RecordingAgentSdkAdapterV0;
+export declare function createNullAgentSdkAdapterV0(payload?: unknown): RecordingAgentSdkAdapterV0;
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/agent-sdk-passthrough/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/agent-sdk-passthrough/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,sBAAsB,EACtB,wBAAwB,EACzB,MAAM,WAAW,CAAC;AAGnB,MAAM,MAAM,8BAA8B,GAAG,CAC3C,OAAO,EAAE,qBAAqB,KAC3B,sBAAsB,CAAC;AAE5B,MAAM,WAAW,0BAA2B,SAAQ,wBAAwB;IAC1E,QAAQ,CAAC,QAAQ,EAAE,MAAM,SAAS,qBAAqB,EAAE,CAAC;CAC3D;AAED,wBAAgB,kCAAkC,CAChD,OAAO,GAAE,8BAEP,GACD,0BAA0B,CAa5B;AAED,wBAAgB,2BAA2B,CACzC,OAAO,GAAE,OAAc,GACtB,0BAA0B,CAI5B"}

package/dist/adapters/agent-sdk-passthrough/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPassthroughAgentSdkAdapterV0 = createPassthroughAgentSdkAdapterV0;
+exports.createNullAgentSdkAdapterV0 = createNullAgentSdkAdapterV0;
+const json_1 = require("../json");
+function createPassthroughAgentSdkAdapterV0(handler = (request) => ({
+    payload: request.payload,
+})) {
+    const launches = [];
+    return {
+        launch(request) {
+            const requestCopy = (0, json_1.cloneAdapterJsonValueV0)(request);
+            launches.push(requestCopy);
+            return (0, json_1.cloneAdapterJsonValueV0)(handler(requestCopy));
+        },
+        launches() {
+            return launches.map((launch) => (0, json_1.cloneAdapterJsonValueV0)(launch));
+        },
+    };
+}
+function createNullAgentSdkAdapterV0(payload = null) {
+    return createPassthroughAgentSdkAdapterV0(() => ({
+        payload: (0, json_1.cloneAdapterJsonValueV0)(payload),
+    }));
+}

package/dist/adapters/clock-system/index.d.ts

@@ -0,0 +1,9 @@
+import type { ReactorClockAdapterV0 } from "../../sdk";
+export interface FixedClockAdapterV0 extends ReactorClockAdapterV0 {
+    readonly set: (instant: string) => void;
+    readonly advanceByMs: (milliseconds: number) => string;
+    readonly readings: () => readonly string[];
+}
+export declare function createSystemClockAdapterV0(): ReactorClockAdapterV0;
+export declare function createFixedClockAdapterV0(initialInstant: string): FixedClockAdapterV0;
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/clock-system/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/clock-system/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAEvD,MAAM,WAAW,mBAAoB,SAAQ,qBAAqB;IAChE,QAAQ,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,QAAQ,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,MAAM,CAAC;IACvD,QAAQ,CAAC,QAAQ,EAAE,MAAM,SAAS,MAAM,EAAE,CAAC;CAC5C;AAED,wBAAgB,0BAA0B,IAAI,qBAAqB,CAIlE;AAED,wBAAgB,yBAAyB,CAAC,cAAc,EAAE,MAAM,GAAG,mBAAmB,CA0BrF"}

package/dist/adapters/clock-system/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSystemClockAdapterV0 = createSystemClockAdapterV0;
+exports.createFixedClockAdapterV0 = createFixedClockAdapterV0;
+function createSystemClockAdapterV0() {
+    return {
+        now: () => new Date().toISOString(),
+    };
+}
+function createFixedClockAdapterV0(initialInstant) {
+    assertReplayableInstant(initialInstant, "initialInstant");
+    let current = initialInstant;
+    const emitted = [];
+    return {
+        now() {
+            emitted.push(current);
+            return current;
+        },
+        set(instant) {
+            assertReplayableInstant(instant, "instant");
+            current = instant;
+        },
+        advanceByMs(milliseconds) {
+            if (!Number.isFinite(milliseconds)) {
+                throw new Error("milliseconds must be finite");
+            }
+            current = new Date(Date.parse(current) + milliseconds).toISOString();
+            return current;
+        },
+        readings() {
+            return [...emitted];
+        },
+    };
+}
+function assertReplayableInstant(value, name) {
+    if (!Number.isFinite(Date.parse(value))) {
+        throw new Error(`${name} must be a replayable instant`);
+    }
+}

package/dist/adapters/connector-static/index.d.ts

@@ -0,0 +1,11 @@
+import type { ReactorConnectorAdapterV0, ReactorConnectorRequestV0 } from "../../sdk";
+export interface StaticConnectorSourceV0 {
+    readonly source_id: string;
+    readonly payload: unknown;
+}
+export interface StaticConnectorAdapterV0 extends ReactorConnectorAdapterV0 {
+    readonly writeSource: (source: StaticConnectorSourceV0) => void;
+    readonly reads: () => readonly ReactorConnectorRequestV0[];
+}
+export declare function createStaticConnectorAdapterV0(sources?: readonly StaticConnectorSourceV0[]): StaticConnectorAdapterV0;
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/connector-static/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/connector-static/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,yBAAyB,EACzB,yBAAyB,EAE1B,MAAM,WAAW,CAAC;AAGnB,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,wBAAyB,SAAQ,yBAAyB;IACzE,QAAQ,CAAC,WAAW,EAAE,CAAC,MAAM,EAAE,uBAAuB,KAAK,IAAI,CAAC;IAChE,QAAQ,CAAC,KAAK,EAAE,MAAM,SAAS,yBAAyB,EAAE,CAAC;CAC5D;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,GAAE,SAAS,uBAAuB,EAAO,GAC/C,wBAAwB,CA2B1B"}

package/dist/adapters/connector-static/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStaticConnectorAdapterV0 = createStaticConnectorAdapterV0;
+const json_1 = require("../json");
+function createStaticConnectorAdapterV0(sources = []) {
+    const records = new Map();
+    const reads = [];
+    for (const source of sources) {
+        writeSource(records, source);
+    }
+    return {
+        read(request) {
+            const requestCopy = (0, json_1.cloneAdapterJsonValueV0)(request);
+            reads.push(requestCopy);
+            if (!records.has(request.source_id)) {
+                throw new Error(`connector source not found: ${request.source_id}`);
+            }
+            return {
+                payload: (0, json_1.cloneAdapterJsonValueV0)(records.get(request.source_id)),
+            };
+        },
+        writeSource(source) {
+            writeSource(records, source);
+        },
+        reads() {
+            return reads.map((read) => (0, json_1.cloneAdapterJsonValueV0)(read));
+        },
+    };
+}
+function writeSource(records, source) {
+    if (source.source_id.length === 0) {
+        throw new Error("connector source_id must be non-empty");
+    }
+    records.set(source.source_id, (0, json_1.cloneAdapterJsonValueV0)(source.payload));
+}

package/dist/adapters/event-sink-memory/index.d.ts

@@ -0,0 +1,10 @@
+import type { ReactorEventSinkAdapterV0, ReactorSdkEventV0 } from "../../sdk";
+export interface MemoryEventSinkAdapterV0 extends ReactorEventSinkAdapterV0 {
+    readonly events: () => readonly ReactorSdkEventV0[];
+    readonly clear: () => void;
+}
+export interface MemoryEventSinkAdapterInputV0 {
+    readonly onEmit?: (event: ReactorSdkEventV0) => void;
+}
+export declare function createMemoryEventSinkAdapterV0(input?: MemoryEventSinkAdapterInputV0): MemoryEventSinkAdapterV0;
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/event-sink-memory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/event-sink-memory/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAG9E,MAAM,WAAW,wBAAyB,SAAQ,yBAAyB;IACzE,QAAQ,CAAC,MAAM,EAAE,MAAM,SAAS,iBAAiB,EAAE,CAAC;IACpD,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;CAC5B;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;CACtD;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,GAAE,6BAAkC,GACxC,wBAAwB,CAgB1B"}

package/dist/adapters/event-sink-memory/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMemoryEventSinkAdapterV0 = createMemoryEventSinkAdapterV0;
+const json_1 = require("../json");
+function createMemoryEventSinkAdapterV0(input = {}) {
+    const events = [];
+    return {
+        emit(event) {
+            const eventCopy = (0, json_1.cloneAdapterJsonValueV0)(event);
+            events.push(eventCopy);
+            input.onEmit?.(eventCopy);
+        },
+        events() {
+            return events.map((event) => (0, json_1.cloneAdapterJsonValueV0)(event));
+        },
+        clear() {
+            events.length = 0;
+        },
+    };
+}

package/dist/adapters/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./agent-sdk-passthrough";
+export * from "./clock-system";
+export * from "./connector-static";
+export * from "./event-sink-memory";
+export * from "./model-gateway-record-replay";
+export * from "./sandbox-null";
+export * from "./storage-fs";
+export * from "./storage-memory";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,SAAS,CAAC"}

package/dist/adapters/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./agent-sdk-passthrough"), exports);
+__exportStar(require("./clock-system"), exports);
+__exportStar(require("./connector-static"), exports);
+__exportStar(require("./event-sink-memory"), exports);
+__exportStar(require("./model-gateway-record-replay"), exports);
+__exportStar(require("./sandbox-null"), exports);
+__exportStar(require("./storage-fs"), exports);
+__exportStar(require("./storage-memory"), exports);
+__exportStar(require("./types"), exports);

package/dist/adapters/json.d.ts

@@ -0,0 +1,3 @@
+export declare function renderAdapterJsonV0(value: unknown): string;
+export declare function cloneAdapterJsonValueV0<T>(value: T): T;
+//# sourceMappingURL=json.d.ts.map

package/dist/adapters/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/adapters/json.ts"],"names":[],"mappings":"AAEA,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE1D;AAED,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAEtD"}

package/dist/adapters/json.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderAdapterJsonV0 = renderAdapterJsonV0;
+exports.cloneAdapterJsonValueV0 = cloneAdapterJsonValueV0;
+const receipt_1 = require("../receipt");
+function renderAdapterJsonV0(value) {
+    return (0, receipt_1.canonicalizeForReceiptV0)(toAdapterJsonValue(value));
+}
+function cloneAdapterJsonValueV0(value) {
+    return JSON.parse(renderAdapterJsonV0(value));
+}
+function toAdapterJsonValue(value) {
+    if (value === null) {
+        return null;
+    }
+    switch (typeof value) {
+        case "boolean":
+        case "string":
+            return value;
+        case "number":
+            if (!Number.isFinite(value)) {
+                throw new TypeError("adapter JSON cannot contain non-finite numbers");
+            }
+            return value;
+        case "object":
+            if (Array.isArray(value)) {
+                return value.map((item) => {
+                    if (item === undefined) {
+                        throw new TypeError("adapter JSON arrays cannot contain undefined");
+                    }
+                    return toAdapterJsonValue(item);
+                });
+            }
+            if (!isPlainRecord(value)) {
+                throw new TypeError("adapter JSON cannot contain non-plain objects");
+            }
+            return normalizeRecord(value);
+        case "undefined":
+        case "bigint":
+        case "function":
+        case "symbol":
+            throw new TypeError(`adapter JSON cannot contain ${typeof value}`);
+    }
+}
+function normalizeRecord(value) {
+    const normalized = {};
+    for (const key of Object.keys(value)) {
+        const item = value[key];
+        if (item !== undefined) {
+            normalized[key] = toAdapterJsonValue(item);
+        }
+    }
+    return normalized;
+}
+function isPlainRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}

package/dist/adapters/model-gateway-record-replay/index.d.ts

@@ -0,0 +1,24 @@
+import type { ReactorModelGatewayRequestV0, ReactorModelGatewayUsageV0 } from "../../sdk";
+import { type ReactorModelGatewayRuntimeAdapterV0 } from "../types";
+export interface RecordReplayModelGatewayRecordV0 {
+    readonly id: string;
+    readonly request: ReactorModelGatewayRequestV0;
+    readonly response: {
+        readonly payload: unknown;
+        readonly usage: ReactorModelGatewayUsageV0;
+    };
+}
+export interface RecordReplayModelGatewayCallV0 {
+    readonly record_id: string;
+    readonly request: ReactorModelGatewayRequestV0;
+    readonly usage: ReactorModelGatewayUsageV0;
+}
+export interface RecordReplayModelGatewayAdapterV0 extends ReactorModelGatewayRuntimeAdapterV0 {
+    readonly calls: () => readonly RecordReplayModelGatewayCallV0[];
+    readonly remaining: () => number;
+}
+export interface RecordReplayModelGatewayInputV0 {
+    readonly records: readonly RecordReplayModelGatewayRecordV0[];
+}
+export declare function createRecordReplayModelGatewayAdapterV0(input: RecordReplayModelGatewayInputV0): RecordReplayModelGatewayAdapterV0;
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/model-gateway-record-replay/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/model-gateway-record-replay/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,4BAA4B,EAC5B,0BAA0B,EAC3B,MAAM,WAAW,CAAC;AAEnB,OAAO,EAIL,KAAK,mCAAmC,EACzC,MAAM,UAAU,CAAC;AAElB,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,OAAO,EAAE,4BAA4B,CAAC;IAC/C,QAAQ,CAAC,QAAQ,EAAE;QACjB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;QAC1B,QAAQ,CAAC,KAAK,EAAE,0BAA0B,CAAC;KAC5C,CAAC;CACH;AAED,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,OAAO,EAAE,4BAA4B,CAAC;IAC/C,QAAQ,CAAC,KAAK,EAAE,0BAA0B,CAAC;CAC5C;AAED,MAAM,WAAW,iCACf,SAAQ,mCAAmC;IAC3C,QAAQ,CAAC,KAAK,EAAE,MAAM,SAAS,8BAA8B,EAAE,CAAC;IAChE,QAAQ,CAAC,SAAS,EAAE,MAAM,MAAM,CAAC;CAClC;AAED,MAAM,WAAW,+BAA+B;IAC9C,QAAQ,CAAC,OAAO,EAAE,SAAS,gCAAgC,EAAE,CAAC;CAC/D;AAED,wBAAgB,uCAAuC,CACrD,KAAK,EAAE,+BAA+B,GACrC,iCAAiC,CAyCnC"}

package/dist/adapters/model-gateway-record-replay/index.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRecordReplayModelGatewayAdapterV0 = createRecordReplayModelGatewayAdapterV0;
+const json_1 = require("../json");
+const types_1 = require("../types");
+function createRecordReplayModelGatewayAdapterV0(input) {
+    const records = input.records.map((record) => normalizeRecord(record));
+    const calls = [];
+    let cursor = 0;
+    return {
+        invoke(request) {
+            const requestCopy = (0, json_1.cloneAdapterJsonValueV0)(request);
+            const record = records[cursor];
+            if (record === undefined) {
+                throw new Error("record-replay model gateway has no remaining records");
+            }
+            const expected = (0, json_1.renderAdapterJsonV0)(record.request);
+            const actual = (0, json_1.renderAdapterJsonV0)(requestCopy);
+            if (actual !== expected) {
+                throw new Error(`record-replay model gateway request mismatch at record ${record.id}`);
+            }
+            cursor += 1;
+            const usage = (0, types_1.cloneModelGatewayUsageV0)(record.response.usage);
+            calls.push({
+                record_id: record.id,
+                request: requestCopy,
+                usage,
+            });
+            return {
+                payload: (0, json_1.cloneAdapterJsonValueV0)(record.response.payload),
+                usage,
+            };
+        },
+        calls() {
+            return calls.map((call) => (0, json_1.cloneAdapterJsonValueV0)(call));
+        },
+        remaining() {
+            return records.length - cursor;
+        },
+    };
+}
+function normalizeRecord(record) {
+    if (record.id.length === 0) {
+        throw new Error("record-replay model gateway record id must be non-empty");
+    }
+    (0, types_1.assertModelGatewayUsageV0)(record.response.usage);
+    return {
+        id: record.id,
+        request: (0, json_1.cloneAdapterJsonValueV0)(record.request),
+        response: {
+            payload: (0, json_1.cloneAdapterJsonValueV0)(record.response.payload),
+            usage: (0, types_1.cloneModelGatewayUsageV0)(record.response.usage),
+        },
+    };
+}

package/dist/adapters/sandbox-null/index.d.ts

@@ -0,0 +1,3 @@
+import type { ReactorSandboxAdapterV0, ReactorSandboxResponseV0 } from "../../sdk";
+export declare function createNullSandboxAdapterV0(response?: ReactorSandboxResponseV0): ReactorSandboxAdapterV0;
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/sandbox-null/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/sandbox-null/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,WAAW,CAAC;AAEnF,wBAAgB,0BAA0B,CACxC,QAAQ,GAAE,wBAAmE,GAC5E,uBAAuB,CAIzB"}

package/dist/adapters/sandbox-null/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNullSandboxAdapterV0 = createNullSandboxAdapterV0;
+function createNullSandboxAdapterV0(response = { exit_code: 0, stdout: "", stderr: "" }) {
+    return {
+        run: () => ({ ...response }),
+    };
+}