@astrale-os/sdk 0.6.0-beta.23 → 0.6.0-beta.25

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

@@ -3,7 +3,8 @@ import { bindQuery } from '../../../application/query/execution/executor.js';
 import { bindDependencies } from '../dependency/index.js';
 import { clients } from '../integration/index.js';
 export function context(request, runtime, authentication, self) {
-    const graph = authentication.graph === null ? null : bindGraph(authentication.graph, runtime.loaded.domain);
+    const sessions = authentication.graph;
+    const graph = bindGraph(sessions, runtime.loaded.domain);
     const execution = Object.freeze({
         signal: request.context.execution.signal,
         deadline: request.context.execution.deadline,
@@ -19,46 +20,31 @@ export function context(request, runtime, authentication, self) {
         input: request.call.input,
         ...(request.context.binary === undefined ? {} : { body: request.context.binary }),
         caller: authentication.caller,
-        kernel: authentication.graph === null
-            ? null
-            : Object.freeze({
-                ...authentication.graph.self,
-                ...authentication.graph,
-            }),
-        dependencies: authentication.graph === null
-            ? null
-            : bindDependencies(runtime.loaded.domain, authentication.graph),
+        kernel: Object.freeze({ ...sessions.self, ...sessions }),
+        dependencies: bindDependencies(runtime.loaded.domain, sessions),
         graph,
-        ...(graph === null
-            ? {}
-            : {
-                query: graph.self.query,
-                mutate: graph.self.mutate,
-            }),
-        integrations: clients(runtime, request.context, authentication.graph === null
-            ? null
-            : {
-                caller: authentication.graph.caller,
-                self: authentication.graph.self,
-                ...(authentication.caller.authentication.expiresAt === undefined
-                    ? {}
-                    : {
-                        expiresAt: authentication.caller.authentication.expiresAt,
-                    }),
-            }),
+        query: graph.self.query,
+        mutate: graph.self.mutate,
+        integrations: clients(runtime, request.context, {
+            ...sessions,
+            ...(authentication.caller.kind !== 'authenticated' ||
+                authentication.caller.authentication.expiresAt === undefined
+                ? {}
+                : { expiresAt: authentication.caller.authentication.expiresAt }),
+        }),
         execution,
         ...(self === undefined ? {} : { self }),
     });
 }
-function bindGraph(clients, domain) {
+function bindGraph(sessions, domain) {
     const bind = (client) => Object.freeze({
         query: bindQuery(client, domain),
         mutate: bindMutation(client, domain),
     });
-    const self = bind(clients.self);
+    const self = bind(sessions.self);
     return Object.freeze({
         ...self,
-        caller: bind(clients.caller),
+        ...('caller' in sessions ? { caller: bind(sessions.caller) } : {}),
         self,
     });
 }

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

@@ -1,12 +1,8 @@
 import { declaredErrorFactory, declaredErrorOf } from '../../../application/error/index.js';
 import { protocolError } from '../result/index.js';
 export async function workflow(selected, context, runner) {
-    if (context.caller.kind !== 'authenticated' || context.kernel === null) {
-        throw protocolError('AUTH_MISSING', 'Workflow authentication is required.');
-    }
     const complete = Object.freeze({
         ...context,
-        caller: context.caller,
         error: declaredErrorFactory(selected.definition),
     });
     try {

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

@@ -1,5 +1,5 @@
 export { createHandler, type HandlerInput } from './handler.js';
 export { invoke, type InvocationInput } from './invocation.js';
 export type * from './admission/index.js';
-export { InvocationDefect, InvocationError } from './result/index.js';
-export type { InvocationDefectCode, InvocationErrorCode } from './result/index.js';
+export { InvocationDefect } from './result/index.js';
+export type { InvocationDefectCode } from './result/index.js';

package/dist/execution/invocation/index.js

@@ -1,3 +1,3 @@
 export { createHandler } from './handler.js';
 export { invoke } from './invocation.js';
-export { InvocationDefect, InvocationError } from './result/index.js';
+export { InvocationDefect } from './result/index.js';

package/dist/execution/invocation/integration/call.d.ts

@@ -2,7 +2,8 @@ import type { InvocationContext } from '@astrale-os/kernel-server';
 import type { IntegrationInvocationOwner } from '../../../application/integration/index.js';
 import type { BoundClientSession } from '../../../platform/client/session/index.js';
 export interface IntegrationInvocationSessions {
-    readonly caller: BoundClientSession;
+    /** Absent when the call carried no credential: there is no caller to invoke for. */
+    readonly caller?: BoundClientSession;
     readonly self: BoundClientSession;
     /** Verified incoming carrier expiry, in Unix seconds. */
     readonly expiresAt?: number;

package/dist/execution/invocation/integration/call.js

@@ -3,7 +3,7 @@ import { bindIntegrationAuthentication } from './authentication.js';
 /** One invocation-owned logical Integration call sequence. */
 export function calls(context, sessions = null) {
     const prefix = context.idempotencyKey ?? JSON.stringify([context.invocation.source, context.invocation.id]);
-    const invoke = sessions?.caller.invoke.bind(sessions.caller);
+    const invoke = sessions?.caller?.invoke.bind(sessions.caller);
     const auth = sessions === null
         ? undefined
         : bindIntegrationAuthentication(context, sessions.self, sessions.expiresAt);

package/dist/execution/invocation/integration/clients.d.ts

@@ -2,4 +2,4 @@ import type { InvocationContext } from '@astrale-os/kernel-server';
 import type { IntegrationClients, Integrations } from '../../../application/integration/index.js';
 import type { InitializedRuntime } from '../../runtime/index.js';
 import type { IntegrationInvocationSessions } from './call.js';
-export declare function clients(runtime: InitializedRuntime, context: InvocationContext, sessions: IntegrationInvocationSessions | null): IntegrationClients<Integrations>;
+export declare function clients(runtime: InitializedRuntime, context: InvocationContext, sessions: IntegrationInvocationSessions): IntegrationClients<Integrations>;

package/dist/execution/invocation/invocation.js

@@ -70,19 +70,10 @@ function refusedAsMiss(cause) {
     return (cause instanceof errors.ProtocolError &&
         errors.reasonOf(cause.payload.data)?.code === FUNCTION_MISS);
 }
-/**
- * The Kernel Server pins every request to the one snapshot it serves: the release of an immutable
- * deployment, or a stable target's Publication. Execution answers only for that exact document.
- */
+/** Execution answers only for the exact release pinned by the Kernel Server snapshot. */
 function pinsRunningRelease(request, running) {
-    if (running.kind === 'release') {
-        return (request.publication === undefined &&
-            request.release !== undefined &&
-            release.matchesReference(request.release.release, release.reference(running.document)));
-    }
-    return (request.release === undefined &&
-        request.publication !== undefined &&
-        release.legacy.matchesReference(request.publication.publication, release.legacy.reference(running.publication)));
+    return (request.release !== undefined &&
+        release.matchesReference(request.release.release, release.reference(running.document)));
 }
 function once(operation) {
     let called = false;

package/dist/execution/invocation/result/errors.d.ts

@@ -2,16 +2,6 @@ import * as errors from '@astrale-os/kernel-protocol/errors';
 import type { ResolvedCallable } from '../../../application/action/index.js';
 import type { Key } from '../../../platform/schema/index.js';
 import type { Value } from '../../../platform/value/index.js';
-export type InvocationErrorCode = Extract<keyof typeof errors.CODES, 'VALIDATION_ERROR' | 'ACCESS_DENIED' | 'NOT_FOUND' | 'CONFLICT' | 'UNSUPPORTED' | 'LIMIT_EXCEEDED' | 'BACKEND_UNAVAILABLE'>;
-/** @deprecated Declare expected failures on defineAction or defineWorkflow instead. */
-export declare class InvocationError extends Error {
-    readonly code: InvocationErrorCode;
-    readonly name = "InvocationError";
-    readonly reason?: errors.ErrorReason;
-    constructor(code: InvocationErrorCode, message: string, options?: ErrorOptions & {
-        readonly reason?: errors.ErrorReason;
-    });
-}
 export type InvocationDefectCode = 'INVOCATION_TARGET_INVALID' | 'INVOCATION_HANDLER_INVALID' | 'INVOCATION_OUTPUT_INVALID' | 'INVOCATION_RESULT_CONTRACT_VIOLATION';
 export declare class InvocationDefect extends Error {
     readonly code: InvocationDefectCode;

package/dist/execution/invocation/result/errors.js

@@ -5,20 +5,6 @@ const PUBLIC_ERROR_CODES = new Set(Object.values(errors.CODES));
 const PUBLIC_ERROR_NAMES = new Map(Object.entries(errors.CODES).map(([name, code]) => [code, name]));
 const MAXIMUM_DIAGNOSTICS = 32;
 const admittedProtocolErrors = new WeakSet();
-/** @deprecated Declare expected failures on defineAction or defineWorkflow instead. */
-export class InvocationError extends Error {
-    code;
-    name = 'InvocationError';
-    reason;
-    constructor(code, message, options = {}) {
-        super(message, options);
-        this.code = code;
-        this.reason =
-            options.reason === undefined
-                ? undefined
-                : errors.acceptReason(options.reason, 'InvocationError reason');
-    }
-}
 export class InvocationDefect extends Error {
     code;
     name = 'InvocationDefect';
@@ -62,9 +48,6 @@ export function projectError(input) {
             ? input
             : protocolError('INTERNAL_ERROR', 'Internal application error.');
     }
-    if (input instanceof InvocationError) {
-        return protocolError('INTERNAL_ERROR', 'Internal application error.');
-    }
     if (input instanceof ResponseError) {
         if (!PUBLIC_ERROR_CODES.has(input.code)) {
             return protocolError('BACKEND_UNAVAILABLE', 'Dependency Kernel returned invalid error evidence.');

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

@@ -1,4 +1,4 @@
-export { inputError, InvocationDefect, InvocationError, projectError, protocolError, } from './errors.js';
-export type { InvocationDefectCode, InvocationErrorCode } from './errors.js';
+export { inputError, InvocationDefect, projectError, protocolError } from './errors.js';
+export type { InvocationDefectCode } from './errors.js';
 export { project } from './project.js';
 export { validateInput, validateOutput } from './validate.js';

package/dist/execution/invocation/result/index.js

@@ -1,3 +1,3 @@
-export { inputError, InvocationDefect, InvocationError, projectError, protocolError, } from './errors.js';
+export { inputError, InvocationDefect, projectError, protocolError } from './errors.js';
 export { project } from './project.js';
 export { validateInput, validateOutput } from './validate.js';

package/dist/execution/runtime/release.d.ts

@@ -1,22 +1,17 @@
 import type * as release from '@astrale-os/kernel-protocol/release';
 import type { Build } from '../../deployment/build/build.js';
-import type * as legacy from '../../deployment/release/legacy/index.js';
 import type { Release } from '../../deployment/release/release.js';
 import type { IssuerId } from '../../platform/auth/index.js';
-/**
- * What one Service serves: the `DomainRelease` v4 Release of an immutable deployment, or the
- * deprecated v3 Release of a stable target (`legacy`, its consumers and removal in
- * `deployment/release/legacy/index.ts`, D10).
- */
-export type ServedRelease<BuildValue extends Build = Build> = Release<BuildValue> | legacy.Release<BuildValue>;
+/** The DomainRelease v4 served by one immutable deployment. */
+export type ServedRelease<BuildValue extends Build = Build> = Release<BuildValue>;
 /** Where and as whom one served Release answers, and the document it serves. */
 export interface Serving {
-    /** Domain identity issuer: a deployment's URL, or a stable target's configured issuer. */
+    /** Domain identity issuer: this deployment's URL. */
     readonly issuer: IssuerId;
-    /** Public origin the Server answers at: a deployment's URL, or a stable target's route. */
+    /** Public origin the Server answers at: this deployment's URL. */
     readonly publicUrl: IssuerId;
-    /** The document served at `release.json`, or a stable target's v3 Publication at `domain.json`. */
-    readonly document: release.DomainRelease | release.legacy.Publication;
+    /** The document served at release.json. */
+    readonly document: release.DomainRelease;
 }
 export declare function isServedRelease(input: unknown): input is ServedRelease;
 export declare function serving(served: ServedRelease): Serving;

package/dist/execution/runtime/release.js

@@ -1,14 +1,7 @@
 import { isRelease } from '../../deployment/release/admission.js';
-import { isRelease as isLegacyRelease } from '../../deployment/release/legacy/admission.js';
 export function isServedRelease(input) {
-    return isRelease(input) || isLegacyRelease(input);
+    return isRelease(input);
 }
 export function serving(served) {
-    return served.kind === 'release'
-        ? Object.freeze({ issuer: served.url, publicUrl: served.url, document: served.document })
-        : Object.freeze({
-            issuer: served.addressing.issuer,
-            publicUrl: served.addressing.publicUrl,
-            document: served.publication,
-        });
+    return Object.freeze({ issuer: served.url, publicUrl: served.url, document: served.document });
 }

package/dist/execution/service/create.js

@@ -4,7 +4,7 @@ import { invocationPath } from '../../deployment/release/invocation.js';
 import { identity as captureIdentity } from '../identity/index.js';
 import { createHandler } from '../invocation/index.js';
 import { initialize, load, serving as servedRelease } from '../runtime/index.js';
-import { createDurableReceiver, durableServing, isDurableRequest, } from '../workflows/index.js';
+import { createDurableReceiver, durableServing, isCanonicalDurableRequest, isDurableRequest, } from '../workflows/index.js';
 import { initialization } from './initialization.js';
 import { lifecycle } from './lifecycle.js';
 import { loadRelease } from './release.js';
@@ -83,6 +83,8 @@ export function createService(input) {
                 return unavailable();
             // Without engine configuration only durable calls fail: the engine's discovery is refused.
             if (isDurableRequest(request)) {
+                if (!isCanonicalDurableRequest(request))
+                    return notServed();
                 const selected = await receiver.get(request);
                 if (!state.accepting)
                     return unavailable();

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

@@ -6,7 +6,7 @@ import type { Identity } from '../identity/index.js';
 import type { ServedRelease } from '../runtime/index.js';
 import type { DurableServing, DurableServingProvider } from '../workflows/index.js';
 import type { ReleaseLoader } from './release.js';
-export type ServiceServerOptions = Omit<ServerOptions, 'path' | 'invocation' | 'issuer' | 'publicOrigin' | 'tokenExchange' | 'release' | 'publication' | 'delivery'>;
+export type ServiceServerOptions = Omit<ServerOptions, 'path' | 'invocation' | 'issuer' | 'publicOrigin' | 'tokenExchange' | 'release' | 'delivery'>;
 export interface ServiceInput<Environment, RuntimeValue extends Runtime = Runtime> {
     readonly runtime: RuntimeValue;
     readonly environment: Environment;
@@ -14,8 +14,7 @@ export interface ServiceInput<Environment, RuntimeValue extends Runtime = Runtim
     readonly identity: Identity;
     readonly server: ServiceServerOptions;
     /**
-     * Answers Delivery in the request's version: v2 over an immutable deployment's release, v1 over
-     * the Publication (a release's frozen v3 projection). Defaults to the Identity's own.
+     * Answers Delivery v2 over an immutable deployment's Release. Defaults to the Identity's own.
      */
     readonly delivery?: release.delivery.Provider;
     readonly workflows?: WorkflowRunner;

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

@@ -1,6 +1,5 @@
 import type { release } from '@astrale-os/kernel-server';
 /**
- * Capture an explicit Delivery Provider. It answers in the request's version: v2 over an immutable
- * deployment's release, v1 over the Publication (a release's frozen v3 projection).
+ * Capture an explicit Delivery v2 Provider over an immutable deployment's Release.
  */
 export declare function delivery(input: release.delivery.Provider | undefined): release.delivery.Provider | undefined;

package/dist/execution/service/serving/delivery.js

@@ -1,6 +1,5 @@
 /**
- * Capture an explicit Delivery Provider. It answers in the request's version: v2 over an immutable
- * deployment's release, v1 over the Publication (a release's frozen v3 projection).
+ * Capture an explicit Delivery v2 Provider over an immutable deployment's Release.
  */
 export function delivery(input) {
     if (input === undefined)

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

@@ -1,18 +1,11 @@
-import type { PublicationSource, ReleaseSource } from '@astrale-os/kernel-server';
+import type { ReleaseSource } from '@astrale-os/kernel-server';
 import type { LoadedRuntime } from '../../runtime/index.js';
 /** The one source a Kernel Server serves, as `ServerOptions` takes it. */
-export type ServingSource = 
-/** The release of an immutable deployment: `release.json` and its v3 projection. */
-{
+export type ServingSource = {
     readonly release: ReleaseSource;
-}
-/** @deprecated A stable target's v3 Publication; see `legacy/index.ts`. */
- | {
-    readonly publication: PublicationSource;
 };
 /**
  * Prepare, once, the exact snapshot the loaded Release serves: an immutable deployment serves its
- * `DomainRelease` through `prepareReleaseSnapshot`, which admits only routing naming that exact
- * release or its exact v3 projection; a stable target keeps serving its v3 Publication.
+ * DomainRelease through prepareReleaseSnapshot, which admits routing naming that exact release.
  */
 export declare function source(runtime: LoadedRuntime): ServingSource;

package/dist/execution/service/serving/source.js

@@ -1,14 +1,10 @@
 import { prepareReleaseSnapshot } from '@astrale-os/kernel-server';
-import { publicationSource } from './legacy/index.js';
 /**
  * Prepare, once, the exact snapshot the loaded Release serves: an immutable deployment serves its
- * `DomainRelease` through `prepareReleaseSnapshot`, which admits only routing naming that exact
- * release or its exact v3 projection; a stable target keeps serving its v3 Publication.
+ * DomainRelease through prepareReleaseSnapshot, which admits routing naming that exact release.
  */
 export function source(runtime) {
     const served = runtime.release;
-    if (served.kind !== 'release')
-        return publicationSource(runtime, served);
     const snapshot = prepareReleaseSnapshot({
         release: served.document,
         bundle: served.build.schema.bundle.bytes(),

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

@@ -1,4 +1,4 @@
 export type { DurableEngine, 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, isLegacyDurableRequest } from './route.js';
+export { isDurableRequest, isCanonicalDurableRequest } from './route.js';

package/dist/execution/workflows/index.js

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

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

@@ -4,11 +4,6 @@ import type { DurableEngine, EngineRetryPolicy } from './engine.js';
 export interface DurableServing {
     /** The Restate SDK Fetch build of this platform. */
     readonly engine: DurableEngine;
-    /**
-     * @deprecated Explicit signing authority for retained callbacks registered before issuer-prefixed
-     * paths. Canonical requests discover their authority from the named Kernel and ignore these keys.
-     */
-    readonly identityKeys?: readonly string[];
     /** Fetch capability used for HTTPS discovery of a canonical request's Kernel engine. */
     readonly fetch?: Fetch;
     /**
@@ -30,7 +25,6 @@ export interface DurableServing {
 export type DurableServingProvider = (request: Request) => DurableServing | undefined | Promise<DurableServing | undefined>;
 export interface AdmittedDurableServing {
     readonly engine: DurableEngine;
-    readonly identityKeys: readonly string[];
     readonly fetch: Fetch;
     readonly retentionMs: number;
     readonly retryPolicy: EngineRetryPolicy;

package/dist/execution/workflows/options.js

@@ -1,14 +1,11 @@
-import { acceptWorkflowEngineIdentityKey } from '@astrale-os/kernel-protocol/issuer/workflow-engine';
 const HOUR_MS = 60 * 60_000;
 const DAY_MS = 24 * HOUR_MS;
-const MAXIMUM_IDENTITY_KEYS = 16;
 /** Capture one durable serving configuration, failing closed on any gap. */
 export function durableServing(input) {
     if (input === null ||
         typeof input !== 'object' ||
         Array.isArray(input) ||
         Reflect.ownKeys(input).some((key) => key !== 'engine' &&
-            key !== 'identityKeys' &&
             key !== 'fetch' &&
             key !== 'retentionMs' &&
             key !== 'retry' &&
@@ -24,20 +21,6 @@ export function durableServing(input) {
         typeof engine.CancelledError !== 'function') {
         invalid('Durable serving requires the Restate SDK Fetch entrypoint of this platform.');
     }
-    const keys = input.identityKeys;
-    let identityKeys = Object.freeze([]);
-    if (keys !== undefined) {
-        if (!Array.isArray(keys) || keys.length === 0 || keys.length > MAXIMUM_IDENTITY_KEYS) {
-            invalid('Durable serving requires engine request identity keys (publickeyv1_…).');
-        }
-        // Legacy callbacks retain their original sixteen-key input budget and duplicate policy.
-        try {
-            identityKeys = Object.freeze(Array.from(keys, acceptWorkflowEngineIdentityKey));
-        }
-        catch (cause) {
-            throw new TypeError('Durable serving requires engine request identity keys (publickeyv1_…).', { cause });
-        }
-    }
     const fetch = input.fetch ?? globalThis.fetch.bind(globalThis);
     if (typeof fetch !== 'function')
         invalid('Durable serving requires Fetch for engine discovery.');
@@ -57,7 +40,6 @@ export function durableServing(input) {
             TerminalError: engine.TerminalError,
             CancelledError: engine.CancelledError,
         }),
-        identityKeys,
         fetch,
         retentionMs: bounded(input.retentionMs, 7 * DAY_MS, HOUR_MS, 365 * DAY_MS, 'retentionMs'),
         retryPolicy: Object.freeze({

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

@@ -8,8 +8,7 @@ export interface DurableReceiver {
 }
 /**
  * Route `…/invoke/restate/<Kernel issuer>/<declaration key>/<service>/{discover,invoke/…}` to one
- * engine endpoint. Retained services registered before issuer-prefixed paths keep their old
- * `<declaration key>/<service>` route with explicit legacy signing keys. Canonical routes discover
+ * engine endpoint. Routes discover
  * their signing authority at the named Kernel; that issuer also binds the run envelope. Each
  * endpoint serves exactly that service with the declared Workflow. A declaration this Release does not
  * serve durably is refused, so an endpoint never runs code it does not declare.

package/dist/execution/workflows/receiver.js

@@ -4,8 +4,7 @@ import { durableHandlers } from './run.js';
 const MAXIMUM_ENDPOINTS = 256;
 /**
  * Route `…/invoke/restate/<Kernel issuer>/<declaration key>/<service>/{discover,invoke/…}` to one
- * engine endpoint. Retained services registered before issuer-prefixed paths keep their old
- * `<declaration key>/<service>` route with explicit legacy signing keys. Canonical routes discover
+ * engine endpoint. Routes discover
  * their signing authority at the named Kernel; that issuer also binds the run envelope. Each
  * endpoint serves exactly that service with the declared Workflow. A declaration this Release does not
  * serve durably is refused, so an endpoint never runs code it does not declare.
@@ -31,21 +30,17 @@ export function createDurableReceiver(input) {
             const workflow = declared.get(declaration);
             if (workflow === undefined)
                 return refused();
-            let identityKeys = input.serving.identityKeys;
-            if (kernel !== undefined) {
-                try {
-                    identityKeys = (await discovery.resolve(kernel)).identity_keys;
-                }
-                catch (cause) {
-                    if (!(cause instanceof WorkflowEngineUnavailable))
-                        throw cause;
-                    return unavailable();
-                }
+            let identityKeys;
+            try {
+                identityKeys = (await discovery.resolve(kernel)).identity_keys;
+            }
+            catch (cause) {
+                if (!(cause instanceof WorkflowEngineUnavailable))
+                    throw cause;
+                return unavailable();
             }
-            else if (identityKeys.length === 0)
-                return refused();
             request.signal.throwIfAborted();
-            const cacheKey = JSON.stringify([kernel ?? null, declaration, service, identityKeys]);
+            const cacheKey = JSON.stringify([kernel, declaration, service, identityKeys]);
             let endpoint = endpoints.get(cacheKey);
             if (endpoint === undefined) {
                 const definition = engine.workflow({
@@ -55,7 +50,7 @@ export function createDurableReceiver(input) {
                         domain: input.domain,
                         executor: bound,
                         serving: input.serving,
-                        ...(kernel === undefined ? {} : { kernel }),
+                        kernel,
                     }),
                     options: {
                         workflowRetention: input.serving.retentionMs,
@@ -68,9 +63,7 @@ export function createDurableReceiver(input) {
                         services: [definition],
                     });
                 }
-                catch (cause) {
-                    if (kernel === undefined)
-                        throw cause;
+                catch {
                     discovery.forget(kernel, identityKeys);
                     return unavailable();
                 }
@@ -79,7 +72,7 @@ export function createDurableReceiver(input) {
                 endpoints.set(cacheKey, endpoint);
             }
             const response = await endpoint(request);
-            if (kernel !== undefined && response.status === 401)
+            if (response.status === 401)
                 discovery.invalidate(kernel, identityKeys);
             return response;
         },

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

@@ -1,6 +1,6 @@
 import type { IssuerId } from '../../platform/auth/index.js';
 export interface DurableRoute {
-    readonly kernel?: IssuerId;
+    readonly kernel: IssuerId;
     readonly declaration: string;
     readonly service: string;
 }
@@ -8,7 +8,5 @@ export interface DurableRoute {
 export declare function isDurableRequest(request: Request): boolean;
 /** Canonical requests discover authority at the HTTPS Kernel named by this admitted route. */
 export declare function isCanonicalDurableRequest(request: Request): boolean;
-/** Retained callbacks need explicit legacy signing authority before an engine module is loaded. */
-export declare function isLegacyDurableRequest(request: Request): boolean;
 /** One wire decoder shared by the receiver and platform lazy-load eligibility. */
 export declare function durableRoute(request: Request): DurableRoute | undefined;

package/dist/execution/workflows/route.js

@@ -12,11 +12,6 @@ export function isDurableRequest(request) {
 export function isCanonicalDurableRequest(request) {
     return durableRoute(request)?.kernel !== undefined;
 }
-/** Retained callbacks need explicit legacy signing authority before an engine module is loaded. */
-export function isLegacyDurableRequest(request) {
-    const route = durableRoute(request);
-    return route !== undefined && route.kernel === undefined;
-}
 /** One wire decoder shared by the receiver and platform lazy-load eligibility. */
 export function durableRoute(request) {
     const pathname = new URL(request.url).pathname;
@@ -25,12 +20,12 @@ export function durableRoute(request) {
     const parts = pathname.slice(PREFIX.length).split('/');
     try {
         const first = decodeURIComponent(parts[0] ?? '');
-        const kernel = Key.is(first) ? undefined : httpIssuer(first, false);
-        const declaration = kernel === undefined ? first : decodeURIComponent(parts[1] ?? '');
-        const service = parts[kernel === undefined ? 1 : 2] ?? '';
+        const kernel = httpIssuer(first, false);
+        const declaration = decodeURIComponent(parts[1] ?? '');
+        const service = parts[2] ?? '';
         if (!Key.is(declaration) || !SERVICE.test(service))
             return undefined;
-        return Object.freeze({ ...(kernel === undefined ? {} : { kernel }), declaration, service });
+        return Object.freeze({ kernel, declaration, service });
     }
     catch (cause) {
         if (cause instanceof URIError || cause instanceof AuthValueError || cause instanceof TypeError)

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

@@ -6,7 +6,7 @@ import type { EngineSharedContext, EngineWorkflowContext } from './engine.js';
 import type { AdmittedDurableServing } from './options.js';
 type Executor = NonNullable<Identity['executor']>;
 export interface DurableRun {
-    readonly kernel?: IssuerId;
+    readonly kernel: IssuerId;
     readonly workflow: RuntimeWorkflow;
     readonly domain: Domain;
     readonly executor: Executor;

package/dist/execution/workflows/run.js

@@ -61,7 +61,7 @@ async function run(input, context, raw) {
 }
 function admitted(workflow, raw, kernel) {
     const envelope = decodeEnvelope(raw);
-    if (kernel !== undefined && envelope.execution.kernel !== kernel) {
+    if (envelope.execution.kernel !== kernel) {
         throw new TypeError('Durable envelope Kernel differs from its authenticated endpoint.');
     }
     const diagnostics = workflow.callable.validateInput(envelope.input);

package/dist/index.d.ts

@@ -13,7 +13,7 @@ export { defineRuntime } from './application/runtime/index.js';
 export type { Runtime } from './application/runtime/index.js';
 export { defineWorkflow } from './application/workflow/index.js';
 export type { Workflow, WorkflowContext } from './application/workflow/index.js';
-export { compile, deploy, runtime } from './deployment/index.js';
+export { compile, runtime } from './deployment/index.js';
 export type { Build, Deployment, Release } from './deployment/index.js';
 export { defineProject } from './project/index.js';
 export type { Project } from './project/index.js';

package/dist/index.js

@@ -6,6 +6,6 @@ export { defineMutation, executeMutation } from './application/mutation/index.js
 export { defineCollectionQuery, defineCompositeQuery, defineQuery, executeQuery, } from './application/query/index.js';
 export { defineRuntime } from './application/runtime/index.js';
 export { defineWorkflow } from './application/workflow/index.js';
-export { compile, deploy, runtime } from './deployment/index.js';
+export { compile, runtime } from './deployment/index.js';
 export { defineProject } from './project/index.js';
 export { serve } from './execution/index.js';

package/dist/platform/graph/alias.d.ts

@@ -1,6 +1,2 @@
 /** Graph-local names retain the canonical Kernel type and constructor identity. */
-export { LocalBinding as LocalAlias, isLocalBinding as isLocalAlias, } from '@astrale-os/kernel-core/graph/graph';
-/** @deprecated Use LocalAlias. */
-export { LocalBinding } from '@astrale-os/kernel-core/graph/graph';
-/** @deprecated Use isLocalAlias. */
-export { isLocalBinding } from '@astrale-os/kernel-core/graph/graph';
+export { LocalAlias, isLocalAlias } from '@astrale-os/kernel-core/graph/graph';

package/dist/platform/graph/alias.js

@@ -1,6 +1,2 @@
 /** Graph-local names retain the canonical Kernel type and constructor identity. */
-export { LocalBinding as LocalAlias, isLocalBinding as isLocalAlias, } from '@astrale-os/kernel-core/graph/graph';
-/** @deprecated Use LocalAlias. */
-export { LocalBinding } from '@astrale-os/kernel-core/graph/graph';
-/** @deprecated Use isLocalAlias. */
-export { isLocalBinding } from '@astrale-os/kernel-core/graph/graph';
+export { LocalAlias, isLocalAlias } from '@astrale-os/kernel-core/graph/graph';