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

package/dist/deployment/worker/response.d.ts

@@ -0,0 +1,101 @@
+import type { WorkerRecord, WorkerRecordWireV1 } from './record.js';
+/** Where a Worker host addresses Services and deployments. */
+export interface WorkerHostingV1 {
+    /**
+     * The DNS name every URL ends with: `https://<service>.<routingDomain>` serves a Service's
+     * current deployment, `https://<label>.<routingDomain>` one deployment.
+     */
+    readonly routingDomain: string;
+}
+/** What a host lists: the deployments of the caller's Services, optionally of one project or environment. */
+export interface WorkerDeploymentListRequestV1 {
+    readonly project?: string;
+    readonly environment?: string;
+}
+/** The lifecycle of one deployment at its host. */
+export type WorkerDeploymentState = 'deploying' | 'active' | 'retiring' | 'retired' | 'failed';
+/**
+ * What a host knows of one deployment. It names a deployment by its label and URL, never by a
+ * provider version. A host keeps every deployment until it is retired: it has no preview, expiry or
+ * last call.
+ */
+export interface WorkerDeploymentSummaryV1 {
+    /** The host's id of the deployment (a node id on Admin's Services). */
+    readonly id: string;
+    readonly url: string;
+    readonly label: string;
+    /** The host's id of the Service this deployment is a version of. */
+    readonly serviceId: string;
+    /** The name of that Service: the first part of the label. */
+    readonly service: string;
+    readonly project: string;
+    readonly environment: string;
+    /** Who owns the Service (an Identity node path on Admin's Services). */
+    readonly owner: string;
+    readonly state: WorkerDeploymentState;
+    /** Whether the Service's stable URL serves this deployment. */
+    readonly current: boolean;
+    readonly createdAt: string;
+    /** When its retirement began; present once it is `retiring`. */
+    readonly retiredAt?: string;
+    readonly buildDigest: string;
+    /** The digest of its `WorkerConfigurationV1`. */
+    readonly configuration: string;
+    /** The RFC 7638 thumbprint of its key, when its configuration asked for a signing identity. */
+    readonly signingKeyId?: string;
+    /** The record it serves, when its configuration asked for one. */
+    readonly record?: WorkerRecordWireV1;
+}
+/** One summary with its record decoded. */
+export type WorkerDeploymentSummary = Omit<WorkerDeploymentSummaryV1, 'record'> & {
+    readonly record?: WorkerRecord;
+};
+/** Why a host refused to host one Worker release. A refusal changed nothing (see each reason). */
+export type WorkerDeploymentRejectionReason = 'invalid-deployment' | 'address-mismatch' | 'build-mismatch' | 'service-owned-elsewhere' | 'deployment-conflict' | 'deployment-retired' | 'hosting-unavailable' | 'service-unavailable';
+export declare const WORKER_DEPLOYMENT_REJECTIONS: readonly WorkerDeploymentRejectionReason[];
+/**
+ * `WorkerDeploymentResponseV1`: a deployment `created` with the request's secrets `bound` to it,
+ * or `reused` with its declared secrets rewritten in place (`updated`) or left `unchanged`, or a
+ * refusal. A refusal changed nothing, except that a `service-unavailable` may follow effects (a
+ * creation that lost its lease after uploading, an in-place rewrite that wrote part of the
+ * values): rerunning the same deploy converges.
+ */
+export type WorkerDeploymentResponseV1 = {
+    readonly kind: 'deployed';
+    readonly state: 'created' | 'reused';
+    readonly secrets: {
+        readonly state: 'bound' | 'updated' | 'unchanged';
+    };
+    readonly deployment: WorkerDeploymentSummaryV1;
+} | WorkerDeploymentRejection;
+export interface WorkerDeploymentRejection {
+    readonly kind: 'rejected';
+    readonly reason: WorkerDeploymentRejectionReason;
+    readonly message: string;
+    /** When a retry may succeed, for a refusal that only waits on another operation. */
+    readonly retryAfter?: string;
+}
+/** One decoded answer of a deploy. */
+export type WorkerDeploymentResult = {
+    readonly kind: 'deployed';
+    readonly state: 'created' | 'reused';
+    readonly secrets: {
+        readonly state: 'bound' | 'updated' | 'unchanged';
+    };
+    readonly deployment: WorkerDeploymentSummary;
+} | WorkerDeploymentRejection;
+/** Admit the answer of a host's `hosting`: exactly its routing domain. */
+export declare function decodeWorkerHosting(input: unknown): WorkerHostingV1;
+/**
+ * Admit the answer of a deploy exactly: a deployment whose state reports the secret state it
+ * pairs with, or a refusal a host can give.
+ */
+export declare function decodeWorkerDeploymentResponse(input: unknown): WorkerDeploymentResult;
+/** Admit the answer of a host's `list`: the summaries of the caller's deployments, in its order. */
+export declare function decodeWorkerDeploymentList(input: unknown): readonly WorkerDeploymentSummary[];
+/**
+ * Admit one summary exactly: node ids and names a person can read, a label whose first part is
+ * the Service's name, the URL of that label, a known state, instants, digests, and a record that
+ * decodes.
+ */
+export declare function decodeWorkerDeploymentSummary(input: unknown): WorkerDeploymentSummary;

package/dist/deployment/worker/response.js

@@ -0,0 +1,207 @@
+import { parseDeploymentLabel } from '../address/label.js';
+import { serviceName } from './address.js';
+import { decodeWorkerRecord } from './record.js';
+export const WORKER_DEPLOYMENT_REJECTIONS = Object.freeze([
+    'invalid-deployment',
+    'address-mismatch',
+    'build-mismatch',
+    'service-owned-elsewhere',
+    'deployment-conflict',
+    'deployment-retired',
+    'hosting-unavailable',
+    'service-unavailable',
+]);
+const STATES = Object.freeze([
+    'deploying',
+    'active',
+    'retiring',
+    'retired',
+    'failed',
+]);
+/** Which secret states each deployment state reports. */
+const SECRETS_BY_STATE = Object.freeze({
+    created: Object.freeze(['bound']),
+    reused: Object.freeze(['updated', 'unchanged']),
+});
+/** Admit the answer of a host's `hosting`: exactly its routing domain. */
+export function decodeWorkerHosting(input) {
+    const value = exact(input, ['routingDomain'], [], 'hosting');
+    if (typeof value.routingDomain !== 'string' || !isDnsName(value.routingDomain)) {
+        invalid('hosting', 'routingDomain');
+    }
+    return Object.freeze({ routingDomain: value.routingDomain });
+}
+/**
+ * Admit the answer of a deploy exactly: a deployment whose state reports the secret state it
+ * pairs with, or a refusal a host can give.
+ */
+export function decodeWorkerDeploymentResponse(input) {
+    const value = exact(input, ['kind'], ['state', 'secrets', 'deployment', 'reason', 'message', 'retryAfter'], 'deploy');
+    if (value.kind === 'rejected') {
+        exact(value, ['kind', 'reason', 'message'], ['retryAfter'], 'refusal');
+        if (!WORKER_DEPLOYMENT_REJECTIONS.includes(value.reason)) {
+            invalid('refusal', 'reason');
+        }
+        if (typeof value.message !== 'string' ||
+            value.message.length < 1 ||
+            value.message.length > 500) {
+            invalid('refusal', 'message');
+        }
+        if (value.retryAfter !== undefined && !isInstant(value.retryAfter)) {
+            invalid('refusal', 'retryAfter');
+        }
+        return Object.freeze({
+            kind: 'rejected',
+            reason: value.reason,
+            message: value.message,
+            ...(value.retryAfter === undefined ? {} : { retryAfter: value.retryAfter }),
+        });
+    }
+    exact(value, ['kind', 'state', 'secrets', 'deployment'], [], 'deploy');
+    if (value.kind !== 'deployed')
+        invalid('deploy', 'kind');
+    if (value.state !== 'created' && value.state !== 'reused')
+        invalid('deploy', 'state');
+    const secrets = exact(value.secrets, ['state'], [], 'secrets');
+    const allowed = SECRETS_BY_STATE[value.state];
+    if (typeof secrets.state !== 'string' || !allowed.includes(secrets.state)) {
+        invalid('deploy', 'secrets.state');
+    }
+    return Object.freeze({
+        kind: 'deployed',
+        state: value.state,
+        secrets: Object.freeze({ state: secrets.state }),
+        deployment: decodeWorkerDeploymentSummary(value.deployment),
+    });
+}
+/** Admit the answer of a host's `list`: the summaries of the caller's deployments, in its order. */
+export function decodeWorkerDeploymentList(input) {
+    const value = exact(input, ['deployments'], [], 'list');
+    if (!Array.isArray(value.deployments))
+        invalid('list', 'deployments');
+    return Object.freeze(value.deployments.map((deployment) => decodeWorkerDeploymentSummary(deployment)));
+}
+/**
+ * Admit one summary exactly: node ids and names a person can read, a label whose first part is
+ * the Service's name, the URL of that label, a known state, instants, digests, and a record that
+ * decodes.
+ */
+export function decodeWorkerDeploymentSummary(input) {
+    const value = exact(input, [
+        'id',
+        'url',
+        'label',
+        'serviceId',
+        'service',
+        'project',
+        'environment',
+        'owner',
+        'state',
+        'current',
+        'createdAt',
+        'buildDigest',
+        'configuration',
+    ], ['retiredAt', 'signingKeyId', 'record'], 'deployment');
+    for (const key of [
+        'id',
+        'url',
+        'label',
+        'serviceId',
+        'service',
+        'project',
+        'environment',
+        'owner',
+    ]) {
+        if (typeof value[key] !== 'string' || !isPrintable(value[key]))
+            invalid('deployment', key);
+    }
+    if (value.signingKeyId !== undefined) {
+        if (typeof value.signingKeyId !== 'string' || !isPrintable(value.signingKeyId)) {
+            invalid('deployment', 'signingKeyId');
+        }
+    }
+    let line;
+    try {
+        line = parseDeploymentLabel(value.label).line;
+    }
+    catch {
+        invalid('deployment', 'label');
+    }
+    if (value.service !== line)
+        invalid('deployment', 'service');
+    let named;
+    try {
+        named = serviceName(value.project, value.environment);
+    }
+    catch {
+        invalid('deployment', 'project');
+    }
+    if (named !== line)
+        invalid('deployment', 'service');
+    if (!isDeploymentUrl(value.url, value.label))
+        invalid('deployment', 'url');
+    if (!STATES.includes(value.state))
+        invalid('deployment', 'state');
+    if (typeof value.current !== 'boolean')
+        invalid('deployment', 'current');
+    if (!isInstant(value.createdAt))
+        invalid('deployment', 'createdAt');
+    if (value.retiredAt !== undefined && !isInstant(value.retiredAt))
+        invalid('deployment', 'retiredAt');
+    for (const key of ['buildDigest', 'configuration']) {
+        if (typeof value[key] !== 'string' || !/^sha256:[0-9a-f]{64}$/u.test(value[key])) {
+            invalid('deployment', key);
+        }
+    }
+    let record;
+    if (value.record !== undefined) {
+        try {
+            record = decodeWorkerRecord(value.record);
+        }
+        catch {
+            invalid('deployment', 'record');
+        }
+    }
+    const summary = { ...value };
+    delete summary.record;
+    return Object.freeze({
+        ...summary,
+        ...(record === undefined ? {} : { record }),
+    });
+}
+/** `https://<label>.<routing domain>`, nothing more. */
+function isDeploymentUrl(url, label) {
+    const prefix = `https://${label}.`;
+    return url.startsWith(prefix) && isDnsName(url.slice(prefix.length));
+}
+/** Text a person can read in a listing: at most 512 characters, none of them a control character. */
+function isPrintable(value) {
+    return value.length > 0 && value.length <= 512 && !/[\p{Cc}]/u.test(value);
+}
+function isInstant(value) {
+    return (typeof value === 'string' &&
+        value.length > 0 &&
+        value.length <= 64 &&
+        !Number.isNaN(Date.parse(value)));
+}
+function isDnsName(value) {
+    return (value.length <= 253 &&
+        value.split('.').every((label) => /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/u.test(label)));
+}
+function exact(input, required, optional, label) {
+    if (input === null || typeof input !== 'object' || Array.isArray(input))
+        invalid(label);
+    const value = input;
+    for (const key of Reflect.ownKeys(value)) {
+        if (typeof key !== 'string' || (!required.includes(key) && !optional.includes(key))) {
+            invalid(label, String(key));
+        }
+    }
+    for (const key of required)
+        if (!Object.hasOwn(value, key))
+            invalid(label, key);
+    return value;
+}
+function invalid(label, member) {
+    throw new TypeError(`The Worker host returned an invalid ${label} answer${member === undefined ? '' : ` (${member})`}.`);
+}

package/dist/execution/cache/cache.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Disposable entries one deployment keeps across its requests, and across its isolates where the
+ * platform shares them. An entry may vanish at any time and never outlives its expiry. A reader
+ * treats a failed or late read as a miss, so nothing that must persist or be coordinated belongs
+ * here: every consumer stays correct when the cache keeps nothing.
+ */
+export interface DeploymentCache {
+    /** The value kept under `key`, or undefined when it expired, vanished or was never kept. */
+    get(key: string): Promise<string | undefined>;
+    /**
+     * Keep `value` under `key` until `expiresAt` (Unix milliseconds) at the latest. The cache may
+     * drop it sooner, or not keep it at all.
+     */
+    put(key: string, value: string, expiresAt: number): Promise<void>;
+}
+/** Capture a caller-supplied cache, receiver-bound, after checking its shape. */
+export declare function deploymentCache(input: DeploymentCache): DeploymentCache;

package/dist/execution/cache/cache.js

@@ -0,0 +1,11 @@
+/** Capture a caller-supplied cache, receiver-bound, after checking its shape. */
+export function deploymentCache(input) {
+    if (input === null ||
+        typeof input !== 'object' ||
+        Array.isArray(input) ||
+        typeof input.get !== 'function' ||
+        typeof input.put !== 'function') {
+        throw new TypeError('Deployment cache is invalid.');
+    }
+    return Object.freeze({ get: input.get.bind(input), put: input.put.bind(input) });
+}

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

@@ -0,0 +1,2 @@
+export { deploymentCache, type DeploymentCache } from './cache.js';
+export { DEFAULT_MEMORY_CACHE_ENTRIES, memoryCache, type MemoryCacheOptions } from './memory.js';

package/dist/execution/cache/index.js

@@ -0,0 +1,2 @@
+export { deploymentCache } from './cache.js';
+export { DEFAULT_MEMORY_CACHE_ENTRIES, memoryCache } from './memory.js';

package/dist/execution/cache/memory.d.ts

@@ -0,0 +1,13 @@
+import type { DeploymentCache } from './cache.js';
+/** Entries one memory cache keeps by default before it evicts the least recently used. */
+export declare const DEFAULT_MEMORY_CACHE_ENTRIES = 1024;
+export interface MemoryCacheOptions {
+    /** Most entries kept at once; the least recently used is evicted first. */
+    readonly maximumEntries?: number;
+}
+/**
+ * A deployment cache held in this process or isolate: bounded, least recently used first out, and
+ * an entry is gone at its expiry. It keeps values only, never a pending operation, so no request
+ * waits on another's I/O.
+ */
+export declare function memoryCache(options?: MemoryCacheOptions, now?: () => number): DeploymentCache;

package/dist/execution/cache/memory.js

@@ -0,0 +1,48 @@
+/** Entries one memory cache keeps by default before it evicts the least recently used. */
+export const DEFAULT_MEMORY_CACHE_ENTRIES = 1_024;
+/**
+ * A deployment cache held in this process or isolate: bounded, least recently used first out, and
+ * an entry is gone at its expiry. It keeps values only, never a pending operation, so no request
+ * waits on another's I/O.
+ */
+export function memoryCache(options = {}, now = Date.now) {
+    if (options === null || typeof options !== 'object' || Array.isArray(options))
+        invalid();
+    const maximum = options.maximumEntries ?? DEFAULT_MEMORY_CACHE_ENTRIES;
+    if (!Number.isSafeInteger(maximum) || maximum < 1) {
+        throw new TypeError('Memory cache maximumEntries must be a positive integer.');
+    }
+    const entries = new Map();
+    return Object.freeze({
+        async get(key) {
+            if (typeof key !== 'string')
+                invalid();
+            const entry = entries.get(key);
+            if (entry === undefined)
+                return undefined;
+            entries.delete(key);
+            if (entry.expiresAt <= now())
+                return undefined;
+            entries.set(key, entry);
+            return entry.value;
+        },
+        async put(key, value, expiresAt) {
+            if (typeof key !== 'string' || typeof value !== 'string' || !Number.isFinite(expiresAt)) {
+                invalid();
+            }
+            entries.delete(key);
+            if (expiresAt <= now())
+                return;
+            while (entries.size >= maximum) {
+                const oldest = entries.keys().next().value;
+                if (oldest === undefined)
+                    break;
+                entries.delete(oldest);
+            }
+            entries.set(key, Object.freeze({ value, expiresAt }));
+        },
+    });
+}
+function invalid() {
+    throw new TypeError('Memory cache input is invalid.');
+}

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

@@ -1,9 +1,18 @@
 import type { Fetch } from '@astrale-os/kernel-client';
-import type { CredentialInput, Grant, IssuerId } from '../../platform/auth/index.js';
-import type { AuthenticatedInvocation } from '../invocation/index.js';
+import type { CredentialInput, IdentityId, IssuerId } from '../../platform/auth/index.js';
+import type { AuthenticatedInvocation, SelfInvocation } 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';
+import { NodeId } from '../../platform/graph/node/index.js';
+/**
+ * How long a callback Session reuses a learned route. It stays at most the Kernel's in-flight
+ * issuer window (`KERNEL_INFLIGHT_ISSUER_MS`, Host default 300 s; CT11): a route learned to a
+ * deployment replaced by a consented install ages out while that deployment is still accepted and
+ * answers the reserved miss, never after its own credential is refused (AM-85).
+ */
+export declare const DEFAULT_ROUTE_AGE_MS = 60000;
 export declare function admit(request: InvocationAdmissionInput, configuration: AuthenticationConfiguration): Promise<unknown>;
 export interface AuthenticationConfiguration {
     readonly issuer: IssuerId;
@@ -17,5 +26,26 @@ export declare function authenticate(credentialInput: CredentialInput, expectedK
     readonly deadline: number;
     readonly signal: AbortSignal;
 }, configuration: AuthenticationConfiguration): Promise<AuthenticatedInvocation>;
-export declare function acceptResolvedDelegation(input: unknown): Grant;
+/**
+ * The Domain's own authority toward the source Kernel of an admitted call that carries no
+ * credential. No caller credential bounds it: its callbacks live as long as the execution, exactly
+ * as the `self` half of an authenticated call does within its carrier.
+ */
+export declare function selfInvocation(kernel: IssuerId, execution: {
+    readonly deadline: number;
+    readonly signal: AbortSignal;
+}, configuration: AuthenticationConfiguration): SelfInvocation;
+/**
+ * The Domain's own authority toward one Kernel for a step of the durable Execution `executionId`,
+ * which no caller credential carries: the run acts as its executor, never as its initiator. Every
+ * credential names `executionId` in `EXECUTION_CLAIM`, so the Kernel can accept a replaced issuer
+ * for the steps of a run in flight at a consented issuer change. The caller owns the returned
+ * Session.
+ */
+export declare function executorSession(kernel: IssuerId, executionId: NodeId, execution: {
+    readonly deadline: number;
+    readonly signal: AbortSignal;
+}, configuration: AuthenticationConfiguration): ClientSession;
+/** Accept a Kernel delegation proof claim naming exactly one resolved caller Identity. */
+export declare function acceptResolvedDelegation(input: unknown): IdentityId;
 export type { VerificationBasis };

package/dist/execution/identity/authentication.js

@@ -7,10 +7,16 @@ 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;
+/**
+ * How long a callback Session reuses a learned route. It stays at most the Kernel's in-flight
+ * issuer window (`KERNEL_INFLIGHT_ISSUER_MS`, Host default 300 s; CT11): a route learned to a
+ * deployment replaced by a consented install ages out while that deployment is still accepted and
+ * answers the reserved miss, never after its own credential is refused (AM-85).
+ */
+export const DEFAULT_ROUTE_AGE_MS = 60_000;
 export async function admit(request, configuration) {
     const execution = request.context.execution;
     requireLive(execution);
@@ -50,15 +56,14 @@ export async function authenticate(credentialInput, expectedKernel, execution, c
         throw protocolError('AUTH_INVALID', 'Credential is invalid.');
     }
     const expressions = callbackIdentities(established.delegation.credential);
+    const session = (expression, validUntil) => callbackSession(expectedKernel, expression, validUntil, execution, configuration);
     const sessions = Object.freeze({
-        caller: callbackSession(expressions.caller),
-        self: callbackSession(expressions.self),
-        union: callbackSession(expressions.union),
+        caller: session(expressions.caller, established.validUntil),
+        self: session(expressions.self, established.verified.exp),
     });
     const graph = Object.freeze({
         caller: bindSession(sessions.caller, execution),
         self: bindSession(sessions.self, execution),
-        union: bindSession(sessions.union, execution),
     });
     let closed = false;
     return Object.freeze({
@@ -70,35 +75,72 @@ export async function authenticate(credentialInput, expectedKernel, execution, c
             closed = true;
             sessions.caller.close();
             sessions.self.close();
-            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 the source Kernel of an admitted call that carries no
+ * credential. No caller credential bounds it: its callbacks live as long as the execution, exactly
+ * as the `self` half of an authenticated call does within its carrier.
+ */
+export function selfInvocation(kernel, execution, configuration) {
+    requireLive(execution);
+    const admitted = httpIssuer(kernel, configuration.policy.allowInsecureHttp === true);
+    admitEndpoint(invocationUrl(admitted), configuration.policy);
+    const session = callbackSession(admitted, selfIdentity, undefined, execution, configuration);
+    let closed = false;
+    return Object.freeze({
+        graph: Object.freeze({ self: bindSession(session, execution) }),
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            session.close();
+        },
+    });
+}
+/**
+ * The Domain's own authority toward one Kernel for a step of the durable Execution `executionId`,
+ * which no caller credential carries: the run acts as its executor, never as its initiator. Every
+ * credential names `executionId` in `EXECUTION_CLAIM`, so the Kernel can accept a replaced issuer
+ * for the steps of a run in flight at a consented issuer change. The caller owns the returned
+ * Session.
+ */
+export function executorSession(kernel, executionId, execution, configuration) {
+    const admitted = httpIssuer(kernel, configuration.policy.allowInsecureHttp === true);
+    admitEndpoint(invocationUrl(admitted), configuration.policy);
+    return callbackSession(admitted, selfIdentity, undefined, execution, configuration, executionId);
+}
+/**
+ * A Session whose callbacks carry `expression`, none outliving the execution or `validUntil`, the
+ * earliest expiry in Unix seconds of the credentials they derive from.
+ */
+function callbackSession(kernel, expression, validUntil, execution, configuration, executionId) {
+    const resolveCallback = createCallbackCredentialResolver(configuration.signing, configuration.issuer, configuration.subject, kernel, expression, validUntil, execution, executionId);
+    const expiresAt = Math.min(execution.deadline, (validUntil ?? Number.POSITIVE_INFINITY) * 1_000);
+    return new ClientSession({
+        kernel,
+        fetch: boundedFetch(configuration.fetch, execution.signal),
+        auth: {
+            ttlSeconds: Math.min(callbackTtl(expiresAt), 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);
@@ -112,7 +154,7 @@ async function establishCaller(input, audience, verification, execution, policy)
         if (proof.verified.sub !== context.verified.sub) {
             throw new CredentialRejected('Destination carrier and authority proof subjects differ.');
         }
-        const authority = acceptResolvedDelegation(proof.verified.claims.delegation);
+        const identity = acceptResolvedDelegation(proof.verified.claims.delegation);
         let principal;
         try {
             principal = NodeId(context.verified.sub);
@@ -122,11 +164,12 @@ async function establishCaller(input, audience, verification, execution, policy)
         }
         return Object.freeze({
             verified: context.verified,
+            validUntil: Math.min(context.verified.exp ?? Number.POSITIVE_INFINITY, proof.verified.exp ?? Number.POSITIVE_INFINITY),
             delegation: carried,
             caller: Object.freeze({
                 kind: 'authenticated',
                 principal,
-                authority,
+                identity,
                 authentication: credential.evidence(context),
             }),
         });
@@ -137,6 +180,7 @@ async function establishCaller(input, audience, verification, execution, policy)
             throw protocolError('BACKEND_UNAVAILABLE', 'Credential issuer is unavailable.');
         }
         if (cause instanceof CredentialRejected ||
+            cause instanceof AuthValueError ||
             cause instanceof joseErrors.JOSEError ||
             cause instanceof protocolErrors.ProtocolError) {
             throw protocolError('AUTH_INVALID', 'Credential is invalid.');
@@ -144,6 +188,7 @@ async function establishCaller(input, audience, verification, execution, policy)
         throw cause;
     }
 }
+/** Accept a Kernel delegation proof claim naming exactly one resolved caller Identity. */
 export function acceptResolvedDelegation(input) {
     if (input === null ||
         typeof input !== 'object' ||
@@ -154,5 +199,14 @@ export function acceptResolvedDelegation(input) {
         Reflect.get(input, 'v') !== 1) {
         throw new AuthValueError('AUTH_GRANT_INVALID', 'Expected resolved delegation.');
     }
-    return grant.accept({ expr: Reflect.get(input, 'expr') });
+    const raw = Reflect.get(input, 'expr');
+    // grant.accept collapses duplicate operands (union(X, X) becomes X), so the leaf is checked as sent.
+    if (raw === null || typeof raw !== 'object' || Reflect.get(raw, 'kind') !== 'identity') {
+        throw new AuthValueError('AUTH_GRANT_INVALID', 'Expected one resolved caller Identity.');
+    }
+    const { expr } = grant.accept({ expr: raw });
+    if (expr.kind !== 'identity') {
+        throw new AuthValueError('AUTH_GRANT_INVALID', 'Expected one resolved caller Identity.');
+    }
+    return expr.id;
 }