@a5c-ai/babysitter-sdk 0.0.16

package/dist/runtime/replay/createReplayEngine.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReplayEngine = createReplayEngine;
+const runFiles_1 = require("../../storage/runFiles");
+const effectIndex_1 = require("./effectIndex");
+const replayCursor_1 = require("./replayCursor");
+const processContext_1 = require("../processContext");
+const constants_1 = require("../constants");
+const exceptions_1 = require("../exceptions");
+const stateCache_1 = require("./stateCache");
+async function createReplayEngine(options) {
+    const metadata = await (0, runFiles_1.readRunMetadata)(options.runDir);
+    ensureCompatibleLayout(metadata.layoutVersion, options.runDir);
+    const inputs = await (0, runFiles_1.readRunInputs)(options.runDir);
+    const effectIndex = await (0, effectIndex_1.buildEffectIndex)({ runDir: options.runDir });
+    const { snapshot: stateCacheSnapshot, rebuildMeta: stateRebuild } = await resolveStateCacheSnapshot({
+        runDir: options.runDir,
+        effectIndex,
+    });
+    const replayCursor = new replayCursor_1.ReplayCursor();
+    const processId = metadata.processId ?? metadata.request ?? metadata.runId;
+    const { context, internalContext } = (0, processContext_1.createProcessContext)({
+        runId: metadata.runId,
+        runDir: options.runDir,
+        processId,
+        effectIndex,
+        replayCursor,
+        now: options.now,
+        logger: options.logger,
+    });
+    return {
+        runId: metadata.runId,
+        runDir: options.runDir,
+        metadata,
+        inputs,
+        effectIndex,
+        replayCursor,
+        context,
+        internalContext,
+        stateCache: stateCacheSnapshot,
+        stateRebuild,
+    };
+}
+async function resolveStateCacheSnapshot({ runDir, effectIndex, }) {
+    let existingSnapshot = null;
+    let corrupted = false;
+    try {
+        existingSnapshot = await (0, stateCache_1.readStateCache)(runDir);
+    }
+    catch {
+        corrupted = true;
+    }
+    if (corrupted || !existingSnapshot) {
+        const reason = corrupted ? "corrupt_cache" : "missing_cache";
+        const rebuilt = await (0, stateCache_1.rebuildStateCache)(runDir, { effectIndex, reason });
+        return { snapshot: rebuilt, rebuildMeta: { reason, previous: null } };
+    }
+    const journalHead = effectIndex.getJournalHead() ?? null;
+    if (!(0, stateCache_1.journalHeadsEqual)(existingSnapshot.journalHead, journalHead)) {
+        const rebuilt = await (0, stateCache_1.rebuildStateCache)(runDir, {
+            effectIndex,
+            reason: "journal_mismatch",
+        });
+        return {
+            snapshot: rebuilt,
+            rebuildMeta: { reason: "journal_mismatch", previous: existingSnapshot.journalHead ?? null },
+        };
+    }
+    return { snapshot: existingSnapshot, rebuildMeta: null };
+}
+function ensureCompatibleLayout(layoutVersion, runDir) {
+    if (!layoutVersion) {
+        throw new exceptions_1.RunFailedError("Run metadata is missing layoutVersion", { runDir });
+    }
+    if (layoutVersion !== constants_1.replaySchemaVersion) {
+        throw new exceptions_1.RunFailedError("Run layout version is not supported by this runtime", {
+            expected: constants_1.replaySchemaVersion,
+            actual: layoutVersion,
+            runDir,
+        });
+    }
+}

package/dist/runtime/replay/effectIndex.d.ts

@@ -0,0 +1,34 @@
+import { JournalEvent } from "../../storage/types";
+import { EffectRecord } from "../types";
+export interface BuildEffectIndexOptions {
+    runDir: string;
+    events?: JournalEvent[];
+}
+export declare class EffectIndex {
+    private readonly runDir;
+    private readonly byInvocation;
+    private readonly byEffectId;
+    private journalHead?;
+    private initialized;
+    private constructor();
+    static build(options: BuildEffectIndexOptions): Promise<EffectIndex>;
+    private applyEvents;
+    applyEvent(event: JournalEvent, expectedSeq?: number): void;
+    getByInvocation(invocationKey: string): EffectRecord | undefined;
+    getByEffectId(effectId: string): EffectRecord | undefined;
+    listEffects(): EffectRecord[];
+    listPendingEffects(): EffectRecord[];
+    getJournalHead(): {
+        seq: number;
+        ulid: string;
+    } | undefined;
+    private validateSequence;
+    private handleEffectRequested;
+    private handleEffectResolved;
+    private expectObject;
+    private expectString;
+    private expectOptionalString;
+    private normalizeLabelArray;
+}
+export declare function buildEffectIndex(options: BuildEffectIndexOptions): Promise<EffectIndex>;
+//# sourceMappingURL=effectIndex.d.ts.map

package/dist/runtime/replay/effectIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effectIndex.d.ts","sourceRoot":"","sources":["../../../src/runtime/replay/effectIndex.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD,OAAO,EAAE,YAAY,EAAuC,MAAM,UAAU,CAAC;AAG7E,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;CACzB;AA0BD,qBAAa,WAAW;IAMF,OAAO,CAAC,QAAQ,CAAC,MAAM;IAL3C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAmC;IAChE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAmC;IAC9D,OAAO,CAAC,WAAW,CAAC,CAAgC;IACpD,OAAO,CAAC,WAAW,CAAS;IAE5B,OAAO;WAEM,KAAK,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,WAAW,CAAC;IAQ1E,OAAO,CAAC,WAAW;IAOnB,UAAU,CAAC,KAAK,EAAE,YAAY,EAAE,WAAW,CAAC,EAAE,MAAM;IAsBpD,eAAe,CAAC,aAAa,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAIhE,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS;IAIzD,WAAW,IAAI,YAAY,EAAE;IAI7B,kBAAkB,IAAI,YAAY,EAAE;IAIpC,cAAc;aA1De,MAAM;cAAQ,MAAM;;IA8DjD,OAAO,CAAC,gBAAgB;IA2CxB,OAAO,CAAC,qBAAqB;IAmC7B,OAAO,CAAC,oBAAoB;IAoC5B,OAAO,CAAC,YAAY;IAOpB,OAAO,CAAC,YAAY;IASpB,OAAO,CAAC,oBAAoB;IAU5B,OAAO,CAAC,mBAAmB;CAkB5B;AA2BD,wBAAsB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,WAAW,CAAC,CAE7F"}

package/dist/runtime/replay/effectIndex.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EffectIndex = void 0;
+exports.buildEffectIndex = buildEffectIndex;
+const journal_1 = require("../../storage/journal");
+const exceptions_1 = require("../exceptions");
+const errorUtils_1 = require("../errorUtils");
+class EffectIndex {
+    runDir;
+    byInvocation = new Map();
+    byEffectId = new Map();
+    journalHead;
+    initialized = false;
+    constructor(runDir) {
+        this.runDir = runDir;
+    }
+    static async build(options) {
+        const events = options.events ?? (await loadJournalSafe(options.runDir));
+        const index = new EffectIndex(options.runDir);
+        index.applyEvents(events);
+        index.initialized = true;
+        return index;
+    }
+    applyEvents(events) {
+        events.forEach((event, idx) => {
+            const expectedSeq = idx + 1;
+            this.applyEvent(event, expectedSeq);
+        });
+    }
+    applyEvent(event, expectedSeq) {
+        this.validateSequence(event, expectedSeq);
+        const type = event.type;
+        switch (type) {
+            case "RUN_CREATED":
+            case "RUN_COMPLETED":
+            case "RUN_FAILED":
+                return;
+            case "EFFECT_REQUESTED":
+                this.handleEffectRequested(event);
+                return;
+            case "EFFECT_RESOLVED":
+                this.handleEffectResolved(event);
+                return;
+            default:
+                throw new exceptions_1.RunFailedError(`Unknown journal event type '${event.type}'`, {
+                    path: event.path,
+                    seq: event.seq,
+                });
+        }
+    }
+    getByInvocation(invocationKey) {
+        return this.byInvocation.get(invocationKey);
+    }
+    getByEffectId(effectId) {
+        return this.byEffectId.get(effectId);
+    }
+    listEffects() {
+        return Array.from(this.byEffectId.values());
+    }
+    listPendingEffects() {
+        return this.listEffects().filter((record) => record.status === "requested");
+    }
+    getJournalHead() {
+        return this.journalHead;
+    }
+    validateSequence(event, expectedSeq) {
+        if (!Number.isFinite(event.seq) || event.seq <= 0) {
+            throw new exceptions_1.RunFailedError(`Invalid journal sequence number in ${event.filename}`, {
+                path: event.path,
+            });
+        }
+        if (typeof event.ulid !== "string" || !event.ulid) {
+            throw new exceptions_1.RunFailedError(`Invalid ULID on journal event ${event.filename}`, {
+                path: event.path,
+            });
+        }
+        if (!this.journalHead) {
+            if (event.seq !== (expectedSeq ?? 1)) {
+                throw new exceptions_1.RunFailedError(`Journal seq mismatch at ${event.filename} (expected 1, got ${event.seq})`, {
+                    path: event.path,
+                });
+            }
+            this.journalHead = { seq: event.seq, ulid: event.ulid };
+            return;
+        }
+        const nextSeq = this.journalHead.seq + 1;
+        const shouldMatch = expectedSeq ?? nextSeq;
+        if (event.seq !== shouldMatch) {
+            throw new exceptions_1.RunFailedError(`Journal sequence gap detected at ${event.filename} (expected ${shouldMatch}, got ${event.seq})`, { path: event.path });
+        }
+        if (event.seq <= this.journalHead.seq) {
+            throw new exceptions_1.RunFailedError(`Journal sequence regression at ${event.filename} (prev ${this.journalHead.seq}, got ${event.seq})`, { path: event.path });
+        }
+        if (event.ulid <= this.journalHead.ulid) {
+            throw new exceptions_1.RunFailedError(`Journal ULID order regression at ${event.filename} (${event.ulid} <= ${this.journalHead.ulid})`, { path: event.path });
+        }
+        this.journalHead = { seq: event.seq, ulid: event.ulid };
+    }
+    handleEffectRequested(event) {
+        const payload = this.expectObject(event, "EFFECT_REQUESTED");
+        const effectId = this.expectString(payload.effectId, "effectId", event);
+        const invocationKey = this.expectString(payload.invocationKey, "invocationKey", event);
+        const stepId = this.expectString(payload.stepId, "stepId", event);
+        const taskId = this.expectString(payload.taskId, "taskId", event);
+        const taskDefRef = this.expectString(payload.taskDefRef, "taskDefRef", event);
+        const inputsRef = this.expectOptionalString(payload.inputsRef, "inputsRef", event);
+        const labels = this.normalizeLabelArray(payload.labels, event);
+        if (this.byEffectId.has(effectId)) {
+            throw new exceptions_1.RunFailedError(`Duplicate effectId detected: ${effectId}`, { path: event.path });
+        }
+        if (this.byInvocation.has(invocationKey)) {
+            throw new exceptions_1.RunFailedError(`Duplicate invocation key detected: ${invocationKey}`, {
+                path: event.path,
+            });
+        }
+        const record = {
+            effectId,
+            invocationKey,
+            invocationHash: payload.invocationHash,
+            stepId,
+            taskId,
+            status: "requested",
+            kind: payload.kind,
+            label: payload.label,
+            labels,
+            taskDefRef,
+            inputsRef,
+            requestedAt: event.recordedAt,
+        };
+        this.byInvocation.set(record.invocationKey, record);
+        this.byEffectId.set(record.effectId, record);
+    }
+    handleEffectResolved(event) {
+        const payload = this.expectObject(event, "EFFECT_RESOLVED");
+        const effectId = this.expectString(payload.effectId, "effectId", event);
+        if (!payload.status) {
+            throw new exceptions_1.RunFailedError("Malformed EFFECT_RESOLVED event missing status", { path: event.path });
+        }
+        if (payload.status !== "ok" && payload.status !== "error") {
+            throw new exceptions_1.RunFailedError(`Unknown EFFECT_RESOLVED status '${payload.status}'`, { path: event.path });
+        }
+        if (payload.resultRef && typeof payload.resultRef !== "string") {
+            throw new exceptions_1.RunFailedError("Malformed EFFECT_RESOLVED event resultRef", { path: event.path });
+        }
+        if (payload.stdoutRef && typeof payload.stdoutRef !== "string") {
+            throw new exceptions_1.RunFailedError("Malformed EFFECT_RESOLVED stdoutRef", { path: event.path });
+        }
+        if (payload.stderrRef && typeof payload.stderrRef !== "string") {
+            throw new exceptions_1.RunFailedError("Malformed EFFECT_RESOLVED stderrRef", { path: event.path });
+        }
+        const record = this.byEffectId.get(effectId);
+        if (!record) {
+            throw new exceptions_1.RunFailedError(`EFFECT_RESOLVED references unknown effectId ${effectId}`, {
+                path: event.path,
+            });
+        }
+        if (record.status !== "requested") {
+            throw new exceptions_1.RunFailedError(`Effect ${effectId} already resolved`, { path: event.path });
+        }
+        const status = payload.status === "ok" ? "resolved_ok" : "resolved_error";
+        record.status = status;
+        record.resultRef = payload.resultRef;
+        record.error = payload.error;
+        record.stdoutRef = payload.stdoutRef;
+        record.stderrRef = payload.stderrRef;
+        record.resolvedAt = event.recordedAt;
+    }
+    expectObject(event, type) {
+        if (!event?.data || typeof event.data !== "object") {
+            throw new exceptions_1.RunFailedError(`Malformed ${type} event payload`, { path: event.path });
+        }
+        return event.data;
+    }
+    expectString(value, field, event) {
+        if (typeof value !== "string" || value.length === 0) {
+            throw new exceptions_1.RunFailedError(`Malformed journal event missing ${field}`, {
+                path: event.path,
+            });
+        }
+        return value;
+    }
+    expectOptionalString(value, field, event) {
+        if (value === undefined)
+            return undefined;
+        if (typeof value !== "string" || value.length === 0) {
+            throw new exceptions_1.RunFailedError(`Malformed journal event ${field}`, {
+                path: event.path,
+            });
+        }
+        return value;
+    }
+    normalizeLabelArray(value, event) {
+        if (value === undefined)
+            return undefined;
+        if (!Array.isArray(value)) {
+            throw new exceptions_1.RunFailedError("Malformed EFFECT_REQUESTED labels payload", { path: event.path });
+        }
+        const seen = new Set();
+        const labels = [];
+        for (const entry of value) {
+            if (typeof entry !== "string") {
+                throw new exceptions_1.RunFailedError("Malformed EFFECT_REQUESTED labels entry", { path: event.path });
+            }
+            const trimmed = entry.trim();
+            if (!trimmed || seen.has(trimmed))
+                continue;
+            seen.add(trimmed);
+            labels.push(trimmed);
+        }
+        return labels.length ? labels : undefined;
+    }
+}
+exports.EffectIndex = EffectIndex;
+async function loadJournalSafe(runDir) {
+    try {
+        return await (0, journal_1.loadJournal)(runDir);
+    }
+    catch (error) {
+        throw normalizeJournalError(error, runDir);
+    }
+}
+function normalizeJournalError(error, runDir) {
+    if (error instanceof exceptions_1.RunFailedError)
+        return error;
+    const err = error;
+    if (err?.code === "JOURNAL_PARSE_FAILED") {
+        return new exceptions_1.RunFailedError("Failed to parse journal event", {
+            path: err.path,
+            runDir,
+            error: err.message,
+        });
+    }
+    const serialized = (0, errorUtils_1.serializeUnknownError)(err);
+    return new exceptions_1.RunFailedError("Failed to load journal for replay", {
+        runDir,
+        error: serialized,
+    });
+}
+async function buildEffectIndex(options) {
+    return EffectIndex.build(options);
+}

package/dist/runtime/replay/index.d.ts

@@ -0,0 +1,7 @@
+export { ReplayCursor } from "./replayCursor";
+export { EffectIndex, buildEffectIndex } from "./effectIndex";
+export { createReplayEngine } from "./createReplayEngine";
+export type { ReplayEngine, CreateReplayEngineOptions } from "./createReplayEngine";
+export { STATE_CACHE_SCHEMA_VERSION, createStateCacheSnapshot, journalHeadsEqual, normalizeJournalHead, normalizeSnapshot, readStateCache, rebuildStateCache, writeStateCache, } from "./stateCache";
+export type { StateCacheSnapshot, StateCacheJournalHead, DerivedEffectSummary } from "./stateCache";
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/replay/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/replay/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,YAAY,EAAE,YAAY,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AACpF,OAAO,EACL,0BAA0B,EAC1B,wBAAwB,EACxB,iBAAiB,EACjB,oBAAoB,EACpB,iBAAiB,EACjB,cAAc,EACd,iBAAiB,EACjB,eAAe,GAChB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC"}

package/dist/runtime/replay/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeStateCache = exports.rebuildStateCache = exports.readStateCache = exports.normalizeSnapshot = exports.normalizeJournalHead = exports.journalHeadsEqual = exports.createStateCacheSnapshot = exports.STATE_CACHE_SCHEMA_VERSION = exports.createReplayEngine = exports.buildEffectIndex = exports.EffectIndex = exports.ReplayCursor = void 0;
+var replayCursor_1 = require("./replayCursor");
+Object.defineProperty(exports, "ReplayCursor", { enumerable: true, get: function () { return replayCursor_1.ReplayCursor; } });
+var effectIndex_1 = require("./effectIndex");
+Object.defineProperty(exports, "EffectIndex", { enumerable: true, get: function () { return effectIndex_1.EffectIndex; } });
+Object.defineProperty(exports, "buildEffectIndex", { enumerable: true, get: function () { return effectIndex_1.buildEffectIndex; } });
+var createReplayEngine_1 = require("./createReplayEngine");
+Object.defineProperty(exports, "createReplayEngine", { enumerable: true, get: function () { return createReplayEngine_1.createReplayEngine; } });
+var stateCache_1 = require("./stateCache");
+Object.defineProperty(exports, "STATE_CACHE_SCHEMA_VERSION", { enumerable: true, get: function () { return stateCache_1.STATE_CACHE_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "createStateCacheSnapshot", { enumerable: true, get: function () { return stateCache_1.createStateCacheSnapshot; } });
+Object.defineProperty(exports, "journalHeadsEqual", { enumerable: true, get: function () { return stateCache_1.journalHeadsEqual; } });
+Object.defineProperty(exports, "normalizeJournalHead", { enumerable: true, get: function () { return stateCache_1.normalizeJournalHead; } });
+Object.defineProperty(exports, "normalizeSnapshot", { enumerable: true, get: function () { return stateCache_1.normalizeSnapshot; } });
+Object.defineProperty(exports, "readStateCache", { enumerable: true, get: function () { return stateCache_1.readStateCache; } });
+Object.defineProperty(exports, "rebuildStateCache", { enumerable: true, get: function () { return stateCache_1.rebuildStateCache; } });
+Object.defineProperty(exports, "writeStateCache", { enumerable: true, get: function () { return stateCache_1.writeStateCache; } });

package/dist/runtime/replay/replayCursor.d.ts

@@ -0,0 +1,7 @@
+export declare class ReplayCursor {
+    private counter;
+    nextStepId(): string;
+    peekNextStepId(): string;
+    get value(): number;
+}
+//# sourceMappingURL=replayCursor.d.ts.map

package/dist/runtime/replay/replayCursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replayCursor.d.ts","sourceRoot":"","sources":["../../../src/runtime/replay/replayCursor.ts"],"names":[],"mappings":"AAGA,qBAAa,YAAY;IACvB,OAAO,CAAC,OAAO,CAAK;IAEpB,UAAU,IAAI,MAAM;IAKpB,cAAc,IAAI,MAAM;IAIxB,IAAI,KAAK,IAAI,MAAM,CAElB;CACF"}

package/dist/runtime/replay/replayCursor.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplayCursor = void 0;
+const STEP_PREFIX = "S";
+const STEP_WIDTH = 6;
+class ReplayCursor {
+    counter = 0;
+    nextStepId() {
+        this.counter += 1;
+        return formatStepId(this.counter);
+    }
+    peekNextStepId() {
+        return formatStepId(this.counter + 1);
+    }
+    get value() {
+        return this.counter;
+    }
+}
+exports.ReplayCursor = ReplayCursor;
+function formatStepId(value) {
+    return `${STEP_PREFIX}${Math.max(value, 0).toString().padStart(STEP_WIDTH, "0")}`;
+}

package/dist/runtime/replay/stateCache.d.ts

@@ -0,0 +1,48 @@
+import { EffectIndex } from "./effectIndex";
+import { EffectStatus } from "../types";
+export declare const STATE_CACHE_SCHEMA_VERSION = "2026.01.state-cache";
+export interface StateCacheJournalHead {
+    seq: number;
+    ulid: string;
+    checksum?: string;
+}
+export interface DerivedEffectSummary {
+    effectId: string;
+    invocationKey: string;
+    status: EffectStatus;
+    kind?: string;
+    label?: string;
+    taskId?: string;
+    stepId?: string;
+    requestedAt?: string;
+    resolvedAt?: string;
+}
+export interface StateCacheSnapshot {
+    schemaVersion: string;
+    savedAt: string;
+    journalHead?: StateCacheJournalHead | null;
+    stateVersion: number;
+    effectsByInvocation: Record<string, DerivedEffectSummary>;
+    pendingEffectsByKind: Record<string, number>;
+    rebuildReason?: string | null;
+}
+export interface CreateStateCacheSnapshotOptions {
+    journalHead?: StateCacheJournalHead | null;
+    savedAt?: string;
+    schemaVersion?: string;
+    stateVersion?: number;
+    effectsByInvocation?: Record<string, DerivedEffectSummary>;
+    pendingEffectsByKind?: Record<string, number>;
+    rebuildReason?: string | null;
+}
+export declare function readStateCache(runDir: string): Promise<StateCacheSnapshot | null>;
+export declare function writeStateCache(runDir: string, snapshot: StateCacheSnapshot): Promise<void>;
+export declare function journalHeadsEqual(a?: StateCacheJournalHead | null, b?: StateCacheJournalHead | null): boolean;
+export declare function createStateCacheSnapshot(journalHeadOrOptions?: StateCacheJournalHead | null | CreateStateCacheSnapshotOptions): StateCacheSnapshot;
+export declare function normalizeJournalHead(raw: unknown): StateCacheJournalHead | null | undefined;
+export declare function normalizeSnapshot(raw: unknown): StateCacheSnapshot;
+export declare function rebuildStateCache(runDir: string, opts?: {
+    effectIndex?: EffectIndex;
+    reason?: string;
+}): Promise<StateCacheSnapshot>;
+//# sourceMappingURL=stateCache.d.ts.map

package/dist/runtime/replay/stateCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stateCache.d.ts","sourceRoot":"","sources":["../../../src/runtime/replay/stateCache.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAoB,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAgB,YAAY,EAAE,MAAM,UAAU,CAAC;AAGtD,eAAO,MAAM,0BAA0B,wBAAwB,CAAC;AAEhE,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,YAAY,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,qBAAqB,GAAG,IAAI,CAAC;IAC3C,YAAY,EAAE,MAAM,CAAC;IACrB,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAC1D,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7C,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,MAAM,WAAW,+BAA+B;IAC9C,WAAW,CAAC,EAAE,qBAAqB,GAAG,IAAI,CAAC;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mBAAmB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAC3D,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9C,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAavF;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAKjG;AAED,wBAAgB,iBAAiB,CAC/B,CAAC,CAAC,EAAE,qBAAqB,GAAG,IAAI,EAChC,CAAC,CAAC,EAAE,qBAAqB,GAAG,IAAI,GAC/B,OAAO,CAMT;AAED,wBAAgB,wBAAwB,CACtC,oBAAoB,CAAC,EAAE,qBAAqB,GAAG,IAAI,GAAG,+BAA+B,GACpF,kBAAkB,CAcpB;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,qBAAqB,GAAG,IAAI,GAAG,SAAS,CAU3F;AAED,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,kBAAkB,CA2BlE;AAED,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE;IAAE,WAAW,CAAC,EAAE,WAAW,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GACpD,OAAO,CAAC,kBAAkB,CAAC,CAmB7B"}