@a5c-ai/babysitter-sdk 0.0.16

package/dist/runtime/errorUtils.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeUnknownError = serializeUnknownError;
+exports.toSerializedEffectError = toSerializedEffectError;
+function serializeUnknownError(error) {
+    if (error instanceof Error) {
+        return {
+            name: error.name ?? "Error",
+            message: error.message ?? "Unknown error",
+            stack: error.stack,
+        };
+    }
+    if (typeof error === "object" && error) {
+        return {
+            name: error.constructor?.name ?? "Error",
+            message: JSON.stringify(error),
+            data: error,
+        };
+    }
+    return {
+        name: "Error",
+        message: String(error),
+    };
+}
+function toSerializedEffectError(error) {
+    if (error && typeof error === "object" && "name" in error) {
+        const err = error;
+        return {
+            name: err.name ?? "Error",
+            message: err.message ?? "Task failed",
+            stack: typeof err.stack === "string" ? err.stack : undefined,
+            data: err.data,
+        };
+    }
+    const serialized = serializeUnknownError(error);
+    return {
+        name: serialized.name,
+        message: serialized.message,
+        stack: serialized.stack,
+        data: serialized.data,
+    };
+}

package/dist/runtime/exceptions.d.ts

@@ -0,0 +1,45 @@
+import { EffectAction, SerializedEffectError } from "./types";
+import { type ParallelBatch } from "../tasks/batching";
+export interface BabysitterErrorDetails {
+    [key: string]: unknown;
+}
+export declare class BabysitterRuntimeError extends Error {
+    readonly details?: BabysitterErrorDetails;
+    constructor(name: string, message: string, details?: BabysitterErrorDetails);
+}
+export declare class BabysitterIntrinsicError extends BabysitterRuntimeError {
+    readonly isIntrinsic = true;
+    constructor(name: string, message: string, details?: BabysitterErrorDetails);
+}
+export declare class EffectRequestedError extends BabysitterIntrinsicError {
+    readonly action: EffectAction;
+    constructor(action: EffectAction);
+}
+export declare class EffectPendingError extends BabysitterIntrinsicError {
+    readonly action: EffectAction;
+    constructor(action: EffectAction);
+}
+export declare class ParallelPendingError extends BabysitterIntrinsicError {
+    readonly batch: ParallelBatch;
+    readonly effects: EffectAction[];
+    constructor(batch: ParallelBatch);
+}
+export declare class InvocationCollisionError extends BabysitterRuntimeError {
+    readonly invocationKey: string;
+    constructor(invocationKey: string);
+}
+export declare class RunFailedError extends BabysitterRuntimeError {
+    constructor(message: string, details?: BabysitterErrorDetails);
+}
+export declare class MissingProcessContextError extends BabysitterRuntimeError {
+    constructor();
+}
+export declare class InvalidTaskDefinitionError extends BabysitterRuntimeError {
+    constructor(reason: string);
+}
+export declare class InvalidSleepTargetError extends BabysitterRuntimeError {
+    constructor(value: string | number);
+}
+export declare function isIntrinsicError(error: unknown): error is BabysitterIntrinsicError;
+export declare function rehydrateSerializedError(data?: SerializedEffectError): Error;
+//# sourceMappingURL=exceptions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"exceptions.d.ts","sourceRoot":"","sources":["../../src/runtime/exceptions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAC9D,OAAO,EAA4B,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEjF,MAAM,WAAW,sBAAsB;IACrC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,qBAAa,sBAAuB,SAAQ,KAAK;IAC/C,QAAQ,CAAC,OAAO,CAAC,EAAE,sBAAsB,CAAC;gBAE9B,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB;CAK5E;AAED,qBAAa,wBAAyB,SAAQ,sBAAsB;IAClE,QAAQ,CAAC,WAAW,QAAQ;gBAEhB,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB;CAG5E;AAED,qBAAa,oBAAqB,SAAQ,wBAAwB;aACpC,MAAM,EAAE,YAAY;gBAApB,MAAM,EAAE,YAAY;CAGjD;AAED,qBAAa,kBAAmB,SAAQ,wBAAwB;aAClC,MAAM,EAAE,YAAY;gBAApB,MAAM,EAAE,YAAY;CAGjD;AAED,qBAAa,oBAAqB,SAAQ,wBAAwB;aAEpC,KAAK,EAAE,aAAa;IADhD,QAAQ,CAAC,OAAO,EAAE,YAAY,EAAE,CAAC;gBACL,KAAK,EAAE,aAAa;CAOjD;AAED,qBAAa,wBAAyB,SAAQ,sBAAsB;aACtC,aAAa,EAAE,MAAM;gBAArB,aAAa,EAAE,MAAM;CAOlD;AAED,qBAAa,cAAe,SAAQ,sBAAsB;gBAC5C,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB;CAG9D;AAED,qBAAa,0BAA2B,SAAQ,sBAAsB;;CAIrE;AAED,qBAAa,0BAA2B,SAAQ,sBAAsB;gBACxD,MAAM,EAAE,MAAM;CAG3B;AAED,qBAAa,uBAAwB,SAAQ,sBAAsB;gBACrD,KAAK,EAAE,MAAM,GAAG,MAAM;CAGnC;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,wBAAwB,CAElF;AAID,wBAAgB,wBAAwB,CAAC,IAAI,CAAC,EAAE,qBAAqB,GAAG,KAAK,CAY5E"}

package/dist/runtime/exceptions.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidSleepTargetError = exports.InvalidTaskDefinitionError = exports.MissingProcessContextError = exports.RunFailedError = exports.InvocationCollisionError = exports.ParallelPendingError = exports.EffectPendingError = exports.EffectRequestedError = exports.BabysitterIntrinsicError = exports.BabysitterRuntimeError = void 0;
+exports.isIntrinsicError = isIntrinsicError;
+exports.rehydrateSerializedError = rehydrateSerializedError;
+const batching_1 = require("../tasks/batching");
+class BabysitterRuntimeError extends Error {
+    details;
+    constructor(name, message, details) {
+        super(message);
+        this.name = name;
+        this.details = details;
+    }
+}
+exports.BabysitterRuntimeError = BabysitterRuntimeError;
+class BabysitterIntrinsicError extends BabysitterRuntimeError {
+    isIntrinsic = true;
+    constructor(name, message, details) {
+        super(name, message, details);
+    }
+}
+exports.BabysitterIntrinsicError = BabysitterIntrinsicError;
+class EffectRequestedError extends BabysitterIntrinsicError {
+    action;
+    constructor(action) {
+        super("EffectRequestedError", `Effect ${action.effectId} requested`, { action });
+        this.action = action;
+    }
+}
+exports.EffectRequestedError = EffectRequestedError;
+class EffectPendingError extends BabysitterIntrinsicError {
+    action;
+    constructor(action) {
+        super("EffectPendingError", `Effect ${action.effectId} pending`, { action });
+        this.action = action;
+    }
+}
+exports.EffectPendingError = EffectPendingError;
+class ParallelPendingError extends BabysitterIntrinsicError {
+    batch;
+    effects;
+    constructor(batch) {
+        super("ParallelPendingError", "One or more parallel invocations are pending", {
+            payload: (0, batching_1.toParallelPendingPayload)(batch),
+            effects: batch.actions,
+        });
+        this.batch = batch;
+        this.effects = batch.actions;
+    }
+}
+exports.ParallelPendingError = ParallelPendingError;
+class InvocationCollisionError extends BabysitterRuntimeError {
+    invocationKey;
+    constructor(invocationKey) {
+        super("InvocationCollisionError", `Invocation key ${invocationKey} is already in use within this run`, { invocationKey });
+        this.invocationKey = invocationKey;
+    }
+}
+exports.InvocationCollisionError = InvocationCollisionError;
+class RunFailedError extends BabysitterRuntimeError {
+    constructor(message, details) {
+        super("RunFailedError", message, details);
+    }
+}
+exports.RunFailedError = RunFailedError;
+class MissingProcessContextError extends BabysitterRuntimeError {
+    constructor() {
+        super("MissingProcessContextError", "No active process context found on the current async call stack");
+    }
+}
+exports.MissingProcessContextError = MissingProcessContextError;
+class InvalidTaskDefinitionError extends BabysitterRuntimeError {
+    constructor(reason) {
+        super("InvalidTaskDefinitionError", reason);
+    }
+}
+exports.InvalidTaskDefinitionError = InvalidTaskDefinitionError;
+class InvalidSleepTargetError extends BabysitterRuntimeError {
+    constructor(value) {
+        super("InvalidSleepTargetError", `Invalid sleep target: ${value}`);
+    }
+}
+exports.InvalidSleepTargetError = InvalidSleepTargetError;
+function isIntrinsicError(error) {
+    return Boolean(error && typeof error === "object" && error.isIntrinsic);
+}
+function rehydrateSerializedError(data) {
+    const name = data?.name ?? "TaskError";
+    const message = data?.message ?? "Task failed";
+    const err = new Error(message);
+    err.name = name;
+    if (data?.stack) {
+        err.stack = data.stack;
+    }
+    if (data?.data !== undefined) {
+        err.data = data.data;
+    }
+    return err;
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,12 @@
+export { createRun } from "./createRun";
+export { orchestrateIteration } from "./orchestrateIteration";
+export { commitEffectResult } from "./commitEffectResult";
+export { createReplayEngine } from "./replay";
+export { createProcessContext, withProcessContext, getActiveProcessContext, requireProcessContext, } from "./processContext";
+export type { OrchestrateOptions, IterationResult, EffectAction, CommitEffectResultOptions, CommitEffectResultArtifacts, ProcessContext, DefinedTask, CreateRunOptions, CreateRunResult, } from "./types";
+export { STATE_CACHE_SCHEMA_VERSION, createStateCacheSnapshot, journalHeadsEqual, normalizeJournalHead, normalizeSnapshot, readStateCache, rebuildStateCache, writeStateCache, } from "./replay";
+export type { ReplayEngine, CreateReplayEngineOptions, StateCacheSnapshot, StateCacheJournalHead, DerivedEffectSummary, } from "./replay";
+export { hashInvocationKey } from "./invocation";
+export { EffectRequestedError, EffectPendingError, ParallelPendingError, RunFailedError } from "./exceptions";
+export { replaySchemaVersion } from "./constants";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runtime/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC9C,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,kBAAkB,EAClB,eAAe,EACf,YAAY,EACZ,yBAAyB,EACzB,2BAA2B,EAC3B,cAAc,EACd,WAAW,EACX,gBAAgB,EAChB,eAAe,GAChB,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,0BAA0B,EAC1B,wBAAwB,EACxB,iBAAiB,EACjB,oBAAoB,EACpB,iBAAiB,EACjB,cAAc,EACd,iBAAiB,EACjB,eAAe,GAChB,MAAM,UAAU,CAAC;AAClB,YAAY,EACV,YAAY,EACZ,yBAAyB,EACzB,kBAAkB,EAClB,qBAAqB,EACrB,oBAAoB,GACrB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9G,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC"}

package/dist/runtime/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaySchemaVersion = exports.RunFailedError = exports.ParallelPendingError = exports.EffectPendingError = exports.EffectRequestedError = exports.hashInvocationKey = exports.writeStateCache = exports.rebuildStateCache = exports.readStateCache = exports.normalizeSnapshot = exports.normalizeJournalHead = exports.journalHeadsEqual = exports.createStateCacheSnapshot = exports.STATE_CACHE_SCHEMA_VERSION = exports.requireProcessContext = exports.getActiveProcessContext = exports.withProcessContext = exports.createProcessContext = exports.createReplayEngine = exports.commitEffectResult = exports.orchestrateIteration = exports.createRun = void 0;
+var createRun_1 = require("./createRun");
+Object.defineProperty(exports, "createRun", { enumerable: true, get: function () { return createRun_1.createRun; } });
+var orchestrateIteration_1 = require("./orchestrateIteration");
+Object.defineProperty(exports, "orchestrateIteration", { enumerable: true, get: function () { return orchestrateIteration_1.orchestrateIteration; } });
+var commitEffectResult_1 = require("./commitEffectResult");
+Object.defineProperty(exports, "commitEffectResult", { enumerable: true, get: function () { return commitEffectResult_1.commitEffectResult; } });
+var replay_1 = require("./replay");
+Object.defineProperty(exports, "createReplayEngine", { enumerable: true, get: function () { return replay_1.createReplayEngine; } });
+var processContext_1 = require("./processContext");
+Object.defineProperty(exports, "createProcessContext", { enumerable: true, get: function () { return processContext_1.createProcessContext; } });
+Object.defineProperty(exports, "withProcessContext", { enumerable: true, get: function () { return processContext_1.withProcessContext; } });
+Object.defineProperty(exports, "getActiveProcessContext", { enumerable: true, get: function () { return processContext_1.getActiveProcessContext; } });
+Object.defineProperty(exports, "requireProcessContext", { enumerable: true, get: function () { return processContext_1.requireProcessContext; } });
+var replay_2 = require("./replay");
+Object.defineProperty(exports, "STATE_CACHE_SCHEMA_VERSION", { enumerable: true, get: function () { return replay_2.STATE_CACHE_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "createStateCacheSnapshot", { enumerable: true, get: function () { return replay_2.createStateCacheSnapshot; } });
+Object.defineProperty(exports, "journalHeadsEqual", { enumerable: true, get: function () { return replay_2.journalHeadsEqual; } });
+Object.defineProperty(exports, "normalizeJournalHead", { enumerable: true, get: function () { return replay_2.normalizeJournalHead; } });
+Object.defineProperty(exports, "normalizeSnapshot", { enumerable: true, get: function () { return replay_2.normalizeSnapshot; } });
+Object.defineProperty(exports, "readStateCache", { enumerable: true, get: function () { return replay_2.readStateCache; } });
+Object.defineProperty(exports, "rebuildStateCache", { enumerable: true, get: function () { return replay_2.rebuildStateCache; } });
+Object.defineProperty(exports, "writeStateCache", { enumerable: true, get: function () { return replay_2.writeStateCache; } });
+var invocation_1 = require("./invocation");
+Object.defineProperty(exports, "hashInvocationKey", { enumerable: true, get: function () { return invocation_1.hashInvocationKey; } });
+var exceptions_1 = require("./exceptions");
+Object.defineProperty(exports, "EffectRequestedError", { enumerable: true, get: function () { return exceptions_1.EffectRequestedError; } });
+Object.defineProperty(exports, "EffectPendingError", { enumerable: true, get: function () { return exceptions_1.EffectPendingError; } });
+Object.defineProperty(exports, "ParallelPendingError", { enumerable: true, get: function () { return exceptions_1.ParallelPendingError; } });
+Object.defineProperty(exports, "RunFailedError", { enumerable: true, get: function () { return exceptions_1.RunFailedError; } });
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "replaySchemaVersion", { enumerable: true, get: function () { return constants_1.replaySchemaVersion; } });

package/dist/runtime/instrumentation.d.ts

@@ -0,0 +1,6 @@
+export type RuntimeLogger = (...args: any[]) => void;
+export interface MetricPayload extends Record<string, unknown> {
+    metric: string;
+}
+export declare function emitRuntimeMetric(logger: RuntimeLogger | undefined, metric: string, payload?: Record<string, unknown>): void;
+//# sourceMappingURL=instrumentation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation.d.ts","sourceRoot":"","sources":["../../src/runtime/instrumentation.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;AAErD,MAAM,WAAW,aAAc,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC5D,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,aAAa,GAAG,SAAS,EACjC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACpC,IAAI,CAQN"}

package/dist/runtime/instrumentation.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitRuntimeMetric = emitRuntimeMetric;
+function emitRuntimeMetric(logger, metric, payload = {}) {
+    if (!logger)
+        return;
+    const entry = { metric, ...payload };
+    try {
+        logger(entry);
+    }
+    catch {
+        // Swallow logger failures to avoid breaking orchestrations.
+    }
+}

package/dist/runtime/intrinsics/breakpoint.d.ts

@@ -0,0 +1,4 @@
+import { TaskInvokeOptions } from "../types";
+import { TaskIntrinsicContext } from "./task";
+export declare function runBreakpointIntrinsic<T = unknown>(payload: T, context: TaskIntrinsicContext, options?: TaskInvokeOptions): Promise<void>;
+//# sourceMappingURL=breakpoint.d.ts.map

package/dist/runtime/intrinsics/breakpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"breakpoint.d.ts","sourceRoot":"","sources":["../../../src/runtime/intrinsics/breakpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC1D,OAAO,EAAoB,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AA0BhE,wBAAgB,sBAAsB,CAAC,CAAC,GAAG,OAAO,EAChD,OAAO,EAAE,CAAC,EACV,OAAO,EAAE,oBAAoB,EAC7B,OAAO,CAAC,EAAE,iBAAiB,iBAU5B"}

package/dist/runtime/intrinsics/breakpoint.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBreakpointIntrinsic = runBreakpointIntrinsic;
+const task_1 = require("./task");
+const BREAKPOINT_TASK_ID = "__sdk.breakpoint";
+const DEFAULT_BREAKPOINT_LABEL = "breakpoint";
+const breakpointTask = {
+    id: BREAKPOINT_TASK_ID,
+    async build(args) {
+        return {
+            kind: "breakpoint",
+            title: args.label,
+            metadata: {
+                payload: args?.payload,
+                requestedAt: args.requestedAt,
+                label: args.label,
+            },
+        };
+    },
+};
+function runBreakpointIntrinsic(payload, context, options) {
+    const label = deriveBreakpointLabel(payload, options?.label);
+    const invokeOptions = { ...options, label };
+    return (0, task_1.runTaskIntrinsic)({
+        task: breakpointTask,
+        args: { payload, label, requestedAt: context.now().toISOString() },
+        invokeOptions,
+        context,
+    });
+}
+function deriveBreakpointLabel(payload, provided) {
+    if (typeof provided === "string" && provided.length) {
+        return provided;
+    }
+    if (payload && typeof payload === "object" && "label" in payload) {
+        const inferred = payload.label;
+        if (typeof inferred === "string" && inferred.length) {
+            return inferred;
+        }
+    }
+    return DEFAULT_BREAKPOINT_LABEL;
+}

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

@@ -0,0 +1,7 @@
+export { runTaskIntrinsic } from "./task";
+export type { TaskIntrinsicContext } from "./task";
+export { runBreakpointIntrinsic } from "./breakpoint";
+export { runSleepIntrinsic } from "./sleep";
+export { runOrchestratorTaskIntrinsic } from "./orchestratorTask";
+export { runParallelAll, runParallelMap, dedupeEffectActions } from "./parallel";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/intrinsics/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,QAAQ,CAAC;AAC1C,YAAY,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AACnD,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAC5C,OAAO,EAAE,4BAA4B,EAAE,MAAM,oBAAoB,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC"}

package/dist/runtime/intrinsics/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dedupeEffectActions = exports.runParallelMap = exports.runParallelAll = exports.runOrchestratorTaskIntrinsic = exports.runSleepIntrinsic = exports.runBreakpointIntrinsic = exports.runTaskIntrinsic = void 0;
+var task_1 = require("./task");
+Object.defineProperty(exports, "runTaskIntrinsic", { enumerable: true, get: function () { return task_1.runTaskIntrinsic; } });
+var breakpoint_1 = require("./breakpoint");
+Object.defineProperty(exports, "runBreakpointIntrinsic", { enumerable: true, get: function () { return breakpoint_1.runBreakpointIntrinsic; } });
+var sleep_1 = require("./sleep");
+Object.defineProperty(exports, "runSleepIntrinsic", { enumerable: true, get: function () { return sleep_1.runSleepIntrinsic; } });
+var orchestratorTask_1 = require("./orchestratorTask");
+Object.defineProperty(exports, "runOrchestratorTaskIntrinsic", { enumerable: true, get: function () { return orchestratorTask_1.runOrchestratorTaskIntrinsic; } });
+var parallel_1 = require("./parallel");
+Object.defineProperty(exports, "runParallelAll", { enumerable: true, get: function () { return parallel_1.runParallelAll; } });
+Object.defineProperty(exports, "runParallelMap", { enumerable: true, get: function () { return parallel_1.runParallelMap; } });
+Object.defineProperty(exports, "dedupeEffectActions", { enumerable: true, get: function () { return parallel_1.dedupeEffectActions; } });

package/dist/runtime/intrinsics/orchestratorTask.d.ts

@@ -0,0 +1,4 @@
+import { TaskInvokeOptions } from "../types";
+import { TaskIntrinsicContext } from "./task";
+export declare function runOrchestratorTaskIntrinsic<TPayload, TResult>(payload: TPayload, context: TaskIntrinsicContext, options?: TaskInvokeOptions): Promise<TResult>;
+//# sourceMappingURL=orchestratorTask.d.ts.map

package/dist/runtime/intrinsics/orchestratorTask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestratorTask.d.ts","sourceRoot":"","sources":["../../../src/runtime/intrinsics/orchestratorTask.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC1D,OAAO,EAAoB,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAuBhE,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,OAAO,EAC5D,OAAO,EAAE,QAAQ,EACjB,OAAO,EAAE,oBAAoB,EAC7B,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,OAAO,CAAC,CASlB"}

package/dist/runtime/intrinsics/orchestratorTask.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runOrchestratorTaskIntrinsic = runOrchestratorTaskIntrinsic;
+const task_1 = require("./task");
+const ORCHESTRATOR_TASK_ID = "__sdk.orchestratorTask";
+const orchestratorTask = {
+    id: ORCHESTRATOR_TASK_ID,
+    async build(args) {
+        return {
+            kind: "orchestrator_task",
+            title: args.label,
+            metadata: {
+                payload: args?.payload,
+                orchestratorTask: true,
+            },
+        };
+    },
+};
+function runOrchestratorTaskIntrinsic(payload, context, options) {
+    const label = options?.label ?? "orchestrator-task";
+    const invokeOptions = { ...options, label };
+    return (0, task_1.runTaskIntrinsic)({
+        task: orchestratorTask,
+        args: { payload, label },
+        invokeOptions,
+        context,
+    });
+}

package/dist/runtime/intrinsics/parallel.d.ts

@@ -0,0 +1,5 @@
+import { EffectAction } from "../types";
+export declare function runParallelAll<T>(thunks: Array<() => T | Promise<T>>): Promise<T[]>;
+export declare function runParallelMap<TItem, TOut>(items: TItem[], fn: (item: TItem) => TOut | Promise<TOut>): Promise<TOut[]>;
+export declare function dedupeEffectActions(actions: EffectAction[]): EffectAction[];
+//# sourceMappingURL=parallel.d.ts.map

package/dist/runtime/intrinsics/parallel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallel.d.ts","sourceRoot":"","sources":["../../../src/runtime/intrinsics/parallel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAIxC,wBAAsB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,CAuBzF;AAED,wBAAsB,cAAc,CAAC,KAAK,EAAE,IAAI,EAC9C,KAAK,EAAE,KAAK,EAAE,EACd,EAAE,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GACxC,OAAO,CAAC,IAAI,EAAE,CAAC,CAGjB;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,YAAY,EAAE,GAAG,YAAY,EAAE,CAE3E"}

package/dist/runtime/intrinsics/parallel.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runParallelAll = runParallelAll;
+exports.runParallelMap = runParallelMap;
+exports.dedupeEffectActions = dedupeEffectActions;
+const exceptions_1 = require("../exceptions");
+const batching_1 = require("../../tasks/batching");
+async function runParallelAll(thunks) {
+    const results = [];
+    const pending = [];
+    for (const thunk of thunks) {
+        try {
+            const value = await thunk();
+            results.push(value);
+        }
+        catch (error) {
+            const actions = collectPendingActions(error);
+            if (actions.length) {
+                pending.push(...actions);
+                continue;
+            }
+            throw error;
+        }
+    }
+    if (pending.length) {
+        throw new exceptions_1.ParallelPendingError((0, batching_1.buildParallelBatch)(pending));
+    }
+    return results;
+}
+async function runParallelMap(items, fn) {
+    const thunks = items.map((item) => () => fn(item));
+    return runParallelAll(thunks);
+}
+function dedupeEffectActions(actions) {
+    return (0, batching_1.buildParallelBatch)(actions).actions;
+}
+function collectPendingActions(error) {
+    if (error instanceof exceptions_1.ParallelPendingError) {
+        return error.batch.actions;
+    }
+    if (error instanceof exceptions_1.EffectPendingError || error instanceof exceptions_1.EffectRequestedError) {
+        return [error.action];
+    }
+    return [];
+}

package/dist/runtime/intrinsics/sleep.d.ts

@@ -0,0 +1,4 @@
+import { TaskInvokeOptions } from "../types";
+import { TaskIntrinsicContext } from "./task";
+export declare function runSleepIntrinsic(target: string | number, context: TaskIntrinsicContext, options?: TaskInvokeOptions): Promise<void>;
+//# sourceMappingURL=sleep.d.ts.map

package/dist/runtime/intrinsics/sleep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../../src/runtime/intrinsics/sleep.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE1D,OAAO,EAAoB,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AA2BhE,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,OAAO,EAAE,oBAAoB,EAC7B,OAAO,CAAC,EAAE,iBAAiB,iBA2B5B"}

package/dist/runtime/intrinsics/sleep.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSleepIntrinsic = runSleepIntrinsic;
+const exceptions_1 = require("../exceptions");
+const task_1 = require("./task");
+const SLEEP_TASK_ID = "__sdk.sleep";
+const sleepTask = {
+    id: SLEEP_TASK_ID,
+    async build(args) {
+        return {
+            kind: "sleep",
+            title: `sleep:${args.iso}`,
+            sleep: {
+                iso: args.iso,
+                targetEpochMs: args.targetEpochMs,
+            },
+            metadata: {
+                targetEpochMs: args.targetEpochMs,
+                iso: args.iso,
+            },
+        };
+    },
+};
+async function runSleepIntrinsic(target, context, options) {
+    const epoch = normalizeSleepTarget(target);
+    if (!Number.isFinite(epoch) || epoch < 0) {
+        throw new exceptions_1.InvalidSleepTargetError(target);
+    }
+    const nowMs = context.now().getTime();
+    if (epoch <= nowMs) {
+        return;
+    }
+    const iso = new Date(epoch).toISOString();
+    const label = options?.label ?? `sleep:${iso}`;
+    const invokeOptions = { ...options, label };
+    try {
+        await (0, task_1.runTaskIntrinsic)({
+            task: sleepTask,
+            args: { targetEpochMs: epoch, iso },
+            invokeOptions,
+            context,
+        });
+    }
+    catch (error) {
+        if (shouldShortCircuitPending(error, nowMs)) {
+            return;
+        }
+        throw error;
+    }
+}
+function normalizeSleepTarget(target) {
+    if (typeof target === "number") {
+        return target;
+    }
+    if (typeof target === "string") {
+        const parsed = Date.parse(target);
+        return Number.isNaN(parsed) ? NaN : parsed;
+    }
+    return NaN;
+}
+function shouldShortCircuitPending(error, nowMs) {
+    if (!(error instanceof exceptions_1.EffectPendingError)) {
+        return false;
+    }
+    const metadata = error.action.taskDef?.metadata;
+    if (typeof metadata?.targetEpochMs !== "number") {
+        return false;
+    }
+    return metadata.targetEpochMs <= nowMs;
+}

package/dist/runtime/intrinsics/task.d.ts

@@ -0,0 +1,20 @@
+import { EffectIndex } from "../replay/effectIndex";
+import { ReplayCursor } from "../replay/replayCursor";
+import { DefinedTask, ProcessLogger, TaskInvokeOptions } from "../types";
+export interface TaskIntrinsicContext {
+    runId: string;
+    runDir: string;
+    processId: string;
+    effectIndex: EffectIndex;
+    replayCursor: ReplayCursor;
+    now: () => Date;
+    logger?: ProcessLogger;
+}
+export interface TaskIntrinsicInvokeOptions<TArgs, TResult> {
+    task: DefinedTask<TArgs, TResult>;
+    args: TArgs;
+    invokeOptions?: TaskInvokeOptions;
+    context: TaskIntrinsicContext;
+}
+export declare function runTaskIntrinsic<TArgs, TResult>(options: TaskIntrinsicInvokeOptions<TArgs, TResult>): Promise<TResult>;
+//# sourceMappingURL=task.d.ts.map

package/dist/runtime/intrinsics/task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.ts","sourceRoot":"","sources":["../../../src/runtime/intrinsics/task.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EACL,WAAW,EAIX,aAAa,EAGb,iBAAiB,EAClB,MAAM,UAAU,CAAC;AAMlB,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,WAAW,CAAC;IACzB,YAAY,EAAE,YAAY,CAAC;IAC3B,GAAG,EAAE,MAAM,IAAI,CAAC;IAChB,MAAM,CAAC,EAAE,aAAa,CAAC;CACxB;AAED,MAAM,WAAW,0BAA0B,CAAC,KAAK,EAAE,OAAO;IACxD,IAAI,EAAE,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAClC,IAAI,EAAE,KAAK,CAAC;IACZ,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAClC,OAAO,EAAE,oBAAoB,CAAC;CAC/B;AAED,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,OAAO,EACnD,OAAO,EAAE,0BAA0B,CAAC,KAAK,EAAE,OAAO,CAAC,GAClD,OAAO,CAAC,OAAO,CAAC,CAmBlB"}