@geonosis/workflows 0.2.0

package/dist/index.d.cts

@@ -0,0 +1,1153 @@
+import { Extensions, EventEnvelope, SeenBefore } from '@geonosis/events';
+
+/**
+ * Facts the engine states about the run itself, and a body never does. A consumer can rely on seeing
+ * exactly one of these per closed run.
+ */
+declare const LIFECYCLE_EVENTS: {
+    readonly compensated: "workflow.compensated";
+    readonly completed: "workflow.completed";
+};
+type LifecycleEventType = (typeof LIFECYCLE_EVENTS)[keyof typeof LIFECYCLE_EVENTS];
+/** What a run is, to whoever names the extensions its envelopes carry. */
+type RunFacts = {
+    actor: string | null;
+    name: string;
+    runId: string;
+    tenantId: string;
+};
+/**
+ * What the emit door is built from, at the composition root and nowhere else.
+ *
+ * `source` is the one CloudEvents concept nothing in a run can stand in for — it identifies the
+ * PRODUCER — so it is configuration, like the clock beside it, and it is spelled once. The tenant,
+ * the actor and the run are not fields here: they are FLAT EXTENSIONS the repo names in its own
+ * vocabulary, because a name one product needed in every envelope is what makes a package
+ * unadoptable by the next one.
+ */
+type EmitConfig<Carried extends Extensions = Extensions> = {
+    extensionsOf?: (run: RunFacts) => Carried;
+    /** The clock, injected. */
+    now?: () => number;
+    source: string;
+};
+type WorkflowExecution = 'durable' | 'inline';
+/**
+ * The statuses and the endings are const tuples rather than bare unions so the type and the value
+ * cannot drift: a conformance suite, a journal migration and a consumer's switch all need to
+ * ENUMERATE them, and a union alone leaves each of the three to write the list out again.
+ */
+declare const RUN_STATUSES: readonly ["cancelled", "compensated", "completed", "failed", "running"];
+type RunStatus = (typeof RUN_STATUSES)[number];
+/** How a run ended. `running` is the only status that is not an ending. */
+declare const RUN_OUTCOMES: readonly ["cancelled", "compensated", "completed", "failed"];
+type RunOutcome = (typeof RUN_OUTCOMES)[number];
+declare const STEP_STATUSES: readonly ["compensated", "completed", "failed"];
+type StepStatus = (typeof STEP_STATUSES)[number];
+/**
+ * How far the undo got. A run that could not be fully reversed is `failed`, not `compensated` —
+ * the difference is the whole point of writing the trail down.
+ */
+type CompensationOutcome = Exclude<RunOutcome, 'completed'>;
+/**
+ * Names the engine uses for its own steps. A caller's step under one of these would be handed the
+ * engine's memoised result on a replay — or would hand the engine its own.
+ */
+declare const RESERVED_STEP_NAMES: {
+    readonly emitEvents: "emit-events";
+    readonly finishRun: "finish-run";
+};
+declare const COMPENSATION_PREFIX = "compensate:";
+/** What the engine calls the step that undoes another one. Declared here, used everywhere. */
+declare const compensationStepName: (stepName: string) => string;
+/**
+ * What the engine accepts wherever it is going to `await` the answer anyway. Plenty of work is not
+ * asynchronous — totalling a basket, deriving a reference — and a step exists to record that it
+ * happened and to hang an undo on it, not because it waits for anybody.
+ */
+type MaybePromise<Value> = Value | Promise<Value>;
+type StepBackoff = 'constant' | 'exponential' | 'linear';
+/**
+ * What a step is allowed to spend before it gives up. `delay` is a duration the inline executor
+ * reads and a durable platform parses itself, so both a number of milliseconds and the platforms'
+ * own `'10 seconds'` spelling are accepted.
+ */
+type StepRetry = {
+    backoff?: StepBackoff;
+    delay?: number | string;
+    limit: number;
+};
+type StepBudget = {
+    retry?: StepRetry;
+    timeout?: number | string;
+};
+/**
+ * What a step is worth spending when it declared nothing.
+ *
+ * The OBJECT is the signal, not its contents: the inline executor tests a budget for identity with
+ * this one to tell "the caller asked for retries" from "the caller said nothing", because an inline
+ * run is holding a request open and a step that cannot finish now should compensate and say so.
+ * The numbers are what a durable platform is told, where waiting costs nothing.
+ */
+declare const DEFAULT_STEP_BUDGET: StepBudget;
+/**
+ * Structurally a Cloudflare Queue producer, so a Queue binding IS an EventSink with no adapter at
+ * all. Batches only, deliberately: a run emits several events and a sweep delivers many, and one
+ * call per message is a round trip per event on the mutation path.
+ */
+type EventSink = {
+    sendBatch: (messages: {
+        body: EventEnvelope;
+    }[]) => Promise<unknown>;
+};
+/**
+ * The run record, as the executors need it.
+ *
+ * `getRun` and `listRunSteps` are REQUIRED here and were optional in the study — see CONTRACT.md,
+ * "Divergences". Every property the TLA+ model states holds only when the trail is read at entry;
+ * an optional read is a second configuration nobody model-checks and every implementer skips.
+ */
+type RunJournal = {
+    /**
+     * MUST throw when the idempotency key is already HELD — that is, when a run with the same
+     * `(tenantId, idempotencyKey)` is `running` or `completed`. The throw IS the dedup signal: the
+     * engine answers it by looking the held run up rather than doing the work twice. A run that
+     * failed, compensated or was cancelled releases its key, so the work can be asked for again.
+     */
+    insertRun: (params: {
+        execution: WorkflowExecution;
+        idempotencyKey: string | null;
+        input: unknown;
+        name: string;
+        /**
+         * The run this one was started from, when a step started it. Provenance and nothing more:
+         * without it a child run is an orphan in the table and nobody can answer "what caused this?".
+         */
+        parentRunId?: string | null;
+        /** The run this one was started to do again, when it is one. Null for nearly every run. */
+        replayOf?: string | null;
+        tenantId: string;
+    }) => Promise<string>;
+    /**
+     * Idempotent on `(runId, seq, attempt)` — a retried step writes one row, not two.
+     *
+     * Answers with the run's cancellation flag, in the SAME round trip that writes the step.
+     * Cooperative cancellation is then free: the engine already had to talk to the journal here.
+     */
+    recordStep: (params: {
+        attempt: number;
+        error?: string | null;
+        name: string;
+        output?: unknown;
+        runId: string;
+        seq: number;
+        status: StepStatus;
+        tenantId: string;
+    }) => Promise<{
+        cancellationRequested: boolean;
+    }>;
+    /**
+     * ONE atomic write. Closing the run and writing down the events it emitted are one call because
+     * they are one batch underneath: a run is completed if and only if its events are durably queued
+     * for delivery. A journal that took them separately could be interrupted between the two, and
+     * "completed, audit trail lost" is the state that must not exist.
+     */
+    finishRun: (params: {
+        error?: string | null;
+        events?: EventEnvelope[];
+        output?: unknown;
+        runId: string;
+        status: RunOutcome;
+        tenantId: string;
+    }) => Promise<void>;
+    /**
+     * Delivered, and recorded as delivered so nothing sweeps it again. Failing this is survivable —
+     * the sweeper re-sends, and the consumer recognises the message by its id.
+     */
+    markEventsDispatched: (params: {
+        ids: string[];
+        tenantId: string;
+    }) => Promise<void>;
+    /**
+     * Raise the cancellation flag on a run. MUST answer true only if the run was `running` — a run
+     * that has already ended cannot be stopped.
+     */
+    requestCancellation: (params: {
+        runId: string;
+        tenantId: string;
+    }) => Promise<boolean>;
+    /**
+     * Every tenant's undispatched events, oldest first — the sweeper's query, and the one place in
+     * the contract that is deliberately not tenant-scoped, because nobody is asking on a tenant's
+     * behalf.
+     */
+    listUndispatchedEvents: (params: {
+        before: number;
+        limit: number;
+    }) => Promise<{
+        envelope: EventEnvelope;
+        tenantId: string;
+    }[]>;
+    /**
+     * The runs of the given kind that were started before the cutoff and are still `running`.
+     *
+     * A list rather than a bulk update, because closing a run is not only a status change: every
+     * closed run announces itself, and an announcement needs the run's name and its tenant.
+     */
+    listAbandonedRuns: (params: {
+        execution: 'inline';
+        limit: number;
+        startedBefore: number;
+    }) => Promise<{
+        name: string;
+        runId: string;
+        tenantId: string;
+    }[]>;
+    /** The run itself, for whoever is asking what happened. */
+    getRun: (params: {
+        runId: string;
+        tenantId: string;
+    }) => Promise<{
+        error: string | null;
+        execution: string;
+        finishedAt: number | null;
+        id: string;
+        input: unknown;
+        name: string;
+        output: unknown;
+        parentRunId: string | null;
+        replayOf: string | null;
+        startedAt: number;
+        status: string;
+    } | null>;
+    /** The run's trail, oldest first. */
+    listRunSteps: (params: {
+        runId: string;
+        tenantId: string;
+    }) => Promise<{
+        attempt: number;
+        error: string | null;
+        name: string;
+        seq: number;
+        status: string;
+    }[]>;
+    /** Held runs only, by the same rule `insertRun` refuses by. */
+    findRunByIdempotencyKey: (params: {
+        idempotencyKey: string;
+        tenantId: string;
+    }) => Promise<{
+        id: string;
+        output: unknown;
+        status: RunStatus;
+    } | null>;
+};
+/** Why a compensation is running. */
+type CompensationReason = {
+    /** The error that unwound the run. A `RunCancelledError` when somebody asked it to stop. */
+    cause: unknown;
+};
+/**
+ * What a step is handed. `idempotencyKey` is the step's own — `${runId}:${seq}`, and
+ * `${runId}:${seq}:undo` for a compensation — stable across every attempt and every replay of that
+ * step, and different for every other step in the run.
+ */
+type StepContext<Scope> = Scope & {
+    /** Which attempt this is, from one. The idempotency key deliberately does NOT move with it. */
+    attempt: number;
+    idempotencyKey: string;
+    runId: string;
+    tenantId: string;
+};
+/**
+ * A step, as the engine holds it.
+ *
+ * There is ONE rule about compensation data: the undo is handed exactly what the step returned. A
+ * step that needs something extra to undo itself returns it, and then its value says everything
+ * about what it did — which is also what the run record holds and what the body was given.
+ *
+ * `invoke` and `compensate` are declared as METHODS rather than function properties so TypeScript
+ * checks their parameters bivariantly, which is what lets a heterogeneous list of steps be held in
+ * one array without every caller reaching for a cast.
+ */
+type Step<Scope, Input, Output> = {
+    budget: StepBudget;
+    compensate?(output: Output, ctx: StepContext<Scope>, reason: CompensationReason): MaybePromise<void>;
+    invoke(input: Input, ctx: StepContext<Scope>): MaybePromise<Output>;
+    name: string;
+};
+/**
+ * The one difference between the two executors: how a unit of work is carried out. Inline calls
+ * it; durable hands it to the platform's step primitive, which checkpoints and retries it.
+ * Everything else — ordering, the trail, the reverse compensation, the held events — is one
+ * implementation, proven once.
+ */
+type StepRunner = <Output>(name: string, budget: StepBudget, run: (ctx: {
+    attempt: number;
+}) => Promise<Output>) => Promise<Output>;
+/**
+ * The seam over a durable engine's step primitives. Cloudflare Workflows implements it against a
+ * real `WorkflowStep`; a suite implements it against an array of calls. Inngest, Restate and
+ * Temporal expose the same three capabilities under other names.
+ */
+type StepPrimitive = {
+    do: <Output>(name: string, budget: StepBudget, run: (ctx: {
+        attempt: number;
+    }) => Promise<Output>) => Promise<Output>;
+    sleep: (name: string, duration: number | string) => Promise<void>;
+    waitForEvent: <Payload>(name: string, options: {
+        timeout?: number | string;
+        type: string;
+    }) => Promise<Payload>;
+};
+/**
+ * Everything a run needs that is not the run itself.
+ *
+ * Built once per isolate for what is static — where records go, where events go, who is watching —
+ * and narrowed per request for who is asking. `context` is whatever else the caller scoped this
+ * request with, and it reaches every step through its `StepContext`.
+ */
+type WorkflowRuntime<Scope extends object = Record<string, unknown>> = {
+    actor?: string | null;
+    context?: Scope;
+    emit?: EmitConfig;
+    events?: EventSink;
+    journal: RunJournal;
+    observer?: RunObserver;
+    scope?: RunScope;
+    tenantId: string;
+};
+/** What a unit of work is wrapped in. `withConnection`, `withCells`, a span — the host's own. */
+type StepScope = <Output>(body: () => Promise<Output>) => Promise<Output>;
+/**
+ * What a DURABLE step's body and its undo are each wrapped in, and nothing else is.
+ *
+ * A durable instance hibernates between steps, so a handle opened once per run is dead by the time
+ * the second step reaches for it: each unit of work opens the one it uses. The engine's own writes —
+ * the trail, the closing batch — are not that unit; they are the runner's, and a scope stretched
+ * over them would put a journal write inside a connection the step is about to close.
+ *
+ * `perStep` is asked for a scope per unit rather than handed one, because a scope is a resource and
+ * the whole point is that a retried step gets its own. An inline run ignores it: it holds one request
+ * open from the first step to the last, so there is nothing to reopen.
+ */
+type RunScope = {
+    perStep: () => StepScope;
+};
+/**
+ * Plain facts about a run going by, for whoever wants to count or trace them. Deliberately plain:
+ * no objects from inside the engine, so an adapter for OpenTelemetry or a log line cannot come to
+ * depend on the engine's shape. Every hook is called defensively — an observability backend having
+ * a bad day is not a reason to refuse somebody's invoice.
+ */
+type RunObserver = {
+    onCompensationEnd?(fact: {
+        attempt: number;
+        durationMs: number;
+        name: string;
+        runId: string;
+        seq: number;
+        status: StepStatus;
+    }): void;
+    onCompensationStart?(fact: {
+        attempt: number;
+        name: string;
+        runId: string;
+        seq: number;
+    }): void;
+    /**
+     * `events` are the TYPES the run queued in the batch that closed it, in order — never their
+     * payloads. A payload is somebody's invoice; it belongs where a person went looking for it, not
+     * in a log line that scrolls past.
+     */
+    onRunEnd?(fact: {
+        durationMs: number;
+        events: string[];
+        name: string;
+        runId: string;
+        status: RunOutcome;
+    }): void;
+    onRunStart?(fact: {
+        name: string;
+        runId: string;
+        tenantId: string;
+    }): void;
+    onStepEnd?(fact: {
+        attempt: number;
+        durationMs: number;
+        name: string;
+        runId: string;
+        seq: number;
+        status: StepStatus;
+    }): void;
+    onStepStart?(fact: {
+        attempt: number;
+        name: string;
+        runId: string;
+        seq: number;
+    }): void;
+};
+
+/**
+ * How the inline executor carries out a step.
+ *
+ * By default it runs it once. An inline run is holding a request open, and a run that cannot finish
+ * now should compensate and say so rather than spend a budget nobody asked it to. A step that DID
+ * ask — one that declares a retry itself — is believed: a flaky provider call inside a 200 ms
+ * mutation is exactly the case where two quick attempts beat compensating the whole run.
+ *
+ * "Asked" is IDENTITY with `DEFAULT_STEP_BUDGET`, which is the object `createStep` uses when the
+ * caller named neither a retry nor a timeout. That is what lets one definition mean "once" inline
+ * and "the platform's default" durably.
+ */
+declare const createInlineRunner: (options?: {
+    sleep?: (milliseconds: number) => Promise<void>;
+}) => StepRunner;
+
+/**
+ * The identities the engine derives from the run rather than from the clock or a random source.
+ *
+ * A durable body invoked twice for one run walks the same steps in the same order, so it arrives
+ * at the same identities: a step retried after a provider already accepted the work presents the
+ * key it presented the first time, and a second write of a run's closure lands on the row that
+ * already exists. They are together here because they are a WIRE FORMAT — they appear in database
+ * rows, in delivered messages and in other people's idempotency records — so changing either is a
+ * breaking change and the two must never quietly drift apart.
+ */
+/** What a step presents to the outside world. Stable across attempts and replays. */
+declare const stepIdempotencyKey: (runId: string, seq: number) => string;
+/**
+ * What a compensation presents. Undoing a charge is a refund — a different side effect, and so a
+ * different key, derived from the step it reverses.
+ */
+declare const compensationIdempotencyKey: (runId: string, seq: number) => string;
+/** What identifies one emission of one run, to the outbox and to every consumer. */
+declare const envelopeId: (runId: string, ordinal: number) => string;
+type RunClosure = 'compensated' | 'completed' | 'start-refused' | 'swept';
+/**
+ * What identifies a fact about the RUN rather than an emission from its body.
+ *
+ * Deliberately not an ordinal from the emission sequence. An ordinal is a function of how far the
+ * body walked, and a re-invoked body can walk further than the invocation that closed the run did —
+ * which minted the announcement at a higher ordinal, under a different id, which the outbox's
+ * conflict clause could not recognise as a repeat. A run closes once, so its closure has one id,
+ * whoever writes it and however far anybody walked.
+ */
+declare const lifecycleEnvelopeId: (runId: string, closure: RunClosure) => string;
+
+/**
+ * What a run puts on the table: one envelope per announcement, plus the fact that the run closed.
+ *
+ * Every field an envelope has that is not its type and its payload is minted by
+ * `@geonosis/events`' emit door and nowhere else — `id`, `occurredAt`, the required `source`, and
+ * the flat extensions the repo declared. This engine spells none of them. What it does supply is
+ * the door's MINTER, and it supplies one derived from the RUN rather than from the clock: a body
+ * invoked twice for one run walks the same emissions in the same order and arrives at the same ids,
+ * so a second write lands on rows that already exist instead of handing a consumer copies it has no
+ * way to recognise. `formal/WorkflowsRandomIds.cfg` is what any other minter costs.
+ */
+type RunEmitter = {
+    /** A fact about the RUN. Identified by what it is, never by a position in the emission sequence:
+     * an ordinal is a function of how far the body walked, and a re-invoked body can walk further. */
+    closure: (closure: RunClosure, type: string, payload: unknown) => EventEnvelope;
+    emission: (type: string, payload: unknown) => EventEnvelope;
+};
+declare const createRunEmitter: (config: EmitConfig, run: RunFacts) => RunEmitter;
+
+/**
+ * What one batched send carries. A drain larger than this is more than one call, and the number
+ * lives beside the only code that makes those calls rather than in a journal, which has no business
+ * knowing what a queue is.
+ */
+declare const EVENT_BATCH_LIMIT = 100;
+/**
+ * The one way an event leaves the process, shared by the drain a run does for itself and the sweep a
+ * cron does for whatever the drain could not finish. Sending and recording the send are one act per
+ * batch: a batch that was sent but not recorded is sent again by the next sweep, which the consumer
+ * recognises by the envelope's id and discards — the safe direction of an at-least-once delivery.
+ */
+declare const dispatchEvents: (options: {
+    envelopes: readonly EventEnvelope[];
+    markDispatched: (ids: string[]) => Promise<void>;
+    sink: EventSink;
+}) => Promise<number>;
+/** How many rows one sweep considers. A sweep takes a bounded bite and lets the next take the rest. */
+declare const EVENT_SWEEP_LIMIT = 500;
+/**
+ * How long a row is left for the run that made it. A row written a moment ago almost certainly
+ * belongs to a run whose own drain is still in flight; waiting a minute costs a minute and saves a
+ * duplicate delivery.
+ */
+declare const EVENT_SWEEP_GRACE_MS = 60000;
+/**
+ * The other half of the outbox: what comes back for the events a run's own drain could not deliver.
+ * The drain is best-effort by design — the mutation committed, and a queue that could not be reached
+ * is not the caller's problem — and this is what makes that true.
+ *
+ * It reads across every tenant, because nobody is asking on a tenant's behalf, and delivers each
+ * tenant's rows under that tenant so a journal that scopes its writes still can.
+ */
+declare const sweepEventOutbox: (options: {
+    journal: RunJournal;
+    limit?: number;
+    now?: number;
+    olderThanMs?: number;
+    sink: EventSink;
+}) => Promise<number>;
+/** How many abandoned runs one sweep closes. The next sweep takes the rest. */
+declare const ABANDONED_SWEEP_LIMIT = 200;
+/**
+ * Close the runs nobody is going to close.
+ *
+ * An inline run lives inside one request. If the process carrying it dies — a deploy, a crash, a
+ * timeout — nothing is left to finish it: it is not running, it was never compensated, and the
+ * record says `running` for as long as the table exists. Those are the runs an operator finds a year
+ * later and cannot explain, and the only honest thing to do with them is say so.
+ *
+ * Durable runs are deliberately not touched at any age. One may be asleep for a week or waiting on a
+ * human, and failing it because it is old would be the sweep inventing an incident.
+ *
+ * Each run is closed through `finishRun` carrying its own announcement, because every closed run
+ * announces itself and a sweeper is not an exception. Run it on a schedule with a window comfortably
+ * longer than your longest inline request.
+ */
+declare const sweepAbandonedRuns: (options: {
+    /** The door's configuration. Without it a swept run closes with nothing to announce. */
+    emit?: EmitConfig;
+    journal: RunJournal;
+    limit?: number;
+    now?: number;
+    olderThanMs: number;
+}) => Promise<number>;
+
+/**
+ * Wait for several step calls at once.
+ *
+ * It is `Promise.all` under Medusa's name, and it is thin on purpose: the calls are ARGUMENTS, so
+ * every one of them has already been made — in array order, synchronously — by the time this
+ * function has anything to wait for. That is what makes start order the array order, and start order
+ * is what the run is unwound by.
+ *
+ * Reverse START order rather than reverse completion order, because completion order is not stable
+ * across a durable re-invocation: a memoised step comes back from the journal instantly, so the same
+ * body would unwind one way the first time and another way the second. Start order is a property of
+ * the body; completion order is a property of the weather.
+ */
+declare const parallelize: <const Calls extends readonly PromiseLike<unknown>[]>(...calls: Calls) => Promise<{ -readonly [Index in keyof Calls]: Awaited<Calls[Index]>; }>;
+
+declare const messageOf: (error: unknown) => string;
+/**
+ * The ancestor of everything this package throws, so one `catch` can recognise all of it. Without
+ * it a caller has to know every concrete name, and every error type added in a later version walks
+ * silently past the catch block somebody wrote carefully.
+ */
+declare class WorkflowsError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * What a failed run throws. It carries the run id because the run RECORD — not the stack — is where
+ * a failure is explained: input, step trail, compensation trail, timings.
+ */
+declare class RunFailedError extends WorkflowsError {
+    /** A literal tag beside `name`, so this slots into tagged-union error handling with no adapter. */
+    readonly _tag: "RunFailedError";
+    /** The steps whose undo came back, in the order they were undone. */
+    readonly compensated: string[];
+    /** The steps whose undo refused. Non-empty means something is still standing. */
+    readonly failedCompensations: string[];
+    readonly failedStep: string | null;
+    readonly outcome: CompensationOutcome;
+    readonly runId: string;
+    readonly workflowName: string;
+    constructor(params: {
+        cause: unknown;
+        compensated: string[];
+        failedCompensations: string[];
+        failedStep: string | null;
+        outcome: CompensationOutcome;
+        runId: string;
+        workflowName: string;
+    });
+}
+/**
+ * What the engine throws when it finds that the run has been asked to stop. It is not a failure:
+ * the run is unwound exactly as a failure would be, but it closes `cancelled` and says so, because
+ * "somebody changed their mind" and "something broke" are different facts.
+ */
+declare class RunCancelledError extends WorkflowsError {
+    readonly _tag: "RunCancelledError";
+    readonly runId: string;
+    constructor(runId: string);
+}
+/**
+ * What a journal throws when the idempotency key is already held.
+ *
+ * A typed refusal rather than a message to match on: a journal built on a store this package has
+ * never heard of can say "this key is taken" unambiguously, and the engine can tell that apart
+ * from the database being on fire.
+ */
+declare class IdempotencyKeyHeldError extends WorkflowsError {
+    readonly idempotencyKey: string;
+    readonly tenantId: string;
+    constructor(params: {
+        idempotencyKey: string;
+        tenantId: string;
+    });
+}
+
+/**
+ * What a run answers with when the caller would rather decide than catch. A run that was undone is a
+ * normal outcome — the undo ran, the record is written, and there is a decision to make — and
+ * requiring a try/catch and an `instanceof` to reach it makes the ordinary case look like the broken
+ * one.
+ */
+type RunResult<Output> = {
+    deduplicated: boolean;
+    ok: true;
+    result: Output;
+    runId: string;
+} | {
+    error: RunFailedError;
+    ok: false;
+    result: undefined;
+    runId: string;
+};
+type WorkflowBody<Input, Output, Scope extends object> = (input: Input, ctx: {
+    runId: string;
+    tenantId: string;
+} & Scope) => Promise<Output>;
+/** One event: its type and its payload. Everything else on the envelope is minted at the door. */
+type Announcement = readonly [type: string, payload: unknown];
+type WorkflowOptions<Input, Output> = {
+    /**
+     * Which door carries this workflow out: `inline` (default) is one request holding it open,
+     * `durable` is a platform re-invoking it. #210: the engine hardcoded `inline` and the lint rule
+     * read a declaration off the call that no consumer could write, so the two disagreed about what a
+     * durable workflow looks like. The definition says it, once, and each door refuses what is not
+     * its own — a body carried the other way replays where it was written not to, or holds a request
+     * open for a run meant to survive one.
+     */
+    execution?: WorkflowExecution;
+    /**
+     * What this run announces when it completes, given what it returned.
+     *
+     * A run knows what it did, so the run says it — in the same place it says its name. A body that
+     * reaches for an emit halfway through is announcing something that has not happened yet: the run
+     * can still fail after that line, and the whole point of the outbox is that nothing is announced
+     * until the run is a fact. Held until the run closes, written in the batch that closes it, and
+     * dropped entirely if the run is undone.
+     */
+    announce?: (output: Output) => Announcement | readonly Announcement[] | null | undefined;
+    /**
+     * How this run is recognised as one somebody already asked for. `true` derives the key from the
+     * input itself — key order is not meaning, so it is the canonical rendering that is hashed, and
+     * the workflow's name is part of the key so two workflows given the same input do not collide. A
+     * function is there for when the key means something to somebody else.
+     */
+    idempotent?: true | ((input: Input) => string);
+};
+type RunOptions<Input, Scope extends object> = {
+    input: Input;
+    /** Overrides whatever the definition's `idempotent` rule would have derived. */
+    idempotencyKey?: string;
+    /** The run this one was started from, when a step started it. Provenance only. */
+    parentRunId?: string | null;
+    runtime: WorkflowRuntime<Scope>;
+    throwOnError?: boolean;
+};
+type Workflow<Input, Output, Scope extends object> = {
+    readonly execution: WorkflowExecution;
+    readonly name: string;
+    run(options: RunOptions<Input, Scope> & {
+        throwOnError?: true;
+    }): Promise<Extract<RunResult<Output>, {
+        ok: true;
+    }>>;
+    run(options: RunOptions<Input, Scope> & {
+        throwOnError: false;
+    }): Promise<RunResult<Output>>;
+};
+/**
+ * What a workflow IS, behind the callable that opens an inline run for it. A durable executor needs
+ * the body and the announcement rule and has no use for `run`, which opens a run of its own.
+ */
+type WorkflowDefinition<Input, Output, Scope extends object> = {
+    announce: (output: Output) => readonly Announcement[];
+    body: WorkflowBody<Input, Output, Scope>;
+    /** What the definition declared (#210). The durable door reads it before it carries anything. */
+    execution: WorkflowExecution;
+    name: string;
+};
+declare const workflowDefinitionOf: <Input, Output, Scope extends object>(workflow: Workflow<Input, Output, Scope>) => WorkflowDefinition<Input, Output, Scope>;
+/**
+ * Declare a workflow: a name, and a body that is an ordinary async function.
+ *
+ * The body's values are REAL. A step call answers with what the step returned, an `if` is an `if`,
+ * and a loop is a loop — which is why there is no `transform` and no `when` here. Medusa needs both
+ * because its body runs once at definition time to build a graph, so everything inside it is a
+ * placeholder; a body that is executed rather than compiled has nothing to transform.
+ *
+ * What the body must NOT do is depend on anything but its input and its step results. A durable
+ * platform memoises steps by name and a replay has to arrive at the same names, so a free read that
+ * gates a branch changes the branch on the replay — see the durable-body law in the README.
+ */
+declare const createWorkflow: <Input, Output, Scope extends object = Record<string, unknown>>(name: string, body: WorkflowBody<Input, Output, Scope>, options?: WorkflowOptions<Input, Output>) => Workflow<Input, Output, Scope>;
+
+type RuntimeConfig<Scope extends object> = {
+    actor?: string | null;
+    /** Whatever the caller scoped this request with beyond the tenant and the actor. */
+    context?: Scope;
+    /** The emit door's configuration: the producer's `source`, the clock, and the extension names. */
+    emit?: EmitConfig;
+    events?: EventSink;
+    journal: RunJournal;
+    observer?: RunObserver;
+    /** What a DURABLE step's body and its undo are each wrapped in. Inline runs ignore it. */
+    scope?: RunScope;
+    tenantId?: string;
+};
+/** What a caller may say about one call once the runtime is already known. */
+type BoundRunOptions<Input> = {
+    input: Input;
+    idempotencyKey?: string;
+    parentRunId?: string | null;
+    throwOnError?: boolean;
+};
+type BoundWorkflow<Input, Output> = {
+    readonly name: string;
+    run(options: BoundRunOptions<Input> & {
+        throwOnError?: true;
+    }): Promise<Extract<RunResult<Output>, {
+        ok: true;
+    }>>;
+    run(options: BoundRunOptions<Input> & {
+        throwOnError: false;
+    }): Promise<RunResult<Output>>;
+};
+type Definitions<Scope extends object> = Record<string, Workflow<never, unknown, Scope>>;
+type Bound<Given> = {
+    [Name in keyof Given]: Given[Name] extends Workflow<infer Input, infer Output, never> ? BoundWorkflow<Input, Output> : never;
+};
+type Runtime<Scope extends object> = {
+    /** The same runtime, knowing one more thing. Adds; never replaces. */
+    for(narrower: {
+        actor?: string | null;
+        context?: Scope;
+        tenantId?: string;
+    }): Runtime<Scope>;
+    bind<Given extends Record<string, Workflow<never, unknown, Scope>>>(definitions: Given): Bound<Given>;
+    readonly runtime: WorkflowRuntime<Scope>;
+};
+/**
+ * Wire the engine once, and narrow it per request.
+ *
+ * Two lifetimes, kept apart. What the workflows ARE — their steps, their undos, their announcements
+ * — is static and is built once per isolate by `createStep` and `createWorkflow`. WHO is asking, and
+ * on which tenant, belongs to one request and is bound here. The consequence worth having is that a
+ * definition can be declared at module scope with nothing attached to it, which is why a test can
+ * build a throwaway runtime around the very same definitions a deployment uses.
+ */
+declare const createRuntime: <Scope extends object = Record<string, unknown>>(config: RuntimeConfig<Scope>) => Runtime<Scope>;
+
+/**
+ * What a body is inside while it runs: the one thing a step call needs in order to reach the run it
+ * belongs to.
+ *
+ * AsyncLocalStorage is the only thing that answers "which run am I in" correctly when two runs are
+ * in flight at once, which in a server is always. It needs Node 16+, Bun, Deno, or a Cloudflare
+ * Worker with `nodejs_compat` — the same requirement the Workers runtime already puts on most
+ * libraries, and the reason the import is at the top rather than behind a fallback that would be
+ * quietly wrong under concurrency.
+ */
+type RunFrame = {
+    call: <Input, Output>(step: Step<never, Input, Output>, input: Input) => Promise<Output>;
+    runId: string;
+    workflowName: string;
+};
+
+type RunExecution<Output> = {
+    /**
+     * Which executor is driving. It decides one thing: whether `scope.perStep` is honoured, because a
+     * durable instance hibernates between steps and an inline run does not.
+     */
+    /** What the run announces once it is a fact, given what the body returned. */
+    announce?: (output: Output) => readonly (readonly [type: string, payload: unknown])[];
+    execution: WorkflowExecution;
+    invoke: (frame: RunFrame) => Promise<Output>;
+    name: string;
+    runId: string;
+    runner: StepRunner;
+    runtime: WorkflowRuntime;
+    /**
+     * What the run's trail said before this invocation began. Empty for an inline run, which cannot
+     * be re-invoked; read from the journal by a durable executor.
+     */
+    completedSteps?: ReadonlySet<string>;
+    refused?: ReadonlySet<string>;
+    unwindingBegan?: boolean;
+};
+/**
+ * One run, from the first step to the write that closes it.
+ *
+ * Ordering, the step trail, the reverse-start unwinding and the closing batch are ONE implementation
+ * whatever executes the steps: the inline executor calls them, a durable platform checkpoints them,
+ * and the only difference between the two is the `runner` handed in.
+ */
+declare const executeRun: <Output>(execution: RunExecution<Output>) => Promise<Output>;
+
+type DurableExecution<Input, Output, Scope extends object> = {
+    input: Input;
+    /** The run record, opened before the instance existed. This invocation only ever writes to it. */
+    runId: string;
+    runtime: WorkflowRuntime<Scope>;
+    /** The platform's step primitives, which checkpoint and retry each unit of work. */
+    step: StepPrimitive;
+    workflow: Workflow<Input, Output, Scope>;
+};
+/**
+ * The same body an inline run would carry out, driven through a durable platform instead.
+ *
+ * The two reads at the top are what make every ordering claim in CONTRACT.md hold across a
+ * re-invocation, and they are REQUIRED rather than feature-detected (D1): the run record says
+ * whether there is anything left to do, and the trail says how far the last invocation got.
+ */
+declare const executeDurable: <Input, Output, Scope extends object>(execution: DurableExecution<Input, Output, Scope>) => Promise<Output>;
+
+/**
+ * A budget in the platform's words. The plural is not a typo and not a preference: Cloudflare reads
+ * `retries`, and `delay` is required there while the engine's is optional, so a budget that named a
+ * limit and no delay would otherwise reach the platform as a config it refuses.
+ */
+type PlatformStepConfig = {
+    retries?: {
+        backoff?: StepBackoff;
+        delay: number | string;
+        limit: number;
+    };
+    timeout?: number | string;
+};
+/**
+ * What a durable instance is handed to checkpoint its work with — Cloudflare's `WorkflowStep`,
+ * described structurally and taken as an argument.
+ *
+ * Declared as METHODS so TypeScript checks their parameters bivariantly: the real one spells a
+ * duration as a template literal and constrains its outputs to what it can serialise, and a
+ * structural type that insisted on neither would refuse the very object it is written for.
+ */
+type PlatformStep = {
+    do<Output>(name: string, config: PlatformStepConfig, run: (context: {
+        attempt: number;
+    }) => Promise<Output>): Promise<Output>;
+    sleep(name: string, duration: number | string): Promise<void>;
+    waitForEvent<Payload>(name: string, options: {
+        timeout?: number | string;
+        type: string;
+    }): Promise<{
+        payload: Payload;
+    }>;
+};
+/**
+ * The `StepPrimitive` seam over a real workflow instance's step object. This file is the only place
+ * in the package that knows the durable executor runs on Cloudflare Workflows — which is what lets
+ * that executor be tested without a worker runtime, and what makes an adapter for the next platform
+ * about twenty lines.
+ */
+declare const createStepPrimitive: (step: PlatformStep) => StepPrimitive;
+
+/** What a durable instance is started with: which workflow, for which run, on whose behalf. */
+type DurableRunParams = {
+    actor?: string | null;
+    input: unknown;
+    name: string;
+    runId: string;
+    tenantId: string;
+};
+type DurableRunEvent = {
+    payload: DurableRunParams;
+};
+/**
+ * `WorkflowEntrypoint` from `cloudflare:workers`, handed in rather than imported.
+ *
+ * That module exists only inside a worker, so a package that imported it could not be loaded by a
+ * test, by a Node process, or by any other runtime — and this one is a foundation every host has to
+ * be able to read. The class is the caller's; what it does with a run is this file's.
+ *
+ * `abstract` because the real `WorkflowEntrypoint` is, and a non-abstract constructor type refuses
+ * it. The execution context is `never` because nothing here reads it and the platform's own type for
+ * it is a class this package cannot name: a parameter is checked contravariantly, so `never` is the
+ * one spelling that accepts whatever the real base declares.
+ */
+type EntrypointBase<Env> = abstract new (context: never, env: Env) => object;
+/** A value, or how to make one out of a worker's env. */
+type FromEnv<Env, Value> = Value | ((env: Env) => Value);
+type DurableEntrypointOptions<Env, Scope extends object> = {
+    base: EntrypointBase<Env>;
+    /**
+     * Called for EVERY run. What a factory opens — a database client above all — belongs to the
+     * invocation that opened it: an instance hibernates between steps and the platform refuses a
+     * handle from an earlier invocation at the first query.
+     */
+    runtime: (env: Env, params: DurableRunParams) => Runtime<Scope>;
+    workflows: FromEnv<Env, readonly Workflow<unknown, unknown, Scope>[]>;
+};
+/**
+ * One entrypoint class for every durable definition a worker has.
+ *
+ * Cloudflare binds a CLASS, not a function, so a binding per workflow would mean a config edit and a
+ * deploy for every new one — and once per named environment, because those inherit nothing. This
+ * dispatches by the name the instance was started with, so adding a workflow is adding it to the
+ * list and nothing else.
+ */
+declare const entrypointFor: <Env, Scope extends object = Record<string, unknown>>(options: DurableEntrypointOptions<Env, Scope>) => {
+    new (context: never, env: Env): {
+        run(event: DurableRunEvent, step: PlatformStep): Promise<unknown>;
+    };
+};
+
+/** One delivered message, as a queue consumer is handed it. */
+type QueueMessage = {
+    ack: () => void;
+    body: unknown;
+    retry: () => void;
+};
+type QueueBatch = {
+    messages: readonly QueueMessage[];
+};
+type QueueOptions = {
+    /** What to do with each event. Without one, a delivered message is only acknowledged. */
+    onEvent?: (envelope: EventEnvelope) => Promise<void> | void;
+    /**
+     * Whether this envelope has been seen before — `@geonosis/events`' half of the outbox. Delivery is
+     * at-least-once, so a consumer that does anything a repeat would do twice needs one of these,
+     * usually a unique index on the envelope id in whatever table the consumer writes.
+     */
+    seen?: SeenBefore;
+};
+/**
+ * The queue consumer, for the events the outbox delivers.
+ *
+ * Each message is acknowledged or retried on its own: one message this consumer cannot handle does
+ * not send the other nine round again. A dedup check that could not ANSWER is a retry rather than a
+ * delivery, because "not known to have been seen" and "not seen" are the same value and not the same
+ * fact.
+ */
+declare const handleQueue: (options?: QueueOptions) => (batch: QueueBatch) => Promise<void>;
+type SweepOptions = {
+    /** How long an inline run may be open before it is declared abandoned. Defaults to 15 minutes. */
+    abandonedAfterMs?: number;
+    /** How long an outbox row is left for the run that made it. Defaults to a minute. */
+    outboxOlderThanMs?: number;
+};
+type Swept = {
+    abandoned: number;
+    delivered: number;
+};
+/**
+ * Both sweeps, on whatever cron you point at this.
+ *
+ * They are separate concerns with the same shape — one carries the events a drain could not deliver,
+ * the other closes inline runs whose process died — and there is no reason to make anybody wire two
+ * handlers for them. Both windows are measured from the moment the cron was SCHEDULED for rather
+ * than from the clock the sweep happens to read, which is also what lets a test ask for tomorrow's
+ * cron instead of waiting for it.
+ *
+ * A durable run is never swept at any age: one may be asleep for a week or waiting on a human. That
+ * is also the boundary this handler stops at — a sweep that could close a run another invocation is
+ * driving needs the claim interlock the journaled executor brings (plan 026, W6), and until then the
+ * two sweeps only ever touch work nothing is carrying.
+ */
+declare const handleScheduled: <Env, Scope extends object>(source: FromEnv<Env, Runtime<Scope>>, options?: SweepOptions) => (controller?: unknown, env?: Env) => Promise<Swept>;
+
+type MemoryPlatform = {
+    /** The budget each step was handed. A durable platform retries by this; the engine does not. */
+    budgets: Map<string, StepBudget>;
+    /** Every step this platform was asked to carry out, in order, the engine's own included. */
+    calls: string[];
+    /** What it has checkpointed, by step name. It outlives an invocation, as a real checkpoint does. */
+    checkpoints: Map<string, unknown>;
+    /**
+     * Stop answering at this step, as an evicted instance does — the invocation ends and the run does
+     * not. It is the one thing a step cannot express: a step that throws is a failure the engine
+     * unwinds, and an eviction is the engine never hearing another word.
+     */
+    evictAt: (stepName: string | null) => void;
+    primitive: StepPrimitive;
+};
+/**
+ * A durable platform in memory: the worked reference for the `StepPrimitive` seam, and what a suite
+ * drives `executeDurable` through when it has no worker runtime.
+ *
+ * It does the three things a real one does — memoise a completed step by NAME, retry a step with the
+ * budget it was handed, and hand each attempt its number — so a body that walks a different path on
+ * a replay fails here exactly as it would on the platform.
+ */
+declare const createMemoryPlatform: (options?: {
+    checkpoints?: Map<string, unknown>;
+}) => MemoryPlatform;
+
+/**
+ * A journal under test, plus the two readings a caller has to supply because the contract itself
+ * has no way to make them: what status a run is in, and how many step rows a run has. Both are one
+ * query in any store.
+ */
+type JournalSubject = {
+    /**
+     * Make outbox writes fail from now on. Required, because the case it enables is the strongest
+     * promise in the contract and an adapter that cannot be broken on purpose cannot prove it.
+     * Dropping the table, revoking the permission or setting a flag are all fine.
+     */
+    breakOutboxWrites: () => Promise<void> | void;
+    countSteps: (params: {
+        runId: string;
+        tenantId: string;
+    }) => Promise<number>;
+    journal: RunJournal;
+    runStatus: (params: {
+        runId: string;
+        tenantId: string;
+    }) => Promise<RunStatus | null>;
+};
+type ConformanceCase = {
+    name: string;
+    run: () => Promise<void>;
+};
+/**
+ * The RunJournal contract, as an executable suite.
+ *
+ * The contract is not a shape — TypeScript already checks the shape — it is a set of promises about
+ * BEHAVIOUR that the engine relies on absolutely: that a held key is refused, that a finish is one
+ * write, that a step row is written once however often it is retried. An adapter that type-checks
+ * and breaks one of those breaks the engine in ways that only show up in production.
+ *
+ * Runner-agnostic on purpose. Wire it into whatever you use:
+ *
+ * ```ts
+ * for (const one of journalConformance(createSubject)) it(one.name, one.run)
+ * ```
+ */
+declare const journalConformance: (createSubject: () => JournalSubject | Promise<JournalSubject>) => ConformanceCase[];
+
+/**
+ * What a step says about itself beyond its name.
+ *
+ * `noCompensation` is the DECLARED absence of an undo, and it exists because a deliberate
+ * non-compensation and a forgotten one are otherwise the same source. It is `true` or it is absent:
+ * `false` would be the inference written out, which says nothing the missing third argument did not
+ * already say.
+ */
+type StepConfig = StepBudget & {
+    name: string;
+    noCompensation?: true;
+};
+type StepInvoke<Scope, Input, Output> = (input: Input, ctx: StepContext<Scope>) => MaybePromise<Output>;
+type StepCompensate<Scope, Output> = (output: Output, ctx: StepContext<Scope>, reason: CompensationReason) => MaybePromise<void>;
+/**
+ * A step, as a body calls it: `const { saved } = await save(doc)`. The value it answers with is the
+ * value `invoke` returned — a real value in a real async body, not a placeholder in a graph.
+ */
+type StepCall<Input, Output> = {
+    (input: Input): Promise<Output>;
+    readonly stepName: string;
+};
+/**
+ * The step the engine runs, behind the callable a body sees. Its scope is `never` because the
+ * engine holds steps from every scope in one run: `invoke` and `compensate` are declared as methods,
+ * so TypeScript checks their parameters bivariantly and a heterogeneous list needs no cast.
+ */
+declare const stepDefinitionOf: <Input, Output>(call: StepCall<Input, Output>) => Step<never, Input, Output>;
+/**
+ * Declare a step: a named unit of work whose undo travels with it.
+ *
+ * Positional and in Medusa's spelling — `createStep(nameOrConfig, invoke, compensate?)` — so one set
+ * of architecture rules reads both engines. The undo is handed exactly what `invoke` RETURNED, and
+ * is registered from that returned value rather than from a closure taken during the step, because
+ * a closure does not survive a replay: on the second invocation the step's body does not run, and
+ * anything living inside it is gone.
+ */
+declare function createStep<Input, Output, Scope = Record<string, unknown>>(config: StepConfig | string, invoke: StepInvoke<Scope, Input, Output>, compensate?: StepCompensate<Scope, Output>): StepCall<Input, Output>;
+
+type MemoryRunRow = {
+    cancelRequested: boolean;
+    error?: string | null;
+    execution: WorkflowExecution;
+    finishedAt?: number | null;
+    id: string;
+    idempotencyKey: string | null;
+    input: unknown;
+    name: string;
+    output?: unknown;
+    parentRunId: string | null;
+    replayOf?: string | null;
+    startedAt: number;
+    status: RunStatus;
+    tenantId: string;
+};
+type MemoryStepRow = {
+    attempt: number;
+    error?: string | null;
+    name: string;
+    output?: unknown;
+    runId: string;
+    seq: number;
+    status: string;
+    tenantId: string;
+};
+type MemoryFinishRow = {
+    error?: string | null;
+    events: EventEnvelope[];
+    output?: unknown;
+    runId: string;
+    status: RunOutcome;
+};
+/**
+ * An outbox row. The tenant is a COLUMN and not a field of the envelope: the envelope is the kit's
+ * (D-057), where a tenant is a flat extension the consumer names — so the store that has to sweep
+ * per tenant keeps its own copy of the one fact it queries by.
+ */
+type MemoryOutboxRow = {
+    envelope: EventEnvelope;
+    tenantId: string;
+};
+/** The journal, plus the rows it is holding, so a test asserts on what was written. */
+type MemoryJournal = {
+    /**
+     * Make every outbox write fail from here on, so a suite can prove that a finish which cannot
+     * queue its events does not close the run either.
+     */
+    breakOutboxWrites: () => void;
+    dispatched: string[];
+    finishes: MemoryFinishRow[];
+    journal: RunJournal;
+    outbox: MemoryOutboxRow[];
+    runs: MemoryRunRow[];
+    steps: MemoryStepRow[];
+};
+/**
+ * The journal a test reaches for, and the worked reference for writing your own: rows in arrays,
+ * and the one invariant a real table has to enforce — a single claim per (tenant, idempotency key)
+ * — enforced here too, so a suite exercises the engine's behaviour rather than a fixture's
+ * convenience.
+ */
+declare const createMemoryJournal: (options?: {
+    now?: () => number;
+}) => MemoryJournal;
+type MemorySink = {
+    /** One entry per `sendBatch` call, so a suite can ask how many calls a drain made. */
+    batches: EventEnvelope[][];
+    /** Every message that travelled, flattened. */
+    sent: EventEnvelope[];
+    sink: EventSink;
+};
+/** A sink that remembers what travelled, and in how many calls. */
+declare const createMemorySink: (options?: {
+    refuses?: boolean;
+}) => MemorySink;
+/**
+ * A sink that hands each envelope straight to a function, in the same process. Delivery is still
+ * at-least-once from the engine's point of view — the drain can fail and the sweeper carries the
+ * rows — so a handler here should be as tolerant of a repeat as a queue consumer would be.
+ */
+declare const createInProcessSink: (deliver: (envelope: EventEnvelope) => Promise<void> | void) => EventSink;
+
+export { ABANDONED_SWEEP_LIMIT, type Announcement, type Bound, type BoundRunOptions, type BoundWorkflow, COMPENSATION_PREFIX, type CompensationOutcome, type CompensationReason, type ConformanceCase, DEFAULT_STEP_BUDGET, type Definitions, type DurableEntrypointOptions, type DurableExecution, type DurableRunEvent, type DurableRunParams, EVENT_BATCH_LIMIT, EVENT_SWEEP_GRACE_MS, EVENT_SWEEP_LIMIT, type EmitConfig, type EntrypointBase, type EventSink, type FromEnv, IdempotencyKeyHeldError, type JournalSubject, LIFECYCLE_EVENTS, type LifecycleEventType, type MaybePromise, type MemoryFinishRow, type MemoryJournal, type MemoryOutboxRow, type MemoryPlatform, type MemoryRunRow, type MemorySink, type MemoryStepRow, type PlatformStep, type PlatformStepConfig, type QueueBatch, type QueueMessage, type QueueOptions, RESERVED_STEP_NAMES, RUN_OUTCOMES, RUN_STATUSES, RunCancelledError, type RunClosure, type RunEmitter, type RunExecution, type RunFacts, RunFailedError, type RunJournal, type RunObserver, type RunOptions, type RunOutcome, type RunResult, type RunScope, type RunStatus, type Runtime, type RuntimeConfig, STEP_STATUSES, type Step, type StepBackoff, type StepBudget, type StepCall, type StepCompensate, type StepConfig, type StepContext, type StepInvoke, type StepPrimitive, type StepRetry, type StepRunner, type StepScope, type StepStatus, type SweepOptions, type Swept, type Workflow, type WorkflowBody, type WorkflowDefinition, type WorkflowExecution, type WorkflowOptions, type WorkflowRuntime, WorkflowsError, compensationIdempotencyKey, compensationStepName, createInProcessSink, createInlineRunner, createMemoryJournal, createMemoryPlatform, createMemorySink, createRunEmitter, createRuntime, createStep, createStepPrimitive, createWorkflow, dispatchEvents, entrypointFor, envelopeId, executeDurable, executeRun, handleQueue, handleScheduled, journalConformance, lifecycleEnvelopeId, messageOf, parallelize, stepDefinitionOf, stepIdempotencyKey, sweepAbandonedRuns, sweepEventOutbox, workflowDefinitionOf };