@a5c-ai/babysitter-sdk 0.0.16

package/dist/runtime/intrinsics/task.js

@@ -0,0 +1,237 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTaskIntrinsic = runTaskIntrinsic;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const journal_1 = require("../../storage/journal");
+const tasks_1 = require("../../storage/tasks");
+const ulids_1 = require("../../storage/ulids");
+const exceptions_1 = require("../exceptions");
+const invocation_1 = require("../invocation");
+const instrumentation_1 = require("../instrumentation");
+const context_1 = require("../../tasks/context");
+const registry_1 = require("../../tasks/registry");
+const serializer_1 = require("../../tasks/serializer");
+async function runTaskIntrinsic(options) {
+    const { task } = options;
+    if (!task || typeof task.build !== "function" || typeof task.id !== "string" || !task.id) {
+        throw new exceptions_1.InvalidTaskDefinitionError("ctx.task requires a DefinedTask created via defineTask()");
+    }
+    const stepId = options.context.replayCursor.nextStepId();
+    const invocation = (0, invocation_1.hashInvocationKey)({
+        processId: options.context.processId,
+        stepId,
+        taskId: task.id,
+    });
+    const existing = options.context.effectIndex.getByInvocation(invocation.key);
+    if (existing) {
+        return handleExistingInvocation(existing, options);
+    }
+    return requestNewEffect(stepId, invocation.key, invocation.digest, options);
+}
+async function handleExistingInvocation(record, options) {
+    if (record.status === "requested") {
+        const taskDef = await ensureTaskDefinition(options.context.runDir, record);
+        throw new exceptions_1.EffectPendingError(buildEffectAction(record, taskDef));
+    }
+    if (record.status === "resolved_error") {
+        const error = record.error ? (0, exceptions_1.rehydrateSerializedError)(record.error) : new Error("Task failed");
+        throw error;
+    }
+    const stored = await (0, tasks_1.readTaskResult)(options.context.runDir, record.effectId, record.resultRef ? normalizeRef(options.context.runDir, record.resultRef) : undefined);
+    if (!stored) {
+        throw new exceptions_1.RunFailedError(`Result for effect ${record.effectId} is missing from disk`, {
+            effectId: record.effectId,
+        });
+    }
+    if (stored.status !== "ok") {
+        const err = stored.error ? (0, exceptions_1.rehydrateSerializedError)(stored.error) : new Error("Task reported failure");
+        throw err;
+    }
+    const value = await resolveStoredResultValue(options.context.runDir, stored);
+    return value;
+}
+async function requestNewEffect(stepId, invocationKey, invocationHash, options) {
+    const effectId = (0, ulids_1.nextUlid)();
+    const buildCtx = (0, context_1.createTaskBuildContext)({
+        effectId,
+        runId: options.context.runId,
+        runDir: options.context.runDir,
+        invocationKey,
+        taskId: options.task.id,
+        label: options.invokeOptions?.label,
+    });
+    const taskDef = await Promise.resolve(options.task.build(options.args, buildCtx));
+    if (!taskDef || typeof taskDef.kind !== "string") {
+        throw new exceptions_1.InvalidTaskDefinitionError(`Task ${options.task.id} did not provide a kind`);
+    }
+    const { taskRef: taskDefRef, inputsRef } = await (0, serializer_1.serializeAndWriteTaskDefinition)({
+        runDir: options.context.runDir,
+        effectId,
+        taskId: options.task.id,
+        invocationKey,
+        stepId,
+        task: taskDef,
+        inputs: options.args,
+    });
+    const kind = taskDef.kind;
+    const normalizedLabels = collectInvocationLabels(buildCtx, taskDef);
+    const label = deriveEffectLabel(buildCtx, taskDef, normalizedLabels, options.task.id);
+    const labelMetadata = normalizedLabels.length ? normalizedLabels : undefined;
+    const eventPayload = {
+        effectId,
+        invocationKey,
+        invocationHash,
+        stepId,
+        taskId: options.task.id,
+        kind,
+        label,
+        taskDefRef,
+        inputsRef,
+        labels: labelMetadata,
+    };
+    const appendResult = await (0, journal_1.appendEvent)({
+        runDir: options.context.runDir,
+        eventType: "EFFECT_REQUESTED",
+        event: eventPayload,
+    });
+    const syntheticEvent = {
+        seq: appendResult.seq,
+        ulid: appendResult.ulid,
+        filename: appendResult.filename,
+        path: appendResult.path,
+        type: "EFFECT_REQUESTED",
+        recordedAt: appendResult.recordedAt,
+        data: eventPayload,
+        checksum: appendResult.checksum,
+    };
+    try {
+        options.context.effectIndex.applyEvent(syntheticEvent);
+    }
+    catch (error) {
+        (0, instrumentation_1.emitRuntimeMetric)(options.context.logger, "invocation.collision", {
+            invocationKey,
+            effectId,
+        });
+        throw new exceptions_1.InvocationCollisionError(invocationKey);
+    }
+    registry_1.globalTaskRegistry.recordEffect({
+        effectId,
+        invocationKey,
+        taskId: options.task.id,
+        kind,
+        label,
+        labels: normalizedLabels,
+        status: "pending",
+        taskDefRef,
+        inputsRef,
+        metadata: taskDef.metadata,
+        stepId,
+        requestedAt: appendResult.recordedAt,
+    });
+    const actionRecord = {
+        effectId,
+        invocationKey,
+        invocationHash,
+        stepId,
+        taskId: options.task.id,
+        status: "requested",
+        kind,
+        label,
+        labels: labelMetadata,
+        taskDefRef,
+        inputsRef,
+        requestedAt: appendResult.recordedAt,
+    };
+    const action = buildEffectAction(actionRecord, taskDef);
+    throw new exceptions_1.EffectRequestedError(action);
+}
+async function ensureTaskDefinition(runDir, record) {
+    const stored = await (0, tasks_1.readTaskDefinition)(runDir, record.effectId);
+    if (!stored) {
+        throw new exceptions_1.RunFailedError(`Task definition missing for effect ${record.effectId}`, {
+            effectId: record.effectId,
+        });
+    }
+    return stored;
+}
+function buildEffectAction(record, taskDef) {
+    const schedulerHints = deriveSchedulerHints(taskDef);
+    return {
+        effectId: record.effectId,
+        invocationKey: record.invocationKey,
+        kind: record.kind ?? taskDef.kind,
+        label: record.label ?? record.labels?.[0] ?? taskDef.title,
+        labels: record.labels ?? taskDef.labels,
+        taskDef,
+        taskId: record.taskId,
+        stepId: record.stepId,
+        taskDefRef: record.taskDefRef,
+        inputsRef: record.inputsRef,
+        requestedAt: record.requestedAt,
+        schedulerHints,
+    };
+}
+function deriveSchedulerHints(taskDef) {
+    const hints = {};
+    const sleepHint = extractSleepTarget(taskDef);
+    if (typeof sleepHint === "number" && Number.isFinite(sleepHint)) {
+        hints.sleepUntilEpochMs = sleepHint;
+    }
+    return Object.keys(hints).length ? hints : undefined;
+}
+function extractSleepTarget(taskDef) {
+    if (typeof taskDef.sleep?.targetEpochMs === "number") {
+        return taskDef.sleep.targetEpochMs;
+    }
+    const metadataTarget = taskDef.metadata?.targetEpochMs;
+    return typeof metadataTarget === "number" ? metadataTarget : undefined;
+}
+function normalizeRef(runDir, ref) {
+    return path_1.default.isAbsolute(ref) ? ref : path_1.default.join(runDir, ref);
+}
+async function resolveStoredResultValue(runDir, stored) {
+    if (stored.result !== undefined) {
+        return stored.result;
+    }
+    if (stored.value !== undefined) {
+        return stored.value;
+    }
+    if (stored.resultRef) {
+        const absolute = normalizeRef(runDir, stored.resultRef);
+        const raw = await fs_1.promises.readFile(absolute, "utf8");
+        return JSON.parse(raw);
+    }
+    throw new exceptions_1.RunFailedError("Result payload missing data", { effectId: stored.effectId });
+}
+function collectInvocationLabels(ctx, taskDef) {
+    const combined = [];
+    const addLabels = (values) => {
+        if (!Array.isArray(values))
+            return;
+        combined.push(...values);
+    };
+    addLabels(ctx.labels);
+    addLabels(taskDef.labels);
+    return dedupeLabels(combined);
+}
+function dedupeLabels(values) {
+    const seen = new Set();
+    const normalized = [];
+    for (const value of values) {
+        if (typeof value !== "string")
+            continue;
+        const trimmed = value.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        normalized.push(trimmed);
+    }
+    return normalized;
+}
+function deriveEffectLabel(ctx, taskDef, labels, fallbackTaskId) {
+    return ctx.label ?? labels[0] ?? taskDef.title ?? fallbackTaskId;
+}

package/dist/runtime/invocation/hashInvocationKey.d.ts

@@ -0,0 +1,12 @@
+export interface InvocationKeyComponents {
+    processId: string;
+    stepId: string;
+    taskId: string;
+}
+export interface InvocationKeyInfo {
+    key: string;
+    digest: string;
+    components: InvocationKeyComponents;
+}
+export declare function hashInvocationKey(components: InvocationKeyComponents): InvocationKeyInfo;
+//# sourceMappingURL=hashInvocationKey.d.ts.map

package/dist/runtime/invocation/hashInvocationKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashInvocationKey.d.ts","sourceRoot":"","sources":["../../../src/runtime/invocation/hashInvocationKey.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,uBAAuB,CAAC;CACrC;AAED,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,uBAAuB,GAAG,iBAAiB,CAIxF"}

package/dist/runtime/invocation/hashInvocationKey.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashInvocationKey = hashInvocationKey;
+const crypto_1 = __importDefault(require("crypto"));
+function hashInvocationKey(components) {
+    const key = `${components.processId}:${components.stepId}:${components.taskId}`;
+    const digest = crypto_1.default.createHash("sha256").update(key).digest("hex");
+    return { key, digest, components };
+}

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

@@ -0,0 +1,3 @@
+export { hashInvocationKey } from "./hashInvocationKey";
+export type { InvocationKeyComponents, InvocationKeyInfo } from "./hashInvocationKey";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/invocation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,YAAY,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/runtime/invocation/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashInvocationKey = void 0;
+var hashInvocationKey_1 = require("./hashInvocationKey");
+Object.defineProperty(exports, "hashInvocationKey", { enumerable: true, get: function () { return hashInvocationKey_1.hashInvocationKey; } });

package/dist/runtime/orchestrateIteration.d.ts

@@ -0,0 +1,3 @@
+import { IterationResult, OrchestrateOptions } from "./types";
+export declare function orchestrateIteration(options: OrchestrateOptions): Promise<IterationResult>;
+//# sourceMappingURL=orchestrateIteration.d.ts.map

package/dist/runtime/orchestrateIteration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrateIteration.d.ts","sourceRoot":"","sources":["../../src/runtime/orchestrateIteration.ts"],"names":[],"mappings":"AAYA,OAAO,EAEL,eAAe,EACf,kBAAkB,EAGnB,MAAM,SAAS,CAAC;AAWjB,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,eAAe,CAAC,CA2DhG"}

package/dist/runtime/orchestrateIteration.js

@@ -0,0 +1,195 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orchestrateIteration = orchestrateIteration;
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const journal_1 = require("../storage/journal");
+const runFiles_1 = require("../storage/runFiles");
+const createReplayEngine_1 = require("./replay/createReplayEngine");
+const processContext_1 = require("./processContext");
+const exceptions_1 = require("./exceptions");
+const errorUtils_1 = require("./errorUtils");
+const instrumentation_1 = require("./instrumentation");
+// Use an indirect dynamic import so TypeScript does not downlevel to require() in CommonJS builds.
+const dynamicImportModule = new Function("specifier", "return import(specifier);");
+async function orchestrateIteration(options) {
+    const iterationStartedAt = Date.now();
+    const nowFn = resolveNow(options.now);
+    const engine = await initializeReplayEngine(options, nowFn, iterationStartedAt);
+    const defaultEntrypoint = {
+        importPath: engine.metadata.entrypoint?.importPath ?? engine.metadata.processPath,
+        exportName: engine.metadata.entrypoint?.exportName,
+    };
+    const processFn = await loadProcessFunction(options, defaultEntrypoint, options.runDir);
+    const inputs = options.inputs ?? engine.inputs;
+    let finalStatus = "failed";
+    const logger = engine.internalContext.logger ?? options.logger;
+    try {
+        const output = await (0, processContext_1.withProcessContext)(engine.internalContext, () => processFn(inputs, engine.context, options.context));
+        const outputRef = await (0, runFiles_1.writeRunOutput)(options.runDir, output);
+        await (0, journal_1.appendEvent)({
+            runDir: options.runDir,
+            eventType: "RUN_COMPLETED",
+            event: {
+                outputRef,
+            },
+        });
+        const result = { status: "completed", output, metadata: createIterationMetadata(engine) };
+        finalStatus = result.status;
+        return result;
+    }
+    catch (error) {
+        const waiting = asWaitingResult(error);
+        if (waiting) {
+            finalStatus = waiting.status;
+            return {
+                status: "waiting",
+                nextActions: annotateWaitingActions(waiting.nextActions),
+                metadata: createIterationMetadata(engine),
+            };
+        }
+        const failure = (0, errorUtils_1.serializeUnknownError)(error);
+        await (0, journal_1.appendEvent)({
+            runDir: options.runDir,
+            eventType: "RUN_FAILED",
+            event: { error: failure },
+        });
+        const result = {
+            status: "failed",
+            error: failure,
+            metadata: createIterationMetadata(engine),
+        };
+        finalStatus = result.status;
+        return result;
+    }
+    finally {
+        (0, instrumentation_1.emitRuntimeMetric)(logger, "replay.iteration", {
+            duration_ms: Date.now() - iterationStartedAt,
+            status: finalStatus,
+            runId: engine.runId,
+            stepCount: engine.replayCursor.value,
+        });
+    }
+}
+async function loadProcessFunction(options, defaults, runDir) {
+    const importPath = options.process?.importPath ?? defaults.importPath;
+    if (!importPath) {
+        throw new exceptions_1.RunFailedError("Process import path is missing");
+    }
+    const exportName = options.process?.exportName ?? defaults.exportName ?? "process";
+    const resolvedPath = path_1.default.isAbsolute(importPath) ? importPath : path_1.default.resolve(runDir, importPath);
+    const moduleUrl = (0, url_1.pathToFileURL)(resolvedPath).href;
+    let mod;
+    try {
+        mod = await dynamicImportModule(moduleUrl);
+    }
+    catch (error) {
+        throw new exceptions_1.RunFailedError(`Failed to load process module at ${resolvedPath}`, {
+            error: (0, errorUtils_1.serializeUnknownError)(error),
+        });
+    }
+    const candidate = (exportName && mod[exportName]) ??
+        (!exportName && mod.default) ??
+        mod.process ??
+        mod.default;
+    if (typeof candidate !== "function") {
+        throw new exceptions_1.RunFailedError(`Export '${exportName}' was not a function in ${resolvedPath}`);
+    }
+    return candidate;
+}
+function asWaitingResult(error) {
+    if (error instanceof exceptions_1.ParallelPendingError) {
+        return { status: "waiting", nextActions: error.batch.actions };
+    }
+    if (error instanceof exceptions_1.EffectRequestedError || error instanceof exceptions_1.EffectPendingError) {
+        return { status: "waiting", nextActions: [error.action] };
+    }
+    return null;
+}
+function resolveNow(now) {
+    if (!now)
+        return () => new Date();
+    if (typeof now === "function") {
+        return now;
+    }
+    const fixed = now;
+    return () => fixed;
+}
+async function initializeReplayEngine(options, nowFn, iterationStartedAt) {
+    try {
+        return await (0, createReplayEngine_1.createReplayEngine)({ runDir: options.runDir, now: nowFn, logger: options.logger });
+    }
+    catch (error) {
+        (0, instrumentation_1.emitRuntimeMetric)(options.logger, "replay.iteration", {
+            duration_ms: Date.now() - iterationStartedAt,
+            status: "failed",
+            runDir: options.runDir,
+            phase: "initialize",
+            error: error instanceof Error ? error.message : String(error),
+        });
+        throw error;
+    }
+}
+function annotateWaitingActions(actions) {
+    const pendingCount = actions.length;
+    return actions.map((action) => {
+        const derivedSleep = deriveSleepHint(action);
+        const nextHints = mergeSchedulerHints(action.schedulerHints, {
+            pendingCount,
+            sleepUntilEpochMs: derivedSleep,
+        });
+        if (nextHints === action.schedulerHints ||
+            (nextHints === undefined && action.schedulerHints === undefined)) {
+            return action;
+        }
+        return {
+            ...action,
+            schedulerHints: nextHints,
+        };
+    });
+}
+function deriveSleepHint(action) {
+    if (typeof action.schedulerHints?.sleepUntilEpochMs === "number") {
+        return action.schedulerHints.sleepUntilEpochMs;
+    }
+    const direct = action.taskDef?.sleep?.targetEpochMs;
+    if (typeof direct === "number") {
+        return direct;
+    }
+    const metadataTarget = action.taskDef?.metadata?.targetEpochMs;
+    return typeof metadataTarget === "number" ? metadataTarget : undefined;
+}
+function mergeSchedulerHints(base, extra) {
+    const merged = { ...(base ?? {}) };
+    let changed = false;
+    if (extra.pendingCount !== undefined && merged.pendingCount !== extra.pendingCount) {
+        merged.pendingCount = extra.pendingCount;
+        changed = true;
+    }
+    if (extra.sleepUntilEpochMs !== undefined &&
+        merged.sleepUntilEpochMs !== extra.sleepUntilEpochMs) {
+        merged.sleepUntilEpochMs = extra.sleepUntilEpochMs;
+        changed = true;
+    }
+    if (extra.parallelGroupId !== undefined &&
+        merged.parallelGroupId !== extra.parallelGroupId) {
+        merged.parallelGroupId = extra.parallelGroupId;
+        changed = true;
+    }
+    if (!changed) {
+        return base;
+    }
+    return merged;
+}
+function createIterationMetadata(engine) {
+    return {
+        stateVersion: engine.stateCache?.stateVersion,
+        pendingEffectsByKind: engine.stateCache?.pendingEffectsByKind,
+        journalHead: engine.stateCache?.journalHead ?? null,
+        stateRebuilt: Boolean(engine.stateRebuild),
+        stateRebuildReason: engine.stateRebuild?.reason ?? null,
+    };
+}

package/dist/runtime/processContext.d.ts

@@ -0,0 +1,19 @@
+import { TaskIntrinsicContext } from "./intrinsics/task";
+import { ProcessContext } from "./types";
+export interface ProcessContextInit extends Omit<TaskIntrinsicContext, "now"> {
+    processId: string;
+    now?: () => Date;
+}
+export interface InternalProcessContext extends TaskIntrinsicContext {
+    processId: string;
+    now: () => Date;
+}
+export interface CreateProcessContextResult {
+    context: ProcessContext;
+    internalContext: InternalProcessContext;
+}
+export declare function createProcessContext(init: ProcessContextInit): CreateProcessContextResult;
+export declare function withProcessContext<T>(internal: InternalProcessContext, fn: () => Promise<T> | T): Promise<T>;
+export declare function getActiveProcessContext(): InternalProcessContext | undefined;
+export declare function requireProcessContext(): InternalProcessContext;
+//# sourceMappingURL=processContext.d.ts.map

package/dist/runtime/processContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"processContext.d.ts","sourceRoot":"","sources":["../../src/runtime/processContext.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAK3E,OAAO,EAAE,cAAc,EAAmB,MAAM,SAAS,CAAC;AAG1D,MAAM,WAAW,kBAAmB,SAAQ,IAAI,CAAC,oBAAoB,EAAE,KAAK,CAAC;IAC3E,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAClB;AAED,MAAM,WAAW,sBAAuB,SAAQ,oBAAoB;IAClE,SAAS,EAAE,MAAM,CAAC;IAClB,GAAG,EAAE,MAAM,IAAI,CAAC;CACjB;AAID,MAAM,WAAW,0BAA0B;IACzC,OAAO,EAAE,cAAc,CAAC;IACxB,eAAe,EAAE,sBAAsB,CAAC;CACzC;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,kBAAkB,GAAG,0BAA0B,CA+BzF;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,QAAQ,EAAE,sBAAsB,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAE5G;AAED,wBAAgB,uBAAuB,IAAI,sBAAsB,GAAG,SAAS,CAE5E;AAED,wBAAgB,qBAAqB,IAAI,sBAAsB,CAM9D"}

package/dist/runtime/processContext.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProcessContext = createProcessContext;
+exports.withProcessContext = withProcessContext;
+exports.getActiveProcessContext = getActiveProcessContext;
+exports.requireProcessContext = requireProcessContext;
+const async_hooks_1 = require("async_hooks");
+const task_1 = require("./intrinsics/task");
+const breakpoint_1 = require("./intrinsics/breakpoint");
+const sleep_1 = require("./intrinsics/sleep");
+const orchestratorTask_1 = require("./intrinsics/orchestratorTask");
+const parallel_1 = require("./intrinsics/parallel");
+const exceptions_1 = require("./exceptions");
+const contextStorage = new async_hooks_1.AsyncLocalStorage();
+function createProcessContext(init) {
+    const internal = {
+        ...init,
+        now: init.now ?? (() => new Date()),
+    };
+    const parallelHelpers = {
+        all: (thunks) => (0, parallel_1.runParallelAll)(thunks),
+        map: (items, fn) => (0, parallel_1.runParallelMap)(items, fn),
+    };
+    const processContext = {
+        now: () => internal.now(),
+        task: (task, args, options) => (0, task_1.runTaskIntrinsic)({
+            task,
+            args,
+            invokeOptions: options,
+            context: internal,
+        }),
+        breakpoint: (payload, options) => (0, breakpoint_1.runBreakpointIntrinsic)(payload, internal, options),
+        sleepUntil: (target, options) => (0, sleep_1.runSleepIntrinsic)(target, internal, options),
+        orchestratorTask: (payload, options) => (0, orchestratorTask_1.runOrchestratorTaskIntrinsic)(payload, internal, options),
+        parallel: parallelHelpers,
+        log: internal.logger,
+    };
+    return {
+        context: processContext,
+        internalContext: internal,
+    };
+}
+function withProcessContext(internal, fn) {
+    return contextStorage.run(internal, () => Promise.resolve().then(fn));
+}
+function getActiveProcessContext() {
+    return contextStorage.getStore();
+}
+function requireProcessContext() {
+    const ctx = getActiveProcessContext();
+    if (!ctx) {
+        throw new exceptions_1.MissingProcessContextError();
+    }
+    return ctx;
+}

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

@@ -0,0 +1,31 @@
+import { RunMetadata } from "../../storage/types";
+import { EffectIndex } from "./effectIndex";
+import { ReplayCursor } from "./replayCursor";
+import { ProcessContext } from "../types";
+import { InternalProcessContext } from "../processContext";
+import { StateCacheSnapshot } from "./stateCache";
+export interface CreateReplayEngineOptions {
+    runDir: string;
+    now?: () => Date;
+    logger?: (...args: any[]) => void;
+}
+export interface ReplayEngine {
+    runId: string;
+    runDir: string;
+    metadata: RunMetadata;
+    inputs?: unknown;
+    effectIndex: EffectIndex;
+    replayCursor: ReplayCursor;
+    context: ProcessContext;
+    internalContext: InternalProcessContext;
+    stateCache?: StateCacheSnapshot | null;
+    stateRebuild?: {
+        reason: string;
+        previous?: {
+            seq: number;
+            ulid: string;
+        } | null;
+    } | null;
+}
+export declare function createReplayEngine(options: CreateReplayEngineOptions): Promise<ReplayEngine>;
+//# sourceMappingURL=createReplayEngine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createReplayEngine.d.ts","sourceRoot":"","sources":["../../../src/runtime/replay/createReplayEngine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAoB,WAAW,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAwB,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAGjF,OAAO,EAAwD,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAExG,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;IACjB,MAAM,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;CACnC;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,WAAW,CAAC;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,WAAW,CAAC;IACzB,YAAY,EAAE,YAAY,CAAC;IAC3B,OAAO,EAAE,cAAc,CAAC;IACxB,eAAe,EAAE,sBAAsB,CAAC;IACxC,UAAU,CAAC,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACvC,YAAY,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE;YAAE,GAAG,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,GAAG,IAAI,CAAA;KAAE,GAAG,IAAI,CAAC;CAC3F;AAED,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,YAAY,CAAC,CAiClG"}