@astrale-os/sdk 0.6.0-beta.40 → 0.6.0-beta.41

package/dist/execution/workflows/run.d.ts

@@ -11,6 +11,8 @@ export interface DurableRun {
     readonly serving: AdmittedDurableServing;
     /** What each Step attempt holds. */
     readonly steps: StepAuthorities;
+    /** The clock that times each Step attempt against its Step's `maxDurationMs`; `Date.now` by default. */
+    readonly now?: () => number;
 }
 /** Engine handlers of one durable Workflow: the `run` and the shared `signal`. */
 export declare function durableHandlers(input: DurableRun): Readonly<{

package/dist/execution/workflows/run.js

@@ -1,17 +1,14 @@
 import { declaredErrorFactory } from '../../application/error/index.js';
 import { acceptStepId } from '../../application/workflow/step/index.js';
 import { acceptStepOutput } from '../../application/workflow/step/output.js';
-import { ResponseError } from '../../platform/client/index.js';
 import { validateOutput } from '../invocation/result/index.js';
+import { BACKOFF, UNAVAILABLE, failedAttemptError, failedAttemptOf, nextAttempt, } from './attempts.js';
 import { decodeEnvelope } from './envelope.js';
-import { delayedRetry, replayedFailure, StepExhausted, StepRetryAfter, attemptFailure, terminalFailure, } from './failure.js';
+import { replayedFailure, StepExhausted, StepRetryAfter, terminalFailure } from './failure.js';
 import { stepServing } from './options.js';
 import { keySequence } from './steps.js';
 const MAXIMUM_SLEEP_MS = 365 * 24 * 60 * 60_000;
 const MAXIMUM_SIGNAL_NAME = 128;
-/** Bounds of one `result` wait and of the durable pause between two of them. */
-const AWAIT_WAIT_MS = 10_000;
-const AWAIT_MAXIMUM_PAUSE_MS = 5 * 60_000;
 /** Engine handlers of one durable Workflow: the `run` and the shared `signal`. */
 export function durableHandlers(input) {
     const { engine } = input.serving;
@@ -95,52 +92,84 @@ function durableContext(input, context, envelope) {
             running = undefined;
         });
     };
+    const now = input.now ?? Date.now;
     /**
-     * One journaled unit of work holding the capabilities of an Action as the Domain alone. Its
-     * Mutations, durable calls and Integration calls share one key sequence derived from its name.
-     * With a `retry` budget, the engine retries a failed attempt within it, after its backoff or the
-     * delay the failure prescribes, and the Step throws `StepExhausted` once it is spent; without
-     * one, a failed attempt fails the run's attempt, which the engine retries until it pauses.
+     * One attempt of Step `id`, holding the capabilities of an Action as the Domain alone. Its
+     * Mutations, durable calls and Integration calls share one key sequence derived from the Step's
+     * name, which every attempt derives again. The engine journals its outcome: the Step's output, its
+     * declared error, or the failed attempt, as `failedAttemptError` records it. The Step decides from
+     * that journal alone whether to go on, so a replay decides alike.
      *
      * The engine promise is returned unawaited: awaiting it is what tells the engine the run waits on
      * it, so parallel Steps hand theirs to the engine's own combinator instead.
      */
-    const journaled = (id, name, timeoutMs, retry, execute) => context.run(name, async () => {
-        const expiry = new AbortController();
-        const timer = setTimeout(() => expiry.abort(new Error(`Workflow Step ${id} exceeded its ${timeoutMs} ms timeout.`)), timeoutMs);
-        let step;
-        try {
-            const lifetime = {
-                deadline: Date.now() + timeoutMs,
-                signal: AbortSignal.any([signal, expiry.signal]),
-            };
-            const next = await keySequence(execution.id, name);
-            const { authority } = (step = input.steps({ name, execution, next, lifetime }));
-            const output = await Promise.race([
-                Promise.resolve().then(() => execute(authority)),
-                expired(expiry.signal),
-            ]);
+    const attempt = (id, held, execute) => {
+        const name = `step:${id}`;
+        const { timeoutMs } = held;
+        return context.run(name, async () => {
+            const startedAt = now();
+            const expiry = new AbortController();
+            const timer = setTimeout(() => expiry.abort(new Error(`Workflow Step ${id} exceeded its ${timeoutMs} ms timeout.`)), timeoutMs);
+            let step;
             try {
-                return acceptStepOutput(output);
+                const lifetime = {
+                    deadline: Date.now() + timeoutMs,
+                    signal: AbortSignal.any([signal, expiry.signal]),
+                };
+                const next = await keySequence(execution.id, name);
+                const { authority } = (step = input.steps({ name, execution, next, lifetime }));
+                const output = await Promise.race([
+                    Promise.resolve().then(() => execute(authority)),
+                    expired(expiry.signal),
+                ]);
+                try {
+                    return acceptStepOutput(output);
+                }
+                catch (cause) {
+                    throw new TypeError(`Workflow ${name} output must be portable.`, { cause });
+                }
             }
             catch (cause) {
-                throw new TypeError(`Workflow ${name} output must be portable.`, { cause });
+                throw (terminalFailure(engine, cause, definition) ??
+                    failedAttemptError(engine, cause, startedAt, now(), step?.repeatsEffects() ?? false));
             }
+            finally {
+                clearTimeout(timer);
+                step?.close();
+            }
+        });
+    };
+    /**
+     * How Step `id` goes on after an attempt that failed with the journaled `outcome`, given what its
+     * earlier attempts spent. A declared error, an exhaustion the Step threw again, and the engine's
+     * cancellation are final: they throw, as the Workflow sees them.
+     */
+    const afterFailure = (id, held, spent, outcome) => {
+        const failed = failedAttemptOf(engine, outcome);
+        if (failed === undefined)
+            throw replayedFailure(engine, outcome, definition, id) ?? outcome;
+        return nextAttempt(spent, failed, held.retry);
+    };
+    /**
+     * One Step, awaited alone: attempted until it succeeds, fails for good or spends its budget, each
+     * attempt after a durable wait the failure of the previous one prescribes.
+     */
+    const attempts = async (id, held, execute) => {
+        let spent;
+        for (;;) {
+            let next;
+            try {
+                return await attempt(id, held, execute);
+            }
+            catch (outcome) {
+                next = afterFailure(id, held, spent, outcome);
+            }
+            if (next.kind === 'exhausted')
+                throw new StepExhausted(id, next.refusal);
+            spent = next.spending;
+            await context.sleep(next.delayMs, `${next.wait}:step:${id}`);
         }
-        catch (cause) {
-            throw (terminalFailure(engine, cause, definition) ??
-                delayedRetry(engine, cause) ??
-                attemptFailure(cause));
-        }
-        finally {
-            clearTimeout(timer);
-            step?.close();
-        }
-    }, retry);
-    /** One Step, awaited alone; its failure reaches the Workflow as `replayedFailure` reads it. */
-    const journal = (id, name, timeoutMs, retry, execute) => Promise.resolve(journaled(id, name, timeoutMs, retry, execute)).catch((cause) => {
-        throw replayedFailure(engine, cause, definition, id) ?? cause;
-    });
+    };
     const step = (declared, execute) => {
         let accepted;
         try {
@@ -152,13 +181,15 @@ function durableContext(input, context, envelope) {
             return Promise.reject(cause);
         }
         steps.add(accepted.id);
-        const { held } = accepted;
-        return sequenced(`Step ${accepted.id}`, () => journal(accepted.id, `step:${accepted.id}`, held.timeoutMs, held.retry, execute));
+        return sequenced(`Step ${accepted.id}`, () => attempts(accepted.id, accepted.held, execute));
     };
     /**
-     * The Steps `declare` declares, started together and awaited through the engine's combinator as
-     * one operation. Once all have settled, their outputs in declaration order, or the failure of the
-     * first failed one in that order, as that Step alone fails.
+     * The Steps `declare` declares, attempted together in rounds, each round awaited through the
+     * engine's combinator as one operation. A Step whose attempt failed and that goes on is attempted
+     * again in the next round, after one durable wait, the longest any of them prescribes; each Step
+     * spends its own budget. Once all have settled, their outputs in declaration order, or the failure
+     * of the first failed one in that order, as that Step alone fails. A cancellation ends the round
+     * it reaches.
      */
     const parallel = (declare) => {
         const declared = new Map();
@@ -201,14 +232,50 @@ function durableContext(input, context, envelope) {
         for (const { id } of group)
             steps.add(id);
         return sequenced(`parallel Steps ${group.map(({ id }) => id).join(', ')}`, async () => {
-            const started = group.map(({ id, held, execute }) => journaled(id, `step:${id}`, held.timeoutMs, held.retry, execute));
-            const settled = await engine.RestatePromise.allSettled(started);
-            const failed = settled.findIndex(({ status }) => status === 'rejected');
-            if (failed === -1) {
-                return settled.map((result) => result.value);
+            const states = group.map((declared) => ({
+                ...declared,
+                spent: undefined,
+                result: undefined,
+            }));
+            for (;;) {
+                const pending = states.filter(({ result }) => result === undefined);
+                const settled = await engine.RestatePromise.allSettled(pending.map(({ id, held, execute }) => attempt(id, held, execute)));
+                const cancelled = settled.find((outcome) => outcome.status === 'rejected' && outcome.reason instanceof engine.CancelledError);
+                if (cancelled !== undefined)
+                    throw cancelled.reason;
+                let delayMs = 0;
+                let wait = BACKOFF;
+                settled.forEach((outcome, index) => {
+                    const state = pending[index];
+                    if (outcome.status === 'fulfilled') {
+                        state.result = outcome;
+                        return;
+                    }
+                    let next;
+                    try {
+                        next = afterFailure(state.id, state.held, state.spent, outcome.reason);
+                    }
+                    catch (failure) {
+                        state.result = { status: 'rejected', reason: failure };
+                        return;
+                    }
+                    if (next.kind === 'exhausted') {
+                        state.result = { status: 'rejected', reason: new StepExhausted(state.id, next.refusal) };
+                        return;
+                    }
+                    state.spent = next.spending;
+                    delayMs = Math.max(delayMs, next.delayMs);
+                    if (next.wait === UNAVAILABLE)
+                        wait = UNAVAILABLE;
+                });
+                if (states.every(({ result }) => result !== undefined))
+                    break;
+                await context.sleep(delayMs, `${wait}:parallel`);
             }
-            const cause = settled[failed].reason;
-            throw replayedFailure(engine, cause, definition, group[failed].id) ?? cause;
+            const failed = states.find(({ result }) => result.status === 'rejected');
+            if (failed !== undefined)
+                throw failed.result.reason;
+            return states.map(({ result }) => result.value);
         });
     };
     return Object.freeze({
@@ -253,29 +320,6 @@ function durableContext(input, context, envelope) {
         cancelled: (error) => error instanceof engine.CancelledError,
         exhausted: (error) => error instanceof StepExhausted,
         retryAfter: (delayMs, cause) => new StepRetryAfter(delayMs, cause),
-        awaitExecution: (target) => sequenced(`wait for Execution ${target.id}`, async () => {
-            for (let poll = 1;; poll++) {
-                // A poll is no Step of the author's: it has no budget, so an outage pauses the run instead.
-                const name = `await:${target.id}:${poll}`;
-                const polled = await journal(name, name, serving.step.timeoutMs, undefined, async ({ kernel }) => {
-                    try {
-                        const outcome = await kernel.execution.result(target, {
-                            waitMs: Math.min(AWAIT_WAIT_MS, Math.floor(serving.step.timeoutMs / 2)),
-                        });
-                        return { ended: true, outcome };
-                    }
-                    catch (cause) {
-                        if (cause instanceof ResponseError && cause.reason?.code === 'EXECUTION_PENDING') {
-                            return { ended: false };
-                        }
-                        throw cause;
-                    }
-                });
-                if (polled.ended)
-                    return polled.outcome;
-                await context.sleep(Math.min(AWAIT_MAXIMUM_PAUSE_MS, 1_000 * 2 ** Math.min(poll, 16)));
-            }
-        }),
         ...(execution.receiver === undefined ? {} : { self: execution.receiver }),
     });
 }

package/dist/execution/workflows/steps.d.ts

@@ -16,6 +16,8 @@ export interface StepAttempt {
 /** What one Step attempt holds, released once the attempt ends. */
 export interface StepAuthorityBinding {
     readonly authority: DurableStepAuthority;
+    /** Whether the attempt ran an `invoke` without a key, which the next attempt runs again. */
+    repeatsEffects(): boolean;
     close(): void;
 }
 /** Bind the capabilities one Step attempt holds. */
@@ -35,8 +37,12 @@ export declare function sessionSteps(input: {
  * replays the same keys: the Kernel answers a Mutation with its receipt and a durable call with the
  * Execution it started, or refuses a request that changed under its key. Any other `invoke` carries
  * no key, because the Kernel accepts one only for a durable Function, and runs again with the Step.
+ *
+ * A keyed call and a Query repeat no effect when sent again, so their failures are marked
+ * resendable: an unreachable Kernel then costs the Step no attempt. `unkeyed` hears each `invoke`
+ * without a key that may have run.
  */
-export declare function keyed<Session extends Pick<BoundClientSession, 'invoke' | 'mutate'>>(session: Session, domain: Domain, next: () => string): Session;
+export declare function keyed<Session extends Pick<BoundClientSession, 'invoke' | 'mutate'>>(session: Session, domain: Domain, next: () => string, unkeyed: () => void): Session;
 /** The key sequence of one Step of one Execution: `<execution>.<digest of the name>.<position>`. */
 export declare function keySequence(execution: DurableExecution['id'], name: string): Promise<() => string>;
 export {};

package/dist/execution/workflows/steps.js

@@ -1,6 +1,7 @@
 import { bindSession } from '../../platform/client/session/index.js';
 import { bindCapabilities } from '../invocation/capabilities/index.js';
 import { bindIntegrationAuthentication } from '../invocation/integration/index.js';
+import { resendableCall, unkeyedCall } from './attempts.js';
 import { stepCalls } from './integrations.js';
 /**
  * Steps acting as the Domain through a Session of the Execution they belong to: the capabilities of
@@ -12,13 +13,20 @@ export function sessionSteps(input) {
         const session = executor(execution.kernel, execution.id, lifetime);
         try {
             const bound = bindSession(session, lifetime);
-            const self = keyed(bound, domain, next);
+            let repeats = false;
+            const self = keyed(bound, domain, next, () => {
+                repeats = true;
+            });
             const auth = bindIntegrationAuthentication(lifetime, bound);
             const authority = Object.freeze({
                 ...bindCapabilities(domain, { self }),
                 integrations: integrations(stepCalls({ next, lifetime, auth })),
             });
-            return Object.freeze({ authority, close: () => session.close() });
+            return Object.freeze({
+                authority,
+                repeatsEffects: () => repeats,
+                close: () => session.close(),
+            });
         }
         catch (cause) {
             session.close();
@@ -32,13 +40,31 @@ export function sessionSteps(input) {
  * replays the same keys: the Kernel answers a Mutation with its receipt and a durable call with the
  * Execution it started, or refuses a request that changed under its key. Any other `invoke` carries
  * no key, because the Kernel accepts one only for a durable Function, and runs again with the Step.
+ *
+ * A keyed call and a Query repeat no effect when sent again, so their failures are marked
+ * resendable: an unreachable Kernel then costs the Step no attempt. `unkeyed` hears each `invoke`
+ * without a key that may have run.
  */
-export function keyed(session, domain, next) {
+export function keyed(session, domain, next, unkeyed) {
     const invokeSource = session.invoke;
     const mutateSource = session.mutate;
-    const invoke = ((reference, value, options) => invokeSource(reference, value, declaredDurable(domain, reference) ? withKey(options, next) : options));
-    const mutate = ((author, options) => mutateSource(author, withKey(options, next)));
-    return Object.freeze({ ...session, invoke, mutate });
+    const querySource = session.query;
+    const invoke = ((reference, value, options) => {
+        const sent = declaredDurable(domain, reference) ? withKey(options, next) : options;
+        const send = () => invokeSource(reference, value, sent);
+        return sent?.idempotencyKey === undefined ? unkeyedCall(send, unkeyed) : resendableCall(send);
+    });
+    const mutate = ((author, options) => {
+        const sent = withKey(options, next);
+        return sentKeyed(sent, () => mutateSource(author, sent));
+    });
+    const query = querySource === undefined
+        ? {}
+        : { query: (...input) => resendableCall(() => querySource(...input)) };
+    return Object.freeze({ ...session, invoke, mutate, ...query });
+}
+function sentKeyed(options, send) {
+    return options?.idempotencyKey === undefined ? send() : resendableCall(send);
 }
 /**
  * Whether the Domain's Schema closure declares the referenced callable durable. An untyped Path

package/dist/testing/durable/engine.d.ts

@@ -7,23 +7,25 @@ import type { NodeId } from '../../platform/graph/node/index.js';
 import type { CallableInputOf, ResolvedMethod, schema } from '../../platform/schema/index.js';
 import type { Value } from '../../platform/value/index.js';
 import type { TestStepCapabilities } from './steps.js';
-export interface TestEngineOptions {
+export interface TestWorkflowEngineOptions {
     /** Start of the virtual clock, in Unix milliseconds; the current time by default. */
     readonly now?: number;
     /**
-     * The deployment's `durable.retry`: the budget of every Step that declares none, 20 attempts by
-     * default, and with `maxAttempts` the attempts of a run failing outside any Step before it pauses.
+     * The deployment's `durable.retry`: the budget of every Step that declares none, and with
+     * `maxAttempts` the attempts of a run failing outside any Step before it pauses.
      */
     readonly retry?: DurableStepRetry;
 }
 /**
  * An in-memory workflow engine that runs durable Workflows with the receiver a Host serves: it
- * journals each Step, replays the journal on every attempt, retries a failed Step within its budget
- * and fails it once the budget is spent, keeps timers on a virtual clock, buffers signals, pauses a
- * run failing outside any Step after its last attempt and cancels cooperatively. A retry does not
- * wait out its backoff, but the backoff it skips counts toward the Step's `maxDurationMs`.
+ * journals each Step attempt, replays the journal on every attempt, keeps timers on a virtual clock,
+ * buffers signals, pauses a run failing outside any Step after its last attempt and cancels
+ * cooperatively. A Step retries as on a Host: a failure of its own code spends its budget, and a
+ * Kernel or a transport that is unavailable makes it wait without spending it. The wait after the
+ * Step's own failure is not waited out, but counts toward its `maxDurationMs`; a wait for the
+ * platform is a timer, which `advance` moves past.
  */
-export interface TestEngine {
+export interface TestWorkflowEngine {
     /** The virtual clock, in Unix milliseconds. */
     readonly now: number;
     /** Start one durable Execution and settle it: it ends, waits, or pauses. */
@@ -56,7 +58,7 @@ type ProvidersOf<Definitions extends Integrations> = keyof Definitions extends n
 } : {
     readonly providers: Providers<Definitions>;
 };
-/** One durable Execution on a test engine. */
+/** One durable Execution on a test workflow engine. */
 export interface TestExecution<Output> {
     readonly id: NodeId;
     readonly state: Extract<ExecutionState, 'running' | 'waiting' | 'paused' | 'completed' | 'failed' | 'cancelled'>;
@@ -96,12 +98,17 @@ export type TestJournalEntry = {
     readonly kind: 'run';
     readonly name: string;
     readonly settled: boolean;
-    /** Times the Step ran, retries and interruptions included; a replay runs it no more. */
+    /**
+     * Times this entry's work ran, interruptions included; a replay runs it no more. Each retry of
+     * a Step is an entry of its own, after the wait its failure prescribes.
+     */
     readonly attempts: number;
     readonly value?: unknown;
     readonly error?: unknown;
 } | {
     readonly kind: 'sleep';
+    /** The wait's name, if it has one: `retry:` or `unavailable:` and what it retries. */
+    readonly name?: string;
     readonly until: number;
     readonly settled: boolean;
 } | {
@@ -117,5 +124,5 @@ export type TestJournalEntry = {
     readonly outcome?: 'signal' | 'timeout' | 'cancelled';
 };
 /** Create an in-memory workflow engine for tests. */
-export declare function createTestEngine(options?: TestEngineOptions): TestEngine;
+export declare function createTestWorkflowEngine(options?: TestWorkflowEngineOptions): TestWorkflowEngine;
 export {};

package/dist/testing/durable/engine.js

@@ -12,6 +12,10 @@ const TEST_KERNEL = issuer.accept('https://kernel.test.astrale.invalid');
 const QUIET_TURNS = 64;
 /** Metadata the Kernel reads a declared failure from. */
 const FAILURE = 'astrale.failure';
+/** Metadata a failed Step attempt's journal entry records it under. */
+const ATTEMPT = 'astrale.attempt';
+/** Name prefix of the wait a Step's code failure prescribes before its next attempt. */
+const BACKOFF = 'retry:';
 class TerminalError extends Error {
     code;
     metadata;
@@ -59,10 +63,10 @@ class JournalMismatch extends Error {
         this.name = 'JournalMismatch';
     }
 }
-/** The promises the test engine's `run` returned: the only ones its combinator accepts. */
+/** The promises the test workflow engine's `run` returned: the only ones its combinator accepts. */
 const RUNS = new WeakSet();
 const ENGINE = Object.freeze({
-    createEndpointHandler: () => () => Promise.reject(new Error('A test engine serves no HTTP.')),
+    createEndpointHandler: () => () => Promise.reject(new Error('A test workflow engine serves no HTTP.')),
     workflow: (definition) => definition,
     TerminalError,
     CancelledError,
@@ -81,7 +85,7 @@ const ENGINE = Object.freeze({
     }),
 });
 /** Create an in-memory workflow engine for tests. */
-export function createTestEngine(options = {}) {
+export function createTestWorkflowEngine(options = {}) {
     const serving = durableServing({
         engine: ENGINE,
         ...(options.retry === undefined ? {} : { retry: options.retry }),
@@ -89,7 +93,7 @@ export function createTestEngine(options = {}) {
     const maxAttempts = serving.retryPolicy.maxAttempts;
     let now = options.now ?? Date.now();
     if (!Number.isFinite(now))
-        throw new TypeError('Test engine now must be finite.');
+        throw new TypeError('Test workflow engine now must be finite.');
     let sequence = 0;
     const runs = new Set();
     const clock = { now: () => now };
@@ -106,7 +110,7 @@ export function createTestEngine(options = {}) {
         },
         async advance(durationMs) {
             if (!Number.isSafeInteger(durationMs) || durationMs < 0) {
-                throw new TypeError('Test engine advance takes a non-negative integer of milliseconds.');
+                throw new TypeError('Test workflow engine advance takes a non-negative integer of milliseconds.');
             }
             now += durationMs;
             for (const run of runs)
@@ -126,6 +130,8 @@ class TestRun {
     signals = new Map();
     interruptions = new Set();
     cancellation = 'none';
+    /** The waits after a Step's own failures the run did not wait out, which its Steps still spent. */
+    skipped = 0;
     failures = 0;
     handlers;
     envelope;
@@ -145,6 +151,7 @@ class TestRun {
             workflow: admitted,
             domain,
             serving,
+            now: () => this.clock.now() + this.skipped,
             steps: testSteps({
                 domain,
                 capabilities: (input.capabilities ?? {}),
@@ -312,12 +319,12 @@ class Attempt {
         this.run = run;
         this.mode = mode;
         this.context = Object.freeze({
-            run: (name, action, options) => {
-                const run = this.journalRun(name, action, options);
+            run: (name, action) => {
+                const run = this.journalRun(name, action);
                 RUNS.add(run);
                 return run;
             },
-            sleep: (durationMs) => this.sleep(durationMs),
+            sleep: (durationMs, name) => this.sleep(durationMs, name ?? ''),
             promise: (name) => ({ get: () => this.promise(name) }),
             request: () => ({ attemptCompletedSignal: this.controller.signal }),
         });
@@ -389,11 +396,10 @@ class Attempt {
         return new Promise(() => { });
     }
     /**
-     * One journaled `run`. A failure within the budget of `options` ends the attempt before the
-     * Workflow sees it, as the engine retries the `run` with a fresh attempt; a spent budget settles
-     * the entry with a `TerminalError`. Without options, the failure reaches the Workflow.
+     * One journaled `run`. A `TerminalError` settles the entry; any other failure reaches the
+     * Workflow unjournaled, so the `run` runs again on the next attempt.
      */
-    journalRun(name, action, options) {
+    journalRun(name, action) {
         let entry;
         try {
             entry = this.take('run', name);
@@ -431,20 +437,14 @@ class Attempt {
                 if (cause instanceof TerminalError) {
                     entry.settled = true;
                     entry.error = cause;
+                    // A failed Step attempt keeps what it threw on the live error, which tests inspect.
+                    if (cause.metadata?.[ATTEMPT] !== undefined) {
+                        this.run.failure = cause.cause ?? cause;
+                    }
                     throw cause;
                 }
                 this.run.failure = cause;
-                if (options === undefined)
-                    throw cause;
-                if (spent(entry, options)) {
-                    entry.settled = true;
-                    entry.error = new TerminalError(cause?.message ?? String(cause));
-                    throw entry.error;
-                }
-                // An attempt takes time too: a zero delay still spends a duration budget, by a millisecond.
-                entry.waitedMs = (entry.waitedMs ?? 0) + Math.max(1, delayOf(entry, options, cause));
-                this.end({ kind: 'retried', error: cause });
-                return this.block();
+                throw cause;
             }
             finally {
                 this.active -= 1;
@@ -452,10 +452,15 @@ class Attempt {
             }
         })();
     }
-    sleep(durationMs) {
+    /**
+     * A durable timer on the virtual clock. The wait after a Step's own failure is not waited out: it
+     * settles at once and ends the attempt, as a timer that suspends the run does, and the time it
+     * skipped counts toward the Step's `maxDurationMs`.
+     */
+    sleep(durationMs, name) {
         let entry;
         try {
-            entry = this.take('sleep', '');
+            entry = this.take('sleep', name);
         }
         catch (cause) {
             return Promise.reject(cause);
@@ -463,6 +468,13 @@ class Attempt {
         entry.until ??= this.run.clock.now() + durationMs;
         if (entry.settled)
             return this.answer(entry);
+        if (this.mode === 'run' && name.startsWith(BACKOFF)) {
+            entry.settled = true;
+            // An attempt takes time too: a zero delay still spends a duration budget, by a millisecond.
+            this.run.skipped += Math.max(1, durationMs);
+            this.end({ kind: 'retried', error: this.run.failure });
+            return this.block();
+        }
         if (this.run.clock.now() >= entry.until) {
             if (this.mode === 'run')
                 entry.settled = true;
@@ -538,18 +550,6 @@ class Attempt {
         return Promise.resolve(value);
     }
 }
-/** Whether a Step that just failed spent its budget: its attempts, or the backoff it waited. */
-function spent(entry, options) {
-    return ((options.maxRetryAttempts !== undefined && (entry.attempts ?? 0) >= options.maxRetryAttempts) ||
-        (options.maxRetryDuration !== undefined && (entry.waitedMs ?? 0) >= options.maxRetryDuration));
-}
-/** The delay before a failed Step's next attempt: the one its failure prescribes, or its backoff. */
-function delayOf(entry, options, cause) {
-    if (cause instanceof RetryableError && cause.retryAfter !== undefined)
-        return cause.retryAfter;
-    const retries = (entry.attempts ?? 1) - 1;
-    return Math.min(options.maxRetryInterval, options.initialRetryInterval * options.retryIntervalFactor ** retries);
-}
 function outcomeOf(error) {
     const declared = error.metadata?.[FAILURE];
     if (declared !== undefined) {
@@ -584,7 +584,12 @@ function snapshot(entry) {
                 ...(entry.error === undefined ? {} : { error: entry.error }),
             });
         case 'sleep':
-            return Object.freeze({ kind: 'sleep', until: entry.until, settled: entry.settled });
+            return Object.freeze({
+                kind: 'sleep',
+                ...(entry.name === '' ? {} : { name: entry.name }),
+                until: entry.until,
+                settled: entry.settled,
+            });
         case 'signal':
             return Object.freeze({
                 kind: 'signal',

package/dist/testing/durable/index.d.ts

@@ -1,3 +1,3 @@
-export { createTestEngine } from './engine.js';
-export type { TestEngine, TestEngineOptions, TestExecution, TestJournalEntry, TestStartOptions, } from './engine.js';
+export { createTestWorkflowEngine } from './engine.js';
+export type { TestExecution, TestJournalEntry, TestStartOptions, TestWorkflowEngine, TestWorkflowEngineOptions, } from './engine.js';
 export type { TestStepCapabilities } from './steps.js';

package/dist/testing/durable/index.js

@@ -1 +1 @@
-export { createTestEngine } from './engine.js';
+export { createTestWorkflowEngine } from './engine.js';

package/dist/testing/durable/steps.js

@@ -1,17 +1,22 @@
 import { bindDependencies } from '../../execution/invocation/dependency/index.js';
+import { resendableCall } from '../../execution/workflows/attempts.js';
 import { stepCalls } from '../../execution/workflows/integrations.js';
 import { keyed } from '../../execution/workflows/steps.js';
 /** Bind each Step attempt of a test Execution to the test's capabilities, keyed as on a Host. */
 export function testSteps(input) {
     const { domain, capabilities, integrations } = input;
     return ({ next, lifetime }) => {
+        let repeats = false;
         const session = keyed({
             ...capabilities.kernel,
             invoke: capabilities.kernel?.invoke ?? absent('kernel.invoke'),
             mutate: capabilities.kernel?.mutate ?? absent('kernel.mutate'),
-        }, domain, next);
-        const query = (definition, value) => call(capabilities.query, 'query', (answer) => answer(definition, value));
-        const mutate = (definition, value) => call(capabilities.mutate, 'mutate', (answer) => answer(definition, value, Object.freeze({ idempotencyKey: next() })));
+        }, domain, next, () => {
+            repeats = true;
+        });
+        // A Query, and a Mutation under its key, repeat no effect when sent again, as on a Host.
+        const query = (definition, value) => resendableCall(() => call(capabilities.query, 'query', (answer) => answer(definition, value)));
+        const mutate = (definition, value) => resendableCall(() => call(capabilities.mutate, 'mutate', (answer) => answer(definition, value, Object.freeze({ idempotencyKey: next() }))));
         const graph = Object.freeze({ query, mutate });
         const auth = Object.freeze({
             mint: (request) => call(capabilities.kernel?.auth?.mint, 'kernel.auth.mint', (mint) => mint(request)),
@@ -24,7 +29,7 @@ export function testSteps(input) {
             mutate,
             integrations: integrations(stepCalls({ next, lifetime, auth })),
         });
-        return Object.freeze({ authority, close() { } });
+        return Object.freeze({ authority, repeatsEffects: () => repeats, close() { } });
     };
 }
 function call(answer, name, apply) {