@openprose/reactor-cradle 0.1.0-rc.1

package/dist/scenario/runner.js

@@ -0,0 +1,345 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runScenarioV0 = runScenarioV0;
+const types_1 = require("./types");
+const time_1 = require("./time");
+const CONTENT_HASH_PATTERN = /^sha256:[a-f0-9]{64}$/;
+function runScenarioV0(input) {
+    const initialInstant = (0, time_1.canonicalScenarioInstant)(input.scenario.initial_instant, "scenario.initial_instant");
+    const initialEpochMs = (0, time_1.parseScenarioInstantMs)(initialInstant, "scenario.initial_instant");
+    initializeClock(input.clock, initialInstant);
+    const state = {
+        initialEpochMs,
+        currentEpochMs: initialEpochMs,
+        observations: [],
+        trace: [],
+    };
+    for (const [index, step] of input.scenario.script.entries()) {
+        applyStepTime(input.clock, state, step);
+        state.trace.push(runStep(input, state, step, index));
+    }
+    const finalInstant = input.clock.now();
+    return {
+        scenario_id: input.scenario.id,
+        schema: types_1.REACTOR_SCENARIO_SCHEMA_V0,
+        v: types_1.REACTOR_SCENARIO_VERSION_V0,
+        world_profile: input.scenario.world.profile,
+        cassette_path: input.scenario.cassette.path,
+        initial_instant: initialInstant,
+        final_instant: finalInstant,
+        trace: Object.freeze([...state.trace]),
+        receipt_log: readReceiptLog(input),
+        expected_relationships: input.scenario.expect.relationships,
+    };
+}
+function runStep(input, state, step, index) {
+    const asOf = input.clock.now();
+    const worldAdvance = input.world.advanceTo?.({
+        scenario_id: input.scenario.id,
+        profile: input.scenario.world.profile,
+        as_of: asOf,
+    });
+    const worldReads = [];
+    switch (step.kind) {
+        case "tick": {
+            const reactorIngests = runForecastRecheckTurns(input, state, step, asOf);
+            return {
+                index,
+                step,
+                as_of: asOf,
+                ...(worldAdvance === undefined ? {} : { world_advance: worldAdvance }),
+                ...reactorTraceFields(reactorIngests),
+                world_reads: worldReads,
+            };
+        }
+        case "ingest": {
+            const worldEvent = input.world.applyEvent?.({
+                scenario_id: input.scenario.id,
+                profile: input.scenario.world.profile,
+                event: step.event,
+                ...(step.source_id === undefined ? {} : { source_id: step.source_id }),
+                as_of: asOf,
+                fields: step.fields,
+            });
+            if (step.source_id !== undefined) {
+                worldReads.push(readWorld(input.world, step.source_id, asOf));
+                state.observations.push(...worldReads);
+            }
+            const reactorIngest = input.reactor?.ingest(createRealInputTurn(input, step, asOf, worldReads));
+            if (reactorIngest !== undefined) {
+                state.lastReactorIngest = reactorIngest;
+            }
+            return {
+                index,
+                step,
+                as_of: asOf,
+                ...(worldAdvance === undefined ? {} : { world_advance: worldAdvance }),
+                ...(worldEvent === undefined ? {} : { world_event: worldEvent }),
+                ...(reactorIngest === undefined
+                    ? {}
+                    : {
+                        reactor_ingest: reactorIngest,
+                        reactor_ingests: Object.freeze([reactorIngest]),
+                    }),
+                world_reads: Object.freeze([...worldReads]),
+            };
+        }
+        case "read":
+            worldReads.push(readWorld(input.world, step.source_id, asOf));
+            state.observations.push(...worldReads);
+            return {
+                index,
+                step,
+                as_of: asOf,
+                ...(worldAdvance === undefined ? {} : { world_advance: worldAdvance }),
+                world_reads: Object.freeze([...worldReads]),
+            };
+        case "model": {
+            const modelRequest = createModelRequest(input.scenario, step, asOf, state);
+            const modelResponse = input.modelGateway.invoke(modelRequest);
+            return {
+                index,
+                step,
+                as_of: asOf,
+                ...(worldAdvance === undefined ? {} : { world_advance: worldAdvance }),
+                world_reads: worldReads,
+                model_request: modelRequest,
+                model_response: modelResponse,
+            };
+        }
+    }
+}
+function createRealInputTurn(input, step, asOf, worldReads) {
+    const evidence = worldReads.map((observation) => evidenceFromObservation(observation));
+    return {
+        kind: "real-input",
+        scenario_id: input.scenario.id,
+        event: step.event,
+        as_of: asOf,
+        fields: step.fields,
+        ...(step.source_id === undefined ? {} : { source_id: step.source_id }),
+        ...(evidence.length === 0 ? {} : { evidence: Object.freeze(evidence) }),
+    };
+}
+function runForecastRecheckTurns(input, state, step, asOf) {
+    if (input.reactor === undefined) {
+        return [];
+    }
+    const recheckKinds = forecastRecheckKindsForTick(state, step, asOf);
+    if (recheckKinds.length === 0) {
+        return [];
+    }
+    const results = recheckKinds.map((recheckKind) => input.reactor?.ingest(createForecastRecheckTurn(input, state, asOf, recheckKind)));
+    const presentResults = results.filter((result) => result !== undefined);
+    const last = presentResults.at(-1);
+    if (last !== undefined) {
+        state.lastReactorIngest = last;
+    }
+    return Object.freeze(presentResults);
+}
+function createForecastRecheckTurn(input, state, asOf, recheckKind) {
+    const evidence = latestEvidenceFromObservations(input, state.observations);
+    return {
+        kind: "forecast-recheck",
+        recheck_kind: recheckKind,
+        scenario_id: input.scenario.id,
+        as_of: asOf,
+        ...(evidence.length === 0 ? {} : { evidence }),
+    };
+}
+function forecastRecheckKindsForTick(state, step, asOf) {
+    const explicit = explicitTickRecheckKind(step);
+    if (explicit !== undefined) {
+        return [explicit];
+    }
+    const prior = state.lastReactorIngest;
+    if (prior === undefined ||
+        prior.next_due_at === undefined ||
+        prior.due_rechecks === undefined ||
+        prior.due_rechecks.length === 0 ||
+        !isAtOrAfter(asOf, prior.next_due_at)) {
+        return [];
+    }
+    return uniqueRecheckKinds(prior.due_rechecks);
+}
+function explicitTickRecheckKind(step) {
+    if (step.recheck_kind !== undefined) {
+        return step.recheck_kind;
+    }
+    return (readRecheckKindField(step.fields, "recheck_kind") ??
+        readRecheckKindField(step.fields, "forecast_recheck"));
+}
+function readRecheckKindField(fields, fieldName) {
+    const value = fields[fieldName];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "evidence-age" || value === "plan-age") {
+        return value;
+    }
+    throw new Error(`${fieldName} must be evidence-age or plan-age`);
+}
+function uniqueRecheckKinds(values) {
+    const result = [];
+    for (const value of values) {
+        if (!result.includes(value)) {
+            result.push(value);
+        }
+    }
+    return Object.freeze(result);
+}
+function isAtOrAfter(asOf, dueAt) {
+    const asOfMs = Date.parse(asOf);
+    const dueAtMs = Date.parse(dueAt);
+    if (!Number.isFinite(asOfMs) || !Number.isFinite(dueAtMs)) {
+        return false;
+    }
+    return asOfMs >= dueAtMs;
+}
+function reactorTraceFields(results) {
+    const last = results.at(-1);
+    if (last === undefined) {
+        return {};
+    }
+    return {
+        reactor_ingest: last,
+        reactor_ingests: Object.freeze([...results]),
+    };
+}
+function latestEvidenceFromObservations(input, observations) {
+    const latestBySource = new Map();
+    for (const observation of observations) {
+        latestBySource.set(observation.source_id, observation);
+    }
+    const ordered = [];
+    for (const source of input.scenario.sources) {
+        const observation = latestBySource.get(source.id);
+        if (observation !== undefined) {
+            ordered.push(observation);
+            latestBySource.delete(source.id);
+        }
+    }
+    ordered.push(...Array.from(latestBySource.values()).sort((left, right) => left.source_id.localeCompare(right.source_id)));
+    return Object.freeze(ordered.map((observation) => evidenceFromObservation(observation)));
+}
+function evidenceFromObservation(observation) {
+    const contentHash = readContentHashFromPayload(observation.payload);
+    if (contentHash !== undefined) {
+        return {
+            source_id: observation.source_id,
+            content_hash: contentHash,
+        };
+    }
+    return {
+        source_id: observation.source_id,
+        payload: observation.payload,
+    };
+}
+function readContentHashFromPayload(payload) {
+    if (!isRecord(payload)) {
+        return undefined;
+    }
+    const payloadHash = payload["payload_hash"] ?? payload["content_hash"];
+    return isContentHash(payloadHash) ? payloadHash : undefined;
+}
+function createModelRequest(scenario, step, asOf, state) {
+    return {
+        kind: step.request_kind,
+        payload: {
+            scenario_id: scenario.id,
+            world_profile: scenario.world.profile,
+            as_of: asOf,
+            prompt: step.prompt,
+            source_ids: scenario.sources.map((source) => source.id),
+            observations: state.observations.map((observation) => ({
+                source_id: observation.source_id,
+                as_of: observation.as_of,
+                payload: observation.payload,
+                surprise_count: observation.surprise?.count ?? null,
+                surprise_causes: observation.surprise?.causes ?? [],
+            })),
+            fields: step.fields,
+        },
+    };
+}
+function readWorld(world, sourceId, asOf) {
+    const response = normalizeWorldReadResponse(world.read({
+        source_id: sourceId,
+        as_of: asOf,
+    }));
+    return {
+        source_id: sourceId,
+        as_of: asOf,
+        payload: response.payload,
+        ...(response.surprise === undefined ? {} : { surprise: response.surprise }),
+    };
+}
+function normalizeWorldReadResponse(response) {
+    if (!isRecord(response)) {
+        throw new Error("world.read must return an object");
+    }
+    if (!Object.hasOwn(response, "payload")) {
+        throw new Error("world.read must return a payload field");
+    }
+    return response;
+}
+function applyStepTime(clock, state, step) {
+    if ("at" in step.time) {
+        const offsetMs = (0, time_1.parseScenarioDurationMs)(step.time.at, "script at");
+        const nextEpochMs = state.initialEpochMs + offsetMs;
+        if (nextEpochMs < state.currentEpochMs) {
+            throw new Error(`scenario step cannot move time backward to ${step.time.at}`);
+        }
+        moveClockTo(clock, nextEpochMs);
+        state.currentEpochMs = nextEpochMs;
+        return;
+    }
+    const elapsedMs = (0, time_1.parseScenarioDurationMs)(step.time.after, "script after");
+    advanceClock(clock, elapsedMs);
+    state.currentEpochMs += elapsedMs;
+}
+function initializeClock(clock, initialInstant) {
+    if (clock.set !== undefined) {
+        clock.set(initialInstant);
+        return;
+    }
+    const now = (0, time_1.canonicalScenarioInstant)(clock.now(), "clock.now");
+    if (now !== initialInstant) {
+        throw new Error(`scenario clock must start at ${initialInstant}; received ${now}`);
+    }
+}
+function moveClockTo(clock, epochMs) {
+    const target = new Date(epochMs).toISOString();
+    if (clock.set !== undefined) {
+        clock.set(target);
+        return;
+    }
+    const currentEpochMs = (0, time_1.parseScenarioInstantMs)(clock.now(), "clock.now");
+    const catchUpMs = epochMs - currentEpochMs;
+    if (catchUpMs < 0) {
+        throw new Error("scenario clock cannot move backward without set()");
+    }
+    advanceClock(clock, catchUpMs);
+}
+function advanceClock(clock, elapsedMs) {
+    if (clock.advanceMs === undefined) {
+        if (elapsedMs === 0) {
+            return;
+        }
+        throw new Error("scenario clock requires advanceMs() for relative time");
+    }
+    clock.advanceMs(elapsedMs);
+}
+function readReceiptLog(input) {
+    const entries = input.reactor?.receipts() ?? input.storage?.listReceipts() ?? [];
+    return {
+        entries: Object.freeze([...entries]),
+        content_hashes: Object.freeze(entries.map((receipt) => receipt.content_hash)),
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isContentHash(value) {
+    return typeof value === "string" && CONTENT_HASH_PATTERN.test(value);
+}

package/dist/scenario/synthetic-world-adapter.d.ts

@@ -0,0 +1,4 @@
+import type { SyntheticWorldConnectorV0 } from "../world";
+import type { ScenarioWorldAdapterV0 } from "./types";
+export declare function adaptSyntheticWorldForScenarioV0(world: SyntheticWorldConnectorV0): ScenarioWorldAdapterV0;
+//# sourceMappingURL=synthetic-world-adapter.d.ts.map

package/dist/scenario/synthetic-world-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synthetic-world-adapter.d.ts","sourceRoot":"","sources":["../../src/scenario/synthetic-world-adapter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAGV,yBAAyB,EAI1B,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAEV,sBAAsB,EAOvB,MAAM,SAAS,CAAC;AAEjB,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,yBAAyB,GAC/B,sBAAsB,CA6CxB"}

package/dist/scenario/synthetic-world-adapter.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adaptSyntheticWorldForScenarioV0 = adaptSyntheticWorldForScenarioV0;
+function adaptSyntheticWorldForScenarioV0(world) {
+    return {
+        read(request) {
+            const response = world.read(request);
+            const surprise = readSurpriseFromPayload(response.payload);
+            return {
+                payload: response.payload,
+                ...(surprise === undefined ? {} : { surprise }),
+            };
+        },
+        applyEvent(event) {
+            if (event.source_id === undefined) {
+                return {
+                    payload: { event: event.event },
+                    surprise: zeroScenarioSurprise(event.profile),
+                };
+            }
+            const payload = payloadFromScenarioFields(event.fields);
+            const record = advanceWorld(world, {
+                kind: "source-event",
+                as_of: event.as_of,
+                source_id: event.source_id,
+                event_id: event.event,
+                ...(payload === undefined ? {} : { payload }),
+            });
+            return {
+                payload: record,
+                surprise: convertSyntheticSurprise(record.surprise),
+            };
+        },
+        advanceTo(input) {
+            const record = advanceWorld(world, {
+                kind: "time",
+                as_of: input.as_of,
+            });
+            return {
+                payload: record,
+                surprise: convertSyntheticSurprise(record.surprise),
+            };
+        },
+    };
+}
+function advanceWorld(world, input) {
+    return world.advance(input);
+}
+function payloadFromScenarioFields(fields) {
+    const entries = Object.entries(fields);
+    if (entries.length === 0) {
+        return undefined;
+    }
+    const payload = {};
+    for (const [key, value] of entries) {
+        payload[key] = value;
+    }
+    return payload;
+}
+function readSurpriseFromPayload(payload) {
+    if (!isRecord(payload) || !isRecord(payload["surprise"])) {
+        return undefined;
+    }
+    return convertSyntheticSurprise(payload["surprise"]);
+}
+function convertSyntheticSurprise(report) {
+    return {
+        profile: report.profile,
+        count: report.surprise_count,
+        causes: report.surprise_events.map((event) => event.kind),
+    };
+}
+function zeroScenarioSurprise(profile) {
+    return {
+        profile,
+        count: 0,
+        causes: [],
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/scenario/time.d.ts

@@ -0,0 +1,4 @@
+export declare function canonicalScenarioInstant(instant: string, label: string): string;
+export declare function parseScenarioInstantMs(instant: string, label: string): number;
+export declare function parseScenarioDurationMs(duration: string, label: string): number;
+//# sourceMappingURL=time.d.ts.map

package/dist/scenario/time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["../../src/scenario/time.ts"],"names":[],"mappings":"AAYA,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GACZ,MAAM,CAER;AAED,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,GACZ,MAAM,CAgBR;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACZ,MAAM,CAgBR"}

package/dist/scenario/time.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalScenarioInstant = canonicalScenarioInstant;
+exports.parseScenarioInstantMs = parseScenarioInstantMs;
+exports.parseScenarioDurationMs = parseScenarioDurationMs;
+const ISO_INSTANT_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
+const DURATION_PATTERN = /^(\d+)(ms|s|m|h|d)$/;
+const DURATION_UNIT_MS = {
+    ms: 1,
+    s: 1_000,
+    m: 60_000,
+    h: 3_600_000,
+    d: 86_400_000,
+};
+function canonicalScenarioInstant(instant, label) {
+    return new Date(parseScenarioInstantMs(instant, label)).toISOString();
+}
+function parseScenarioInstantMs(instant, label) {
+    if (!ISO_INSTANT_PATTERN.test(instant)) {
+        throw new RangeError(`${label} must be an ISO-8601 UTC instant`);
+    }
+    const epochMs = Date.parse(instant);
+    if (!Number.isFinite(epochMs)) {
+        throw new RangeError(`${label} must be a valid ISO-8601 UTC instant`);
+    }
+    const canonical = new Date(epochMs).toISOString();
+    if (instant !== canonical && instant !== canonical.replace(".000Z", "Z")) {
+        throw new RangeError(`${label} must be a valid ISO-8601 UTC instant`);
+    }
+    return epochMs;
+}
+function parseScenarioDurationMs(duration, label) {
+    const match = DURATION_PATTERN.exec(duration);
+    if (match === null) {
+        throw new RangeError(`${label} must be a duration like 0m, 15m, 6h, or 1d`);
+    }
+    const amountText = match[1];
+    const unit = match[2];
+    const amount = Number(amountText);
+    const ms = amount * DURATION_UNIT_MS[unit];
+    if (!Number.isSafeInteger(ms)) {
+        throw new RangeError(`${label} duration is outside safe integer range`);
+    }
+    return ms;
+}

package/dist/scenario/types.d.ts

@@ -0,0 +1,149 @@
+import type { ReceiptRecheckKindV0, ReceiptV0 } from "@openprose/reactor/receipt";
+import type { ReactorConnectorRequestV0, ReactorConnectorResponseV0, ReactorIngestResultV0, ReactorModelGatewayRequestV0, ReactorModelGatewayResponseV0 } from "@openprose/reactor/sdk";
+export declare const REACTOR_SCENARIO_SCHEMA_V0: "openprose.reactor-cradle.scenario";
+export declare const REACTOR_SCENARIO_VERSION_V0: 0;
+export type ScenarioFieldValueV0 = string | number | boolean;
+export type ScenarioFieldsV0 = Readonly<Record<string, ScenarioFieldValueV0>>;
+export type ScenarioWorldProfileV0 = "static" | "periodic-surprise" | "adversarial-silent";
+export interface ReactorScenarioV0 {
+    readonly schema: typeof REACTOR_SCENARIO_SCHEMA_V0;
+    readonly v: typeof REACTOR_SCENARIO_VERSION_V0;
+    readonly id: string;
+    readonly world: ScenarioWorldConfigV0;
+    readonly initial_instant: string;
+    readonly cassette: ScenarioCassetteReferenceV0;
+    readonly sources: readonly ScenarioSourceV0[];
+    readonly script: readonly ScenarioScriptStepV0[];
+    readonly expect: ScenarioExpectationsV0;
+}
+export interface ScenarioWorldConfigV0 {
+    readonly profile: ScenarioWorldProfileV0;
+    readonly every_events?: number;
+}
+export interface ScenarioCassetteReferenceV0 {
+    readonly path: string;
+}
+export interface ScenarioSourceV0 {
+    readonly id: string;
+    readonly kind?: string;
+    readonly fixture_ref?: string;
+    readonly fields: ScenarioFieldsV0;
+}
+export type ScenarioStepTimeV0 = {
+    readonly at: string;
+} | {
+    readonly after: string;
+};
+interface ScenarioScriptStepBaseV0 {
+    readonly time: ScenarioStepTimeV0;
+    readonly label?: string;
+    readonly fields: ScenarioFieldsV0;
+}
+export interface ScenarioIngestStepV0 extends ScenarioScriptStepBaseV0 {
+    readonly kind: "ingest";
+    readonly event: string;
+    readonly source_id?: string;
+}
+export interface ScenarioTickStepV0 extends ScenarioScriptStepBaseV0 {
+    readonly kind: "tick";
+    readonly recheck_kind?: ReceiptRecheckKindV0;
+}
+export interface ScenarioReadStepV0 extends ScenarioScriptStepBaseV0 {
+    readonly kind: "read";
+    readonly source_id: string;
+}
+export interface ScenarioModelStepV0 extends ScenarioScriptStepBaseV0 {
+    readonly kind: "model";
+    readonly request_kind: ReactorModelGatewayRequestV0["kind"];
+    readonly prompt: string;
+}
+export type ScenarioScriptStepV0 = ScenarioIngestStepV0 | ScenarioTickStepV0 | ScenarioReadStepV0 | ScenarioModelStepV0;
+export interface ScenarioExpectationsV0 {
+    readonly relationships: readonly ScenarioExpectedRelationshipV0[];
+}
+export interface ScenarioExpectedRelationshipV0 {
+    readonly relationship: string;
+    readonly fields: ScenarioFieldsV0;
+}
+export interface ScenarioClockAdapterV0 {
+    readonly now: () => string;
+    readonly advanceMs?: (ms: number) => void;
+    readonly set?: (instant: string) => void;
+}
+export interface ScenarioWorldSurpriseV0 {
+    readonly profile: ScenarioWorldProfileV0;
+    readonly count: number;
+    readonly causes: readonly string[];
+}
+export interface ScenarioWorldReadResponseV0 extends ReactorConnectorResponseV0 {
+    readonly surprise?: ScenarioWorldSurpriseV0;
+}
+export interface ScenarioWorldEventInputV0 {
+    readonly scenario_id: string;
+    readonly profile: ScenarioWorldProfileV0;
+    readonly event: string;
+    readonly source_id?: string;
+    readonly as_of: string;
+    readonly fields: ScenarioFieldsV0;
+}
+export interface ScenarioWorldEventResultV0 {
+    readonly surprise?: ScenarioWorldSurpriseV0;
+    readonly payload?: unknown;
+}
+export interface ScenarioWorldAdvanceInputV0 {
+    readonly scenario_id: string;
+    readonly profile: ScenarioWorldProfileV0;
+    readonly as_of: string;
+}
+export interface ScenarioWorldAdvanceResultV0 {
+    readonly surprise?: ScenarioWorldSurpriseV0;
+    readonly payload?: unknown;
+}
+export interface ScenarioWorldAdapterV0 {
+    readonly read: (request: ReactorConnectorRequestV0) => ScenarioWorldReadResponseV0;
+    readonly applyEvent?: (event: ScenarioWorldEventInputV0) => ScenarioWorldEventResultV0;
+    readonly advanceTo?: (input: ScenarioWorldAdvanceInputV0) => ScenarioWorldAdvanceResultV0;
+}
+export interface ScenarioRunnerStorageV0 {
+    readonly listReceipts: () => readonly ReceiptV0[];
+}
+export interface ScenarioRunnerReactorV0 {
+    readonly ingest: (event: unknown) => ReactorIngestResultV0;
+    readonly receipts: () => readonly ReceiptV0[];
+}
+export interface ScenarioRunTraceEntryV0 {
+    readonly index: number;
+    readonly step: ScenarioScriptStepV0;
+    readonly as_of: string;
+    readonly world_advance?: ScenarioWorldAdvanceResultV0;
+    readonly world_event?: ScenarioWorldEventResultV0;
+    readonly world_reads: readonly ScenarioWorldObservationV0[];
+    readonly model_request?: ReactorModelGatewayRequestV0;
+    readonly model_response?: ReactorModelGatewayResponseV0;
+    readonly reactor_ingest?: ReactorIngestResultV0;
+    readonly reactor_ingests?: readonly ReactorIngestResultV0[];
+}
+export interface ScenarioWorldObservationV0 {
+    readonly source_id: string;
+    readonly as_of: string;
+    readonly payload: unknown;
+    readonly surprise?: ScenarioWorldSurpriseV0;
+}
+export interface ScenarioReceiptLogV0 {
+    readonly entries: readonly ReceiptV0[];
+    readonly content_hashes: readonly string[];
+}
+export interface ScenarioRunReceiptV0 {
+    readonly scenario_id: string;
+    readonly schema: typeof REACTOR_SCENARIO_SCHEMA_V0;
+    readonly v: typeof REACTOR_SCENARIO_VERSION_V0;
+    readonly world_profile: ScenarioWorldProfileV0;
+    readonly cassette_path: string;
+    readonly initial_instant: string;
+    readonly final_instant: string;
+    readonly trace: readonly ScenarioRunTraceEntryV0[];
+    readonly receipt_log: ScenarioReceiptLogV0;
+    readonly expected_relationships: readonly ScenarioExpectedRelationshipV0[];
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/scenario/types.d.ts.map

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

package/dist/scenario/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REACTOR_SCENARIO_VERSION_V0 = exports.REACTOR_SCENARIO_SCHEMA_V0 = void 0;
+exports.REACTOR_SCENARIO_SCHEMA_V0 = "openprose.reactor-cradle.scenario";
+exports.REACTOR_SCENARIO_VERSION_V0 = 0;

package/dist/spikes/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./k1-ensemble-spread";
+export * from "./k2-policy-author";
+export * from "./live-refresh";
+export declare const REACTOR_CRADLE_SPIKE_PUBLIC_EXPORTS_V0: Readonly<{
+    readonly live_refresh: "./spikes/live-refresh";
+    readonly k1_ensemble_spread: "./spikes/k1-ensemble-spread";
+    readonly k2_policy_author: "./spikes/k2-policy-author";
+}>;
+export declare const REACTOR_CRADLE_SPIKE_INTEGRATION_NOTES_V0: readonly ["K1/K2 spike evaluators are recorded-only by default; normal tests must not invoke live model refresh.", "Live OpenRouter refresh is an explicit opt-in guard path with cap/accounting input and secret redaction."];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/spikes/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAE/B,eAAO,MAAM,sCAAsC;;;;EAIxC,CAAC;AAEZ,eAAO,MAAM,yCAAyC,gOAG3C,CAAC"}