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

package/dist/execution/invocation/invocation.js

@@ -1,6 +1,6 @@
 import * as errors from '@astrale-os/kernel-protocol/errors';
 import * as release from '@astrale-os/kernel-protocol/release';
-import { authentication, input, requireVia, target } from './admission/index.js';
+import { admission as acceptAdmission, admissionKey, admissionScope, authentication, credentialAuthentication, input, keepAdmission, recallAdmission, requireVia, } from './admission/index.js';
 import { action, context, select, workflow } from './dispatch/index.js';
 import { active, settle } from './lifecycle/index.js';
 import { project, protocolError } from './result/index.js';
@@ -8,35 +8,110 @@ import { project, protocolError } from './result/index.js';
 const MISS = Object.freeze({ kind: 'miss' });
 const FUNCTION_MISS = 'FUNCTION_MISS';
 export async function invoke(request, inputConfig) {
-    active(request.context);
+    active(request.context.execution);
     if (!pinsRunningRelease(request, inputConfig.runtime.loaded.release)) {
         throw protocolError('CONFLICT', 'Invocation release differs from the running Release.');
     }
     if (request.credential !== undefined && typeof request.credential !== 'string') {
         throw protocolError('AUTH_INVALID', 'Credential is invalid.');
     }
-    const admitted = await admit(inputConfig.authority, {
+    const admission = {
         call: request.call,
         ...(request.credential === undefined ? {} : { credential: request.credential }),
         via: requireVia(request),
         domain: inputConfig.runtime.loaded.domain,
         context: request.context,
-    });
-    if (admitted === undefined)
-        return MISS;
-    const selected = select(inputConfig.runtime.loaded.registry, admitted);
-    if (selected === undefined)
-        return MISS;
-    if (selected.implementation.kind === 'workflow' && selected.implementation.durable) {
-        // The Kernel records a durable call as an Execution and runs it on the engine; running it
-        // inline here would silently drop durability.
-        throw protocolError('UNSUPPORTED', 'A durable Workflow runs only as a Kernel Execution.');
+    };
+    const { cache } = inputConfig;
+    const scope = cache === undefined
+        ? undefined
+        : admissionScope(inputConfig.runtime.loaded.registry, request.call);
+    if (cache === undefined || scope === undefined) {
+        return dispatchAdmitted(request, inputConfig, await admittedTarget(inputConfig, admission));
+    }
+    // The caller is verified before any kept admission is read: an unproven credential never learns
+    // whether another caller's admission is kept. A credential this verification refuses is decided
+    // as without a cache, the Kernel's admission first.
+    let established;
+    if (request.credential !== undefined) {
+        try {
+            established = await credentialAuthentication(request, inputConfig.runtime.loaded.domain, inputConfig.authority);
+        }
+        catch {
+            return dispatchAdmitted(request, inputConfig, await admittedTarget(inputConfig, admission));
+        }
+    }
+    let admitted;
+    try {
+        admitted = await recallOrAdmit(cache, scope, admission, inputConfig, established);
+    }
+    catch (cause) {
+        established?.close();
+        throw cause;
     }
-    input(selected.implementation.callable, request.call.input, request.context.binary);
-    const admittedAuthentication = await authentication(selected.implementation.callable, request, inputConfig.runtime.loaded.domain, inputConfig.authority);
-    const close = once(admittedAuthentication.close);
+    return dispatchAdmitted(request, inputConfig, admitted, established);
+}
+/**
+ * The admission of a call whose callable declares an admission age: one this deployment kept while
+ * it is younger than the age it carried, else the source Kernel's, kept for the calls that follow.
+ */
+async function recallOrAdmit(cache, scope, admission, inputConfig, established) {
+    let key;
+    try {
+        key = await admissionKey(scope, {
+            kernel: admission.via.issuer,
+            release: inputConfig.runtime.loaded.release.document.digest,
+            ...(established === undefined
+                ? {}
+                : {
+                    caller: {
+                        principal: established.caller.principal,
+                        identity: established.caller.identity,
+                    },
+                }),
+        }, admission.call);
+    }
+    catch {
+        // Without a key nothing is kept or read: the Kernel admits this call.
+        return admittedTarget(inputConfig, admission);
+    }
+    const kept = await recallAdmission(cache, key, scope);
+    if (kept !== undefined)
+        return kept;
+    const sentAt = Date.now();
+    const admitted = await admit(inputConfig.authority, admission);
+    if (admitted === undefined)
+        return undefined;
+    keepAdmission(cache, key, scope, admitted, sentAt, admission.context.background);
+    return admitted.target;
+}
+/** The target the source Kernel admits, or undefined when it no longer places the call here. */
+async function admittedTarget(inputConfig, admission) {
+    return (await admit(inputConfig.authority, admission))?.target;
+}
+/** Run the admitted target: everything after admission, identical however it was admitted. */
+async function dispatchAdmitted(request, inputConfig, admitted, established) {
+    let admittedAuthentication = established;
+    let close = established === undefined ? undefined : once(established.close);
     try {
-        active(request.context);
+        if (admitted === undefined) {
+            close?.();
+            return MISS;
+        }
+        const selected = select(inputConfig.runtime.loaded.registry, admitted);
+        if (selected === undefined) {
+            close?.();
+            return MISS;
+        }
+        if (selected.implementation.kind === 'workflow' && selected.implementation.durable) {
+            // The Kernel records a durable call as an Execution and runs it on the engine; running it
+            // inline here would silently drop durability.
+            throw protocolError('UNSUPPORTED', 'A durable Workflow runs only as a Kernel Execution.');
+        }
+        input(selected.implementation.callable, request.call.input, request.context.binary);
+        admittedAuthentication ??= await authentication(selected.implementation.callable, request, inputConfig.runtime.loaded.domain, inputConfig.authority);
+        close ??= once(admittedAuthentication.close);
+        active(request.context.execution);
         const dispatchContext = context(request, inputConfig.runtime, admittedAuthentication, selected.self);
         const output = selected.implementation.kind === 'action'
             ? await action(selected.implementation, dispatchContext)
@@ -44,7 +119,7 @@ export async function invoke(request, inputConfig) {
         return settle(project(selected.implementation.callable, output), close);
     }
     catch (cause) {
-        close();
+        close?.();
         throw cause;
     }
 }
@@ -64,7 +139,7 @@ async function admit(authority, admission) {
             return undefined;
         throw cause;
     }
-    return target(admitted);
+    return acceptAdmission(admitted);
 }
 function refusedAsMiss(cause) {
     return (cause instanceof errors.ProtocolError &&

package/dist/execution/invocation/lifecycle/active.d.ts

@@ -1,4 +1,10 @@
-import type { HandlerResult, InvocationContext } from '@astrale-os/kernel-server';
-export declare function active(context: InvocationContext): void;
+import type { HandlerResult } from '@astrale-os/kernel-server';
+/** The bounds of one unit of work: an invocation, or one attempt of a durable Step. */
+export interface Lifetime {
+    readonly signal: AbortSignal;
+    /** Absolute Unix time in milliseconds. */
+    readonly deadline: number;
+}
+export declare function active(lifetime: Lifetime): void;
 /** Close authenticated resources after finite results or stream settlement. */
 export declare function settle(result: HandlerResult, close: () => void): HandlerResult;

package/dist/execution/invocation/lifecycle/active.js

@@ -1,9 +1,9 @@
 import { protocolError } from '../result/index.js';
-export function active(context) {
-    if (context.execution.signal.aborted) {
+export function active(lifetime) {
+    if (lifetime.signal.aborted) {
         throw protocolError('CANCELLED', 'Invocation was cancelled.');
     }
-    if (Date.now() >= context.execution.deadline) {
+    if (Date.now() >= lifetime.deadline) {
         throw protocolError('DEADLINE_EXCEEDED', 'Invocation deadline was exceeded.');
     }
 }

package/dist/execution/invocation/lifecycle/index.d.ts

@@ -1 +1 @@
-export { active, settle } from './active.js';
+export { active, settle, type Lifetime } from './active.js';

package/dist/execution/serve.d.ts

@@ -2,6 +2,7 @@ import type { ServerCloseOptions } from '@astrale-os/kernel-server';
 import type { release } from '@astrale-os/kernel-server';
 import type { Runtime } from '../application/runtime/index.js';
 import type { WorkflowRunner } from '../application/workflow/runner/index.js';
+import type { DeploymentCache } from './cache/index.js';
 import type { Identity } from './identity/index.js';
 import type { ReleaseLoader } from './service/index.js';
 import type { ServiceServerOptions } from './service/index.js';
@@ -18,6 +19,13 @@ export interface ServeInput<Environment, RuntimeValue extends Runtime, RuntimeEn
     readonly server: ServiceServerOptions;
     readonly delivery?: (environment: Environment) => release.delivery.Provider | undefined;
     readonly workflows?: WorkflowRunner;
+    /**
+     * The deployment's cache of disposable entries, created once with the Service. It keeps the
+     * admissions of callables whose Schema declares an admission age, so that a call within that age
+     * skips its `Function.admit` round trip. Defaults to a bounded memory cache of this process or
+     * isolate; `false` keeps nothing, and every call is admitted by its source Kernel.
+     */
+    readonly cache?: ((environment: Environment) => DeploymentCache) | false;
     /**
      * Serve durable Workflows to the workflow engine; required when the Release declares any.
      * Undefined for an environment that names no engine: engine requests are then refused.

package/dist/execution/serve.js

@@ -1,3 +1,4 @@
+import { memoryCache } from './cache/index.js';
 import { createService } from './service/index.js';
 /** Create one provider-neutral Fetch entrypoint around a lazily initialized current Service. */
 export function serve(input) {
@@ -11,6 +12,9 @@ export function serve(input) {
             return service;
         if (typeof input.identity !== 'function')
             invalid();
+        if (input.cache !== undefined && input.cache !== false && typeof input.cache !== 'function') {
+            invalid();
+        }
         const runtimeEnvironment = input.initialize === undefined
             ? environment
             : input.initialize(environment);
@@ -22,6 +26,9 @@ export function serve(input) {
             server: input.server,
             ...(input.delivery === undefined ? {} : { delivery: input.delivery(environment) }),
             ...(input.workflows === undefined ? {} : { workflows: input.workflows }),
+            ...(input.cache === false
+                ? {}
+                : { cache: input.cache === undefined ? memoryCache() : input.cache(environment) }),
             ...(input.durable === undefined
                 ? {}
                 : { durable: (request) => input.durable(environment, request) }),

package/dist/execution/service/create.js

@@ -54,6 +54,7 @@ export function createService(input) {
             runtime,
             authority: selectedIdentity,
             ...(input.workflows === undefined ? {} : { workflows: input.workflows }),
+            ...(input.cache === undefined ? {} : { cache: input.cache }),
         }));
         running = Object.freeze({ release, runtime, server });
         if (!state.accepting)
@@ -71,6 +72,7 @@ export function createService(input) {
             domain: runtime.loaded.domain,
             identity: selectedIdentity,
             serving: configuration,
+            integrations: runtime.clients,
         });
     });
     let closing;

package/dist/execution/service/service.d.ts

@@ -2,6 +2,7 @@ import type { ApplicationHost, ServerCloseOptions, ServerOptions } from '@astral
 import type { release } from '@astrale-os/kernel-server';
 import type { Runtime } from '../../application/runtime/index.js';
 import type { WorkflowRunner } from '../../application/workflow/runner/index.js';
+import type { DeploymentCache } from '../cache/index.js';
 import type { Identity } from '../identity/index.js';
 import type { ServedRelease } from '../runtime/index.js';
 import type { DurableServing, DurableServingProvider } from '../workflows/index.js';
@@ -18,6 +19,11 @@ export interface ServiceInput<Environment, RuntimeValue extends Runtime = Runtim
      */
     readonly delivery?: release.delivery.Provider;
     readonly workflows?: WorkflowRunner;
+    /**
+     * Where admissions of callables that declare an admission age are kept for the next calls.
+     * Absent: every call is admitted by its source Kernel.
+     */
+    readonly cache?: DeploymentCache;
     /**
      * Serve the Release's durable Workflows. A provider is resolved on the first engine request,
      * shared by concurrent requests, and retried after initialization fails.

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

@@ -15,6 +15,8 @@ export interface DurableEngine {
         readonly metadata?: Record<string, string>;
     }) => Error;
     readonly CancelledError: abstract new (...input: never[]) => Error;
+    /** The rejection of `orTimeout` once its duration elapses first. */
+    readonly TimeoutError: abstract new (...input: never[]) => Error;
 }
 export interface EngineWorkflowDefinition {
     readonly name: string;
@@ -34,12 +36,20 @@ export interface EngineRetryPolicy {
     readonly maxInterval: number;
     readonly exponentiationFactor: 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.
+ */
+export interface EnginePromise<Output> extends PromiseLike<Output> {
+    /** Settle with this promise, or reject with `TimeoutError` once `millis` elapse first. */
+    orTimeout(millis: number): PromiseLike<unknown>;
+}
 /** Journaled operations of one workflow run. */
 export interface EngineWorkflowContext {
     run<Output>(name: string, action: () => Promise<Output>): PromiseLike<Output>;
     sleep(durationMs: number, name?: string): PromiseLike<void>;
-    promise<Output>(name: string): {
-        get(): PromiseLike<Output>;
+    promise(name: string): {
+        get(): EnginePromise<unknown>;
     };
     request(): {
         readonly attemptCompletedSignal: AbortSignal;

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

@@ -1,4 +1,4 @@
-export type { DurableEngine, EngineRetryPolicy, EngineSharedContext, EngineWorkflowContext, EngineWorkflowDefinition, } from './engine.js';
+export type { DurableEngine, EnginePromise, EngineRetryPolicy, EngineSharedContext, EngineWorkflowContext, EngineWorkflowDefinition, } from './engine.js';
 export { 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/integrations.d.ts

@@ -0,0 +1,13 @@
+import type { IntegrationAuthentication, IntegrationInvocationOwner } from '../../application/integration/index.js';
+import type { Lifetime } from '../invocation/lifecycle/index.js';
+/**
+ * The Integration calls of one Step attempt. Each call takes the Step's next derived key as its
+ * call id, so every attempt presents the same ids in the same order, and a keyed operation of
+ * source `execution` sends the same idempotency key. A retried Step may run an operation again,
+ * so an `unsafe` one is refused before its Provider runs. There is no caller to invoke for.
+ */
+export declare function stepCalls(input: {
+    readonly next: () => string;
+    readonly lifetime: Lifetime;
+    readonly auth: IntegrationAuthentication;
+}): IntegrationInvocationOwner;

package/dist/execution/workflows/integrations.js

@@ -0,0 +1,25 @@
+import { active } from '../invocation/lifecycle/index.js';
+/**
+ * The Integration calls of one Step attempt. Each call takes the Step's next derived key as its
+ * call id, so every attempt presents the same ids in the same order, and a keyed operation of
+ * source `execution` sends the same idempotency key. A retried Step may run an operation again,
+ * so an `unsafe` one is refused before its Provider runs. There is no caller to invoke for.
+ */
+export function stepCalls(input) {
+    const { next, lifetime, auth } = input;
+    return Object.freeze({
+        invoke(call) {
+            if (call.replay.kind === 'unsafe') {
+                throw new TypeError(`Integration operation ${call.integration}.${call.operation} is unsafe, and a retried ` +
+                    'durable Step would run it again.');
+            }
+            active(lifetime);
+            return call.attempt({
+                callId: next(),
+                signal: lifetime.signal,
+                deadline: lifetime.deadline,
+                auth,
+            });
+        },
+    });
+}

package/dist/execution/workflows/options.js

@@ -18,7 +18,8 @@ export function durableServing(input) {
         typeof engine.createEndpointHandler !== 'function' ||
         typeof engine.workflow !== 'function' ||
         typeof engine.TerminalError !== 'function' ||
-        typeof engine.CancelledError !== 'function') {
+        typeof engine.CancelledError !== 'function' ||
+        typeof engine.TimeoutError !== 'function') {
         invalid('Durable serving requires the Restate SDK Fetch entrypoint of this platform.');
     }
     const fetch = input.fetch ?? globalThis.fetch.bind(globalThis);
@@ -39,6 +40,7 @@ export function durableServing(input) {
             workflow: engine.workflow.bind(engine),
             TerminalError: engine.TerminalError,
             CancelledError: engine.CancelledError,
+            TimeoutError: engine.TimeoutError,
         }),
         fetch,
         retentionMs: bounded(input.retentionMs, 7 * DAY_MS, HOUR_MS, 365 * DAY_MS, 'retentionMs'),

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

@@ -1,3 +1,4 @@
+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';
@@ -18,4 +19,6 @@ export declare function createDurableReceiver(input: {
     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

@@ -1,6 +1,7 @@
 import { workflowEngineDiscovery, WorkflowEngineUnavailable } from './discovery.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
@@ -14,7 +15,11 @@ export function createDurableReceiver(input) {
     if (executor === undefined) {
         throw new TypeError('Durable Workflows require an execution Identity that can act as the Domain.');
     }
-    const bound = executor.bind(input.identity);
+    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]));
@@ -48,8 +53,8 @@ export function createDurableReceiver(input) {
                     handlers: durableHandlers({
                         workflow,
                         domain: input.domain,
-                        executor: bound,
                         serving: input.serving,
+                        steps,
                         kernel,
                     }),
                     options: {

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

@@ -1,16 +1,16 @@
 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 { Identity } from '../identity/index.js';
 import type { EngineSharedContext, EngineWorkflowContext } from './engine.js';
 import type { AdmittedDurableServing } from './options.js';
-type Executor = NonNullable<Identity['executor']>;
+import type { StepAuthorities } from './steps.js';
 export interface DurableRun {
     readonly kernel: IssuerId;
     readonly workflow: RuntimeWorkflow;
     readonly domain: Domain;
-    readonly executor: Executor;
     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<{
@@ -19,4 +19,3 @@ export declare function durableHandlers(input: DurableRun): Readonly<{
         accepted: boolean;
     }>;
 }>;
-export {};

package/dist/execution/workflows/run.js

@@ -1,17 +1,15 @@
 import { declaredErrorFactory } from '../../application/error/index.js';
-import { bindMutation } from '../../application/mutation/execution/executor.js';
-import { bindQuery } from '../../application/query/execution/executor.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 { bindSession } from '../../platform/client/session/index.js';
 import { validateOutput } from '../invocation/result/index.js';
 import { decodeEnvelope } from './envelope.js';
 import { replayedFailure, terminalFailure } from './failure.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_PROMISE_NAME = 128;
+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;
@@ -81,17 +79,16 @@ function durableContext(input, context, envelope) {
     const execution = envelope.execution;
     const signal = context.request().attemptCompletedSignal;
     const steps = new Set();
-    /** One journaled unit of work acting as the Domain, with keys derived from its name. */
+    /**
+     * 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.
+     */
     const journal = (name, execute) => Promise.resolve(context.run(name, async () => {
-        const deadline = Date.now() + serving.stepTimeoutMs;
-        const session = input.executor(execution.kernel, execution.id, { deadline, signal });
+        const lifetime = { deadline: Date.now() + serving.stepTimeoutMs, signal };
+        const next = await keySequence(execution.id, name);
+        const step = input.steps({ name, execution, next, lifetime });
         try {
-            const kernel = keyed(bindSessionOf(session, deadline, signal), domain, await keySequence(execution.id, name));
-            const output = await execute(Object.freeze({
-                kernel,
-                query: bindQuery(kernel, domain),
-                mutate: bindMutation(kernel, domain),
-            }));
+            const output = await execute(step.authority);
             try {
                 return acceptStepOutput(output);
             }
@@ -103,7 +100,7 @@ function durableContext(input, context, envelope) {
             throw terminalFailure(engine, cause, definition) ?? cause;
         }
         finally {
-            session.close();
+            step.close();
         }
     })).catch((cause) => {
         throw replayedFailure(engine, cause, definition) ?? cause;
@@ -128,6 +125,7 @@ function durableContext(input, context, envelope) {
         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)),
         }),
         async sleep(durationMs) {
@@ -136,11 +134,26 @@ function durableContext(input, context, envelope) {
             }
             await context.sleep(durationMs);
         },
-        async promise(name) {
-            if (typeof name !== 'string' || name.length === 0 || name.length > MAXIMUM_PROMISE_NAME) {
-                throw new TypeError('Durable promise name must have 1 to 128 characters.');
+        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 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 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;
             }
-            return (await context.promise(name).get());
         },
         cancelled: (error) => error instanceof engine.CancelledError,
         async awaitExecution(target) {
@@ -167,47 +180,6 @@ function durableContext(input, context, envelope) {
         ...(execution.receiver === undefined ? {} : { self: execution.receiver }),
     });
 }
-function bindSessionOf(session, deadline, signal) {
-    return bindSession(session, { deadline, signal });
-}
-/**
- * Every Mutation and every `invoke` of a durable callable of one Step without its own key carries
- * the next key of the Step's sequence. The sequence restarts with every attempt, so a retried Step
- * replays the same keys: the Kernel answers a Mutation with its receipt and a durable call with the
- * Execution it started, or refuses a request that changed under its key. Any other `invoke` carries
- * no key, because the Kernel accepts one only for a durable Function, and runs again with the Step.
- */
-function keyed(session, domain, next) {
-    const invokeSource = session.invoke;
-    const mutateSource = session.mutate;
-    const invoke = ((reference, value, options) => invokeSource(reference, value, declaredDurable(domain, reference) ? withKey(options, next) : options));
-    const mutate = ((author, options) => mutateSource(author, withKey(options, next)));
-    return Object.freeze({ ...session, invoke, mutate });
-}
-/**
- * Whether the Domain's Schema closure declares the referenced callable durable. An untyped Path
- * names no declaration and a callable outside the closure has none here: both need their own key.
- */
-function declaredDurable(domain, reference) {
-    if (reference === null || typeof reference !== 'object')
-        return false;
-    const key = reference.callable;
-    return (typeof key === 'string' && domain.callable(key)?.execution?.durable === true);
-}
-function withKey(options, next) {
-    if (options?.idempotencyKey !== undefined || options?.body !== undefined)
-        return options;
-    return { ...options, idempotencyKey: next() };
-}
-async function keySequence(execution, name) {
-    const digest = new Uint8Array(await crypto.subtle.digest('SHA-256', new TextEncoder().encode(name)));
-    const prefix = `${execution}.${Array.from(digest.subarray(0, 12), hex).join('')}`;
-    let position = 0;
-    return () => `${prefix}.${++position}`;
-}
-function hex(byte) {
-    return byte.toString(16).padStart(2, '0');
-}
 function signalRequest(input) {
     if (input === null ||
         typeof input !== 'object' ||
@@ -216,7 +188,7 @@ function signalRequest(input) {
         throw new TypeError('Durable signal request is invalid.');
     }
     const { name, value } = input;
-    if (name.length === 0 || name.length > MAXIMUM_PROMISE_NAME) {
+    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 };

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

@@ -0,0 +1,42 @@
+import type { IntegrationClientFactory, Integrations } from '../../application/integration/index.js';
+import type { DurableExecution, DurableStepAuthority } from '../../application/workflow/index.js';
+import type { BoundClientSession } from '../../platform/client/session/index.js';
+import type { Domain } from '../../platform/schema/index.js';
+import type { Identity } from '../identity/index.js';
+import type { Lifetime } from '../invocation/lifecycle/index.js';
+type Executor = NonNullable<Identity['executor']>;
+/** One attempt of one Step: its journal name, its Execution, its key sequence and its bounds. */
+export interface StepAttempt {
+    readonly name: string;
+    readonly execution: DurableExecution;
+    /** The next key of the Step's sequence; the sequence restarts with every attempt. */
+    readonly next: () => string;
+    readonly lifetime: Lifetime;
+}
+/** What one Step attempt holds, released once the attempt ends. */
+export interface StepAuthorityBinding {
+    readonly authority: DurableStepAuthority;
+    close(): void;
+}
+/** Bind the capabilities one Step attempt holds. */
+export type StepAuthorities = (attempt: StepAttempt) => StepAuthorityBinding;
+/**
+ * Steps acting as the Domain through a Session of the Execution they belong to: the capabilities of
+ * an Action over the keyed Session, and the Runtime's Integration clients over the same keys.
+ */
+export declare function sessionSteps(input: {
+    readonly executor: Executor;
+    readonly domain: Domain;
+    readonly integrations: IntegrationClientFactory<Integrations>;
+}): StepAuthorities;
+/**
+ * Every Mutation and every `invoke` of a durable callable of one Step without its own key carries
+ * the next key of the Step's sequence. The sequence restarts with every attempt, so a retried Step
+ * replays the same keys: the Kernel answers a Mutation with its receipt and a durable call with the
+ * Execution it started, or refuses a request that changed under its key. Any other `invoke` carries
+ * no key, because the Kernel accepts one only for a durable Function, and runs again with the Step.
+ */
+export declare function keyed<Session extends Pick<BoundClientSession, 'invoke' | 'mutate'>>(session: Session, domain: Domain, next: () => string): Session;
+/** The key sequence of one Step of one Execution: `<execution>.<digest of the name>.<position>`. */
+export declare function keySequence(execution: DurableExecution['id'], name: string): Promise<() => string>;
+export {};