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

package/dist/execution/workflows/options.js

@@ -0,0 +1,148 @@
+/**
+ * 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',
+    'RestatePromise',
+]);
+/**
+ * Whether `module` exports the members of the Restate SDK Fetch entrypoint the durable receiver
+ * uses: each a function, but `RestatePromise`, the namespace of its combinators.
+ */
+export function isDurableEngine(module) {
+    if (module === null || typeof module !== 'object')
+        return false;
+    return DURABLE_ENGINE_EXPORTS.every((member) => {
+        const value = Reflect.get(module, member);
+        if (member !== 'RestatePromise')
+            return typeof value === 'function';
+        return (typeof value === 'object' &&
+            value !== null &&
+            typeof Reflect.get(value, 'allSettled') === 'function');
+    });
+}
+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 ||
+        typeof input !== 'object' ||
+        Array.isArray(input) ||
+        Reflect.ownKeys(input).some((key) => key !== 'engine' &&
+            key !== 'fetch' &&
+            key !== 'retentionMs' &&
+            key !== 'retry' &&
+            key !== 'stepTimeoutMs')) {
+        invalid('Durable serving options are invalid.');
+    }
+    const engine = input.engine;
+    if (!isDurableEngine(engine)) {
+        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 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,
+            RestatePromise: Object.freeze({
+                allSettled: engine.RestatePromise.allSettled.bind(engine.RestatePromise),
+            }),
+        }),
+        fetch,
+        retentionMs: bounded(input.retentionMs, 7 * DAY_MS, HOUR_MS, 365 * DAY_MS, 'retentionMs'),
+        retryPolicy: Object.freeze({
+            maxAttempts: input.retry?.maxAttempts ?? DEFAULT_ATTEMPTS,
+            onMaxAttempts: 'pause',
+            initialInterval: step.retry.initialRetryInterval,
+            maxInterval: step.retry.maxRetryInterval,
+            exponentiationFactor: step.retry.retryIntervalFactor,
+        }),
+        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;
+    if (!Number.isSafeInteger(input) || input < minimum || input > maximum) {
+        invalid(`Durable ${label} must be an integer between ${minimum} and ${maximum}.`);
+    }
+    return input;
+}
+function invalid(message) {
+    throw new TypeError(message);
+}

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

@@ -0,0 +1,24 @@
+import type { IntegrationClientFactory, Integrations } from '../../application/integration/index.js';
+import type { RuntimeWorkflow } from '../../application/runtime/workflows.js';
+import type { Domain } from '../../platform/schema/index.js';
+import type { Identity } from '../identity/index.js';
+import type { AdmittedDurableServing } from './options.js';
+/** Serves the engine's discovery and invocations of this deployment's durable Workflows. */
+export interface DurableReceiver {
+    fetch(request: Request): Promise<Response>;
+}
+/**
+ * Route `…/invoke/restate/<Kernel issuer>/<declaration key>/<service>/{discover,invoke/…}` to one
+ * engine endpoint. Routes discover
+ * their signing authority at the named Kernel; that issuer also binds the run envelope. Each
+ * endpoint serves exactly that service with the declared Workflow. A declaration this Release does not
+ * serve durably is refused, so an endpoint never runs code it does not declare.
+ */
+export declare function createDurableReceiver(input: {
+    readonly workflows: readonly RuntimeWorkflow[];
+    readonly domain: Domain;
+    readonly identity: Identity;
+    readonly serving: AdmittedDurableServing;
+    /** Integration clients of the initialized Runtime, which every Step holds. */
+    readonly integrations: IntegrationClientFactory<Integrations>;
+}): DurableReceiver;

package/dist/execution/workflows/receiver.js

@@ -0,0 +1,99 @@
+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';
+const MAXIMUM_ENDPOINTS = 256;
+/**
+ * Route `…/invoke/restate/<Kernel issuer>/<declaration key>/<service>/{discover,invoke/…}` to one
+ * engine endpoint. Routes discover
+ * their signing authority at the named Kernel; that issuer also binds the run envelope. Each
+ * endpoint serves exactly that service with the declared Workflow. A declaration this Release does not
+ * serve durably is refused, so an endpoint never runs code it does not declare.
+ */
+export function createDurableReceiver(input) {
+    const executor = input.identity.executor;
+    if (executor === undefined) {
+        throw new TypeError('Durable Workflows require an execution Identity that can act as the Domain.');
+    }
+    const steps = sessionSteps({
+        executor: executor.bind(input.identity),
+        domain: input.domain,
+        integrations: input.integrations,
+    });
+    const declared = new Map(input.workflows
+        .filter((workflow) => workflow.durable)
+        .map((workflow) => [workflow.callable.key, workflow]));
+    const endpoints = new Map();
+    const { engine } = input.serving;
+    const discovery = workflowEngineDiscovery(input.serving.fetch);
+    return Object.freeze({
+        async fetch(request) {
+            const route = durableRoute(request);
+            if (route === undefined)
+                return refused();
+            const { kernel, declaration, service } = route;
+            const workflow = declared.get(declaration);
+            if (workflow === undefined)
+                return refused();
+            let identityKeys;
+            try {
+                identityKeys = (await discovery.resolve(kernel)).identity_keys;
+            }
+            catch (cause) {
+                if (!(cause instanceof WorkflowEngineUnavailable))
+                    throw cause;
+                return unavailable();
+            }
+            request.signal.throwIfAborted();
+            const cacheKey = JSON.stringify([kernel, declaration, service, identityKeys]);
+            let endpoint = endpoints.get(cacheKey);
+            if (endpoint === undefined) {
+                const definition = engine.workflow({
+                    name: service,
+                    handlers: durableHandlers({
+                        workflow,
+                        domain: input.domain,
+                        serving: input.serving,
+                        steps,
+                        kernel,
+                    }),
+                    options: {
+                        workflowRetention: input.serving.retentionMs,
+                        retryPolicy: input.serving.retryPolicy,
+                        abortTimeout: ENGINE_ABORT_TIMEOUT_MS,
+                    },
+                });
+                try {
+                    endpoint = engine.createEndpointHandler({
+                        identityKeys: [...identityKeys],
+                        services: [definition],
+                    });
+                }
+                catch {
+                    discovery.forget(kernel, identityKeys);
+                    return unavailable();
+                }
+                if (endpoints.size >= MAXIMUM_ENDPOINTS)
+                    endpoints.delete(endpoints.keys().next().value);
+                endpoints.set(cacheKey, endpoint);
+            }
+            const response = await endpoint(request);
+            if (response.status === 401)
+                discovery.invalidate(kernel, identityKeys);
+            return response;
+        },
+    });
+}
+function refused() {
+    return new Response('{"error":"Unknown durable declaration."}', {
+        status: 404,
+        headers: { 'content-type': 'application/json', 'cache-control': 'no-store' },
+    });
+}
+function unavailable() {
+    return new Response('{"error":"Workflow engine authority is unavailable."}', {
+        status: 503,
+        headers: { 'content-type': 'application/json', 'cache-control': 'no-store' },
+    });
+}

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

@@ -0,0 +1,12 @@
+import type { IssuerId } from '../../platform/auth/index.js';
+export interface DurableRoute {
+    readonly kernel: IssuerId;
+    readonly declaration: string;
+    readonly service: string;
+}
+/** Whether the request is owned by the durable receiver, including malformed paths. */
+export declare function isDurableRequest(request: Request): boolean;
+/** Canonical requests discover authority at the HTTPS Kernel named by this admitted route. */
+export declare function isCanonicalDurableRequest(request: Request): boolean;
+/** One wire decoder shared by the receiver and platform lazy-load eligibility. */
+export declare function durableRoute(request: Request): DurableRoute | undefined;

package/dist/execution/workflows/route.js

@@ -0,0 +1,35 @@
+import { Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import { invocationPath } from '../../deployment/release/invocation.js';
+import { AuthValueError } from '../../platform/auth/index.js';
+import { httpIssuer } from '../identity/errors.js';
+const PREFIX = `${invocationPath()}/restate/`;
+const SERVICE = /^[A-Za-z_][A-Za-z0-9_]{0,127}$/u;
+/** Whether the request is owned by the durable receiver, including malformed paths. */
+export function isDurableRequest(request) {
+    return new URL(request.url).pathname.startsWith(PREFIX);
+}
+/** Canonical requests discover authority at the HTTPS Kernel named by this admitted route. */
+export function isCanonicalDurableRequest(request) {
+    return durableRoute(request)?.kernel !== undefined;
+}
+/** One wire decoder shared by the receiver and platform lazy-load eligibility. */
+export function durableRoute(request) {
+    const pathname = new URL(request.url).pathname;
+    if (!pathname.startsWith(PREFIX))
+        return undefined;
+    const parts = pathname.slice(PREFIX.length).split('/');
+    try {
+        const first = decodeURIComponent(parts[0] ?? '');
+        const kernel = httpIssuer(first, false);
+        const declaration = decodeURIComponent(parts[1] ?? '');
+        const service = parts[2] ?? '';
+        if (!Key.is(declaration) || !SERVICE.test(service))
+            return undefined;
+        return Object.freeze({ kernel, declaration, service });
+    }
+    catch (cause) {
+        if (cause instanceof URIError || cause instanceof AuthValueError || cause instanceof TypeError)
+            return undefined;
+        throw cause;
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { RuntimeWorkflow } from '../../application/runtime/workflows.js';
+import type { IssuerId } from '../../platform/auth/index.js';
+import type { Domain } from '../../platform/schema/index.js';
+import type { EngineSharedContext, EngineWorkflowContext } from './engine.js';
+import type { AdmittedDurableServing } from './options.js';
+import type { StepAuthorities } from './steps.js';
+export interface DurableRun {
+    readonly kernel: IssuerId;
+    readonly workflow: RuntimeWorkflow;
+    readonly domain: Domain;
+    readonly serving: AdmittedDurableServing;
+    /** What each Step attempt holds. */
+    readonly steps: StepAuthorities;
+}
+/** Engine handlers of one durable Workflow: the `run` and the shared `signal`. */
+export declare function durableHandlers(input: DurableRun): Readonly<{
+    run: (context: EngineWorkflowContext, raw: unknown) => Promise<import("../../platform/schema/index.js").Value>;
+    signal(context: EngineSharedContext, raw: unknown): Promise<{
+        accepted: boolean;
+    }>;
+}>;

package/dist/execution/workflows/run.js

@@ -0,0 +1,321 @@
+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 { decodeEnvelope } from './envelope.js';
+import { delayedRetry, replayedFailure, StepExhausted, StepRetryAfter, attemptFailure, 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;
+    return Object.freeze({
+        run: (context, raw) => run(input, context, raw),
+        async signal(context, raw) {
+            const request = signalRequest(raw);
+            try {
+                await context.promise(request.name).resolve(request.value);
+                return { accepted: true };
+            }
+            catch (cause) {
+                // The engine refuses to resolve a promise twice with a terminal failure.
+                if (cause instanceof engine.TerminalError)
+                    return { accepted: false };
+                throw cause;
+            }
+        },
+    });
+}
+async function run(input, context, raw) {
+    const { workflow, serving } = input;
+    const { engine } = serving;
+    const definition = workflow.definition;
+    // 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;
+    try {
+        output = await definition.run(durable);
+    }
+    catch (cause) {
+        throw terminalFailure(engine, cause, definition) ?? cause;
+    }
+    return validateOutput(workflow.callable, output);
+}
+function admitted(workflow, raw, kernel) {
+    const envelope = decodeEnvelope(raw);
+    if (envelope.execution.kernel !== kernel) {
+        throw new TypeError('Durable envelope Kernel differs from its authenticated endpoint.');
+    }
+    const diagnostics = workflow.callable.validateInput(envelope.input);
+    if (diagnostics.length > 0) {
+        throw new TypeError(`Workflow ${workflow.address} cannot read the recorded input.`);
+    }
+    const instance = 'static' in workflow.callable && workflow.callable.static === false;
+    if (instance !== (envelope.execution.receiver !== undefined)) {
+        throw new TypeError(`Workflow ${workflow.address} cannot use the recorded receiver.`);
+    }
+    return envelope;
+}
+function durableContext(input, context, envelope) {
+    const { serving, domain, workflow } = input;
+    const { engine } = serving;
+    const definition = workflow.definition;
+    const execution = envelope.execution;
+    const signal = context.request().attemptCompletedSignal;
+    const steps = new Set();
+    let running;
+    /**
+     * Starts one durable operation, a Step or a wait, once the previous one has settled. The engine
+     * follows one awaited operation at a time: operations awaited together through `Promise` combinators
+     * make it lose track of the run, which then pauses.
+     */
+    const sequenced = (operation, start) => {
+        if (running !== undefined) {
+            return Promise.reject(new TypeError(`Workflow ${operation} started while ${running} runs: durable Steps and waits run one after another.`));
+        }
+        running = operation;
+        let started;
+        try {
+            started = start();
+        }
+        catch (cause) {
+            running = undefined;
+            return Promise.reject(cause);
+        }
+        return started.finally(() => {
+            running = undefined;
+        });
+    };
+    /**
+     * 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.
+     *
+     * 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),
+            ]);
+            try {
+                return acceptStepOutput(output);
+            }
+            catch (cause) {
+                throw new TypeError(`Workflow ${name} output must be portable.`, { cause });
+            }
+        }
+        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 {
+            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.id);
+        const { held } = accepted;
+        return sequenced(`Step ${accepted.id}`, () => journal(accepted.id, `step:${accepted.id}`, held.timeoutMs, held.retry, 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.
+     */
+    const parallel = (declare) => {
+        const declared = new Map();
+        const declaration = (id, execute) => {
+            const accepted = stepDeclaration(id, serving.step);
+            const token = Object.freeze({});
+            declared.set(token, { ...accepted, execute });
+            return token;
+        };
+        let group;
+        try {
+            if (typeof declare !== 'function') {
+                throw new TypeError('step.parallel takes a function declaring its Steps.');
+            }
+            const returned = declare(Object.freeze({
+                run: (id, execute) => declaration(id, execute),
+                query: (id, query, value) => declaration(id, (authority) => authority.query(query, value)),
+                mutate: (id, mutation, value) => declaration(id, (authority) => authority.mutate(mutation, value)),
+            }));
+            if (!Array.isArray(returned) ||
+                returned.length !== declared.size ||
+                new Set(returned).size !== returned.length ||
+                returned.some((entry) => !declared.has(entry))) {
+                throw new TypeError('step.parallel takes exactly the Steps its function declares, each once, as an array.');
+            }
+            group = returned.map((entry) => declared.get(entry));
+            const ids = new Set();
+            for (const { id } of group) {
+                if (steps.has(id) || ids.has(id)) {
+                    throw new TypeError(`Workflow Step ${id} occurs more than once.`);
+                }
+                ids.add(id);
+            }
+        }
+        catch (cause) {
+            return Promise.reject(cause);
+        }
+        if (group.length === 0)
+            return Promise.resolve([]);
+        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 cause = settled[failed].reason;
+            throw replayedFailure(engine, cause, definition, group[failed].id) ?? cause;
+        });
+    };
+    return Object.freeze({
+        domain,
+        input: envelope.input,
+        execution,
+        error: declaredErrorFactory(definition),
+        step: Object.freeze({
+            run: step,
+            query: (id, query, value) => step(id, (authority) => authority.query(query, value)),
+            mutate: (id, mutation, value) => step(id, (authority) => authority.mutate(mutation, value)),
+            parallel,
+        }),
+        async sleep(durationMs) {
+            if (!Number.isSafeInteger(durationMs) || durationMs < 0 || durationMs > MAXIMUM_SLEEP_MS) {
+                throw new TypeError(`Durable sleep must be an integer between 0 and ${MAXIMUM_SLEEP_MS} ms.`);
+            }
+            await sequenced('sleep', () => Promise.resolve(context.sleep(durationMs)));
+        },
+        async awaitSignal(name, options) {
+            if (typeof name !== 'string' || name.length === 0 || name.length > MAXIMUM_SIGNAL_NAME) {
+                throw new TypeError('Durable signal name must have 1 to 128 characters.');
+            }
+            if (options === undefined) {
+                return (await sequenced(`wait for signal ${name}`, () => Promise.resolve(context.promise(name).get())));
+            }
+            const timeoutMs = options?.timeoutMs;
+            if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 0 || timeoutMs > MAXIMUM_SLEEP_MS) {
+                throw new TypeError(`Durable signal timeout must be an integer between 0 and ${MAXIMUM_SLEEP_MS} ms.`);
+            }
+            // The engine journals the race between the signal and the timer: a replay settles it alike.
+            try {
+                const value = await sequenced(`wait for signal ${name}`, () => Promise.resolve(context.promise(name).get().orTimeout(timeoutMs)));
+                return Object.freeze({ kind: 'signal', value });
+            }
+            catch (cause) {
+                if (cause instanceof engine.TimeoutError)
+                    return Object.freeze({ kind: 'timeout' });
+                throw cause;
+            }
+        },
+        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 }),
+    });
+}
+/** 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' ||
+        Array.isArray(input) ||
+        typeof input.name !== 'string') {
+        throw new TypeError('Durable signal request is invalid.');
+    }
+    const { name, value } = input;
+    if (name.length === 0 || name.length > MAXIMUM_SIGNAL_NAME) {
+        throw new TypeError('Durable signal name must have 1 to 128 characters.');
+    }
+    return { name, value: value ?? null };
+}