@executablemd/testing 0.3.1 → 0.4.0

package/esm/durable-streams/effect.js

@@ -1,273 +0,0 @@
-/**
- * createDurableEffect / createDurableOperation — core factories for durable effects.
- *
- * Each DurableEffect handles its own replay/live dispatch inside enter().
- * It reads DurableContext from the scope, checks the replay index, and
- * either feeds the stored result (replay) or executes live with
- * persist-before-resume semantics.
- *
- * Two factories are provided:
- * - createDurableEffect: callback-based executor (resolve/reject/teardown)
- *   for timer-like and callback-based APIs (durableSleep, durableAction).
- * - createDurableOperation: Operation-based executor for structured
- *   concurrency. The live path runs entirely as a generator — execute,
- *   capture result, persist, resolve. No callbacks, no .then().
- *
- * Divergence policy is delegated to the Divergence API (DEC-031).
- * By default, mismatches are fatal. Users can install middleware via
- * yield* Divergence.around(...) to override behavior per-scope.
- *
- * See integration doc §5.1, protocol spec §4.2, §5, §6.
- */
-import { DurableCtx } from "./context.ts";
-import { Divergence } from "./divergence.ts";
-import { StaleInputError } from "./errors.ts";
-import { ReplayGuard } from "./replay-guard.ts";
-import { protocolToEffection, serializeError } from "./serialize.ts";
-/** Effection void-ok result, used for no-op teardowns. */
-const VOID_OK = {
-    ok: true,
-    value: undefined,
-};
-/**
- * Shared replay logic for both createDurableEffect and createDurableOperation.
- *
- * Checks the replay index for a matching entry, runs divergence detection,
- * and runs replay guards. If replay succeeds, resolves the generator
- * synchronously and returns "replayed". Otherwise returns "live" to
- * indicate the caller should execute the effect.
- */
-function checkReplay(desc, resolve, routine, ctx) {
-    const entry = ctx.replayIndex.peekYield(ctx.coroutineId);
-    // ── REPLAY PATH ──
-    // Use a labeled block so that divergence decisions of type "run-live"
-    // can break out to fall through to the live execution path.
-    // biome-ignore lint/suspicious/noConfusingLabels: deliberate labeled block for break-out-of-replay pattern
-    replay: {
-        if (entry) {
-            // §6.2: Validate description identity match.
-            // Only type and name are identity fields — extra metadata fields
-            // (path, URL, marker, etc.) are stored for replay guards to inspect
-            // but do not participate in divergence detection.
-            // The current desc is passed to the Divergence API as `actual` so
-            // guards can compare both sides if needed.
-            if (entry.description.type !== desc.type || entry.description.name !== desc.name) {
-                // Delegate divergence policy to the Divergence API.
-                const cursor = ctx.replayIndex.getCursor(ctx.coroutineId);
-                const decision = Divergence.invoke(routine.scope, "decide", [
-                    {
-                        kind: "description-mismatch",
-                        coroutineId: ctx.coroutineId,
-                        cursor,
-                        expected: entry.description,
-                        actual: desc,
-                    },
-                ]);
-                if (decision.type === "throw") {
-                    resolve({ ok: false, error: decision.error });
-                    return { path: "replayed", teardown: (exit) => exit(VOID_OK) };
-                }
-                // decision.type === "run-live"
-                ctx.replayIndex.disableReplay(ctx.coroutineId);
-                break replay;
-            }
-            // Description matches — now check replay guards before replaying.
-            // ── REPLAY GUARD: Decide phase ──
-            const yieldEvent = {
-                type: "yield",
-                coroutineId: ctx.coroutineId,
-                description: entry.description,
-                result: entry.result,
-            };
-            const outcome = ReplayGuard.invoke(routine.scope, "decide", [yieldEvent]);
-            if (outcome.outcome === "error") {
-                ctx.replayIndex.consumeYield(ctx.coroutineId);
-                const error = outcome.error ??
-                    new StaleInputError(`Stale input detected for ${desc.type}("${desc.name}")`, {
-                        coroutineId: ctx.coroutineId,
-                        description: desc,
-                    });
-                resolve({ ok: false, error });
-                return { path: "replayed", teardown: (exit) => exit(VOID_OK) };
-            }
-            // All guards approved — consume the entry and advance cursor
-            ctx.replayIndex.consumeYield(ctx.coroutineId);
-            // Feed stored result synchronously
-            resolve(protocolToEffection(entry.result));
-            return { path: "replayed", teardown: (exit) => exit(VOID_OK) };
-        }
-        // No replay entry. Check for continue-past-close divergence (§6.3).
-        if (ctx.replayIndex.hasClose(ctx.coroutineId)) {
-            const yieldCount = ctx.replayIndex.yieldCount(ctx.coroutineId);
-            const decision = Divergence.invoke(routine.scope, "decide", [
-                {
-                    kind: "continue-past-close",
-                    coroutineId: ctx.coroutineId,
-                    yieldCount,
-                },
-            ]);
-            if (decision.type === "throw") {
-                resolve({ ok: false, error: decision.error });
-                return { path: "replayed", teardown: (exit) => exit(VOID_OK) };
-            }
-            // decision.type === "run-live"
-            ctx.replayIndex.disableReplay(ctx.coroutineId);
-            break replay;
-        }
-    } // end replay block
-    return { path: "live" };
-}
-// ---------------------------------------------------------------------------
-// createDurableEffect — callback-based (Executor pattern)
-// ---------------------------------------------------------------------------
-/**
- * Creates a DurableEffect using a callback-based executor.
- *
- * Use this for timer-like and callback-based APIs (durableSleep, durableAction)
- * where the resolve/reject/teardown pattern is natural.
- *
- * For Operation-based effects, prefer createDurableOperation.
- *
- * @param desc Structured description for the journal and divergence detection
- * @param execute Called only during live execution (skipped during replay)
- */
-export function createDurableEffect(desc, execute) {
-    return {
-        description: `${desc.type}(${desc.name})`,
-        effectDescription: desc,
-        enter(resolve, routine) {
-            const ctx = routine.scope.expect(DurableCtx);
-            const replay = checkReplay(desc, resolve, routine, ctx);
-            if (replay.path === "replayed")
-                return replay.teardown;
-            // ── LIVE PATH ──
-            let settled = false;
-            let tornDown = false;
-            let teardown = () => { };
-            /** Persist a Yield event then resume the generator. */
-            function persistAndResolve(result) {
-                if (settled)
-                    return;
-                settled = true;
-                const event = {
-                    type: "yield",
-                    coroutineId: ctx.coroutineId,
-                    description: desc,
-                    result,
-                };
-                // Uses scope.run() to call the Operation-returning stream.append()
-                // from inside the callback-based enter(). The append runs as a
-                // structured operation in the routine's scope — if the scope tears
-                // down, the append is cancelled.
-                routine.scope.run(function* () {
-                    try {
-                        yield* ctx.stream.append(event);
-                        resolve(protocolToEffection(result));
-                    }
-                    catch (err) {
-                        resolve({
-                            ok: false,
-                            error: err instanceof Error ? err : new Error(String(err)),
-                        });
-                    }
-                });
-            }
-            // Guard against synchronous throws from the executor.
-            try {
-                teardown = execute((result) => persistAndResolve(result), (error) => {
-                    persistAndResolve({
-                        status: "err",
-                        error: serializeError(error),
-                    });
-                });
-            }
-            catch (e) {
-                const error = e instanceof Error ? e : new Error(String(e));
-                persistAndResolve({
-                    status: "err",
-                    error: serializeError(error),
-                });
-                return (exit) => exit(VOID_OK);
-            }
-            // Return teardown that Effection calls during scope destruction
-            return (exit) => {
-                if (tornDown) {
-                    exit(VOID_OK);
-                    return;
-                }
-                tornDown = true;
-                settled = true;
-                try {
-                    teardown();
-                    exit(VOID_OK);
-                }
-                catch (e) {
-                    const error = e instanceof Error ? e : new Error(String(e));
-                    exit({ ok: false, error });
-                }
-            };
-        },
-    };
-}
-// ---------------------------------------------------------------------------
-// createDurableOperation — Operation-based (structured concurrency)
-// ---------------------------------------------------------------------------
-/**
- * Creates a DurableEffect from an Operation-returning function.
- *
- * The live path runs entirely as a generator inside scope.run():
- * execute the Operation, capture the result, persist the Yield event,
- * then resolve the generator. No callbacks, no .then(), full structured
- * concurrency — if the scope tears down, the operation is cancelled.
- *
- * Use this for durableCall and any effect where the work is expressed
- * as an Operation (or can be wrapped as one via Effection's call()).
- *
- * @param desc Structured description for the journal and divergence detection
- * @param execute Returns an Operation to run during live execution
- */
-export function createDurableOperation(desc, execute) {
-    return {
-        description: `${desc.type}(${desc.name})`,
-        effectDescription: desc,
-        enter(resolve, routine) {
-            const ctx = routine.scope.expect(DurableCtx);
-            const replay = checkReplay(desc, resolve, routine, ctx);
-            if (replay.path === "replayed")
-                return replay.teardown;
-            // ── LIVE PATH ──
-            // Run the entire execute → capture → persist → resolve sequence
-            // as a structured operation in the routine's scope.
-            routine.scope.run(function* () {
-                let result;
-                try {
-                    const value = yield* execute();
-                    result = { status: "ok", value: value };
-                }
-                catch (e) {
-                    const error = e instanceof Error ? e : new Error(String(e));
-                    result = { status: "err", error: serializeError(error) };
-                }
-                const event = {
-                    type: "yield",
-                    coroutineId: ctx.coroutineId,
-                    description: desc,
-                    result,
-                };
-                try {
-                    yield* ctx.stream.append(event);
-                    resolve(protocolToEffection(result));
-                }
-                catch (err) {
-                    resolve({
-                        ok: false,
-                        error: err instanceof Error ? err : new Error(String(err)),
-                    });
-                }
-            });
-            // No teardown needed — scope.run() ties the operation's lifecycle
-            // to the routine's scope. Cancellation is handled by Effection.
-            return (exit) => exit(VOID_OK);
-        },
-    };
-}

package/esm/durable-streams/ephemeral.js

@@ -1,80 +0,0 @@
-/**
- * ephemeral — explicit escape hatch for non-durable Operations inside Workflows.
- *
- * Wraps an Operation<T> so it satisfies the Workflow<T> type contract.
- * The wrapped operation is **transparent to the journal** — no Yield event
- * is written, no replay index entry is consumed. On replay, the operation
- * simply re-runs.
- *
- * This is analogous to Rust's `unsafe {}` — it marks the boundary where
- * the user is opting out of durable guarantees. Every non-durable
- * Operation that needs to participate in a Workflow must go through
- * ephemeral() to make the escape explicit and auditable.
- *
- * Usage:
- *   yield* durableAll([
- *     () => myDurableWorkflow(),              // Workflow<T> — journaled
- *     function*() {                            // Workflow<T> with ephemeral child
- *       return yield* ephemeral(someOperation());
- *     },
- *   ]);
- *
- * See DEC-034 for the design rationale.
- */
-/** Effection void-ok result, used for no-op teardowns. */
-const VOID_OK = {
-    ok: true,
-    value: undefined,
-};
-/**
- * Create a DurableEffect that runs an Operation transparently.
- *
- * - No journal write (no Yield event appended)
- * - No replay index consumption (cursor not advanced)
- * - The Operation runs via scope.run() with full structured concurrency
- * - Cancellation of the scope cancels the inner Operation
- * - On replay, the Operation re-runs (not cached)
- *
- * The effect is invisible to the durable execution protocol — it exists
- * solely to satisfy the Workflow<T> type constraint.
- */
-function createEphemeralEffect(operation) {
-    return {
-        description: "ephemeral",
-        effectDescription: { type: "ephemeral", name: "ephemeral" },
-        enter(resolve, routine) {
-            // Run the operation in the routine's scope — full structured
-            // concurrency, proper cancellation. No journal interaction.
-            routine.scope.run(function* () {
-                try {
-                    const value = yield* operation;
-                    resolve({ ok: true, value });
-                }
-                catch (e) {
-                    const error = e instanceof Error ? e : new Error(String(e));
-                    resolve({ ok: false, error });
-                }
-            });
-            // No teardown needed — scope.run() ties the operation's lifecycle
-            // to the routine's scope.
-            return (exit) => exit(VOID_OK);
-        },
-    };
-}
-/**
- * Wrap a non-durable Operation so it can be used inside a Workflow.
- *
- * The operation is transparent to the durable execution protocol:
- * - No Yield event is written to the journal
- * - On replay, the operation re-runs (it is not cached)
- * - Cancellation flows through normally via structured concurrency
- *
- * Use this when you need to run infrastructure Operations (or intentionally
- * non-durable work) inside a Workflow where only DurableEffects are allowed.
- *
- * @param operation The Operation to wrap
- * @returns A Workflow that yields the operation's result
- */
-export function* ephemeral(operation) {
-    return (yield createEphemeralEffect(operation));
-}

package/esm/durable-streams/errors.js

@@ -1,92 +0,0 @@
-/**
- * Error types for the durable execution protocol.
- */
-/**
- * Raised when the replay index entry at the current cursor position
- * does not match the effect yielded by the generator. See spec §6.2.
- *
- * A DivergenceError is NOT recoverable. The workflow cannot continue
- * because the generator's execution path has diverged from the recorded
- * history.
- */
-export class DivergenceError extends Error {
-    name = "DivergenceError";
-    coroutineId;
-    /** Cursor position within the coroutine where divergence was detected. */
-    position;
-    /** The description from the journal (what was expected). */
-    expected;
-    /** The description from the generator (what was actually yielded). */
-    actual;
-    constructor(coroutineId, position, expected, actual, message) {
-        super(message ??
-            `Divergence at ${coroutineId}[${position}]: ` +
-                `expected ${expected.type}("${expected.name}"), ` +
-                `got ${actual.type}("${actual.name}")`);
-        this.coroutineId = coroutineId;
-        this.position = position;
-        this.expected = expected;
-        this.actual = actual;
-    }
-}
-/**
- * Raised when the generator finishes (returns) while the replay index
- * still has unconsumed entries for this coroutine. See spec §6.3.
- */
-export class EarlyReturnDivergenceError extends Error {
-    name = "EarlyReturnDivergenceError";
-    coroutineId;
-    consumedCount;
-    totalCount;
-    constructor(coroutineId, consumedCount, totalCount) {
-        super(`Divergence: generator ${coroutineId} returned after ${consumedCount} yields, ` +
-            `but journal has ${totalCount} yield entries`);
-        this.coroutineId = coroutineId;
-        this.consumedCount = consumedCount;
-        this.totalCount = totalCount;
-    }
-}
-/**
- * Raised when the journal has a Close event for a coroutine but the
- * generator has not finished after consuming all recorded yields.
- * See spec §6.3.
- */
-export class ContinuePastCloseDivergenceError extends Error {
-    name = "ContinuePastCloseDivergenceError";
-    coroutineId;
-    yieldCount;
-    constructor(coroutineId, yieldCount) {
-        super(`Divergence: journal shows ${coroutineId} closed after ${yieldCount} yields, but generator continues to yield effects`);
-        this.coroutineId = coroutineId;
-        this.yieldCount = yieldCount;
-    }
-}
-/**
- * Raised by a replay guard when a journal entry's recorded result is
- * stale (e.g., the source file has changed since the effect was
- * originally executed).
- *
- * Guards detect staleness by comparing current state against data stored
- * in the effect description (input fields like file path) and result
- * value (output fields like content hash).
- *
- * StaleInputError is NOT a divergence — the effect identity matches,
- * but the external world has changed. The correct response depends on
- * application policy: re-run from scratch, accept stale results, or
- * (in future versions) re-execute the effect and continue.
- *
- * See replay-guard-spec.md §4.4.
- */
-export class StaleInputError extends Error {
-    name = "StaleInputError";
-    /** The Yield event that was detected as stale. */
-    event;
-    constructor(
-    /** Human-readable description of what changed. */
-    message, 
-    /** The Yield event that was detected as stale. */
-    event) {
-        super(message);
-        this.event = event;
-    }
-}

package/esm/durable-streams/http-stream.js

@@ -1,207 +0,0 @@
-/**
- * HTTP-backed DurableStream implementation using the Durable Streams protocol.
- *
- * Uses raw fetch() for appends (not IdempotentProducer) because durable
- * execution requires synchronous acknowledgment on every write
- * (persist-before-resume). See DEC-026.
- *
- * Concurrent appends are serialized via a Queue + spawned worker so that
- * the server always receives them in sequence order. The worker lives
- * inside a resource scope and is cancelled when the stream is no longer
- * in use. See DEC-033 (supersedes DEC-027's Promise chain approach).
- *
- * The stream is created as an Effection resource via useHttpDurableStream().
- */
-import { stream, PRODUCER_EPOCH_HEADER, PRODUCER_EXPECTED_SEQ_HEADER, PRODUCER_ID_HEADER, PRODUCER_RECEIVED_SEQ_HEADER, PRODUCER_SEQ_HEADER, STREAM_OFFSET_HEADER, SequenceGapError, StaleEpochError, } from "@durable-streams/client";
-import { call, createQueue, resource, spawn, withResolvers } from "effection";
-/**
- * Create an HTTP-backed DurableStream as an Effection resource.
- *
- * The resource:
- * 1. Creates the stream on the server (idempotent PUT)
- * 2. Spawns a serial worker that processes appends in FIFO order
- * 3. Returns a DurableStream handle with Operation-native readAll/append
- *
- * The worker is cancelled when the resource scope is torn down.
- *
- * Usage:
- *   yield* useHttpDurableStream({ baseUrl, streamId, producerId, epoch })
- */
-export function useHttpDurableStream(opts) {
-    return resource(function* (provide) {
-        const baseUrl = new URL(opts.baseUrl);
-        if (!baseUrl.pathname.endsWith("/")) {
-            baseUrl.pathname = `${baseUrl.pathname}/`;
-        }
-        const streamUrl = new URL(encodeURIComponent(opts.streamId), baseUrl).toString();
-        const producerId = opts.producerId;
-        const epoch = opts.epoch;
-        const fetchFn = opts.fetch ?? globalThis.fetch.bind(globalThis);
-        // ── One-time setup: create the stream on the server ──
-        yield* call(async () => {
-            const res = await fetchFn(streamUrl, {
-                method: "PUT",
-                headers: { "Content-Type": "application/json" },
-            });
-            await res.text(); // consume body to free connection
-            if (res.status !== 201 && res.status !== 200) {
-                throw new Error(`Failed to create stream: HTTP ${res.status}`);
-            }
-        });
-        // ── Mutable state owned by the resource scope ──
-        let nextSeq = 0;
-        let fatalError;
-        let lastOffset;
-        // ── Append worker queue ──
-        const queue = createQueue();
-        // ── Spawn the serial append worker ──
-        // Processes one append at a time in FIFO order. Each HTTP POST
-        // completes before the next one starts, guaranteeing server-side
-        // sequence ordering. Fatal errors (stale epoch, network failure)
-        // are propagated to the specific caller and stored for fail-fast.
-        yield* spawn(function* () {
-            let item = yield* queue.next();
-            while (!item.done) {
-                const { event, seq, resolve, reject } = item.value;
-                try {
-                    yield* call(() => doAppend(event, seq));
-                    resolve(undefined);
-                }
-                catch (err) {
-                    reject(err instanceof Error ? err : new Error(String(err)));
-                }
-                item = yield* queue.next();
-            }
-        });
-        /**
-         * Execute a single HTTP append with the given event and sequence number.
-         *
-         * Any uncertain write outcome (network error, unexpected HTTP status,
-         * sequence gap) is treated as fatal — `fatalError` is set so all future
-         * appends fail-fast.
-         */
-        async function doAppend(event, seq) {
-            // Double-check fatal error (may have been set by a preceding append)
-            if (fatalError) {
-                throw fatalError;
-            }
-            let res;
-            try {
-                res = await fetchFn(streamUrl, {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/json",
-                        [PRODUCER_ID_HEADER]: producerId,
-                        [PRODUCER_EPOCH_HEADER]: String(epoch),
-                        [PRODUCER_SEQ_HEADER]: String(seq),
-                    },
-                    body: JSON.stringify(event),
-                });
-            }
-            catch (err) {
-                // Network failure — fatal, sequence state is now uncertain
-                const error = err instanceof Error ? err : new Error(String(err));
-                fatalError = error;
-                throw error;
-            }
-            // Always consume the body to free the connection
-            await res.text();
-            switch (res.status) {
-                case 200: {
-                    // Success — capture offset
-                    const offset = res.headers.get(STREAM_OFFSET_HEADER);
-                    if (offset) {
-                        lastOffset = offset;
-                    }
-                    return;
-                }
-                case 204: {
-                    // Duplicate (idempotent success) — capture offset if present
-                    const offset = res.headers.get(STREAM_OFFSET_HEADER);
-                    if (offset) {
-                        lastOffset = offset;
-                    }
-                    return;
-                }
-                case 403: {
-                    // Stale epoch — fatal error
-                    const currentEpoch = Number(res.headers.get(PRODUCER_EPOCH_HEADER) ?? 0);
-                    const error = new StaleEpochError(currentEpoch);
-                    fatalError = error;
-                    throw error;
-                }
-                case 409: {
-                    // Sequence gap — fatal (should never happen due to serialization,
-                    // but if it does, sequence state is irrecoverably desynchronized)
-                    const expected = Number(res.headers.get(PRODUCER_EXPECTED_SEQ_HEADER) ?? 0);
-                    const received = Number(res.headers.get(PRODUCER_RECEIVED_SEQ_HEADER) ?? 0);
-                    const error = new SequenceGapError(expected, received);
-                    fatalError = error;
-                    throw error;
-                }
-                default: {
-                    // Unexpected status — fatal, write outcome is uncertain.
-                    // TODO: Transient errors (500, 503) could be retried with the
-                    // same seq in a future version. See DEC-026 rationale.
-                    const error = new Error(`Unexpected append response: HTTP ${res.status}`);
-                    fatalError = error;
-                    throw error;
-                }
-            }
-        }
-        // ── Provide the DurableStream handle ──
-        yield* provide({
-            get lastOffset() {
-                return lastOffset;
-            },
-            /**
-             * Read all events in the stream, in append order.
-             *
-             * Uses the stream() function from @durable-streams/client with
-             * offset="-1" (start of stream) and live=false (no tailing).
-             */
-            *readAll() {
-                return yield* call(async () => {
-                    const res = await stream({
-                        url: streamUrl,
-                        offset: "-1",
-                        live: false,
-                        fetch: fetchFn,
-                    });
-                    const events = (await res.json());
-                    // Track offset from read (DEC-029)
-                    if (res.offset) {
-                        lastOffset = res.offset;
-                    }
-                    return events;
-                });
-            },
-            /**
-             * Append an event to the stream.
-             *
-             * Sequence numbers are assigned synchronously when the generator is
-             * started. The actual HTTP call is dispatched to the serial worker
-             * via the queue. The caller suspends until the worker completes the
-             * POST and signals via withResolvers.
-             *
-             * Fatal errors (stale epoch, network failure) are stored and cause
-             * all future appends to fail-fast without enqueuing.
-             */
-            *append(event) {
-                // Fail-fast if a fatal error has been set
-                if (fatalError) {
-                    throw fatalError;
-                }
-                // Assign seq synchronously — ordering is locked in before any
-                // async work, even when multiple coroutines call append concurrently
-                const seq = nextSeq++;
-                // Create a resolver so we can wait for this specific append to complete
-                const { operation, resolve, reject } = withResolvers();
-                // Enqueue the request — the worker will process it in FIFO order
-                queue.add({ event, seq, resolve, reject });
-                // Suspend until the worker finishes the HTTP POST for this item
-                yield* operation;
-            },
-        });
-    });
-}

package/esm/durable-streams/mod.js

@@ -1,34 +0,0 @@
-/**
- * @module
- * Durable execution for Effection.
- *
- * Implements the two-event durable execution protocol for generator-based
- * structured concurrency, with Durable Streams as the persistence backend.
- */
-// ReplayIndex
-export { ReplayIndex } from "./replay-index.ts";
-export { InMemoryStream } from "./stream.ts";
-// HTTP-backed stream adapter
-export { useHttpDurableStream } from "./http-stream.ts";
-// Errors
-export { ContinuePastCloseDivergenceError, DivergenceError, EarlyReturnDivergenceError, StaleInputError, } from "./errors.ts";
-// Divergence API — pluggable policy for replay mismatches (DEC-031)
-export { Divergence } from "./divergence.ts";
-// ReplayGuard API — pluggable validation for replay staleness detection
-export { ReplayGuard } from "./replay-guard.ts";
-// Context
-export { DurableCtx } from "./context.ts";
-// Serialization utilities
-export { deserializeError, effectionToProtocol, protocolToEffection, serializeError, } from "./serialize.ts";
-// Core effect factories
-export { createDurableEffect, createDurableOperation } from "./effect.ts";
-// Workflow-enabled effects
-export { durableAction, durableCall, durableSleep, versionCheck } from "./operations.ts";
-// Structured concurrency combinators
-export { durableAll, durableRace, durableSpawn } from "./combinators.ts";
-// Durable iteration
-export { durableEach } from "./each.ts";
-// Ephemeral — explicit escape hatch for non-durable Operations in Workflows
-export { ephemeral } from "./ephemeral.ts";
-// Entry point
-export { durableRun } from "./run.ts";