@astrale-os/sdk 0.6.0-beta.37 → 0.6.0-beta.39

package/dist/execution/workflows/options.js

@@ -1,5 +1,32 @@
+/**
+ * The members of the Restate SDK Fetch entrypoint the durable receiver uses, which a platform's
+ * engine module must export.
+ */
+export const DURABLE_ENGINE_EXPORTS = Object.freeze([
+    'createEndpointHandler',
+    'workflow',
+    'TerminalError',
+    'CancelledError',
+    'RetryableError',
+    'TimeoutError',
+]);
 const HOUR_MS = 60 * 60_000;
 const DAY_MS = 24 * HOUR_MS;
+const DEFAULT_ATTEMPTS = 20;
+/** The longest attempt a Step may declare, which the engine's abort timeout leaves to end first. */
+const MAXIMUM_STEP_TIMEOUT_MS = 10 * 60_000;
+/**
+ * How long the engine lets an attempt run without progress before it aborts it, declared on every
+ * Workflow service. Restate's own default is ten minutes, which a ten-minute Step would race: the
+ * margin lets a Step's own timeout fail the attempt, and report it, before the engine cuts it.
+ */
+export const ENGINE_ABORT_TIMEOUT_MS = MAXIMUM_STEP_TIMEOUT_MS + 5 * 60_000;
+const DEFAULT_STEP_RETRY = Object.freeze({
+    maxRetryAttempts: DEFAULT_ATTEMPTS,
+    initialRetryInterval: 1_000,
+    maxRetryInterval: 60_000,
+    retryIntervalFactor: 2,
+});
 /** Capture one durable serving configuration, failing closed on any gap. */
 export function durableServing(input) {
     if (input === null ||
@@ -15,45 +42,81 @@ export function durableServing(input) {
     const engine = input.engine;
     if (engine === null ||
         typeof engine !== 'object' ||
-        typeof engine.createEndpointHandler !== 'function' ||
-        typeof engine.workflow !== 'function' ||
-        typeof engine.TerminalError !== 'function' ||
-        typeof engine.CancelledError !== 'function' ||
-        typeof engine.TimeoutError !== 'function') {
+        DURABLE_ENGINE_EXPORTS.some((member) => typeof engine[member] !== 'function')) {
         invalid('Durable serving requires the Restate SDK Fetch entrypoint of this platform.');
     }
     const fetch = input.fetch ?? globalThis.fetch.bind(globalThis);
     if (typeof fetch !== 'function')
         invalid('Durable serving requires Fetch for engine discovery.');
-    const retry = input.retry ?? {};
-    if (retry === null ||
-        typeof retry !== 'object' ||
-        Array.isArray(retry) ||
-        Reflect.ownKeys(retry).some((key) => key !== 'maxAttempts' && key !== 'initialIntervalMs' && key !== 'maxIntervalMs')) {
-        invalid('Durable retry options are invalid.');
-    }
-    const initialInterval = bounded(retry.initialIntervalMs, 1_000, 1, HOUR_MS, 'initialIntervalMs');
-    const maxInterval = bounded(retry.maxIntervalMs, 60_000, initialInterval, DAY_MS, 'maxIntervalMs');
+    const step = stepServing({ retry: input.retry, timeoutMs: input.stepTimeoutMs }, { retry: DEFAULT_STEP_RETRY, timeoutMs: 60_000 });
     return Object.freeze({
         engine: Object.freeze({
             createEndpointHandler: engine.createEndpointHandler.bind(engine),
             workflow: engine.workflow.bind(engine),
             TerminalError: engine.TerminalError,
             CancelledError: engine.CancelledError,
+            RetryableError: engine.RetryableError,
             TimeoutError: engine.TimeoutError,
         }),
         fetch,
         retentionMs: bounded(input.retentionMs, 7 * DAY_MS, HOUR_MS, 365 * DAY_MS, 'retentionMs'),
         retryPolicy: Object.freeze({
-            maxAttempts: bounded(retry.maxAttempts, 20, 1, 1_000, 'maxAttempts'),
+            maxAttempts: input.retry?.maxAttempts ?? DEFAULT_ATTEMPTS,
             onMaxAttempts: 'pause',
-            initialInterval,
-            maxInterval,
-            exponentiationFactor: 2,
+            initialInterval: step.retry.initialRetryInterval,
+            maxInterval: step.retry.maxRetryInterval,
+            exponentiationFactor: step.retry.retryIntervalFactor,
         }),
-        stepTimeoutMs: bounded(input.stepTimeoutMs, 60_000, 1_000, HOUR_MS, 'stepTimeoutMs'),
+        step,
     });
 }
+/**
+ * What one Step is held to: the retry budget and timeout it declares, in place of `fallback`'s. A
+ * declared limit replaces both limits of the fallback; an undeclared interval keeps the fallback's.
+ */
+export function stepServing(declared, fallback) {
+    const retry = declared.retry;
+    if (retry === undefined) {
+        return Object.freeze({
+            retry: fallback.retry,
+            timeoutMs: stepTimeout(declared.timeoutMs, fallback.timeoutMs),
+        });
+    }
+    if (retry === null ||
+        typeof retry !== 'object' ||
+        Array.isArray(retry) ||
+        Reflect.ownKeys(retry).some((key) => key !== 'maxAttempts' &&
+            key !== 'maxDurationMs' &&
+            key !== 'initialIntervalMs' &&
+            key !== 'maxIntervalMs')) {
+        invalid('Durable retry options are invalid.');
+    }
+    const limited = retry.maxAttempts !== undefined || retry.maxDurationMs !== undefined;
+    const maxAttempts = limited
+        ? optionalBounded(retry.maxAttempts, 1, 1_000, 'maxAttempts')
+        : fallback.retry.maxRetryAttempts;
+    const maxDuration = limited
+        ? optionalBounded(retry.maxDurationMs, 1, 365 * DAY_MS, 'maxDurationMs')
+        : fallback.retry.maxRetryDuration;
+    const initialInterval = bounded(retry.initialIntervalMs, fallback.retry.initialRetryInterval, 1, HOUR_MS, 'initialIntervalMs');
+    const maxInterval = bounded(retry.maxIntervalMs, Math.max(fallback.retry.maxRetryInterval, initialInterval), initialInterval, DAY_MS, 'maxIntervalMs');
+    return Object.freeze({
+        retry: Object.freeze({
+            ...(maxAttempts === undefined ? {} : { maxRetryAttempts: maxAttempts }),
+            ...(maxDuration === undefined ? {} : { maxRetryDuration: maxDuration }),
+            initialRetryInterval: initialInterval,
+            maxRetryInterval: maxInterval,
+            retryIntervalFactor: fallback.retry.retryIntervalFactor,
+        }),
+        timeoutMs: stepTimeout(declared.timeoutMs, fallback.timeoutMs),
+    });
+}
+function stepTimeout(input, fallback) {
+    return bounded(input, fallback, 1_000, MAXIMUM_STEP_TIMEOUT_MS, 'Step timeout');
+}
+function optionalBounded(input, minimum, maximum, label) {
+    return input === undefined ? undefined : bounded(input, minimum, minimum, maximum, label);
+}
 function bounded(input, fallback, minimum, maximum, label) {
     if (input === undefined)
         return fallback;

package/dist/execution/workflows/receiver.js

@@ -1,4 +1,5 @@
 import { workflowEngineDiscovery, WorkflowEngineUnavailable } from './discovery.js';
+import { ENGINE_ABORT_TIMEOUT_MS } from './options.js';
 import { durableRoute } from './route.js';
 import { durableHandlers } from './run.js';
 import { sessionSteps } from './steps.js';
@@ -60,6 +61,7 @@ export function createDurableReceiver(input) {
                     options: {
                         workflowRetention: input.serving.retentionMs,
                         retryPolicy: input.serving.retryPolicy,
+                        abortTimeout: ENGINE_ABORT_TIMEOUT_MS,
                     },
                 });
                 try {

package/dist/execution/workflows/run.js

@@ -4,10 +4,9 @@ import { acceptStepOutput } from '../../application/workflow/step/output.js';
 import { ResponseError } from '../../platform/client/index.js';
 import { validateOutput } from '../invocation/result/index.js';
 import { decodeEnvelope } from './envelope.js';
-import { replayedFailure, terminalFailure } from './failure.js';
+import { delayedRetry, replayedFailure, StepExhausted, StepRetryAfter, attemptFailure, terminalFailure, } from './failure.js';
+import { stepServing } from './options.js';
 import { keySequence } from './steps.js';
-/** Token of a Workflow that declares none. */
-const DEFAULT_COMPAT = '0';
 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. */
@@ -37,15 +36,9 @@ async function run(input, context, raw) {
     const { workflow, serving } = input;
     const { engine } = serving;
     const definition = workflow.definition;
-    // Journaled first. A redeployment that changed the token cannot replay this run: it fails every
-    // attempt with this reason until the engine pauses it, then `resume` on compatible code or cancel.
-    const token = definition.compat ?? DEFAULT_COMPAT;
-    const recorded = await context.run('compat', async () => token);
-    if (recorded !== token) {
-        throw new Error(`Workflow ${workflow.address} started under compat token ${JSON.stringify(recorded)}; ` +
-            `this deployment declares ${JSON.stringify(token)}.`);
-    }
-    // Code that cannot read what the Kernel recorded pauses the run the same way.
+    // A run replays the code of the release that started it, each release at its own URL. Code
+    // served in place of it replays the journal: the engine refuses a journal whose Steps no longer
+    // match, and code that cannot read what the Kernel recorded fails every attempt; both pause.
     const envelope = admitted(workflow, raw, input.kernel);
     const durable = durableContext(input, context, envelope);
     let output;
@@ -82,13 +75,25 @@ function durableContext(input, context, envelope) {
     /**
      * 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.
      */
-    const journal = (name, execute) => Promise.resolve(context.run(name, async () => {
-        const lifetime = { deadline: Date.now() + serving.stepTimeoutMs, signal };
-        const next = await keySequence(execution.id, name);
-        const step = input.steps({ name, execution, next, lifetime });
+    const journal = (id, name, timeoutMs, retry, execute) => Promise.resolve(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 output = await execute(step.authority);
+            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);
             }
@@ -97,26 +102,30 @@ function durableContext(input, context, envelope) {
             }
         }
         catch (cause) {
-            throw terminalFailure(engine, cause, definition) ?? cause;
+            throw (terminalFailure(engine, cause, definition) ??
+                delayedRetry(engine, cause) ??
+                attemptFailure(cause));
         }
         finally {
-            step.close();
+            clearTimeout(timer);
+            step?.close();
         }
-    })).catch((cause) => {
-        throw replayedFailure(engine, cause, definition) ?? cause;
+    }, retry)).catch((cause) => {
+        throw replayedFailure(engine, cause, definition, id) ?? cause;
     });
-    const step = (id, execute) => {
+    const step = (declared, execute) => {
         let accepted;
         try {
-            accepted = acceptStepId(id);
-            if (steps.has(accepted))
-                throw new TypeError(`Workflow Step ${accepted} occurs more than once.`);
+            accepted = stepDeclaration(declared, serving.step);
+            if (steps.has(accepted.id))
+                throw new TypeError(`Workflow Step ${accepted.id} occurs more than once.`);
         }
         catch (cause) {
             return Promise.reject(cause);
         }
-        steps.add(accepted);
-        return journal(`step:${accepted}`, execute);
+        steps.add(accepted.id);
+        const { held } = accepted;
+        return journal(accepted.id, `step:${accepted.id}`, held.timeoutMs, held.retry, execute);
     };
     return Object.freeze({
         domain,
@@ -156,12 +165,16 @@ function durableContext(input, context, envelope) {
             }
         },
         cancelled: (error) => error instanceof engine.CancelledError,
+        exhausted: (error) => error instanceof StepExhausted,
+        retryAfter: (delayMs, cause) => new StepRetryAfter(delayMs, cause),
         async awaitExecution(target) {
             for (let poll = 1;; poll++) {
-                const polled = await journal(`await:${target.id}:${poll}`, async ({ kernel }) => {
+                // 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.stepTimeoutMs / 2)),
+                            waitMs: Math.min(AWAIT_WAIT_MS, Math.floor(serving.step.timeoutMs / 2)),
                         });
                         return { ended: true, outcome };
                     }
@@ -180,6 +193,33 @@ function durableContext(input, context, envelope) {
         ...(execution.receiver === undefined ? {} : { self: execution.receiver }),
     });
 }
+/** Admit a Step's id, and its declared retry budget and timeout over the deployment's. */
+function stepDeclaration(declared, fallback) {
+    if (typeof declared === 'string')
+        return { id: acceptStepId(declared), held: fallback };
+    if (declared === null ||
+        typeof declared !== 'object' ||
+        Array.isArray(declared) ||
+        Reflect.ownKeys(declared).some((key) => key !== 'id' && key !== 'retry' && key !== 'timeoutMs')) {
+        throw new TypeError('A Workflow Step declaration takes only id, retry and timeoutMs.');
+    }
+    return {
+        id: acceptStepId(declared.id),
+        held: stepServing({ retry: declared.retry, timeoutMs: declared.timeoutMs }, fallback),
+    };
+}
+/**
+ * Rejects with the abort reason once `signal` aborts, at once if it already has: a timeout may fire
+ * while the attempt derives its keys. Never settles otherwise.
+ */
+function expired(signal) {
+    return new Promise((_, reject) => {
+        if (signal.aborted)
+            reject(signal.reason);
+        else
+            signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+    });
+}
 function signalRequest(input) {
     if (input === null ||
         typeof input !== 'object' ||

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

@@ -1,7 +1,7 @@
 import type { ActionOutputOf, ResolvedDomainOf } from '../../application/action/index.js';
 import type { DeclaredErrors } from '../../application/error/index.js';
 import type { Integrations, Providers } from '../../application/integration/index.js';
-import type { CallableAtWorkflowAddress, WorkflowAddress, WorkflowDefinition } from '../../application/workflow/index.js';
+import type { CallableAtWorkflowAddress, DurableStepRetry, WorkflowAddress, WorkflowDefinition } from '../../application/workflow/index.js';
 import type { ExecutionOutcome, ExecutionState } from '../../platform/client/session/index.js';
 import type { NodeId } from '../../platform/graph/node/index.js';
 import type { CallableInputOf, ResolvedMethod, schema } from '../../platform/schema/index.js';
@@ -10,13 +10,18 @@ import type { TestStepCapabilities } from './steps.js';
 export interface TestEngineOptions {
     /** Start of the virtual clock, in Unix milliseconds; the current time by default. */
     readonly now?: number;
-    /** Attempts of a run before it pauses; 20 by default, as on a Host. */
-    readonly maxAttempts?: 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.
+     */
+    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 failed attempts, keeps timers
- * on a virtual clock, buffers signals, pauses after the last attempt and cancels cooperatively.
+ * 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`.
  */
 export interface TestEngine {
     /** The virtual clock, in Unix milliseconds. */
@@ -57,7 +62,10 @@ export interface TestExecution<Output> {
     readonly state: Extract<ExecutionState, 'running' | 'waiting' | 'paused' | 'completed' | 'failed' | 'cancelled'>;
     /** Present once the Execution ended, as `Execution.result` answers it. */
     readonly outcome: ExecutionOutcome<Output> | undefined;
-    /** What the last failed attempt threw; it is why a paused Execution paused. */
+    /**
+     * What the last failed attempt threw: why a paused Execution paused, or what the last attempt of
+     * an exhausted Step threw, which its `STEP_EXHAUSTED` outcome does not carry.
+     */
     readonly failure: unknown;
     /** Attempts made so far, replays included. */
     readonly attempts: number;
@@ -88,6 +96,8 @@ 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. */
+    readonly attempts: number;
     readonly value?: unknown;
     readonly error?: unknown;
 } | {

package/dist/testing/durable/engine.js

@@ -8,8 +8,6 @@ import { NodeId as nodeId } from '../../platform/graph/node/index.js';
 import { testSteps } from './steps.js';
 /** Kernel every test Execution names; Steps never reach it. */
 const TEST_KERNEL = issuer.accept('https://kernel.test.astrale.invalid');
-/** Attempts before a run pauses, as on a Host. */
-const DEFAULT_MAXIMUM_ATTEMPTS = 20;
 /** Microtask turns without progress after which a blocked attempt counts as suspended. */
 const QUIET_TURNS = 64;
 /** Metadata the Kernel reads a declared failure from. */
@@ -37,6 +35,15 @@ class TimeoutError extends TerminalError {
         this.name = 'TimeoutError';
     }
 }
+class RetryableError extends Error {
+    retryAfter;
+    constructor(message, options) {
+        super(message, options?.cause === undefined ? undefined : { cause: options.cause });
+        this.name = 'RetryableError';
+        if (options?.retryAfter !== undefined)
+            this.retryAfter = options.retryAfter;
+    }
+}
 /** The attempt lost its Step result on purpose; the engine retries it. */
 class Interruption extends Error {
     constructor(step) {
@@ -57,14 +64,16 @@ const ENGINE = Object.freeze({
     workflow: (definition) => definition,
     TerminalError,
     CancelledError,
+    RetryableError,
     TimeoutError,
 });
 /** Create an in-memory workflow engine for tests. */
 export function createTestEngine(options = {}) {
-    const maxAttempts = options.maxAttempts ?? DEFAULT_MAXIMUM_ATTEMPTS;
-    if (!Number.isSafeInteger(maxAttempts) || maxAttempts < 1) {
-        throw new TypeError('Test engine maxAttempts must be a positive integer.');
-    }
+    const serving = durableServing({
+        engine: ENGINE,
+        ...(options.retry === undefined ? {} : { retry: options.retry }),
+    });
+    const maxAttempts = serving.retryPolicy.maxAttempts;
     let now = options.now ?? Date.now();
     if (!Number.isFinite(now))
         throw new TypeError('Test engine now must be finite.');
@@ -77,7 +86,7 @@ export function createTestEngine(options = {}) {
         },
         async start(workflow, input) {
             sequence += 1;
-            const run = new TestRun(workflow, input, clock, maxAttempts, sequence);
+            const run = new TestRun(workflow, input, clock, serving, maxAttempts, sequence);
             runs.add(run);
             await run.settle();
             return run.execution;
@@ -108,7 +117,7 @@ class TestRun {
     handlers;
     envelope;
     execution;
-    constructor(workflow, input, clock, maxAttempts, sequence) {
+    constructor(workflow, input, clock, serving, maxAttempts, sequence) {
         this.clock = clock;
         this.maxAttempts = maxAttempts;
         const domain = input.schema;
@@ -122,7 +131,7 @@ class TestRun {
             kernel: TEST_KERNEL,
             workflow: admitted,
             domain,
-            serving: durableServing({ engine: ENGINE }),
+            serving,
             steps: testSteps({
                 domain,
                 capabilities: (input.capabilities ?? {}),
@@ -158,6 +167,10 @@ class TestRun {
                 this.end({ kind: 'completed', value: attempted.value });
                 return;
             }
+            if (attempted.kind === 'retried') {
+                this.failure = attempted.error;
+                continue;
+            }
             const { error } = attempted;
             if (error instanceof TerminalError) {
                 this.end(outcomeOf(error));
@@ -186,7 +199,7 @@ class TestRun {
             .then(() => this.handlers.run(attempt.context, this.envelope))
             .then((value) => ({ kind: 'completed', value }), (error) => ({ kind: 'failed', error }))
             .finally(() => attempt.finish());
-        return Promise.race([running, attempt.suspended()]).finally(() => attempt.finish());
+        return Promise.race([running, attempt.suspended(), attempt.ended]).finally(() => attempt.finish());
     }
     async signal(name, value) {
         if (this.ended)
@@ -276,12 +289,17 @@ class Attempt {
     progress = 0;
     done = false;
     controller = new AbortController();
+    end;
+    /** Settles when a Step ends the attempt without reaching the Workflow, as a retry or a crash. */
+    ended = new Promise((resolve) => {
+        this.end = resolve;
+    });
     context;
     constructor(run, mode) {
         this.run = run;
         this.mode = mode;
         this.context = Object.freeze({
-            run: (name, action) => this.journalRun(name, action),
+            run: (name, action, options) => this.journalRun(name, action, options),
             sleep: (durationMs) => this.sleep(durationMs),
             promise: (name) => ({ get: () => this.promise(name) }),
             request: () => ({ attemptCompletedSignal: this.controller.signal }),
@@ -353,7 +371,12 @@ class Attempt {
         this.progress += 1;
         return new Promise(() => { });
     }
-    journalRun(name, action) {
+    /**
+     * 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.
+     */
+    journalRun(name, action, options) {
         let entry;
         try {
             entry = this.take('run', name);
@@ -369,11 +392,15 @@ class Attempt {
             return Promise.reject(new JournalMismatch(this.cursor - 1, 'a pending entry', `${name} to run again`));
         }
         this.active += 1;
+        entry.attempts = (entry.attempts ?? 0) + 1;
         return (async () => {
             try {
                 const value = await action();
-                if (this.run.interruptions.delete(name))
-                    throw new Interruption(name.replace(/^step:/u, ''));
+                if (this.run.interruptions.delete(name)) {
+                    // A crash after the effect: the run is attempted again, and the Step with it.
+                    this.end({ kind: 'failed', error: new Interruption(name.replace(/^step:/u, '')) });
+                    return this.block();
+                }
                 entry.settled = true;
                 entry.value = value;
                 return value;
@@ -382,8 +409,20 @@ class Attempt {
                 if (cause instanceof TerminalError) {
                     entry.settled = true;
                     entry.error = cause;
+                    throw 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();
             }
             finally {
                 this.active -= 1;
@@ -477,6 +516,18 @@ 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) {
@@ -506,6 +557,7 @@ function snapshot(entry) {
                 kind: 'run',
                 name: entry.name,
                 settled: entry.settled,
+                attempts: entry.attempts ?? 0,
                 ...(entry.settled && entry.error === undefined ? { value: entry.value } : {}),
                 ...(entry.error === undefined ? {} : { error: entry.error }),
             });

package/dist/tooling/linter/implementations/source/dependencies.js

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import { propertyChain, resolveImportedSymbol, unwrap, visit, } from '../../adapters/typescript/index.js';
 import { domainFunctionRequirements, callableReference, callableSelector, declaredDomainDependencies, remoteCallableKey, } from './callable-requirements.js';
-import { ambiguity, calls, isForeignDomain, production, violation } from './shared.js';
+import { ambiguity, calls, contextPath, isForeignDomain, production, violation } from './shared.js';
 export const dependencyRules = [
     {
         id: 'FNC-XDOM-DECLARED',
@@ -158,75 +158,3 @@ function selectedCallable(input) {
     const chain = expression && propertyChain(expression);
     return chain && chain[0] === parameter.text ? chain.slice(1) : undefined;
 }
-/** Resolve handler context bindings and one immutable local alias without following arbitrary helpers. */
-function contextPath(input, run, aliases = 1) {
-    const expression = unwrap(input);
-    if (ts.isPropertyAccessExpression(expression)) {
-        const base = contextPath(expression.expression, run, aliases);
-        return base && [...base, expression.name.text];
-    }
-    if (ts.isElementAccessExpression(expression)) {
-        const base = contextPath(expression.expression, run, aliases);
-        return base && [...base, '[computed]'];
-    }
-    if (!ts.isIdentifier(expression))
-        return undefined;
-    let current = expression.parent;
-    while (current) {
-        if (ts.isFunctionLike(current)) {
-            for (const parameter of current.parameters) {
-                const path = bindingPath(parameter.name, expression.text);
-                if (path)
-                    return parameter === current.parameters[0] &&
-                        (current === run || stepCallback(current, run))
-                        ? path
-                        : undefined;
-            }
-        }
-        if (ts.isBlock(current) || ts.isSourceFile(current)) {
-            for (const statement of current.statements) {
-                if (ts.isFunctionDeclaration(statement) && statement.name?.text === expression.text)
-                    return undefined;
-                if (!ts.isVariableStatement(statement))
-                    continue;
-                for (const declaration of statement.declarationList.declarations) {
-                    const path = bindingPath(declaration.name, expression.text);
-                    if (!path)
-                        continue;
-                    if (aliases === 0 ||
-                        !declaration.initializer ||
-                        declaration.end > expression.pos ||
-                        !(statement.declarationList.flags & ts.NodeFlags.Const))
-                        return undefined;
-                    const base = contextPath(declaration.initializer, run, aliases - 1);
-                    return base && [...base, ...path];
-                }
-            }
-        }
-        current = current.parent;
-    }
-    return undefined;
-}
-/** A durable Step callback receives the handler's capabilities under the same names. */
-function stepCallback(callback, run) {
-    const call = callback.parent;
-    if (!ts.isCallExpression(call) || call.arguments[1] !== callback)
-        return false;
-    const callee = contextPath(call.expression, run, 0);
-    return callee?.length === 2 && callee[0] === 'step' && callee[1] === 'run';
-}
-function bindingPath(name, identifier) {
-    if (ts.isIdentifier(name))
-        return name.text === identifier ? [] : undefined;
-    if (!ts.isObjectBindingPattern(name))
-        return undefined;
-    for (const element of name.elements) {
-        if (element.dotDotDotToken)
-            continue;
-        const nested = bindingPath(element.name, identifier);
-        const property = element.propertyName ?? (ts.isIdentifier(element.name) ? element.name : undefined);
-        if (nested && property && (ts.isIdentifier(property) || ts.isStringLiteral(property)))
-            return [property.text, ...nested];
-    }
-    return undefined;
-}

package/dist/tooling/linter/implementations/source/shared.d.ts

@@ -36,5 +36,12 @@ export declare function hasForbiddenGlobalCall(file: SourceFile): Array<{
     node: ts.Node;
     name: string;
 }>;
+/** The global a call reaches, as `name(…)` with no import or local binding, or `globalThis.name(…)`. */
+export declare function globalCallName(file: SourceFile, node: ts.CallExpression): string | undefined;
+/**
+ * Resolve the path of `input` from the first parameter of `run`, or of a durable Step callback in
+ * it, through one immutable local alias, without following arbitrary helpers.
+ */
+export declare function contextPath(input: ts.Expression, run: ts.FunctionLikeDeclaration, aliases?: number): readonly string[] | undefined;
 export declare function isLocallyBoundIdentifier(node: ts.Identifier): boolean;
 export declare function forbiddenIoImport(specifier: string): boolean;