@mokronos/wfkit 0.1.0

package/dist/core.js

@@ -0,0 +1,1061 @@
+import { createHash } from "node:crypto";
+import { Activity, DurableClock, DurableDeferred, Workflow, WorkflowEngine } from "effect/unstable/workflow";
+import { Cause, Context, Effect, Exit, Option, Schedule, Schema } from "effect";
+import { currentWorkflowEventSink, emitWorkflowEvent } from "./events.js";
+import { ExecutionId, jsonSchemaOf } from "./schemas.js";
+import { awaitSignal, registerSignalSchema, SignalDeliveryError, takeBufferedSignal } from "./signal.js";
+const TerminalFailureTypeId = Symbol.for("wf/TerminalFailure");
+export const defineStep = (config) => ({
+    ...config,
+    errors: config.errors ?? Schema.Never
+});
+const SecretRefPrefix = "secret:";
+export const SecretRef = Schema.declare((value) => typeof value === "string" && value.startsWith(SecretRefPrefix)).pipe(Schema.brand("SecretRef"));
+export const secret = (name) => SecretRef.make(`${SecretRefPrefix}${name}`);
+const defaultSecretEnvName = (name) => name.replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase();
+export const envSecretResolver = (options = {}) => ({
+    resolve: (name) => {
+        const envName = options.mapping?.[name] ?? defaultSecretEnvName(name);
+        const value = process.env[envName];
+        if (value !== undefined) {
+            return value;
+        }
+        if (options.fallback !== undefined) {
+            return options.fallback;
+        }
+        throw new Error(`Secret "${name}" not found: set env var ${envName}`);
+    }
+});
+export const isSecretRef = (value) => Schema.is(SecretRef)(value);
+const secretName = (value) => value.slice(SecretRefPrefix.length);
+export const currentSecretResolver = Context.Reference("wf/currentSecretResolver", { defaultValue: () => undefined });
+// Durable executions run on engine entity fibers that don't inherit the
+// caller's context reference, so the runtime also registers resolvers per execution.
+const executionSecretResolvers = new Map();
+export const setExecutionSecretResolver = (executionId, resolver) => {
+    executionSecretResolvers.set(executionId, resolver);
+};
+export const removeExecutionSecretResolver = (executionId) => {
+    executionSecretResolvers.delete(executionId);
+};
+export const getExecutionSecretResolver = (executionId) => executionSecretResolvers.get(executionId);
+export class Cancelled extends Error {
+    _tag = "Cancelled";
+    _wfSkipCompensation;
+    constructor(options) {
+        super("Workflow execution cancelled");
+        this.name = "Cancelled";
+        if (!options.compensate) {
+            this._wfSkipCompensation = true;
+        }
+    }
+}
+/** Reserved per-execution deferred the durable client completes to request
+ *  cancellation. Every suspension point races against it. */
+export const cancellationDeferredName = "wf:cancel";
+const CancellationRequestSchema = Schema.Struct({
+    compensate: Schema.Boolean,
+    actor: Schema.optional(Schema.String)
+});
+export class NonDeterminismError extends Error {
+    _tag = "NonDeterminismError";
+    expected;
+    actual;
+    constructor(options) {
+        super(`Non-deterministic workflow replay: expected ${formatCall(options.expected)} but saw ${formatCall(options.actual)}`);
+        this.name = "NonDeterminismError";
+        this.expected = options.expected;
+        this.actual = options.actual;
+    }
+}
+export const DefinedWorkflowTypeId = Symbol.for("wf/DefinedWorkflow");
+class AsyncFailure extends Error {
+    _tag = "AsyncFailure";
+    error;
+    constructor(error) {
+        super(error instanceof Error ? error.message : "Async operation failed");
+        this.name = "AsyncFailure";
+        this.error = error;
+    }
+}
+const OrchestrationCallSchema = Schema.Struct({
+    kind: Schema.Union([
+        Schema.Literal("step"),
+        Schema.Literal("sleep"),
+        Schema.Literal("signal"),
+        Schema.Literal("now"),
+        Schema.Literal("random"),
+        Schema.Literal("code"),
+        Schema.Literal("all")
+    ]),
+    name: Schema.String,
+    counter: Schema.Number,
+    branches: Schema.optional(Schema.Number)
+});
+export const createInMemoryDeterminismState = () => ({
+    calls: [],
+    blocks: [],
+    values: new Map()
+});
+const formatCall = (call) => `${call.kind}:${call.name}#${call.counter}${call.branches === undefined ? "" : ` branches=${call.branches}`}`;
+const callsEqual = (left, right) => left.kind === right.kind &&
+    left.name === right.name &&
+    left.counter === right.counter &&
+    left.branches === right.branches;
+const verifyCall = (expected, actual) => {
+    if (!callsEqual(expected, actual)) {
+        throw new NonDeterminismError({ expected, actual });
+    }
+};
+const valueKey = (call) => formatCall(call);
+const skipsCompensation = (error) => typeof error === "object" &&
+    error !== null &&
+    error._wfSkipCompensation === true;
+const isTerminalFailure = (value) => typeof value === "object" &&
+    value !== null &&
+    value[TerminalFailureTypeId] ===
+        TerminalFailureTypeId;
+const isActivityFailure = (value) => typeof value === "object" &&
+    value !== null &&
+    (value._wfFailureType === "terminal" ||
+        value._wfFailureType === "transient");
+const unwrapActivityFailure = (error) => isActivityFailure(error) ? error.error : error;
+const unwrapAsyncFailure = (error) => error instanceof AsyncFailure ? error.error : error;
+const makeStepContext = (executionId, attempt) => ({
+    attempt,
+    executionId,
+    fail: (error) => ({ [TerminalFailureTypeId]: TerminalFailureTypeId, error })
+});
+const nextInvocation = (counters, name) => {
+    const invocation = (counters.get(name) ?? 0) + 1;
+    counters.set(name, invocation);
+    return invocation;
+};
+const decodeSync = (schema, value) => Schema.decodeUnknownSync(schema)(value);
+const encodeSync = (schema, value) => Schema.encodeSync(schema)(value);
+const resolveSecretRefs = async (value, resolver) => {
+    if (isSecretRef(value)) {
+        if (resolver === undefined) {
+            throw new Error(`No secret resolver configured for ${secretName(value)}`);
+        }
+        return await resolver.resolve(secretName(value));
+    }
+    if (Array.isArray(value)) {
+        return await Promise.all(value.map((item) => resolveSecretRefs(item, resolver)));
+    }
+    if (value instanceof Date || typeof value !== "object" || value === null) {
+        return value;
+    }
+    const entries = await Promise.all(Object.entries(value).map(async ([key, entry]) => [key, await resolveSecretRefs(entry, resolver)]));
+    return Object.fromEntries(entries);
+};
+const concurrencySemaphores = new Map();
+const acquireConcurrency = async (step, input) => {
+    const limit = step.concurrency?.limit;
+    if (limit === undefined) {
+        return () => undefined;
+    }
+    if (!Number.isInteger(limit) || limit < 1) {
+        throw new Error(`Invalid concurrency limit for step ${step.name}: ${limit}`);
+    }
+    const key = step.concurrency?.key?.(input) ?? step.name;
+    const semaphoreKey = `${step.name}\0${key}`;
+    const state = concurrencySemaphores.get(semaphoreKey) ?? { active: 0, queue: [] };
+    concurrencySemaphores.set(semaphoreKey, state);
+    if (state.active >= limit) {
+        await new Promise((resolve) => {
+            state.queue.push(resolve);
+        });
+    }
+    state.active++;
+    let released = false;
+    return () => {
+        if (released) {
+            return;
+        }
+        released = true;
+        state.active--;
+        const next = state.queue.shift();
+        if (next !== undefined) {
+            next();
+        }
+        if (state.active === 0 && state.queue.length === 0) {
+            concurrencySemaphores.delete(semaphoreKey);
+        }
+    };
+};
+// Durable race with a persisted winner. This deliberately does NOT use
+// DurableDeferred.raceAll: its replay path runs `Effect.flatten(exit)` over
+// the stored winner, which dies with "Not a valid effect" for plain (non-
+// Effect) winner values. We store/unwrap the same way DurableDeferred.await
+// does — a single `yield*` of the persisted exit.
+const raceDurable = (name, effects) => Effect.gen(function* () {
+    const deferred = DurableDeferred.make(name, { success: Schema.Unknown });
+    const engine = yield* WorkflowEngine.WorkflowEngine;
+    const exit = yield* Workflow.wrapActivityResult(engine.deferredResult(deferred), Option.isNone);
+    if (Option.isSome(exit)) {
+        return yield* exit.value;
+    }
+    return yield* DurableDeferred.into(Effect.raceAll(effects), deferred);
+});
+const retrySchedule = (retry) => {
+    const attempts = Math.max(1, retry?.attempts ?? 1);
+    const recurs = Schedule.recurs(attempts - 1);
+    return retry?.backoff === "exponential"
+        ? Schedule.exponential("10 millis").pipe(Schedule.both(recurs))
+        : recurs;
+};
+const transientAttempts = (retry) => Math.max(1, retry?.attempts ?? 1);
+const makeCtx = (wf, executionId, workflowErrors) => {
+    const counters = new Map();
+    let journalPosition = 0;
+    let parallelDepth = 0;
+    const recordCall = (actual) => {
+        const position = ++journalPosition;
+        const activityName = parallelDepth > 0
+            ? `determinism:${actual.kind}:${actual.name}#${actual.counter}`
+            : `determinism#${position}`;
+        return Activity.make({
+            name: activityName,
+            success: OrchestrationCallSchema,
+            execute: Effect.succeed(actual)
+        }).pipe(Effect.flatMap((expected) => callsEqual(expected, actual)
+            ? Effect.void
+            : Effect.fail(new NonDeterminismError({ expected, actual }))));
+    };
+    const cancellationDeferred = DurableDeferred.make(cancellationDeferredName, {
+        success: CancellationRequestSchema
+    });
+    // A suspension point races its own durable operation against the reserved
+    // cancellation deferred, so a cancel request wakes the execution and unwinds
+    // it instead of leaving it parked forever.
+    const cancellationBranch = DurableDeferred.await(cancellationDeferred).pipe(Effect.map((request) => ({
+        type: "cancelled",
+        compensate: request.compensate,
+        actor: request.actor
+    })));
+    const failCancelled = (outcome) => Effect.gen(function* () {
+        yield* emitWorkflowEvent({
+            type: "cancellation.received",
+            executionId,
+            compensate: outcome.compensate,
+            ...(outcome.actor === undefined ? {} : { actor: outcome.actor })
+        });
+        // A plain failure exit: withCompensation finalizers run for compensate:
+        // true. compensate: false never reaches here (the client interrupts the
+        // engine directly), but failing is still the safe fallback.
+        return yield* Effect.fail(new Cancelled({ compensate: outcome.compensate }));
+    });
+    return {
+        executionId,
+        run(step, rawInput) {
+            const invocation = nextInvocation(counters, step.name);
+            const activityName = `${step.name}#${invocation}`;
+            const call = { kind: "step", name: step.name, counter: invocation };
+            const input = decodeSync(step.input, rawInput);
+            const execute = Effect.gen(function* () {
+                const attempt = yield* Activity.CurrentAttempt;
+                yield* emitWorkflowEvent({
+                    type: "step.started",
+                    executionId,
+                    stepName: step.name,
+                    invocation,
+                    activityName,
+                    attempt,
+                    input
+                });
+                const contextResolver = yield* currentSecretResolver;
+                const resolver = getExecutionSecretResolver(executionId) ?? contextResolver;
+                const result = yield* Effect.tryPromise({
+                    try: async () => {
+                        const release = await acquireConcurrency(step, input);
+                        try {
+                            const executeInput = await resolveSecretRefs(input, resolver);
+                            const value = await step.execute(executeInput, makeStepContext(executionId, attempt));
+                            if (isTerminalFailure(value)) {
+                                throw value;
+                            }
+                            return decodeSync(step.output, value);
+                        }
+                        finally {
+                            release();
+                        }
+                    },
+                    catch: (error) => {
+                        if (isTerminalFailure(error)) {
+                            return {
+                                _wfFailureType: "terminal",
+                                error: decodeSync(step.errors, error.error)
+                            };
+                        }
+                        return { _wfFailureType: "transient", error };
+                    }
+                });
+                yield* emitWorkflowEvent({
+                    type: "step.completed",
+                    executionId,
+                    stepName: step.name,
+                    invocation,
+                    activityName,
+                    attempt,
+                    result
+                });
+                return result;
+            }).pipe(Effect.tapError((error) => emitWorkflowEvent({
+                type: "step.failed",
+                executionId,
+                stepName: step.name,
+                invocation,
+                activityName,
+                error: unwrapActivityFailure(error)
+            })));
+            let activity = Activity.make({
+                name: activityName,
+                success: step.output,
+                error: Schema.Unknown,
+                execute
+            });
+            activity = activity.pipe(Activity.retry({
+                schedule: retrySchedule(step.retry),
+                while: (error) => isActivityFailure(error) && error._wfFailureType === "transient"
+            }), Effect.mapError(unwrapActivityFailure));
+            if (step.compensate !== undefined) {
+                activity = activity.pipe(wf.withCompensation((value, cause) => Effect.gen(function* () {
+                    yield* emitWorkflowEvent({
+                        type: "compensation.started",
+                        executionId,
+                        stepName: step.name,
+                        invocation,
+                        activityName,
+                        result: value,
+                        input,
+                        reason: cause
+                    });
+                    yield* Effect.tryPromise({
+                        try: () => Promise.resolve(step.compensate(value, input, cause)),
+                        catch: (error) => new AsyncFailure(error)
+                    }).pipe(Effect.tapError((error) => emitWorkflowEvent({
+                        type: "compensation.failed",
+                        executionId,
+                        stepName: step.name,
+                        invocation,
+                        activityName,
+                        error: unwrapAsyncFailure(error)
+                    })), Effect.orDie);
+                    yield* emitWorkflowEvent({
+                        type: "compensation.completed",
+                        executionId,
+                        stepName: step.name,
+                        invocation,
+                        activityName
+                    });
+                })));
+            }
+            return Effect.gen(function* () {
+                yield* recordCall(call);
+                return yield* activity;
+            });
+        },
+        all(effects, options) {
+            const name = options?.name ?? "all";
+            const invocation = nextInvocation(counters, name);
+            const activityName = `${name}#${invocation}`;
+            const branches = effects.length;
+            const call = { kind: "all", name, counter: invocation, branches };
+            return Effect.gen(function* () {
+                yield* recordCall(call);
+                yield* emitWorkflowEvent({
+                    type: "all.started",
+                    executionId,
+                    name,
+                    invocation,
+                    activityName,
+                    branches
+                });
+                yield* Effect.sync(() => {
+                    parallelDepth++;
+                });
+                const combined = Effect.all(effects, {
+                    concurrency: options?.concurrency ?? "unbounded"
+                });
+                return yield* combined.pipe(Effect.ensuring(Effect.sync(() => {
+                    parallelDepth--;
+                })), Effect.tap(() => emitWorkflowEvent({
+                    type: "all.completed",
+                    executionId,
+                    name,
+                    invocation,
+                    activityName,
+                    branches
+                })), Effect.tapError((error) => emitWorkflowEvent({
+                    type: "all.failed",
+                    executionId,
+                    name,
+                    invocation,
+                    activityName,
+                    branches,
+                    error
+                })));
+            });
+        },
+        sleep(duration, name) {
+            const baseName = name ?? `sleep:${String(duration)}`;
+            const invocation = nextInvocation(counters, baseName);
+            const sleepName = `${baseName}#${invocation}`;
+            const call = { kind: "sleep", name: baseName, counter: invocation };
+            return Effect.gen(function* () {
+                yield* recordCall(call);
+                yield* emitWorkflowEvent({
+                    type: "sleep.started",
+                    executionId,
+                    name: baseName,
+                    invocation,
+                    activityName: sleepName,
+                    duration
+                });
+                const outcome = (yield* raceDurable(`race:${sleepName}`, [
+                    // Sleeps under the engine's in-memory threshold (60s) run inside
+                    // an activity that holds the entity mailbox, so a cancellation
+                    // delivered mid-sleep is consumed at the NEXT suspension point,
+                    // not instantly — bounded by the threshold. Longer sleeps go
+                    // durable and wake immediately on cancellation.
+                    DurableClock.sleep({ name: sleepName, duration }).pipe(Effect.map(() => ({ type: "slept" }))),
+                    cancellationBranch
+                ]));
+                if (outcome.type === "cancelled") {
+                    return yield* failCancelled(outcome);
+                }
+                yield* emitWorkflowEvent({
+                    type: "sleep.completed",
+                    executionId,
+                    name: baseName,
+                    invocation,
+                    activityName: sleepName,
+                    duration
+                });
+            });
+        },
+        waitForSignal(name, schema, opts) {
+            const invocation = nextInvocation(counters, name);
+            const waitName = `${name}#${invocation}`;
+            const call = { kind: "signal", name, counter: invocation };
+            const payloadSchema = jsonSchemaOf(schema);
+            return Effect.gen(function* () {
+                yield* recordCall(call);
+                // Delivery-side validation needs the schema of the wait the run is
+                // parked at; replay re-registers it in a fresh process.
+                registerSignalSchema(executionId, name, schema);
+                yield* emitWorkflowEvent({
+                    type: "signal.waiting",
+                    executionId,
+                    name,
+                    invocation,
+                    activityName: waitName,
+                    timeout: opts?.timeout,
+                    ...(payloadSchema === undefined ? {} : { payloadSchema })
+                });
+                const deferredName = `signal:${waitName}`;
+                const deferred = DurableDeferred.make(deferredName, { success: schema });
+                // The race winner is persisted, so the signal value crosses replay as
+                // its encoded form and is re-decoded below.
+                const signalBranch = DurableDeferred.await(deferred).pipe(Effect.map((value) => ({
+                    type: "signal",
+                    encoded: encodeSync(schema, value)
+                })));
+                const timeoutBranch = opts?.timeout === undefined
+                    ? []
+                    : [
+                        DurableClock.sleep({
+                            name: `signal-timeout:${waitName}`,
+                            duration: opts.timeout,
+                            inMemoryThreshold: "1 milli"
+                        }).pipe(Effect.map(() => ({ type: "timeout" })))
+                    ];
+                const outcome = (yield* raceDurable(`race:${waitName}`, [
+                    signalBranch,
+                    ...timeoutBranch,
+                    cancellationBranch
+                ]));
+                if (outcome.type === "cancelled") {
+                    return yield* failCancelled(outcome);
+                }
+                if (outcome.type === "timeout") {
+                    yield* emitWorkflowEvent({
+                        type: "signal.timeout",
+                        executionId,
+                        name,
+                        invocation,
+                        activityName: waitName,
+                        timeout: opts?.timeout
+                    });
+                    return { type: "timeout" };
+                }
+                const value = decodeSync(schema, outcome.encoded);
+                yield* emitWorkflowEvent({
+                    type: "signal.received",
+                    executionId,
+                    name,
+                    invocation,
+                    activityName: waitName,
+                    payload: value
+                });
+                return { type: "signal", value };
+            });
+        },
+        now() {
+            const invocation = nextInvocation(counters, "now");
+            const activityName = `now#${invocation}`;
+            const call = { kind: "now", name: "now", counter: invocation };
+            const activity = Activity.make({
+                name: activityName,
+                success: Schema.Date,
+                execute: Effect.sync(() => new Date())
+            });
+            return Effect.gen(function* () {
+                yield* recordCall(call);
+                return yield* activity;
+            });
+        },
+        random() {
+            const invocation = nextInvocation(counters, "random");
+            const activityName = `random#${invocation}`;
+            const call = { kind: "random", name: "random", counter: invocation };
+            const activity = Activity.make({
+                name: activityName,
+                success: Schema.Number,
+                execute: Effect.sync(() => Math.random())
+            });
+            return Effect.gen(function* () {
+                yield* recordCall(call);
+                return yield* activity;
+            });
+        },
+        code(name, options) {
+            const invocation = nextInvocation(counters, name);
+            const activityName = `${name}#${invocation}`;
+            const call = { kind: "code", name, counter: invocation };
+            const execute = Effect.gen(function* () {
+                yield* emitWorkflowEvent({
+                    type: "code.started",
+                    executionId,
+                    name,
+                    invocation,
+                    activityName,
+                    ...(options.reason === undefined ? {} : { reason: options.reason })
+                });
+                const result = yield* Effect.tryPromise({
+                    try: async () => options.run(),
+                    catch: (error) => new AsyncFailure(error)
+                });
+                yield* emitWorkflowEvent({
+                    type: "code.completed",
+                    executionId,
+                    name,
+                    invocation,
+                    activityName,
+                    ...(options.reason === undefined ? {} : { reason: options.reason }),
+                    result
+                });
+                return result;
+            }).pipe(Effect.tapError((error) => emitWorkflowEvent({
+                type: "code.failed",
+                executionId,
+                name,
+                invocation,
+                activityName,
+                ...(options.reason === undefined ? {} : { reason: options.reason }),
+                error: unwrapAsyncFailure(error)
+            })));
+            const activity = Activity.make({
+                name: activityName,
+                success: Schema.Unknown,
+                error: Schema.Unknown,
+                execute
+            }).pipe(Effect.mapError(unwrapAsyncFailure));
+            return Effect.gen(function* () {
+                yield* recordCall(call);
+                return yield* activity;
+            });
+        },
+        fail(error) {
+            return Effect.fail(decodeSync(workflowErrors, error));
+        },
+        effect(effect) {
+            return effect;
+        }
+    };
+};
+const makeInMemoryCtx = (executionId, workflowErrors, compensations, determinism, emit, options = {}) => {
+    const counters = new Map();
+    let journalPosition = 0;
+    let blockPosition = 0;
+    const branchCollectors = [];
+    const recordCall = async (actual) => {
+        const index = journalPosition++;
+        const expected = determinism.calls[index];
+        if (expected === undefined) {
+            determinism.calls.push(actual);
+        }
+        else {
+            verifyCall(expected, actual);
+        }
+        branchCollectors[branchCollectors.length - 1]?.push(actual);
+    };
+    return {
+        executionId,
+        run(step, rawInput) {
+            const invocation = nextInvocation(counters, step.name);
+            const activityName = `${step.name}#${invocation}`;
+            const input = decodeSync(step.input, rawInput);
+            return Effect.tryPromise({
+                try: async () => {
+                    await recordCall({ kind: "step", name: step.name, counter: invocation });
+                    const attempts = transientAttempts(step.retry);
+                    let lastTransient;
+                    for (let attempt = 1; attempt <= attempts; attempt++) {
+                        await emit({
+                            type: "step.started",
+                            executionId,
+                            stepName: step.name,
+                            invocation,
+                            activityName,
+                            attempt,
+                            input
+                        });
+                        try {
+                            const stepContext = makeStepContext(executionId, attempt);
+                            const executeStep = options.stepExecutors?.get(step);
+                            const release = await acquireConcurrency(step, input);
+                            try {
+                                const executeInput = await resolveSecretRefs(input, options.secrets);
+                                const value = await (options.stepExecutor?.({ step, input: executeInput, invocation, activityName, context: stepContext }) ??
+                                    executeStep?.(executeInput, stepContext) ??
+                                    step.execute(executeInput, stepContext));
+                                if (isTerminalFailure(value)) {
+                                    const terminal = decodeSync(step.errors, value.error);
+                                    throw terminal;
+                                }
+                                const result = decodeSync(step.output, value);
+                                encodeSync(step.output, result);
+                                await emit({
+                                    type: "step.completed",
+                                    executionId,
+                                    stepName: step.name,
+                                    invocation,
+                                    activityName,
+                                    attempt,
+                                    result
+                                });
+                                if (step.compensate !== undefined) {
+                                    compensations.push({
+                                        stepName: step.name,
+                                        invocation,
+                                        result,
+                                        input,
+                                        compensate: step.compensate
+                                    });
+                                }
+                                return result;
+                            }
+                            finally {
+                                release();
+                            }
+                        }
+                        catch (error) {
+                            if (attempt === attempts || isDeclaredTerminal(step.errors, error)) {
+                                await emit({
+                                    type: "step.failed",
+                                    executionId,
+                                    stepName: step.name,
+                                    invocation,
+                                    activityName,
+                                    error
+                                });
+                                throw error;
+                            }
+                            lastTransient = error;
+                        }
+                    }
+                    throw lastTransient;
+                },
+                catch: (error) => new AsyncFailure(error)
+            }).pipe(Effect.mapError(unwrapAsyncFailure));
+        },
+        sleep(duration, name) {
+            const baseName = name ?? `sleep:${String(duration)}`;
+            const invocation = nextInvocation(counters, baseName);
+            const activityName = `${baseName}#${invocation}`;
+            return Effect.promise(async () => {
+                await recordCall({ kind: "sleep", name: baseName, counter: invocation });
+                await emit({
+                    type: "sleep.started",
+                    executionId,
+                    name: baseName,
+                    invocation,
+                    activityName,
+                    duration
+                });
+                await options.sleep?.({ executionId, name: activityName, duration });
+                await emit({
+                    type: "sleep.completed",
+                    executionId,
+                    name: baseName,
+                    invocation,
+                    activityName,
+                    duration
+                });
+            });
+        },
+        waitForSignal(name, schema, opts) {
+            const invocation = nextInvocation(counters, name);
+            const activityName = `${name}#${invocation}`;
+            const payloadSchema = jsonSchemaOf(schema);
+            return Effect.tryPromise({
+                try: async () => {
+                    await recordCall({ kind: "signal", name, counter: invocation });
+                    registerSignalSchema(executionId, name, schema);
+                    await emit({
+                        type: "signal.waiting",
+                        executionId,
+                        name,
+                        invocation,
+                        activityName,
+                        timeout: opts?.timeout,
+                        ...(payloadSchema === undefined ? {} : { payloadSchema })
+                    });
+                    const buffered = takeBufferedSignal(executionId, name, schema);
+                    if (buffered !== undefined) {
+                        await emit({
+                            type: "signal.received",
+                            executionId,
+                            name,
+                            invocation,
+                            activityName,
+                            payload: buffered
+                        });
+                        return { type: "signal", value: buffered };
+                    }
+                    if (options.signalValue !== undefined) {
+                        const value = decodeSync(schema, await options.signalValue({ executionId, name, schema }));
+                        await emit({
+                            type: "signal.received",
+                            executionId,
+                            name,
+                            invocation,
+                            activityName,
+                            payload: value
+                        });
+                        return { type: "signal", value };
+                    }
+                    if (opts?.timeout !== undefined) {
+                        if (options.signalTimeout !== undefined) {
+                            const outcome = await Promise.race([
+                                awaitSignal(executionId, name, schema).then((value) => ({ type: "signal", value })),
+                                options.signalTimeout({ executionId, name: activityName, duration: opts.timeout })
+                                    .then(() => ({ type: "timeout" }))
+                            ]);
+                            if (outcome.type === "signal") {
+                                await emit({
+                                    type: "signal.received",
+                                    executionId,
+                                    name,
+                                    invocation,
+                                    activityName,
+                                    payload: outcome.value
+                                });
+                            }
+                            else {
+                                await emit({
+                                    type: "signal.timeout",
+                                    executionId,
+                                    name,
+                                    invocation,
+                                    activityName,
+                                    timeout: opts.timeout
+                                });
+                            }
+                            return outcome;
+                        }
+                        await emit({
+                            type: "signal.timeout",
+                            executionId,
+                            name,
+                            invocation,
+                            activityName,
+                            timeout: opts.timeout
+                        });
+                        return { type: "timeout" };
+                    }
+                    const value = await awaitSignal(executionId, name, schema);
+                    await emit({
+                        type: "signal.received",
+                        executionId,
+                        name,
+                        invocation,
+                        activityName,
+                        payload: value
+                    });
+                    return { type: "signal", value };
+                },
+                catch: (error) => new AsyncFailure(error)
+            }).pipe(Effect.mapError(unwrapAsyncFailure));
+        },
+        now() {
+            const invocation = nextInvocation(counters, "now");
+            const call = { kind: "now", name: "now", counter: invocation };
+            return Effect.promise(async () => {
+                await recordCall(call);
+                const key = valueKey(call);
+                const existing = determinism.values.get(key);
+                if (existing instanceof Date) {
+                    return existing;
+                }
+                const value = new Date();
+                determinism.values.set(key, value);
+                return value;
+            });
+        },
+        random() {
+            const invocation = nextInvocation(counters, "random");
+            const call = { kind: "random", name: "random", counter: invocation };
+            return Effect.promise(async () => {
+                await recordCall(call);
+                const key = valueKey(call);
+                const existing = determinism.values.get(key);
+                if (typeof existing === "number") {
+                    return existing;
+                }
+                const value = Math.random();
+                determinism.values.set(key, value);
+                return value;
+            });
+        },
+        code(name, options) {
+            const invocation = nextInvocation(counters, name);
+            const activityName = `${name}#${invocation}`;
+            const call = { kind: "code", name, counter: invocation };
+            return Effect.tryPromise({
+                try: async () => {
+                    await recordCall(call);
+                    await emit({
+                        type: "code.started",
+                        executionId,
+                        name,
+                        invocation,
+                        activityName,
+                        ...(options.reason === undefined ? {} : { reason: options.reason })
+                    });
+                    const key = valueKey(call);
+                    if (determinism.values.has(key)) {
+                        const result = determinism.values.get(key);
+                        await emit({
+                            type: "code.completed",
+                            executionId,
+                            name,
+                            invocation,
+                            activityName,
+                            ...(options.reason === undefined ? {} : { reason: options.reason }),
+                            result
+                        });
+                        return result;
+                    }
+                    try {
+                        const result = await options.run();
+                        determinism.values.set(key, result);
+                        await emit({
+                            type: "code.completed",
+                            executionId,
+                            name,
+                            invocation,
+                            activityName,
+                            ...(options.reason === undefined ? {} : { reason: options.reason }),
+                            result
+                        });
+                        return result;
+                    }
+                    catch (error) {
+                        await emit({
+                            type: "code.failed",
+                            executionId,
+                            name,
+                            invocation,
+                            activityName,
+                            ...(options.reason === undefined ? {} : { reason: options.reason }),
+                            error
+                        });
+                        throw error;
+                    }
+                },
+                catch: (error) => new AsyncFailure(error)
+            }).pipe(Effect.mapError(unwrapAsyncFailure));
+        },
+        all(effects, options) {
+            const name = options?.name ?? "all";
+            const invocation = nextInvocation(counters, name);
+            const activityName = `${name}#${invocation}`;
+            const branches = effects.length;
+            const call = { kind: "all", name, counter: invocation, branches };
+            const record = Effect.tryPromise({
+                try: () => recordCall(call),
+                catch: (error) => error
+            });
+            const emitEvent = (event) => Effect.promise(() => emit(event));
+            const persistBlock = (branchCalls) => Effect.sync(() => {
+                if (determinism.blocks[blockPosition++] === undefined) {
+                    determinism.blocks.push({ call, branches: branchCalls });
+                }
+            });
+            return Effect.gen(function* () {
+                yield* record;
+                yield* emitEvent({
+                    type: "all.started",
+                    executionId,
+                    name,
+                    invocation,
+                    activityName,
+                    branches
+                });
+                const branchCalls = [];
+                const wrapped = effects.map((effect) => Effect.acquireUseRelease(Effect.sync(() => {
+                    const calls = [];
+                    branchCalls.push(calls);
+                    branchCollectors.push(calls);
+                }), () => effect, () => Effect.sync(() => {
+                    branchCollectors.pop();
+                })));
+                return yield* Effect.all(wrapped, { concurrency: 1 }).pipe(Effect.tap(() => Effect.gen(function* () {
+                    yield* persistBlock(branchCalls);
+                    yield* emitEvent({
+                        type: "all.completed",
+                        executionId,
+                        name,
+                        invocation,
+                        activityName,
+                        branches
+                    });
+                })), Effect.tapError((error) => Effect.gen(function* () {
+                    yield* persistBlock(branchCalls);
+                    yield* emitEvent({
+                        type: "all.failed",
+                        executionId,
+                        name,
+                        invocation,
+                        activityName,
+                        branches,
+                        error
+                    });
+                })));
+            });
+        },
+        fail(error) {
+            return Effect.fail(decodeSync(workflowErrors, error));
+        },
+        effect(effect) {
+            return effect;
+        }
+    };
+};
+const isDeclaredTerminal = (schema, error) => {
+    try {
+        decodeSync(schema, error);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const defineWorkflow = (config) => {
+    const errors = config.errors ?? Schema.Never;
+    const engineName = `${config.name}@v${config.version}`;
+    const sourceHash = createHash("sha256")
+        .update(config.name)
+        .update("\0")
+        .update(String(config.version))
+        .update("\0")
+        .update(config.run.toString())
+        .digest("hex");
+    const workflow = Workflow.make(engineName, {
+        payload: config.input,
+        idempotencyKey: (payload) => JSON.stringify(payload),
+        success: config.output,
+        error: Schema.Unknown
+    });
+    const layer = workflow.toLayer(Effect.fn(function* (payload, executionId) {
+        const input = decodeSync(config.input, payload);
+        const result = yield* config.run(input, makeCtx(workflow, ExecutionId.make(executionId), errors));
+        return decodeSync(config.output, result);
+    }));
+    const executeInMemory = async (payload, options = {}) => {
+        const executionId = ExecutionId.make(options.executionId ?? `memory-${crypto.randomUUID()}`);
+        const compensations = [];
+        const determinism = options.determinism ?? createInMemoryDeterminismState();
+        const input = decodeSync(config.input, payload);
+        const emit = async (event) => {
+            await options.onEvent?.(event);
+        };
+        const ctx = makeInMemoryCtx(executionId, errors, compensations, determinism, emit, {
+            ...(options.stepExecutors === undefined ? {} : { stepExecutors: options.stepExecutors }),
+            ...(options.stepExecutor === undefined ? {} : { stepExecutor: options.stepExecutor }),
+            ...(options.sleep === undefined ? {} : { sleep: options.sleep }),
+            ...(options.signalTimeout === undefined ? {} : { signalTimeout: options.signalTimeout }),
+            ...(options.signalValue === undefined ? {} : { signalValue: options.signalValue }),
+            ...(options.secrets === undefined ? {} : { secrets: options.secrets })
+        });
+        const effect = Effect.gen(function* () {
+            return yield* config.run(input, ctx);
+        }).pipe(Effect.map((result) => decodeSync(config.output, result)), Effect.catch((error) => Effect.gen(function* () {
+            if (skipsCompensation(error)) {
+                return yield* Effect.fail(error);
+            }
+            for (const compensation of compensations.slice().reverse()) {
+                yield* emitWorkflowEvent({
+                    type: "compensation.started",
+                    executionId,
+                    stepName: compensation.stepName,
+                    invocation: compensation.invocation,
+                    activityName: `${compensation.stepName}#${compensation.invocation}`,
+                    result: compensation.result,
+                    input: compensation.input,
+                    reason: error
+                });
+                yield* Effect.promise(() => Promise.resolve(compensation.compensate(compensation.result, compensation.input, error))).pipe(Effect.tapError((compensationError) => emitWorkflowEvent({
+                    type: "compensation.failed",
+                    executionId,
+                    stepName: compensation.stepName,
+                    invocation: compensation.invocation,
+                    activityName: `${compensation.stepName}#${compensation.invocation}`,
+                    error: compensationError
+                })), Effect.orDie);
+                yield* emitWorkflowEvent({
+                    type: "compensation.completed",
+                    executionId,
+                    stepName: compensation.stepName,
+                    invocation: compensation.invocation,
+                    activityName: `${compensation.stepName}#${compensation.invocation}`
+                });
+            }
+            return yield* Effect.fail(error);
+        })));
+        const exit = await Effect.runPromiseExit(effect.pipe(Effect.provideService(currentWorkflowEventSink, options.onEvent)));
+        if (Exit.isSuccess(exit)) {
+            return exit.value;
+        }
+        const failure = Option.getOrUndefined(Cause.findErrorOption(exit.cause));
+        throw failure ?? Cause.squash(exit.cause);
+    };
+    return {
+        [DefinedWorkflowTypeId]: DefinedWorkflowTypeId,
+        name: config.name,
+        version: config.version,
+        engineName,
+        sourceHash,
+        input: config.input,
+        output: config.output,
+        errors,
+        workflow,
+        layer,
+        execute: (payload) => workflow.execute(payload),
+        executeInMemory
+    };
+};
+//# sourceMappingURL=core.js.map