@mnci/az-durable 0.1.0

package/dist/src/rules/shared.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Minimal ESLint rule shapes, declared locally.
+ *
+ * @remarks
+ * Declared here rather than imported from `@types/eslint` or
+ * `@typescript-eslint/utils` because this package ships **zero runtime
+ * dependencies**, and a type-only dependency is still a dependency a consumer
+ * must be able to resolve. These cover exactly what the three rules use.
+ */
+/**
+ * An ESTree-ish node, narrowed only where a rule actually reads it.
+ *
+ * @remarks
+ * The index signature is what keeps this honest: a rule reads whatever
+ * property it needs and casts at the read site, rather than this file growing
+ * a partial mirror of ESTree that would drift against the real one.
+ *
+ * @typeParam None - this interface has no generic type parameters.
+ */
+export interface Node {
+    type: string;
+    [key: string]: unknown;
+}
+/**
+ * The subset of ESLint's rule context these rules touch.
+ *
+ * @remarks
+ * Only `report` is declared, because only `report` is used. Widening this to
+ * the real context type would pull in a dependency for no gain.
+ *
+ * @typeParam None - this interface has no generic type parameters.
+ */
+export interface RuleContext {
+    report: (descriptor: {
+        node: Node;
+        messageId: string;
+        data?: Record<string, string>;
+    }) => void;
+}
+/**
+ * An ESLint rule module, as the plugin exports it.
+ *
+ * @remarks
+ * `schema: []` is deliberate rather than omitted - every rule here is
+ * option-free, and an empty schema makes ESLint reject an options object
+ * instead of silently ignoring it.
+ *
+ * @typeParam None - this interface has no generic type parameters.
+ */
+export interface Rule {
+    meta: {
+        type: 'problem' | 'suggestion';
+        docs: {
+            description: string;
+        };
+        schema: [];
+        messages: Record<string, string>;
+    };
+    create: (context: RuleContext) => Record<string, (node: Node) => void>;
+}
+/**
+ * Whether a call expression registers an orchestration.
+ *
+ * @remarks
+ * Matches both `defineOrchestration(...)` and the raw
+ * `df.app.orchestration(...)`, since an orchestration written either way has
+ * the same determinism constraints.
+ *
+ * **Heuristic, by construction.** These rules match on call-site SHAPE, so an
+ * orchestration body extracted into a helper function is not caught. That is a
+ * documented limit rather than a defect: following the value would require type
+ * information the rule deliberately does not depend on.
+ *
+ * @param node - A `CallExpression` node.
+ * @returns `true` when the call registers an orchestration.
+ * @throws Never - pure inspection.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export declare function isOrchestrationRegistration(node: Node): boolean;
+/**
+ * The name a callee refers to, if it is a plain identifier or member access.
+ *
+ * @remarks
+ * For a member expression this returns the TRAILING property, so `df.now()`
+ * and `context.df.now()` both read as `now`. Callers that must distinguish a
+ * bare call from a member call check `node.type` themselves - `require-yield-star`
+ * does exactly that, because `yield c.df.callActivity(...)` is the correct raw
+ * SDK call and must not be flagged.
+ *
+ * @param node - A callee node.
+ * @returns The identifier or property name, or `undefined`.
+ * @throws Never - pure inspection.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export declare function calleeName(node: Node | undefined): string | undefined;
+//# sourceMappingURL=shared.d.ts.map

package/dist/src/status.d.ts

@@ -0,0 +1,32 @@
+import type { OrchestrationContext } from 'durable-functions';
+/**
+ * Declares the custom statuses an orchestration can report.
+ *
+ * @remarks
+ * `const` on the type parameter preserves the literal types, so `setStatus`
+ * can check the key against the actual set rather than against `string`. The
+ * object is returned unchanged — this is a typing device, not a transform.
+ *
+ * @param statuses - The status map.
+ * @returns The same object, with its literal types preserved.
+ * @throws Never - returns its argument.
+ * @typeParam T - The status map's literal type.
+ */
+export declare function defineStatuses<const T extends Record<string, string>>(statuses: T): T;
+/**
+ * Sets the orchestration's custom status from a declared set.
+ *
+ * @remarks
+ * `setCustomStatus` accepts `unknown`, so a typo in a status string is invisible
+ * until someone reads the instance's status and finds a value nothing produces.
+ * Constraining `key` to the declared map is the whole point.
+ *
+ * @param context - The orchestration context.
+ * @param statuses - The declared status map.
+ * @param key - Which status to set; checked against the map.
+ * @returns Nothing.
+ * @throws Never - delegates to the SDK.
+ * @typeParam T - The status map's literal type.
+ */
+export declare function setStatus<T extends Record<string, string>>(context: OrchestrationContext, statuses: T, key: keyof T): void;
+//# sourceMappingURL=status.d.ts.map

package/dist/src/testing.d.ts

@@ -0,0 +1,122 @@
+import type { TypedOrchestration } from './types';
+/**
+ * A recorded activity or sub-orchestration call.
+ *
+ * @remarks
+ * The ORDER of these is what replay compatibility depends on, which is why the
+ * harness returns them as a list rather than a set: reordering two activity
+ * calls is a breaking change to an orchestration, and this is what makes that
+ * directly assertable.
+ *
+ * @typeParam None - this interface has no generic type parameters.
+ */
+export interface RecordedCall {
+    /** The activity or orchestration name, as scheduled. */
+    readonly name: string;
+    /** The input it was scheduled with. */
+    readonly input: unknown;
+}
+/**
+ * What a stubbed activity returns, or an `Error` to make it throw.
+ *
+ * @remarks
+ * Deliberately `unknown` rather than generic: a stub map covers many activities
+ * with different outputs, so a single parameter could only be their union,
+ * which is less useful than an explicit cast at the one place it matters.
+ *
+ * @typeParam None - this type has no generic type parameters.
+ */
+export type StubResult = unknown;
+/**
+ * The fakes a workflow run is driven against.
+ *
+ * @remarks
+ * `activities` is keyed by the same name literal `defineActivity` registered —
+ * deliberately, since that string is the contract the task hub stores.
+ *
+ * @typeParam None - this interface has no generic type parameters.
+ */
+export interface WorkflowStub {
+    /**
+     * Result per activity name. Returning an `Error` instance makes that call
+     * THROW inside the orchestration, which is how failure branches and
+     * retry-exhaustion paths become testable.
+     */
+    readonly activities: Record<string, (input: unknown) => StubResult>;
+    /** Fixed clock, so time-dependent output is deterministic. Defaults to the epoch. */
+    readonly now?: Date;
+    /** Instance id the orchestration sees. Defaults to `test-instance`. */
+    readonly instanceId?: string;
+    /**
+     * Picks the winner of a `Task.any` race, by scheduled name.
+     *
+     * @remarks
+     * Defaults to the first candidate, and returning `undefined` accepts that
+     * default — so a selector only has to name the cases it cares about, rather
+     * than inventing a fallback for a list it knows is non-empty. Worth setting
+     * whenever a race decides something important: the approval-versus-timeout
+     * pattern has a branch per outcome, and with a fixed winner only one of them
+     * is ever reachable. A timer candidate is named `__timer`.
+     */
+    readonly raceWinner?: (candidates: string[]) => string | undefined;
+}
+/**
+ * What a completed {@link runWorkflow} reports.
+ *
+ * @remarks
+ * `calls` and `statuses` are ordered lists rather than sets because the order
+ * is the property worth asserting: it is what replay compatibility depends on.
+ *
+ * @typeParam TInput - The orchestration's input type.
+ * @typeParam TOutput - The orchestration's return type.
+ */
+export interface WorkflowRun<TInput, TOutput> {
+    /** The orchestration's return value. */
+    readonly result: TOutput;
+    /** Every activity and sub-orchestration call, in order. */
+    readonly calls: RecordedCall[];
+    /** Every `setCustomStatus` transition, in order. */
+    readonly statuses: string[];
+    /**
+     * The input the orchestration asked to restart with, if it called
+     * `self.continueAsNew`.
+     *
+     * @remarks
+     * The harness records the request and lets the run finish rather than
+     * looping: an eternal orchestration restarts forever by design, so a harness
+     * that honoured it would never return. What is worth asserting is that the
+     * restart was requested and with what — the next generation is then a
+     * separate `runWorkflow` call with that input.
+     */
+    readonly continuedAsNew?: TInput;
+}
+/**
+ * Runs an orchestration against stubbed activities, with no Azure running.
+ *
+ * @remarks
+ * Drives the generator synchronously, feeding each yielded task the stubbed
+ * result for that activity's name. There is no host, no emulator and no
+ * storage — a three-step workflow with a short-circuit branch is testable in
+ * about fifteen lines.
+ *
+ * **How it intercepts.** The orchestration is driven with a fake
+ * `OrchestrationContext`, which works only because every scheduling call in
+ * this package goes through `context.df` rather than through the registered
+ * callable. The alternative — reading the name off `task.action.functionName` —
+ * is an undocumented SDK internal the package's non-goals forbid.
+ *
+ * **Limits, stated rather than discovered later.** Retry policies are not
+ * simulated: a stub returning an `Error` throws once, it does not exhaust
+ * attempts. `Task.any` resolves to the FIRST task in the list, since there is
+ * no real concurrency to race. Timers complete immediately.
+ *
+ * @param orchestration - The orchestration to run.
+ * @param input - The input, checked against its declared type.
+ * @param stub - The activity fakes, clock and instance id.
+ * @returns The result, the ordered calls, and the status transitions.
+ * @throws Error when an activity is called with no stub registered for it.
+ * @typeParam TInput - The orchestration's input type.
+ * @typeParam TOutput - The orchestration's output type.
+ */
+export declare function runWorkflow<TInput, TOutput>(orchestration: TypedOrchestration<TInput, TOutput>, input: TInput, stub: WorkflowStub): WorkflowRun<TInput, TOutput>;
+//# sourceMappingURL=testing.d.ts.map

package/dist/src/time.d.ts

@@ -0,0 +1,79 @@
+import type { OrchestrationContext, Task } from 'durable-functions';
+import type { TypedTimerTask } from './types';
+/**
+ * The current time, safely for replay.
+ *
+ * @remarks
+ * `new Date()` and `Date.now()` return a different value on every replay, which
+ * silently corrupts orchestration output rather than failing. `currentUtcDateTime`
+ * is derived from orchestration history and returns the same value at the same
+ * point every time. This is the replacement the lint rule suggests.
+ *
+ * @param context - The orchestration context.
+ * @returns The replay-safe current time.
+ * @throws Never - reads a property.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export declare function now(context: OrchestrationContext): Date;
+/**
+ * Sleeps until an absolute time.
+ *
+ * @remarks
+ * **Must be invoked with `yield *`.**
+ *
+ * @param context - The orchestration context.
+ * @param when - The absolute time to wake at.
+ * @returns A generator that completes when the timer fires.
+ * @throws Never - the timer either fires or the instance ends.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export declare function sleepUntil(context: OrchestrationContext, when: Date): Generator<Task, void, unknown>;
+/**
+ * Sleeps for a duration.
+ *
+ * @remarks
+ * The deadline is computed from {@link now}, **never** `Date.now()`. Using wall
+ * clock here would make the deadline move on every replay, so a timer could fire
+ * early, late, or repeatedly. This is the single most common determinism bug in
+ * hand-written orchestrations.
+ *
+ * **Must be invoked with `yield *`.**
+ *
+ * @param context - The orchestration context.
+ * @param ms - How long to sleep, in milliseconds.
+ * @returns A generator that completes when the timer fires.
+ * @throws Never - the timer either fires or the instance ends.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export declare function sleepFor(context: OrchestrationContext, ms: number): Generator<Task, void, unknown>;
+/**
+ * Schedules a durable timer for an absolute instant, without yielding it.
+ *
+ * @remarks
+ * The task form of {@link sleepUntil}, so a timer can race an event or an
+ * activity through `any`. See {@link TypedTimerTask} for why the returned
+ * value carries `cancel` — **a pending timer keeps the instance alive**, so the
+ * loser of a race must be cancelled.
+ *
+ * @param context - The orchestration context.
+ * @param when - The instant to fire at.
+ * @returns A cancellable timer task.
+ * @throws Never - scheduling only.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export declare function timerTaskUntil(context: OrchestrationContext, when: Date): TypedTimerTask;
+/**
+ * Schedules a durable timer a fixed duration ahead, without yielding it.
+ *
+ * @remarks
+ * Computes the deadline from `context.df.currentUtcDateTime`, never
+ * `Date.now()` — the same replay-safety reason {@link sleepFor} does.
+ *
+ * @param context - The orchestration context.
+ * @param ms - How far ahead to fire, in milliseconds.
+ * @returns A cancellable timer task.
+ * @throws Never - scheduling only.
+ * @typeParam None - this function has no generic type parameters.
+ */
+export declare function timerTask(context: OrchestrationContext, ms: number): TypedTimerTask;
+//# sourceMappingURL=time.d.ts.map

package/dist/src/types.d.ts

@@ -0,0 +1,96 @@
+import type { OrchestrationContext, RegisteredActivity, RegisteredOrchestration, Task, TimerTask } from 'durable-functions';
+/**
+ * An activity with its input and output types attached.
+ *
+ * @remarks
+ * `__input` and `__output` are **phantom**: never assigned, never read, and
+ * erased at build time. They exist only to carry `TInput`/`TOutput` through the
+ * type system, since `RegisteredActivity` is `(input?: unknown) => …` and
+ * therefore forgets both.
+ *
+ * `__input` is written as a function *parameter* rather than a bare property so
+ * that `TInput` is **contravariant**. That is not decoration: with a covariant
+ * property, an activity accepting a wider input would be assignable where a
+ * narrower one is expected, and the wrapper would accept calls the handler
+ * cannot serve.
+ *
+ * @typeParam TInput - The JSON-serialisable input the activity accepts.
+ * @typeParam TOutput - The awaited output the activity produces.
+ */
+export interface TypedActivity<TInput, TOutput> {
+    /** The activity name as registered in the Function App, verbatim. */
+    readonly name: string;
+    /** The value `durable-functions` returned from `app.activity`. */
+    readonly registered: RegisteredActivity;
+    /** Phantom. Never assigned. Makes `TInput` contravariant. */
+    readonly __input?: (input: TInput) => void;
+    /** Phantom. Never assigned. Carries `TOutput`. */
+    readonly __output?: () => TOutput;
+}
+/**
+ * An orchestration with its input and output types attached.
+ *
+ * @remarks
+ * Same phantom-member design as {@link TypedActivity}; see there for why
+ * `__input` is a function parameter.
+ *
+ * @typeParam TInput - The JSON-serialisable input the orchestration accepts.
+ * @typeParam TOutput - The value the orchestration returns.
+ */
+export interface TypedOrchestration<TInput, TOutput> {
+    /** The orchestration name as registered in the Function App, verbatim. */
+    readonly name: string;
+    /** The value `durable-functions` returned from `app.orchestration`. */
+    readonly registered: RegisteredOrchestration;
+    /**
+     * The handler, retained so `runWorkflow` can drive it directly.
+     *
+     * @remarks
+     * The SDK keeps no accessible reference to the generator once registered, so
+     * without this the testing harness would have to go through the Functions
+     * host. Reading it outside `@mnci/az-durable/testing` is not supported.
+     */
+    readonly handler: (context: OrchestrationContext, input: TInput) => Generator<Task, TOutput, unknown>;
+    /** Phantom. Never assigned. Makes `TInput` contravariant. */
+    readonly __input?: (input: TInput) => void;
+    /** Phantom. Never assigned. Carries `TOutput`. */
+    readonly __output?: () => TOutput;
+}
+/**
+ * A task that has been scheduled but not yet yielded, for fan-out.
+ *
+ * @remarks
+ * Produced by `activityTask` and consumed by `all`/`any`. Holding the SDK
+ * `Task` rather than yielding it immediately is what lets several activities
+ * run concurrently.
+ *
+ * @typeParam TOutput - The output the task will produce.
+ */
+export interface TypedTask<TOutput> {
+    /** The underlying SDK task. Yield it, or hand it to `all`/`any`. */
+    readonly task: Task;
+    /** Phantom. Never assigned. Carries `TOutput`. */
+    readonly __output?: () => TOutput;
+}
+/**
+ * A durable timer, scheduled but not yet yielded.
+ *
+ * @remarks
+ * Separate from {@link TypedTask} because a timer carries `cancel`, and losing
+ * it is a real bug rather than a missing convenience: **an orchestration does
+ * not complete until every scheduled timer has fired or been cancelled**, so a
+ * timeout timer left pending after its race is won keeps the instance alive
+ * until it expires. The SDK documents this on `TimerTask`; surfacing `cancel`
+ * here is what lets a caller obey it without reaching for the raw task.
+ *
+ * @typeParam None - this interface has no generic type parameters.
+ */
+export interface TypedTimerTask extends TypedTask<void> {
+    /** The underlying SDK timer. */
+    readonly task: TimerTask;
+    /** Requests cancellation, applied on the next `yield` or `return`. */
+    readonly cancel: () => void;
+    /** Whether the timer has fired. */
+    readonly isCompleted: () => boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/testing.d.ts

@@ -0,0 +1 @@
+export * from "./src/testing";

package/dist/testing.esm.js

@@ -0,0 +1,225 @@
+function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else return left instanceof right;
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+/**
+ * Runs an orchestration against stubbed activities, with no Azure running.
+ *
+ * @remarks
+ * Drives the generator synchronously, feeding each yielded task the stubbed
+ * result for that activity's name. There is no host, no emulator and no
+ * storage — a three-step workflow with a short-circuit branch is testable in
+ * about fifteen lines.
+ *
+ * **How it intercepts.** The orchestration is driven with a fake
+ * `OrchestrationContext`, which works only because every scheduling call in
+ * this package goes through `context.df` rather than through the registered
+ * callable. The alternative — reading the name off `task.action.functionName` —
+ * is an undocumented SDK internal the package's non-goals forbid.
+ *
+ * **Limits, stated rather than discovered later.** Retry policies are not
+ * simulated: a stub returning an `Error` throws once, it does not exhaust
+ * attempts. `Task.any` resolves to the FIRST task in the list, since there is
+ * no real concurrency to race. Timers complete immediately.
+ *
+ * @param orchestration - The orchestration to run.
+ * @param input - The input, checked against its declared type.
+ * @param stub - The activity fakes, clock and instance id.
+ * @returns The result, the ordered calls, and the status transitions.
+ * @throws Error when an activity is called with no stub registered for it.
+ * @typeParam TInput - The orchestration's input type.
+ * @typeParam TOutput - The orchestration's output type.
+ */ function runWorkflow(orchestration, input, stub) {
+    var _stub_now, _stub_instanceId;
+    var calls = [];
+    var statuses = [];
+    var continuedAsNew;
+    var clock = (_stub_now = stub.now) !== null && _stub_now !== void 0 ? _stub_now : new Date(0);
+    var schedule = function schedule(name, scheduledInput) {
+        calls.push({
+            name: name,
+            input: scheduledInput
+        });
+        return {
+            isCompleted: false,
+            isFaulted: false,
+            __name: name,
+            __input: scheduledInput
+        };
+    };
+    var context = {
+        df: {
+            instanceId: (_stub_instanceId = stub.instanceId) !== null && _stub_instanceId !== void 0 ? _stub_instanceId : 'test-instance',
+            isReplaying: false,
+            currentUtcDateTime: clock,
+            callActivity: schedule,
+            callActivityWithRetry: function callActivityWithRetry(name, _retry, i) {
+                return schedule(name, i);
+            },
+            callSubOrchestrator: function callSubOrchestrator(name, i) {
+                return schedule(name, i);
+            },
+            callSubOrchestratorWithRetry: function callSubOrchestratorWithRetry(name, _retry, i) {
+                return schedule(name, i);
+            },
+            waitForExternalEvent: function waitForExternalEvent(name) {
+                return schedule(name, undefined);
+            },
+            // Timers complete immediately: there is no real time to wait for, and a
+            // harness that blocked on one would be useless. `cancel` is real,
+            // because an orchestration that correctly cancels its losing timer must
+            // not crash in a test for doing the right thing.
+            createTimer: function createTimer(fireAt) {
+                var timer = schedule('__timer', fireAt.toISOString());
+                timer.isCanceled = false;
+                timer.cancel = function() {
+                    timer.isCanceled = true;
+                };
+                return timer;
+            },
+            setCustomStatus: function setCustomStatus(value) {
+                statuses.push(String(value));
+            },
+            continueAsNew: function continueAsNew(next) {
+                continuedAsNew = next;
+            },
+            Task: {
+                all: function all(tasks) {
+                    return {
+                        isCompleted: false,
+                        isFaulted: false,
+                        __all: tasks
+                    };
+                },
+                // A marker, not a winner. `Task.any` resolves to the winning TASK, not
+                // to its value, so choosing here would hand the orchestration the
+                // wrong kind of thing — which is exactly the bug the reconstructed
+                // workflows found.
+                any: function any(tasks) {
+                    return {
+                        isCompleted: false,
+                        isFaulted: false,
+                        __any: tasks
+                    };
+                }
+            }
+        }
+    };
+    var generator = orchestration.handler(context, input);
+    var step = generator.next();
+    while(!step.done){
+        var resumed = resolve(step.value, stub);
+        // INTO the generator, not out of the driver. Throwing here instead is the
+        // bug the reconstructed workflows found: every compensation branch was
+        // unreachable, while the docstring promised the opposite.
+        step = isThrowRequest(resumed) ? generator.throw(resumed.__throw) : generator.next(resumed);
+    }
+    return continuedAsNew === undefined ? {
+        result: step.value,
+        calls: calls,
+        statuses: statuses
+    } : {
+        result: step.value,
+        calls: calls,
+        statuses: statuses,
+        continuedAsNew: continuedAsNew
+    };
+}
+/**
+ * Produces the value the driver resumes a yielded task with.
+ *
+ * @remarks
+ * Separated so the `Task.all` fan-out case — where one yielded task stands for
+ * several — is handled in one place rather than inline in the drive loop.
+ *
+ * @param task - The task the orchestration yielded.
+ * @param stub - The stubs to resolve against.
+ * @returns The value to resume with, or a {@link ThrowRequest} for the driver to inject.
+ * @throws Error naming an activity with no stub registered.
+ * @typeParam None - this function has no generic type parameters.
+ */ function resolve(task, stub) {
+    var fanOut = task.__all;
+    if (fanOut !== undefined) {
+        return fanOut.map(function(t) {
+            return resolve(t, stub);
+        });
+    }
+    var race = task.__any;
+    if (race !== undefined) {
+        return resolveRace(race, stub);
+    }
+    var name = task.__name, input = task.__input;
+    if (name === '__timer') {
+        return undefined;
+    }
+    var activity = stub.activities[name];
+    if (activity === undefined) {
+        // Naming the activity matters: the alternative is `undefined` flowing into
+        // the orchestration and failing somewhere unrelated.
+        throw new Error("No stub registered for '".concat(name, "'. Add it to stub.activities to run this workflow."));
+    }
+    var result = activity(input);
+    if (_instanceof(result, Error)) {
+        // A returned Error becomes a THROWN error inside the orchestration, which
+        // is what makes failure branches testable at all. Handed back as a request
+        // so the DRIVER injects it; see {@link ThrowRequest}.
+        return {
+            __throw: result
+        };
+    }
+    return result;
+}
+/**
+ * Settles a `Task.any` race and returns the winning TASK.
+ *
+ * @remarks
+ * The distinction that matters: the SDK's `Task.any` resolves to the winning
+ * task object, not to its value, and callers read the value afterwards with
+ * `resultOf`. An earlier harness returned the resolved value instead, which
+ * made every orchestration using a race fail with "Task.any returned a task
+ * that was not one of the inputs" — correct code, rejected by the fake.
+ *
+ * The winner's `result` is populated and `isCompleted` set, so `resultOf` and
+ * an `isCompleted` check on the loser both behave as they do in production.
+ *
+ * @param candidates - The racing tasks.
+ * @param stub - The stubs to resolve the winner against.
+ * @returns The winning task, completed and carrying its result.
+ * @throws Error when `raceWinner` names a task that is not racing.
+ * @typeParam None - this function has no generic type parameters.
+ */ function resolveRace(candidates, stub) {
+    var _ref;
+    var _stub_raceWinner;
+    var names = candidates.map(function(c) {
+        return c.__name;
+    });
+    var chosen = (_ref = (_stub_raceWinner = stub.raceWinner) === null || _stub_raceWinner === void 0 ? void 0 : _stub_raceWinner.call(stub, names)) !== null && _ref !== void 0 ? _ref : names[0];
+    var winner = candidates.find(function(c) {
+        return c.__name === chosen;
+    });
+    if (winner === undefined) {
+        throw new Error("raceWinner chose '".concat(String(chosen), "', which is not racing. Candidates: ").concat(names.join(', '), "."));
+    }
+    var mutable = winner;
+    mutable.result = winner.__name === '__timer' ? undefined : resolve(winner, stub);
+    mutable.isCompleted = true;
+    return winner;
+}
+/**
+ * Whether a resolved value is a request to throw inside the orchestration.
+ *
+ * @param value - Whatever `resolve` produced.
+ * @returns `true` when the driver should call `generator.throw`.
+ * @throws Never - a type guard.
+ * @typeParam None - this function has no generic type parameters.
+ */ function isThrowRequest(value) {
+    return (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && value !== null && '__throw' in value;
+}
+
+export { runWorkflow };