@astrale-os/sdk 0.6.0-beta.0 → 0.6.0-beta.10

package/dist/application/workflow/step/output.js

@@ -0,0 +1,73 @@
+import * as value from '../../../platform/value/index.js';
+/** Capture optional Object fields as absence without changing portable Array or scalar semantics. */
+export function acceptStepOutput(input) {
+    if (input === undefined)
+        return input;
+    const captured = new WeakMap();
+    const omitted = new WeakMap();
+    const pending = [];
+    let members = 0;
+    function capture(source, depth) {
+        if (source === null || typeof source !== 'object')
+            return source;
+        const retained = captured.get(source);
+        if (retained !== undefined)
+            return retained;
+        if (depth >= value.defaultLimits.maxDepth) {
+            throw new value.BoundaryError('VALUE_LIMIT', 'Workflow Step container depth exceeds the portable limit', '');
+        }
+        const array = Array.isArray(source);
+        const snapshot = array ? [] : Object.create(Object.getPrototypeOf(source));
+        captured.set(source, snapshot);
+        pending.push({ source, snapshot, depth, array });
+        return snapshot;
+    }
+    const snapshot = capture(input, 0);
+    for (let index = 0; index < pending.length; index += 1) {
+        const { source, snapshot: container, depth, array } = pending[index];
+        const descriptors = Object.getOwnPropertyDescriptors(source);
+        const keys = Reflect.ownKeys(descriptors);
+        // Bound this preparatory capture too; canonical admission subsequently checks each path.
+        members += keys.length - (array ? 1 : 0);
+        if (members > value.defaultLimits.maxMembers) {
+            throw new value.BoundaryError('VALUE_LIMIT', 'Workflow Step member count exceeds the portable limit', '');
+        }
+        const absent = new Set();
+        for (const key of keys) {
+            const descriptor = Object.getOwnPropertyDescriptor(descriptors, key)
+                .value;
+            if ('value' in descriptor) {
+                if (!array &&
+                    typeof key === 'string' &&
+                    descriptor.enumerable &&
+                    descriptor.value === undefined) {
+                    // Validate this member's key, descriptor and budget before interpreting its absence.
+                    descriptor.value = null;
+                    absent.add(key);
+                }
+                else {
+                    descriptor.value = capture(descriptor.value, depth + 1);
+                }
+            }
+            Object.defineProperty(container, key, descriptor);
+        }
+        if (absent.size > 0)
+            omitted.set(container, absent);
+    }
+    // The canonical owner still rejects cycles, invalid descriptors/prototypes/keys and lossy values.
+    const output = value.accept(snapshot);
+    const pruning = [{ snapshot, output }];
+    for (let index = 0; index < pruning.length; index += 1) {
+        const pair = pruning[index];
+        if (pair.output === null || typeof pair.output !== 'object')
+            continue;
+        const source = pair.snapshot;
+        const target = pair.output;
+        for (const key of omitted.get(source) ?? [])
+            delete target[key];
+        for (const key of Object.keys(target)) {
+            pruning.push({ snapshot: source[key], output: target[key] });
+        }
+    }
+    return output;
+}

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

@@ -12,11 +12,23 @@ export type WorkflowAddress<Schema extends schema.DomainSchema> = ActionAddressO
 export type CallableAtWorkflowAddress<Schema extends schema.DomainSchema, Address extends WorkflowAddress<Schema>> = WorkflowCallable<Extract<CallableAtAddress<Schema, Address>, ResolvedCallable>>;
 export type Workflow<Callable extends ResolvedCallable, Definitions extends Integrations = Readonly<Record<never, never>>, DomainValue extends Domain = Domain, Errors extends DeclaredErrors = NoDeclaredErrors> = (context: WorkflowContext<Callable, DomainValue, Definitions, Errors>) => Promise<ActionOutputOf<Callable>>;
 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/environment.d.ts

@@ -0,0 +1,6 @@
+/**
+ * The name of a project environment, the target a deployment is made for (`staging`, `production`,
+ * `pr-42`), as `defineProject` admits it: lower-case letters, digits, `.`, `_` and `-`, starting and
+ * ending with a letter or a digit. It stays Worker-safe because a deployment name renders it.
+ */
+export declare const ENVIRONMENT_NAME: RegExp;

package/dist/deployment/environment.js

@@ -0,0 +1,6 @@
+/**
+ * The name of a project environment, the target a deployment is made for (`staging`, `production`,
+ * `pr-42`), as `defineProject` admits it: lower-case letters, digits, `.`, `_` and `-`, starting and
+ * ending with a letter or a digit. It stays Worker-safe because a deployment name renders it.
+ */
+export const ENVIRONMENT_NAME = /^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/u;

package/dist/deployment/release/publication/seal.d.ts

@@ -1,5 +1,5 @@
 import * as publication from '@astrale-os/kernel-protocol/publication';
-import * as protocolRoutes from '@astrale-os/kernel-protocol/routes';
+import * as protocolRoutes from '@astrale-os/kernel-protocol/routes/legacy';
 import type { Build } from '../../build/index.js';
 import type { Addressing } from '../addressing.js';
 export declare const DELIVERY_PATH: '/install';

package/dist/deployment/release/publication/seal.js

@@ -1,5 +1,5 @@
 import * as publication from '@astrale-os/kernel-protocol/publication';
-import * as protocolRoutes from '@astrale-os/kernel-protocol/routes';
+import * as protocolRoutes from '@astrale-os/kernel-protocol/routes/legacy';
 import { evidenceOf } from '../../build/admission.js';
 import { callables } from './callables.js';
 import { manifest } from './manifest.js';

package/dist/deployment/release/release.d.ts

@@ -1,5 +1,5 @@
 import type * as publication from '@astrale-os/kernel-protocol/publication';
-import type * as routes from '@astrale-os/kernel-protocol/routes';
+import type * as routes from '@astrale-os/kernel-protocol/routes/legacy';
 import type { Build } from '../build/index.js';
 import type { Addressing } from './addressing.js';
 export interface Release<BuildValue extends Build = Build> {

package/dist/deployment/verify/preflight/publication.js

@@ -1,4 +1,5 @@
-import { publication as protocolPublication, routes } from '@astrale-os/kernel-protocol';
+import { publication as protocolPublication } from '@astrale-os/kernel-protocol';
+import * as routes from '@astrale-os/kernel-protocol/routes/legacy';
 import { evidenceOf } from '../../build/admission.js';
 import { assemble } from '../../release/index.js';
 /** Verify locally assemblable Publication evidence before any provider mutation. */

package/dist/execution/identity/authentication.d.ts

@@ -4,6 +4,7 @@ import type { AuthenticatedInvocation } from '../invocation/index.js';
 import type { InvocationAdmissionInput } from '../invocation/index.js';
 import type { IdentityNetworkPolicy, VerificationBasis, VerificationBasisResolver } from './jwks.js';
 import type { SigningMaterial } from './signing.js';
+import { ClientSession } from '../../platform/client/session/index.js';
 export declare function admit(request: InvocationAdmissionInput, configuration: AuthenticationConfiguration): Promise<unknown>;
 export interface AuthenticationConfiguration {
     readonly issuer: IssuerId;
@@ -17,5 +18,13 @@ export declare function authenticate(credentialInput: CredentialInput, expectedK
     readonly deadline: number;
     readonly signal: AbortSignal;
 }, configuration: AuthenticationConfiguration): Promise<AuthenticatedInvocation>;
+/**
+ * The Domain's own authority toward one Kernel, for work no caller credential carries: a durable
+ * run acts as its executor, never as its initiator. The caller owns the returned Session.
+ */
+export declare function executorSession(kernel: IssuerId, execution: {
+    readonly deadline: number;
+    readonly signal: AbortSignal;
+}, configuration: AuthenticationConfiguration): ClientSession;
 export declare function acceptResolvedDelegation(input: unknown): Grant;
 export type { VerificationBasis };

package/dist/execution/identity/authentication.js

@@ -7,8 +7,8 @@ import { bindSession, ClientSession } from '../../platform/client/session/index.
 import { NodeId } from '../../platform/graph/node/index.js';
 import { Path } from '../../platform/graph/path/index.js';
 import { projectError, protocolError } from '../invocation/result/index.js';
-import { callbackIdentities, createCallbackCredentialResolver, maximumCallbackDelegationTtlSeconds, signDomainCallback, } from './callback.js';
-import { CredentialRejected, IssuerUnavailable, boundedFetch, callbackTtl, invocationUrl, admitEndpoint, requireLive, } from './errors.js';
+import { callbackIdentities, createCallbackCredentialResolver, maximumCallbackDelegationTtlSeconds, selfIdentity, signDomainCallback, } from './callback.js';
+import { CredentialRejected, IssuerUnavailable, boundedFetch, callbackTtl, httpIssuer, invocationUrl, admitEndpoint, requireLive, } from './errors.js';
 import { verifyCredential, verifyCredentialAgainst } from './jwks.js';
 const DEFAULT_ROUTE_AGE_MS = 60_000;
 export async function admit(request, configuration) {
@@ -32,10 +32,7 @@ export async function admit(request, configuration) {
         }), {
             signal: execution.signal,
             timeoutMs: Math.max(1, execution.deadline - Date.now()),
-            delegate: {
-                ttlSeconds: callbackTtl(execution.deadline),
-                attenuation: { kind: 'identity', self: true },
-            },
+            delegate: { ttlSeconds: callbackTtl(execution.deadline) },
         });
         return result.value;
     }
@@ -53,10 +50,11 @@ export async function authenticate(credentialInput, expectedKernel, execution, c
         throw protocolError('AUTH_INVALID', 'Credential is invalid.');
     }
     const expressions = callbackIdentities(established.delegation.credential);
+    const session = (expression) => callbackSession(expectedKernel, expression, established.verified, execution, configuration);
     const sessions = Object.freeze({
-        caller: callbackSession(expressions.caller),
-        self: callbackSession(expressions.self),
-        union: callbackSession(expressions.union),
+        caller: session(expressions.caller),
+        self: session(expressions.self),
+        union: session(expressions.union),
     });
     const graph = Object.freeze({
         caller: bindSession(sessions.caller, execution),
@@ -76,32 +74,41 @@ export async function authenticate(credentialInput, expectedKernel, execution, c
             sessions.union.close();
         },
     });
-    function callbackSession(expression) {
-        const resolveCallback = createCallbackCredentialResolver(configuration.signing, configuration.issuer, configuration.subject, expectedKernel, expression, established.verified, execution);
-        return new ClientSession({
-            kernel: expectedKernel,
-            fetch: boundedFetch(configuration.fetch, execution.signal),
-            auth: {
-                ttlSeconds: Math.min(callbackTtl(execution.deadline), maximumCallbackDelegationTtlSeconds),
-                async resolve(_call, signal) {
-                    const callback = await resolveCallback(signal);
-                    signal.throwIfAborted();
-                    return {
-                        credential: callback.credential,
-                        delegate: { ttlSeconds: callback.delegateTtlSeconds },
-                    };
-                },
-            },
-            policy: {
-                maximumRouteAgeMs: DEFAULT_ROUTE_AGE_MS,
-                ...(configuration.policy.allowEndpoint === undefined
-                    ? {}
-                    : { allowEndpoint: configuration.policy.allowEndpoint }),
-                ...(configuration.policy.allowInsecureHttp === true ? { allowInsecureHttp: true } : {}),
+}
+/**
+ * The Domain's own authority toward one Kernel, for work no caller credential carries: a durable
+ * run acts as its executor, never as its initiator. The caller owns the returned Session.
+ */
+export function executorSession(kernel, execution, configuration) {
+    const admitted = httpIssuer(kernel, configuration.policy.allowInsecureHttp === true);
+    admitEndpoint(invocationUrl(admitted), configuration.policy);
+    return callbackSession(admitted, selfIdentity, undefined, execution, configuration);
+}
+function callbackSession(kernel, expression, carrier, execution, configuration) {
+    const resolveCallback = createCallbackCredentialResolver(configuration.signing, configuration.issuer, configuration.subject, kernel, expression, carrier, execution);
+    return new ClientSession({
+        kernel,
+        fetch: boundedFetch(configuration.fetch, execution.signal),
+        auth: {
+            ttlSeconds: Math.min(callbackTtl(execution.deadline), maximumCallbackDelegationTtlSeconds),
+            async resolve(_call, signal) {
+                const callback = await resolveCallback(signal);
+                signal.throwIfAborted();
+                return {
+                    credential: callback.credential,
+                    delegate: { ttlSeconds: callback.delegateTtlSeconds },
+                };
             },
-            timeoutMs: Math.max(1, execution.deadline - Date.now()),
-        });
-    }
+        },
+        policy: {
+            maximumRouteAgeMs: DEFAULT_ROUTE_AGE_MS,
+            ...(configuration.policy.allowEndpoint === undefined
+                ? {}
+                : { allowEndpoint: configuration.policy.allowEndpoint }),
+            ...(configuration.policy.allowInsecureHttp === true ? { allowInsecureHttp: true } : {}),
+        },
+        timeoutMs: Math.max(1, execution.deadline - Date.now()),
+    });
 }
 async function establishCaller(input, audience, verification, execution, policy) {
     requireLive(execution);

package/dist/execution/identity/callback.d.ts

@@ -8,6 +8,11 @@ export interface SignedCallback {
     readonly delegateTtlSeconds: number;
 }
 export type CallbackGrantMode = 'caller' | 'self' | 'union';
+/** The Domain's own authority, independent of any caller. */
+export declare const selfIdentity: Readonly<{
+    kind: 'identity';
+    self: true;
+}>;
 /** Exact callback Grant expressions corresponding to the Kernel Domain graph modes. */
 export declare function callbackIdentities(nested: string | Uint8Array): Readonly<{
     caller: Readonly<{
@@ -22,10 +27,10 @@ export declare function callbackIdentities(nested: string | Uint8Array): Readonl
         kind: 'union';
         operands: readonly (Readonly<{
             kind: 'identity';
-            credential: string | Uint8Array<ArrayBufferLike>;
+            self: true;
         }> | Readonly<{
             kind: 'identity';
-            self: true;
+            credential: string | Uint8Array<ArrayBufferLike>;
         }>)[];
     }>;
 }>;
@@ -37,8 +42,11 @@ export declare function signCallback(signing: SigningMaterial, issuer: IssuerId,
     readonly deadline: number;
     readonly signal: AbortSignal;
 }): Promise<string>;
-/** Reuse one exact callback authority partition, refreshing only near its bounded expiry. */
-export declare function createCallbackCredentialResolver(signing: SigningMaterial, issuer: IssuerId, subject: string, audience: IssuerId, expression: UnresolvedIdentityExpr, carrier: VerifiedCredential, execution: {
+/**
+ * Reuse one exact callback authority partition, refreshing only near its bounded expiry. Without a
+ * carrier the callback is the Domain's own authority, bounded by the execution alone.
+ */
+export declare function createCallbackCredentialResolver(signing: SigningMaterial, issuer: IssuerId, subject: string, audience: IssuerId, expression: UnresolvedIdentityExpr, carrier: VerifiedCredential | undefined, execution: {
     readonly deadline: number;
     readonly signal: AbortSignal;
 }): (signal: AbortSignal) => Promise<SignedCallback>;

package/dist/execution/identity/callback.js

@@ -4,10 +4,12 @@ import { requireLive } from './errors.js';
 export const maximumCallbackTtlSeconds = 120;
 export const maximumCallbackDelegationTtlSeconds = 60;
 const CALLBACK_DELEGATION_SKEW_SECONDS = 5;
+/** The Domain's own authority, independent of any caller. */
+export const selfIdentity = Object.freeze({ kind: 'identity', self: true });
 /** Exact callback Grant expressions corresponding to the Kernel Domain graph modes. */
 export function callbackIdentities(nested) {
     const caller = Object.freeze({ kind: 'identity', credential: nested });
-    const self = Object.freeze({ kind: 'identity', self: true });
+    const self = selfIdentity;
     return Object.freeze({
         caller,
         self,
@@ -18,15 +20,18 @@ export function callbackIdentities(nested) {
     });
 }
 export async function signDomainCallback(signing, issuer, subject, audience, execution) {
-    return (await sign(signing, issuer, subject, audience, { kind: 'identity', self: true }, execution)).credential;
+    return (await sign(signing, issuer, subject, audience, selfIdentity, execution)).credential;
 }
 export async function signCallback(signing, issuer, subject, audience, expression, carrier, execution) {
     const maximum = carrier.exp ?? Number.POSITIVE_INFINITY;
     return (await sign(signing, issuer, subject, audience, expression, execution, maximum)).credential;
 }
-/** Reuse one exact callback authority partition, refreshing only near its bounded expiry. */
+/**
+ * Reuse one exact callback authority partition, refreshing only near its bounded expiry. Without a
+ * carrier the callback is the Domain's own authority, bounded by the execution alone.
+ */
 export function createCallbackCredentialResolver(signing, issuer, subject, audience, expression, carrier, execution) {
-    const maximum = carrier.exp ?? Number.POSITIVE_INFINITY;
+    const maximum = carrier?.exp ?? Number.POSITIVE_INFINITY;
     let cached;
     let pending;
     return async (signal) => {

package/dist/execution/identity/identity.d.ts

@@ -2,6 +2,7 @@ import type { Fetch } from '@astrale-os/kernel-client';
 import type * as publicationProtocol from '@astrale-os/kernel-protocol/publication';
 import type { Issuer, exchange, publication } from '@astrale-os/kernel-server';
 import type { IssuerId, JsonWebKey } from '../../platform/auth/index.js';
+import type { ClientSession } from '../../platform/client/session/index.js';
 import type { InvocationAuthority } from '../invocation/index.js';
 import type { ExchangeOptions } from './exchange.js';
 import type { IdentityNetworkPolicy } from './jwks.js';
@@ -10,6 +11,14 @@ export interface Identity extends Issuer, InvocationAuthority {
     readonly subject: string;
     readonly tokenExchange?: exchange.Provider;
     delivery(publication: publicationProtocol.Publication): publication.delivery.Provider;
+    /**
+     * The Domain's own authority toward one Kernel for work no caller credential carries, such as a
+     * durable run. Required to serve durable Workflows; the caller closes the Session.
+     */
+    executor?(kernel: IssuerId, execution: {
+        readonly deadline: number;
+        readonly signal: AbortSignal;
+    }): ClientSession;
 }
 export interface IdentityInput extends IdentityNetworkPolicy {
     readonly issuer: IssuerId;

package/dist/execution/identity/identity.js

@@ -1,4 +1,4 @@
-import { admit, authenticate } from './authentication.js';
+import { admit, authenticate, executorSession } from './authentication.js';
 import { publicationDelivery } from './delivery.js';
 import { httpIssuer } from './errors.js';
 import { maximumExchangeTtl, tokenExchange } from './exchange.js';
@@ -51,6 +51,7 @@ export function createIdentity(input) {
         ...(exchangeProvider === undefined ? {} : { tokenExchange: exchangeProvider }),
         delivery: (publication) => publicationDelivery(material, issuer, input.subject, publication),
         admit: (request) => admit(request, configuration),
+        executor: (kernel, execution) => executorSession(kernel, execution, configuration),
         authenticate: (request) => authenticate(request.credential, request.via.issuer, request.context.execution, configuration),
     });
 }
@@ -67,6 +68,7 @@ export function identity(input) {
         'delivery',
         'admit',
         'authenticate',
+        'executor',
     ]);
     if (Reflect.ownKeys(input).some((key) => !allowed.has(key)) ||
         typeof input.subject !== 'string' ||
@@ -74,7 +76,8 @@ export function identity(input) {
         typeof input.loadPublicKeys !== 'function' ||
         typeof input.delivery !== 'function' ||
         typeof input.admit !== 'function' ||
-        typeof input.authenticate !== 'function') {
+        typeof input.authenticate !== 'function' ||
+        (input.executor !== undefined && typeof input.executor !== 'function')) {
         invalid();
     }
     const receiver = Object.freeze({ ...input });
@@ -92,6 +95,7 @@ export function identity(input) {
         delivery: receiver.delivery.bind(receiver),
         admit: receiver.admit.bind(receiver),
         authenticate: receiver.authenticate.bind(receiver),
+        ...(receiver.executor === undefined ? {} : { executor: receiver.executor.bind(receiver) }),
     });
 }
 function invalid() {

package/dist/execution/index.d.ts

@@ -1,5 +1,7 @@
 export { serve } from './serve.js';
 export type { ExecutionContext, ServedApplication, ServeInput } from './serve.js';
-export { createIdentity, type ExchangeOptions, type Identity, type IdentityInput, } from './identity/index.js';
+export { createIdentity, maximumExchangeTtl, type ExchangeOptions, type Identity, type IdentityInput, } from './identity/index.js';
 export { InvocationError } from './invocation/index.js';
 export type { InvocationErrorCode } from './invocation/index.js';
+export type { DurableEngine, DurableServing, DurableServingProvider } from './workflows/index.js';
+export { isCanonicalDurableRequest, isLegacyDurableRequest } from './workflows/route.js';

package/dist/execution/index.js

@@ -1,3 +1,4 @@
 export { serve } from './serve.js';
-export { createIdentity, } from './identity/index.js';
+export { createIdentity, maximumExchangeTtl, } from './identity/index.js';
 export { InvocationError } from './invocation/index.js';
+export { isCanonicalDurableRequest, isLegacyDurableRequest } from './workflows/route.js';

package/dist/execution/invocation/admission/authority.d.ts

@@ -7,14 +7,14 @@ import type { Domain } from '../../../platform/schema/index.js';
 export interface InvocationAdmissionInput {
     readonly call: invocation.Call;
     readonly credential?: string;
-    readonly via: invocation.Via;
+    readonly via: invocation.Via | invocation.PublicationVia;
     readonly publication: publication.Publication;
     readonly domain: Domain;
     readonly context: InvocationContext;
 }
 export interface InvocationAuthenticationInput {
     readonly credential: string;
-    readonly via: invocation.Via;
+    readonly via: invocation.Via | invocation.PublicationVia;
     readonly publication: publication.Publication;
     readonly domain: Domain;
     readonly context: InvocationContext;
@@ -31,4 +31,4 @@ export interface InvocationAuthority {
 }
 /** Capture the execution Identity capability and receiver-bind both privileged operations. */
 export declare function authority(input: InvocationAuthority): InvocationAuthority;
-export declare function requireVia(request: HandlerRequest): invocation.Via;
+export declare function requireVia(request: HandlerRequest): invocation.Via | invocation.PublicationVia;

package/dist/execution/invocation/admission/input.d.ts

@@ -1,2 +1,2 @@
-import type { ResolvedCallable } from '../../../application/action/index.js';
-export declare function input(callable: ResolvedCallable, value: unknown): void;
+import type { ResolvedCallable, ActionBinaryInput } from '../../../application/action/index.js';
+export declare function input(callable: ResolvedCallable, value: unknown, binary?: ActionBinaryInput): void;

package/dist/execution/invocation/admission/input.js

@@ -1,4 +1,18 @@
-import { validateInput } from '../result/index.js';
-export function input(callable, value) {
+import { isBinaryInput } from '@astrale-os/kernel-dsl/v1/language';
+import { validateInput, protocolError } from '../result/index.js';
+export function input(callable, value, binary) {
+    if (isBinaryInput(callable.input)) {
+        if (binary === undefined) {
+            throw protocolError('VALIDATION_ERROR', 'Binary Function request body is required.');
+        }
+        if (!Number.isSafeInteger(binary.length) ||
+            binary.length < 0 ||
+            binary.length > callable.input.maximumBytes) {
+            throw protocolError('LIMIT_EXCEEDED', 'Binary Function request body exceeds its limit.');
+        }
+    }
+    else if (binary !== undefined) {
+        throw protocolError('VALIDATION_ERROR', 'Callable does not accept a binary request body.');
+    }
     validateInput(callable, value);
 }

package/dist/execution/invocation/dependency/bind.js

@@ -1,4 +1,5 @@
 import { Key } from '@astrale-os/kernel-dsl/v1/addressing';
+import { isBinaryInput } from '@astrale-os/kernel-dsl/v1/language';
 import { reference } from '../../../platform/client/session/index.js';
 import { NodeId } from '../../../platform/graph/node/index.js';
 import { Path } from '../../../platform/graph/path/index.js';
@@ -20,19 +21,14 @@ function bindDependency(dependency, session) {
     const invoke = session.invoke.bind(session);
     return Object.freeze({
         async invoke(select, ...args) {
-            if (typeof select !== 'function')
-                invalid();
-            const selected = select(dependency);
-            if (selected === null ||
-                typeof selected !== 'object' ||
-                !('key' in selected) ||
-                typeof selected.key !== 'string')
-                invalid();
-            const callable = dependency.callable(selected.key);
-            if (callable !== selected || Key.origin(callable.key) !== dependency.origin)
-                invalid();
-            if ('owner' in callable && (!callable.executable || !ownMethod(dependency, callable)))
-                invalid();
+            const callable = selectedCallable(dependency, select);
+            if (isBinaryInput(callable.input)) {
+                if ('owner' in callable || args.length !== 2)
+                    invalid();
+                // Runtime selection is wider than the authored Function; mode was checked above.
+                const binaryReference = reference(dependency, callable);
+                return invoke(binaryReference, args[0], binaryOptions(args[1]));
+            }
             if ('owner' in callable && !callable.static) {
                 if (args.length < 2 || args.length > 3 || typeof args[0] !== 'string')
                     invalid();
@@ -45,6 +41,22 @@ function bindDependency(dependency, session) {
         },
     });
 }
+function selectedCallable(domain, select) {
+    if (typeof select !== 'function')
+        invalid();
+    const selected = select(domain);
+    if (selected === null ||
+        typeof selected !== 'object' ||
+        !('key' in selected) ||
+        typeof selected.key !== 'string')
+        invalid();
+    const callable = domain.callable(selected.key);
+    if (callable !== selected || Key.origin(callable.key) !== domain.origin)
+        invalid();
+    if ('owner' in callable && (!callable.executable || !ownMethod(domain, callable)))
+        invalid();
+    return callable;
+}
 function ownMethod(domain, callable) {
     const owner = Object.values(domain.classes).find((value) => value === callable.owner);
     if (owner === undefined)
@@ -63,6 +75,16 @@ function options(value) {
     // Canonical ClientSession admits option values and clamps them to the parent lifetime.
     return value;
 }
+function binaryOptions(value) {
+    if (value === null ||
+        typeof value !== 'object' ||
+        Array.isArray(value) ||
+        !Object.hasOwn(value, 'body') ||
+        !(value.body instanceof Blob) ||
+        Reflect.ownKeys(value).some((key) => key !== 'body' && key !== 'timeoutMs'))
+        invalid();
+    return value;
+}
 function invalid() {
     throw new TypeError('Dependency invocation requires one owned executable callable, its input, and valid instance/options.');
 }

package/dist/execution/invocation/dispatch/context.d.ts

@@ -1,5 +1,5 @@
 import type { HandlerRequest } from '@astrale-os/kernel-server';
-import type { ActionExecution, Caller, DomainGraphExecutors, DomainKernelSessions } from '../../../application/action/index.js';
+import type { ActionExecution, ActionBinaryInput, Caller, DomainGraphExecutors, DomainKernelSessions } from '../../../application/action/index.js';
 import type { HandlerDependencies } from '../../../application/dependency/index.js';
 import type { MutationExecutor } from '../../../application/mutation/index.js';
 import type { QueryExecutor } from '../../../application/query/index.js';
@@ -10,6 +10,7 @@ import type { InvocationAuthentication } from '../admission/index.js';
 export interface DispatchContext {
     readonly domain: Domain;
     readonly input: unknown;
+    readonly body?: ActionBinaryInput;
     readonly caller: Caller;
     readonly dependencies: HandlerDependencies<Domain> | null;
     readonly kernel: DomainKernelSessions | null;

package/dist/execution/invocation/dispatch/context.js

@@ -17,6 +17,7 @@ export function context(request, runtime, authentication, self) {
     return Object.freeze({
         domain: runtime.loaded.domain,
         input: request.call.input,
+        ...(request.context.binary === undefined ? {} : { body: request.context.binary }),
         caller: authentication.caller,
         kernel: authentication.graph === null
             ? null

package/dist/execution/invocation/invocation.js

@@ -26,11 +26,16 @@ export async function invoke(request, inputConfig) {
     const selected = select(inputConfig.runtime.loaded.registry, selectedTarget);
     if (selected === undefined)
         return Object.freeze({ kind: 'miss' });
-    input(selected.implementation.callable, request.call.input);
+    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);
     const admittedAuthentication = await authentication(selected.implementation.callable, request, release, inputConfig.runtime.loaded.domain, inputConfig.authority);
     const close = once(admittedAuthentication.close);
-    active(request.context);
     try {
+        active(request.context);
         const dispatchContext = context(request, inputConfig.runtime, admittedAuthentication, selected.self);
         const output = selected.implementation.kind === 'action'
             ? await action(selected.implementation, dispatchContext)

package/dist/execution/serve.d.ts

@@ -5,6 +5,7 @@ import type { WorkflowRunner } from '../application/workflow/runner/index.js';
 import type { Identity } from './identity/index.js';
 import type { ReleaseLoader } from './service/index.js';
 import type { ServiceServerOptions } from './service/index.js';
+import type { DurableServingProvider } from './workflows/index.js';
 export interface ExecutionContext {
     waitUntil(promise: Promise<unknown>): void;
     readonly sleep?: (durationMs: number) => Promise<void>;
@@ -17,6 +18,11 @@ export interface ServeInput<Environment, RuntimeValue extends Runtime, RuntimeEn
     readonly server: ServiceServerOptions;
     readonly delivery?: (environment: Environment) => publication.delivery.Provider | undefined;
     readonly workflows?: WorkflowRunner;
+    /**
+     * 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.
+     */
+    readonly durable?: (environment: Environment, request: Request) => ReturnType<DurableServingProvider>;
 }
 export interface ServedApplication<Environment> {
     fetch(request: Request, environment: Environment, context?: ExecutionContext): Promise<Response>;

package/dist/execution/serve.js

@@ -22,6 +22,9 @@ export function serve(input) {
             server: input.server,
             ...(input.delivery === undefined ? {} : { delivery: input.delivery(environment) }),
             ...(input.workflows === undefined ? {} : { workflows: input.workflows }),
+            ...(input.durable === undefined
+                ? {}
+                : { durable: (request) => input.durable(environment, request) }),
         });
         if (drained)
             service.drain();