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

package/dist/application/runtime/workflows.js

@@ -20,9 +20,6 @@ export function admitWorkflows(callables, input) {
             throw new TypeError(`Runtime Workflow ${definition.address} must have value output.`);
         }
         const durable = callable.execution?.durable === true;
-        if (!durable && definition.compat !== undefined) {
-            throw new TypeError(`Runtime Workflow ${definition.address} declares compat but its callable is not durable.`);
-        }
         return Object.freeze({
             kind: 'workflow',
             address: definition.address,

package/dist/application/workflow/authoring.d.ts

@@ -1,5 +1,5 @@
 export { defineWorkflow } from './define.js';
 export type { InlineWorkflowContext, WorkflowContext } from './context.js';
-export type { DurableCallable, DurableExecution, DurableStep, DurableStepAuthority, DurableWorkflowContext, SignalOutcome, } from './durable.js';
+export type { DurableCallable, DurableExecution, DurableStep, DurableStepAuthority, DurableStepDeclaration, DurableStepId, DurableStepRetry, DurableWorkflowContext, SignalOutcome, } from './durable.js';
 export type { Workflow, WorkflowAddress, WorkflowDefinition, WorkflowOptions } from './workflow.js';
 export type { DeclaredErrorDefinition, DeclaredErrorFactory, DeclaredErrorFamily, DeclaredErrorOptions, DeclaredErrors, } from '../error/index.js';

package/dist/application/workflow/define.js

@@ -1,7 +1,6 @@
 import { patterns } from '@astrale-os/kernel-dsl/v1/addressing';
 import { rememberDeclaredErrors } from '../error/index.js';
 const admittedWorkflows = new WeakSet();
-const COMPAT_TOKEN = /^[A-Za-z0-9._~-]{1,64}$/u;
 /** Define one multi-step value-output implementation by its SDK Action address. */
 export function defineWorkflow() {
     return function define(address, optionsOrRun, possibleRun) {
@@ -10,12 +9,7 @@ export function defineWorkflow() {
         const run = possibleRun ?? optionsOrRun;
         if (typeof run !== 'function')
             throw new TypeError('Workflow run must be a function.');
-        const workflow = Object.freeze({
-            kind: 'workflow',
-            address,
-            run,
-            ...(options?.compat === undefined ? {} : { compat: options.compat }),
-        });
+        const workflow = Object.freeze({ kind: 'workflow', address, run });
         if (options?.errors !== undefined)
             rememberDeclaredErrors(workflow, { errors: options.errors });
         admittedWorkflows.add(workflow);
@@ -26,15 +20,10 @@ function acceptOptions(input) {
     if (input === null ||
         typeof input !== 'object' ||
         Array.isArray(input) ||
-        Reflect.ownKeys(input).some((key) => key !== 'errors' && key !== 'compat')) {
-        throw new TypeError('Workflow options accept only errors and compat.');
+        Reflect.ownKeys(input).some((key) => key !== 'errors')) {
+        throw new TypeError('Workflow options accept only errors.');
     }
-    const options = input;
-    if (options.compat !== undefined &&
-        (typeof options.compat !== 'string' || !COMPAT_TOKEN.test(options.compat))) {
-        throw new TypeError(`Invalid Workflow compat token: ${JSON.stringify(options.compat)}.`);
-    }
-    return options;
+    return input;
 }
 export function isWorkflow(input) {
     return input !== null && typeof input === 'object' && admittedWorkflows.has(input);

package/dist/application/workflow/durable.d.ts

@@ -61,24 +61,55 @@ export interface DurableStepAuthority<DomainValue extends Domain = Domain, Defin
      */
     readonly integrations: ReplayableIntegrationClients<Definitions>;
 }
+/**
+ * How long a failing Step is retried. Its limits, `maxAttempts` and `maxDurationMs`, go together: a
+ * Step that declares either replaces both limits of the deployment, and the one it omits does not
+ * bound it. The budget is spent at the first limit reached.
+ */
+export interface DurableStepRetry {
+    /** Attempts, the first one included: 1 to 1,000. */
+    readonly maxAttempts?: number;
+    /**
+     * Time from the first attempt after which a failed attempt is not retried, 1 ms to 365 days; an
+     * attempt already scheduled, such as after a long prescribed delay, still runs.
+     */
+    readonly maxDurationMs?: number;
+    /** Delay before the first retry, doubled on each failure: 1 ms to one hour. */
+    readonly initialIntervalMs?: number;
+    /** Longest delay between two attempts: `initialIntervalMs` to one day. */
+    readonly maxIntervalMs?: number;
+}
+/** A Step: its id, and the retry budget and timeout it declares instead of the deployment's. */
+export interface DurableStepDeclaration {
+    readonly id: string;
+    readonly retry?: DurableStepRetry;
+    /** Deadline of one attempt, including its Kernel calls: one second to ten minutes. */
+    readonly timeoutMs?: number;
+}
+/**
+ * A Step's id alone, under the deployment's retry budget and Step timeout, or a declaration of its
+ * own. A Step that spends its budget throws an error `exhausted` recognizes; uncaught, the Execution
+ * ends `failed` with code `STEP_EXHAUSTED`.
+ */
+export type DurableStepId = string | DurableStepDeclaration;
 export interface DurableStep<DomainValue extends Domain = Domain, Definitions extends Integrations = Readonly<Record<never, never>>> {
     /**
      * Run `execute` once and journal its portable output; a replay returns the journaled output. A
      * Step may run again when its outcome was not journaled: its Mutations, durable calls and keyed
      * Integration operations are answered from their keys, and any other effect must be idempotent.
      */
-    run<Output>(id: string, execute: (authority: DurableStepAuthority<DomainValue, Definitions>) => Output | Promise<Output>): Promise<Output>;
+    run<Output>(step: DurableStepId, execute: (authority: DurableStepAuthority<DomainValue, Definitions>) => Output | Promise<Output>): Promise<Output>;
     /**
      * One journaled Query. A replay returns the result of its first run, so a later Step that depends
      * on it resends the same request whenever it is retried.
      */
-    query<Output>(id: string, query: QueryDefinition<DomainValue, void, Output>): Promise<Output>;
-    query<Input, Output>(id: string, query: QueryDefinition<DomainValue, Input, Output>, input: Input): Promise<Output>;
+    query<Output>(step: DurableStepId, query: QueryDefinition<DomainValue, void, Output>): Promise<Output>;
+    query<Input, Output>(step: DurableStepId, query: QueryDefinition<DomainValue, Input, Output>, input: Input): Promise<Output>;
     /**
      * One journaled Mutation. A Step replayed after its commit receives the result of that commit
      * from the Kernel's receipt instead of writing again.
      */
-    mutate<Input, Output>(id: string, mutation: Mutation<DomainValue, Input, Output>, input: Input): Promise<Output>;
+    mutate<Input, Output>(step: DurableStepId, mutation: Mutation<DomainValue, Input, Output>, input: Input): Promise<Output>;
 }
 type DurableSelfOf<Callable> = Callable extends ResolvedMethod<unknown, unknown, false> ? {
     readonly self: NodeId;
@@ -116,6 +147,14 @@ export type DurableWorkflowContext<Callable, DomainValue extends Domain = Domain
     }): Promise<SignalOutcome<Signal>>;
     /** Whether `error` is the engine's cooperative cancellation, which the Workflow may compensate. */
     cancelled(error: unknown): boolean;
+    /** Whether `error` is a Step that spent its retry budget, which the Workflow may handle. */
+    exhausted(error: unknown): boolean;
+    /**
+     * The failure of a Step attempt, to throw inside the Step, that the engine attempts again no
+     * earlier than `delayMs` (at most one hour), as an HTTP `Retry-After` asks. The attempt counts
+     * toward the Step's budget. A Kernel refusal that prescribes a delay is retried this way already.
+     */
+    retryAfter(delayMs: number, cause?: unknown): Error;
     /** Wait durably for another Execution to end, by journaled polling of its `result`. */
     awaitExecution<Output>(execution: ExecutionRef<Output>): Promise<ExecutionOutcome<Output>>;
 } & DurableSelfOf<Callable>;

package/dist/application/workflow/index.d.ts

@@ -1,6 +1,6 @@
 export { defineWorkflow, isWorkflow } from './define.js';
 export type { InlineWorkflowContext, WorkflowContext } from './context.js';
-export type { DurableCallable, DurableExecution, DurableStep, DurableStepAuthority, DurableWorkflowContext, SignalOutcome, } from './durable.js';
+export type { DurableCallable, DurableExecution, DurableStep, DurableStepAuthority, DurableStepDeclaration, DurableStepId, DurableStepRetry, DurableWorkflowContext, SignalOutcome, } from './durable.js';
 export type { CallableAtWorkflowAddress, Workflow, WorkflowAddress, WorkflowCallable, WorkflowDefinition, WorkflowOptions, } from './workflow.js';
 export * as step from './step/index.js';
 export * as runner from './runner/index.js';

package/dist/application/workflow/workflow.d.ts

@@ -13,20 +13,12 @@ declare const WORKFLOW_SCHEMA: unique symbol;
 /** Options of one Workflow implementation. */
 export interface WorkflowOptions<out Errors extends DeclaredErrors = DeclaredErrors> {
     readonly errors?: Errors;
-    /**
-     * Durable only. Compatibility token journaled first by every run: keep it while a redeployment
-     * can replay the journals of running Executions, change it when it cannot, and those runs pause
-     * until they are resumed on compatible code or cancelled.
-     */
-    readonly compat?: string;
 }
 /** Sealed multi-step Workflow awaiting canonical callable association by Runtime admission. */
 export interface WorkflowDefinition<Schema extends schema.DomainSchema = schema.DomainSchema, Address extends WorkflowAddress<Schema> = WorkflowAddress<Schema>, Definitions extends Integrations = Readonly<Record<never, never>>, Errors extends DeclaredErrors = NoDeclaredErrors> {
     readonly kind: 'workflow';
     readonly address: Address;
     readonly run: Workflow<CallableAtWorkflowAddress<Schema, Address>, Definitions, ResolvedDomainOf<Schema>, Errors>;
-    /** Durable compatibility token; absent means the default token. */
-    readonly compat?: string;
     /** Invariant type-only Schema witness; absent from emitted JavaScript. */
     readonly [WORKFLOW_SCHEMA]: (schema: Schema) => Schema;
 }

package/dist/deployment/address/configuration.d.ts

@@ -67,6 +67,7 @@ export interface FrozenDurableOptions {
     readonly retry?: {
         readonly initialIntervalMs?: number;
         readonly maxAttempts?: number;
+        readonly maxDurationMs?: number;
         readonly maxIntervalMs?: number;
     };
     readonly stepTimeoutMs?: number;

package/dist/deployment/address/configuration.js

@@ -195,11 +195,12 @@ function durableOptionsOf(input) {
     const options = input;
     let retry;
     if (Object.hasOwn(options, 'retry')) {
-        exact(options.retry, [], ['initialIntervalMs', 'maxAttempts', 'maxIntervalMs']);
+        exact(options.retry, [], ['initialIntervalMs', 'maxAttempts', 'maxDurationMs', 'maxIntervalMs']);
         const value = options.retry;
         retry = Object.freeze({
             ...optional(value, 'initialIntervalMs'),
             ...optional(value, 'maxAttempts'),
+            ...optional(value, 'maxDurationMs'),
             ...optional(value, 'maxIntervalMs'),
         });
     }

package/dist/execution/index.d.ts

@@ -3,4 +3,5 @@ export type { ExecutionContext, ServedDomain, ServeInput } from './serve.js';
 export { DEFAULT_MEMORY_CACHE_ENTRIES, memoryCache, type DeploymentCache, type MemoryCacheOptions, } from './cache/index.js';
 export { createIdentity, maximumExchangeTtl, type ExchangeOptions, type Identity, type IdentityInput, } from './identity/index.js';
 export type { DurableEngine, DurableServing, DurableServingProvider } from './workflows/index.js';
+export { DURABLE_ENGINE_EXPORTS } from './workflows/options.js';
 export { isCanonicalDurableRequest } from './workflows/route.js';

package/dist/execution/index.js

@@ -1,4 +1,5 @@
 export { serve } from './serve.js';
 export { DEFAULT_MEMORY_CACHE_ENTRIES, memoryCache, } from './cache/index.js';
 export { createIdentity, maximumExchangeTtl, } from './identity/index.js';
+export { DURABLE_ENGINE_EXPORTS } from './workflows/options.js';
 export { isCanonicalDurableRequest } from './workflows/route.js';

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

@@ -15,6 +15,11 @@ export interface DurableEngine {
         readonly metadata?: Record<string, string>;
     }) => Error;
     readonly CancelledError: abstract new (...input: never[]) => Error;
+    /** A failure inside `run` that the engine attempts again no earlier than `retryAfter` ms. */
+    readonly RetryableError: new (message: string, options?: {
+        readonly retryAfter?: number;
+        readonly cause?: unknown;
+    }) => Error;
     /** The rejection of `orTimeout` once its duration elapses first. */
     readonly TimeoutError: abstract new (...input: never[]) => Error;
 }
@@ -27,6 +32,8 @@ export interface EngineWorkflowDefinition {
     readonly options: {
         readonly workflowRetention: number;
         readonly retryPolicy: EngineRetryPolicy;
+        /** How long an attempt may run without progress before the engine aborts it. */
+        readonly abortTimeout: number;
     };
 }
 export interface EngineRetryPolicy {
@@ -36,6 +43,17 @@ export interface EngineRetryPolicy {
     readonly maxInterval: number;
     readonly exponentiationFactor: number;
 }
+/**
+ * The retry budget of one journaled `run`. Spent, the `run` rejects with a `TerminalError` and the
+ * engine attempts it no more; an absent limit does not bound it.
+ */
+export interface EngineRunOptions {
+    readonly maxRetryAttempts?: number;
+    readonly maxRetryDuration?: number;
+    readonly initialRetryInterval: number;
+    readonly maxRetryInterval: number;
+    readonly retryIntervalFactor: number;
+}
 /**
  * A promise the engine journals. Its combinators are journaled too, so a replay settles them as the
  * first run did; racing it against another promise with `Promise.race` would not be.
@@ -46,7 +64,7 @@ export interface EnginePromise<Output> extends PromiseLike<Output> {
 }
 /** Journaled operations of one workflow run. */
 export interface EngineWorkflowContext {
-    run<Output>(name: string, action: () => Promise<Output>): PromiseLike<Output>;
+    run<Output>(name: string, action: () => Promise<Output>, options?: EngineRunOptions): PromiseLike<Output>;
     sleep(durationMs: number, name?: string): PromiseLike<void>;
     promise(name: string): {
         get(): EnginePromise<unknown>;

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

@@ -1,11 +1,46 @@
 import type { DurableEngine } from './engine.js';
+/** Failure code of an Execution whose Workflow did not catch a Step that spent its retry budget. */
+export declare const STEP_EXHAUSTED = "STEP_EXHAUSTED";
+/** A Kernel refusal as the wire names it: its protocol code and, when given, its reason code. */
+export interface KernelRefusal {
+    readonly code: number;
+    readonly reason?: string;
+}
 /**
- * Encode a declared business error of `definition` as a terminal engine failure, or return
- * undefined for any other error, which the engine retries.
+ * A Step that spent its retry budget. Its message never carries what the last attempt threw; when
+ * the Kernel refused that attempt, `refusal` names the refusal by its codes alone.
+ */
+export declare class StepExhausted extends Error {
+    readonly step: string;
+    readonly refusal?: KernelRefusal;
+    constructor(step: string, refusal?: KernelRefusal);
+}
+/** The Kernel refusal behind `cause`, itself or one of its causes. */
+export declare function kernelRefusalOf(cause: unknown): KernelRefusal | undefined;
+/**
+ * The failure a Step attempt hands the engine: `cause` itself, or, when the Kernel refused the
+ * attempt, an error whose message starts with the refusal's codes, so the exhaustion can name it.
+ */
+export declare function attemptFailure(cause: unknown): unknown;
+/** A Step attempt's failure that asks the engine to wait `delayMs` before the next attempt. */
+export declare class StepRetryAfter extends Error {
+    readonly delayMs: number;
+    constructor(delayMs: number, cause?: unknown);
+}
+/**
+ * The failure of a Step attempt that waits out a prescribed delay before the next attempt, instead
+ * of the Step's backoff: a `retryAfter` failure, or a Kernel refusal that prescribes `retryAfterMs`.
+ */
+export declare function delayedRetry(engine: DurableEngine, cause: unknown): Error | undefined;
+/**
+ * Encode a declared business error of `definition`, or a Step that spent its retry budget, as a
+ * terminal engine failure, or return undefined for any other error, which the engine retries.
  */
 export declare function terminalFailure(engine: DurableEngine, cause: unknown, definition: object): Error | undefined;
 /**
- * The declared business error a journaled Step failed with, rebuilt through the definition's own
- * factory, so a replay throws what the live run threw.
+ * What a journaled Step failed with, as the Workflow sees it: its declared business error, rebuilt
+ * through the definition's own factory, or `StepExhausted` once the engine spent its retry budget
+ * or the Step threw an exhaustion caught from an earlier Step. A replay throws what the live run
+ * threw.
  */
-export declare function replayedFailure(engine: DurableEngine, cause: unknown, definition: object): Error | undefined;
+export declare function replayedFailure(engine: DurableEngine, cause: unknown, definition: object, step: string): Error | undefined;

package/dist/execution/workflows/failure.js

@@ -1,6 +1,101 @@
 import { declaredErrorFactory, declaredErrorOf } from '../../application/error/index.js';
+import { ResponseError, retryAfterOf } from '../../platform/client/index.js';
 /** Metadata key the Kernel reads a declared failure from (`backend/restate` outcome decoding). */
 const FAILURE = 'astrale.failure';
+/** Failure code of an Execution whose Workflow did not catch a Step that spent its retry budget. */
+export const STEP_EXHAUSTED = 'STEP_EXHAUSTED';
+/** The longest delay a Step attempt may ask for, as the Kernel bounds a `retryAfterMs` hint. */
+const MAXIMUM_RETRY_AFTER_MS = 3_600_000;
+/** How deep a failure's causes are searched for the Kernel refusal behind it. */
+const MAXIMUM_CAUSE_DEPTH = 8;
+const REASON_CODE = /^[A-Z][A-Z0-9_]{0,63}$/u;
+/**
+ * The mark a failed attempt's message carries when the Kernel refused it. The engine journals only
+ * that message, and gives back the last one when the budget is spent.
+ */
+const REFUSAL_MARK = /\[kernel refusal ([1-9][0-9]{3})(?: ([A-Z][A-Z0-9_]{0,63}))?\] /gu;
+/**
+ * A Step that spent its retry budget. Its message never carries what the last attempt threw; when
+ * the Kernel refused that attempt, `refusal` names the refusal by its codes alone.
+ */
+export class StepExhausted extends Error {
+    step;
+    refusal;
+    constructor(step, refusal) {
+        super(`Workflow Step ${step} exhausted its retries.`);
+        this.name = 'StepExhausted';
+        this.step = step;
+        if (refusal !== undefined)
+            this.refusal = refusal;
+    }
+}
+/** The Kernel refusal behind `cause`, itself or one of its causes. */
+export function kernelRefusalOf(cause) {
+    let current = cause;
+    for (let depth = 0; depth < MAXIMUM_CAUSE_DEPTH; depth += 1) {
+        if (current instanceof ResponseError) {
+            const reason = current.reason?.code;
+            return Object.freeze({
+                code: current.code,
+                ...(reason !== undefined && REASON_CODE.test(reason) ? { reason } : {}),
+            });
+        }
+        if (current === null || typeof current !== 'object')
+            return undefined;
+        current = current.cause;
+    }
+    return undefined;
+}
+/**
+ * The failure a Step attempt hands the engine: `cause` itself, or, when the Kernel refused the
+ * attempt, an error whose message starts with the refusal's codes, so the exhaustion can name it.
+ */
+export function attemptFailure(cause) {
+    const refusal = kernelRefusalOf(cause);
+    if (refusal === undefined)
+        return cause;
+    return new Error(attemptMessage(cause, refusal), { cause });
+}
+function attemptMessage(cause, refusal = kernelRefusalOf(cause)) {
+    const message = cause instanceof Error ? cause.message : String(cause);
+    if (refusal === undefined)
+        return message;
+    const reason = refusal.reason === undefined ? '' : ` ${refusal.reason}`;
+    return `[kernel refusal ${refusal.code}${reason}] ${message}`;
+}
+/** The refusal the last attempt's message names, if the Kernel refused it. */
+function refusalIn(message) {
+    const marks = [...message.matchAll(REFUSAL_MARK)];
+    const last = marks.at(-1);
+    if (last === undefined)
+        return undefined;
+    return Object.freeze({
+        code: Number(last[1]),
+        ...(last[2] === undefined ? {} : { reason: last[2] }),
+    });
+}
+/** A Step attempt's failure that asks the engine to wait `delayMs` before the next attempt. */
+export class StepRetryAfter extends Error {
+    delayMs;
+    constructor(delayMs, cause) {
+        if (!Number.isSafeInteger(delayMs) || delayMs < 0 || delayMs > MAXIMUM_RETRY_AFTER_MS) {
+            throw new TypeError(`A Step retry delay must be an integer between 0 and ${MAXIMUM_RETRY_AFTER_MS} ms.`);
+        }
+        super(cause instanceof Error ? cause.message : `Workflow Step asked to retry after ${delayMs} ms.`, cause === undefined ? undefined : { cause });
+        this.name = 'StepRetryAfter';
+        this.delayMs = delayMs;
+    }
+}
+/**
+ * The failure of a Step attempt that waits out a prescribed delay before the next attempt, instead
+ * of the Step's backoff: a `retryAfter` failure, or a Kernel refusal that prescribes `retryAfterMs`.
+ */
+export function delayedRetry(engine, cause) {
+    const delayMs = cause instanceof StepRetryAfter ? cause.delayMs : retryAfterOf(cause);
+    if (delayMs === undefined)
+        return undefined;
+    return new engine.RetryableError(attemptMessage(cause), { retryAfter: delayMs, cause });
+}
 const STATUS = {
     VALIDATION_ERROR: 422,
     NOT_FOUND: 404,
@@ -8,10 +103,24 @@ const STATUS = {
     UNSUPPORTED: 422,
 };
 /**
- * Encode a declared business error of `definition` as a terminal engine failure, or return
- * undefined for any other error, which the engine retries.
+ * Encode a declared business error of `definition`, or a Step that spent its retry budget, as a
+ * terminal engine failure, or return undefined for any other error, which the engine retries.
  */
 export function terminalFailure(engine, cause, definition) {
+    if (cause instanceof StepExhausted) {
+        return new engine.TerminalError(cause.message, {
+            metadata: {
+                [FAILURE]: JSON.stringify({
+                    code: STEP_EXHAUSTED,
+                    message: cause.message,
+                    details: {
+                        step: cause.step,
+                        ...(cause.refusal === undefined ? {} : { refusal: cause.refusal }),
+                    },
+                }),
+            },
+        });
+    }
     const declared = declaredErrorOf(cause, definition);
     if (declared === undefined)
         return undefined;
@@ -28,16 +137,24 @@ export function terminalFailure(engine, cause, definition) {
     });
 }
 /**
- * The declared business error a journaled Step failed with, rebuilt through the definition's own
- * factory, so a replay throws what the live run threw.
+ * What a journaled Step failed with, as the Workflow sees it: its declared business error, rebuilt
+ * through the definition's own factory, or `StepExhausted` once the engine spent its retry budget
+ * or the Step threw an exhaustion caught from an earlier Step. A replay throws what the live run
+ * threw.
  */
-export function replayedFailure(engine, cause, definition) {
+export function replayedFailure(engine, cause, definition, step) {
     if (!(cause instanceof engine.TerminalError) || cause instanceof engine.CancelledError) {
         return undefined;
     }
     const encoded = cause.metadata?.[FAILURE];
+    // The Step's own code turns every terminal failure into a declared one; the engine's is its budget.
     if (encoded === undefined)
-        return undefined;
+        return new StepExhausted(step, refusalIn(cause.message));
     const failure = JSON.parse(encoded);
+    // Only a declared business error has a family, so a declared code may be STEP_EXHAUSTED too.
+    if (failure.family === undefined && failure.code === STEP_EXHAUSTED) {
+        const details = failure.details;
+        return new StepExhausted(details.step, details.refusal);
+    }
     return declaredErrorFactory(definition)(failure.code, failure.details);
 }

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

@@ -1,4 +1,4 @@
-export type { DurableEngine, EnginePromise, EngineRetryPolicy, EngineSharedContext, EngineWorkflowContext, EngineWorkflowDefinition, } from './engine.js';
-export { durableServing, type AdmittedDurableServing, type DurableServing, type DurableServingProvider, } from './options.js';
+export type { DurableEngine, EnginePromise, EngineRetryPolicy, EngineRunOptions, EngineSharedContext, EngineWorkflowContext, EngineWorkflowDefinition, } from './engine.js';
+export { DURABLE_ENGINE_EXPORTS, durableServing, type AdmittedDurableServing, type DurableServing, type DurableServingProvider, } from './options.js';
 export { createDurableReceiver, type DurableReceiver } from './receiver.js';
 export { isDurableRequest, isCanonicalDurableRequest } from './route.js';

package/dist/execution/workflows/index.js

@@ -1,3 +1,3 @@
-export { durableServing, } from './options.js';
+export { DURABLE_ENGINE_EXPORTS, durableServing, } from './options.js';
 export { createDurableReceiver } from './receiver.js';
 export { isDurableRequest, isCanonicalDurableRequest } from './route.js';

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

@@ -1,5 +1,6 @@
 import type { Fetch } from '@astrale-os/kernel-client';
-import type { DurableEngine, EngineRetryPolicy } from './engine.js';
+import type { DurableStepRetry } from '../../application/workflow/index.js';
+import type { DurableEngine, EngineRetryPolicy, EngineRunOptions } from './engine.js';
 /** Serving configuration of the durable Workflows of one deployment. */
 export interface DurableServing {
     /** The Restate SDK Fetch build of this platform. */
@@ -12,13 +13,13 @@ export interface DurableServing {
      * default.
      */
     readonly retentionMs?: number;
-    /** Attempts of a failing run before it pauses for `resume` or `cancel`. The Host caps them. */
-    readonly retry?: {
-        readonly maxAttempts?: number;
-        readonly initialIntervalMs?: number;
-        readonly maxIntervalMs?: number;
-    };
-    /** Deadline of one Step, including its Kernel calls. One minute by default. */
+    /**
+     * Retry budget of every Step that declares none: 20 attempts from 1 s to 60 s by default. A Step
+     * that spends it fails into its Workflow. `maxAttempts` also bounds the attempts of a run that
+     * fails outside any Step, which then pauses for `resume` or `cancel`. The Host caps them.
+     */
+    readonly retry?: DurableStepRetry;
+    /** Deadline of one Step attempt that declares none, including its Kernel calls. One minute by default. */
     readonly stepTimeoutMs?: number;
 }
 /** Resolve a deployment's engine only when its durable receiver is first requested. */
@@ -27,8 +28,34 @@ export interface AdmittedDurableServing {
     readonly engine: DurableEngine;
     readonly fetch: Fetch;
     readonly retentionMs: number;
+    /** Attempts of a run that fails outside any Step, before the engine pauses it. */
     readonly retryPolicy: EngineRetryPolicy;
-    readonly stepTimeoutMs: number;
+    /** Retry budget and attempt deadline of a Step that declares none. */
+    readonly step: StepServing;
+}
+/** What a Step is held to: its retry budget, as the engine applies it, and its attempt deadline. */
+export interface StepServing {
+    readonly retry: EngineRunOptions;
+    readonly timeoutMs: number;
 }
+/**
+ * The members of the Restate SDK Fetch entrypoint the durable receiver uses, which a platform's
+ * engine module must export.
+ */
+export declare const DURABLE_ENGINE_EXPORTS: readonly ["createEndpointHandler", "workflow", "TerminalError", "CancelledError", "RetryableError", "TimeoutError"];
+/**
+ * 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 declare const ENGINE_ABORT_TIMEOUT_MS: number;
 /** Capture one durable serving configuration, failing closed on any gap. */
 export declare function durableServing(input: DurableServing): AdmittedDurableServing;
+/**
+ * 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 declare function stepServing(declared: {
+    readonly retry?: DurableStepRetry | undefined;
+    readonly timeoutMs?: number | undefined;
+}, fallback: StepServing): StepServing;