@astrale-os/kernel-server 0.5.0-beta.2 → 0.5.0-beta.21

package/dist/capture.d.ts

@@ -1,3 +1,2 @@
 /** Capture one receiver-bound method while preserving the capability's exact method type. */
 export declare function captureMethod<Receiver extends object, Name extends keyof Receiver>(input: Receiver, name: Name, invalidMessage: string): Receiver[Name];
-//# sourceMappingURL=capture.d.ts.map

package/dist/capture.js

@@ -7,4 +7,3 @@ export function captureMethod(input, name, invalidMessage) {
         throw new TypeError(invalidMessage);
     return method.bind(input);
 }
-//# sourceMappingURL=capture.js.map

package/dist/cors/cors.d.ts

@@ -19,4 +19,3 @@ export interface CorsPolicy {
 }
 /** Admit one immutable policy. `false` delegates the complete concern to an outer application. */
 export declare function prepareCors(input: CorsConfig | false | undefined): CorsPolicy;
-//# sourceMappingURL=cors.d.ts.map

package/dist/cors/cors.js

@@ -133,4 +133,3 @@ function appendVary(headers, value) {
     names.add(value);
     headers.set('vary', [...names].join(', '));
 }
-//# sourceMappingURL=cors.js.map

package/dist/cors/index.d.ts

@@ -1,3 +1,2 @@
 export { prepareCors, type CorsPolicy, type CorsRoute } from './cors.js';
 export type { CorsConfig } from './types.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/cors/index.js

@@ -1,2 +1 @@
 export { prepareCors } from './cors.js';
-//# sourceMappingURL=index.js.map

package/dist/cors/types.d.ts

@@ -9,4 +9,3 @@ export interface CorsConfig {
     /** Emit Access-Control-Allow-Credentials; requires one explicit origin rather than `*`. */
     readonly credentials?: boolean;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/cors/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/errors/availability.d.ts

@@ -8,4 +8,3 @@ export declare class IssuerKeysUnavailableError extends Error {
     readonly name = "IssuerKeysUnavailableError";
     constructor(message?: string, options?: ErrorOptions);
 }
-//# sourceMappingURL=availability.d.ts.map

package/dist/errors/availability.js

@@ -12,4 +12,3 @@ export class IssuerKeysUnavailableError extends Error {
         super(message, options);
     }
 }
-//# sourceMappingURL=availability.js.map

package/dist/errors/classify.d.ts

@@ -1,4 +1,3 @@
-import { errors } from '@astrale-os/kernel-protocol';
-/** Convert only errors owned by an admitted protocol boundary into safe public data. */
+import * as errors from '@astrale-os/kernel-protocol/errors';
+/** Convert only errors owned by an admitted Server or Protocol boundary into safe public data. */
 export declare function classifyError(input: unknown): errors.ErrorPayload;
-//# sourceMappingURL=classify.d.ts.map

package/dist/errors/classify.js

@@ -1,15 +1,8 @@
 import { PathError } from '@astrale-os/kernel-core/path';
-import { AuthenticationError } from '@astrale-os/kernel-ports/authentication';
-import { AuthorizationError } from '@astrale-os/kernel-ports/authorization';
-import { EventError } from '@astrale-os/kernel-ports/events';
-import { FunctionError } from '@astrale-os/kernel-ports/functions';
-import { NetworkError } from '@astrale-os/kernel-ports/network';
-import { ObservabilityError } from '@astrale-os/kernel-ports/observability';
-import { SchemaError } from '@astrale-os/kernel-ports/schema';
-import { errors } from '@astrale-os/kernel-protocol';
+import * as errors from '@astrale-os/kernel-protocol/errors';
 import { RequestBodyTooLargeError } from './request-body.js';
 import { ResponseBodyTooLargeError } from './response-body.js';
-/** Convert only errors owned by an admitted protocol boundary into safe public data. */
+/** Convert only errors owned by an admitted Server or Protocol boundary into safe public data. */
 export function classifyError(input) {
     if (input instanceof errors.ProtocolError)
         return input.payload;
@@ -22,282 +15,15 @@ export function classifyError(input) {
     if (input instanceof PathError) {
         return publicError('VALIDATION_ERROR', 'Target Path is invalid.');
     }
-    if (input instanceof FunctionError)
-        return classifyFunction(input);
-    if (input instanceof AuthenticationError)
-        return classifyAuthentication(input);
-    if (input instanceof AuthorizationError)
-        return classifyAuthorization(input);
-    if (input instanceof SchemaError)
-        return classifySchema(input);
-    if (input instanceof EventError)
-        return classifyEvent(input);
-    if (input instanceof ObservabilityError)
-        return classifyObservability(input);
-    if (input instanceof NetworkError)
-        return classifyNetwork(input);
     return internal(input);
 }
-function classifyFunction(input) {
-    const reason = errors.reasonOf(input.reason);
-    switch (input.code) {
-        case 'FUNCTION_INVOCATION_INVALID':
-            return publicError('VALIDATION_ERROR', 'Function invocation is invalid.', input.code);
-        case 'FUNCTION_INPUT_INVALID':
-            return publicError('VALIDATION_ERROR', reasonMessage(reason, 'Function input is invalid.'), reason);
-        case 'FUNCTION_CONFLICT':
-            return publicError('CONFLICT', reasonMessage(reason, 'Function execution conflicts with current state.'), reason ?? input.code);
-        case 'FUNCTION_UNAVAILABLE':
-            return publicError('METHOD_NOT_FOUND', 'Callable was not found.');
-        case 'FUNCTION_DENIED':
-            return publicError('ACCESS_DENIED', 'Access denied.', reason);
-        case 'FUNCTION_MISS':
-            return publicError('METHOD_NOT_FOUND', 'Callable is not served by this application.', input.code);
-        case 'FUNCTION_BINDING_UNAVAILABLE':
-            return publicError('BACKEND_UNAVAILABLE', 'Callable execution is unavailable.');
-        case 'FUNCTION_EXECUTION_LIMIT':
-            return publicError('LIMIT_EXCEEDED', 'Function execution limit exceeded.', reason);
-        case 'FUNCTION_CANCELLED':
-            return publicError('CANCELLED', 'Function invocation was cancelled.', reason ?? input.code);
-        case 'FUNCTION_DEADLINE_EXCEEDED':
-            return publicError('DEADLINE_EXCEEDED', 'Function invocation deadline exceeded.', reason ?? input.code);
-        case 'FUNCTION_OUTCOME_UNKNOWN':
-            reportUnknownFunction(input);
-            return publicError('OUTCOME_UNKNOWN', 'Function outcome is unknown; do not retry automatically.', reason ?? input.code);
-        case 'FUNCTION_OUTPUT_INVALID':
-        case 'FUNCTION_BINDING_INVALID':
-        case 'FUNCTION_REDIRECT_INVALID':
-        case 'FUNCTION_RESULT_MISMATCH':
-        case 'RESULT_CONTRACT_VIOLATION':
-            return internal(input);
-        case 'FUNCTION_EXECUTION_FAILED':
-            return reason === undefined
-                ? internal(input)
-                : publicError('BACKEND_UNAVAILABLE', reasonMessage(reason, 'Function execution is unavailable.'), reason);
-    }
-}
-function classifyAuthentication(input) {
-    switch (input.code) {
-        case 'NO_AUTH':
-            return publicError('AUTH_MISSING', 'Authentication is required.');
-        case 'INVALID_CREDENTIAL':
-        case 'INVALID_GRANT':
-        case 'IDENTITY_NOT_FOUND':
-        case 'ISSUER_INVALID':
-        case 'ISSUER_NOT_FOUND':
-            return publicError('AUTH_INVALID', 'Credential is invalid.');
-        case 'GRANT_BROADENING':
-        case 'PROVISION_DENIED':
-            return publicError('ACCESS_DENIED', 'Access denied.');
-        case 'PROVISION_INVALID':
-            return publicError('VALIDATION_ERROR', 'Identity provision request is invalid.', input.code);
-        case 'IDENTITY_CONFLICT':
-        case 'PROVISION_CONFLICT':
-        case 'TRUST_REVISION_CONFLICT':
-            return publicError('CONFLICT', 'Authentication state changed.', input.code);
-        case 'PROVISION_OUTCOME_UNKNOWN':
-            return publicError('OUTCOME_UNKNOWN', 'Identity provision outcome is unknown; do not retry automatically.', input.code);
-        case 'TRUST_UPDATE_OUTCOME_UNKNOWN':
-            return publicError('OUTCOME_UNKNOWN', 'Authentication Trust outcome is unknown; do not retry automatically.', input.code);
-        case 'TRUST_INVALID':
-            return internal(input);
-        case 'MINT_FAILED':
-        case 'AUTHENTICATION_BACKEND_FAILED':
-            return publicError('BACKEND_UNAVAILABLE', 'Authentication is unavailable.');
-    }
-}
-function classifyAuthorization(input) {
-    switch (input.code) {
-        case 'POLICY_NOT_FOUND':
-        case 'CAPABILITY_TARGET_INVALID':
-            return publicError('NOT_FOUND', 'Requested resource was not found.');
-        case 'POLICY_COMPILATION_FAILED':
-            return internal(input);
-        case 'POLICY_SNAPSHOT_MISMATCH':
-            return publicError('CONFLICT', 'Authorization basis changed.', input.code);
-        case 'POLICY_PLAN_TOO_COMPLEX':
-            return publicError('LIMIT_EXCEEDED', 'Authorization plan limit exceeded.', input.code);
-        case 'POLICY_EVALUATION_TIMEOUT':
-            return publicError('DEADLINE_EXCEEDED', 'Authorization evaluation deadline exceeded.', input.code);
-        case 'POLICY_BACKEND_ERROR':
-            return publicError('BACKEND_UNAVAILABLE', 'Authorization is unavailable.');
-        case 'AUTHORITY_DENIED':
-            return publicError('ACCESS_DENIED', 'Access denied.');
-        case 'RESULT_CONTRACT_VIOLATION':
-            return internal(input);
-    }
-}
-function classifySchema(input) {
-    if (input.outcome === 'unknown') {
-        return publicError('OUTCOME_UNKNOWN', 'Schema activation outcome is unknown; do not retry automatically.', input.code);
-    }
-    switch (input.code) {
-        case 'SCHEMA_INPUT_INVALID':
-            return publicError('VALIDATION_ERROR', 'Schema request is invalid.');
-        case 'SCHEMA_NOT_FOUND':
-            return publicError('NOT_FOUND', 'Domain was not found.');
-        case 'SCHEMA_ARTIFACT_INVALID':
-        case 'SCHEMA_DEPENDENCY_MISSING':
-            return publicError('VALIDATION_ERROR', 'Domain schema is invalid.');
-        case 'SCHEMA_ARTIFACT_UNAVAILABLE':
-            return publicError('NOT_FOUND', 'Domain Runtime artifact is unavailable.');
-        case 'SCHEMA_REVISION_CONFLICT':
-            return publicError('CONFLICT', 'Domain revision conflicts with current state.');
-        case 'SCHEMA_OPERATION_CONFLICT':
-            return publicError('CONFLICT', 'Schema operation identity conflicts with retained state.');
-        case 'SCHEMA_REQUIREMENTS_UNSATISFIED':
-            return publicError('ACCESS_DENIED', 'Domain installation requirements are not satisfied.');
-        case 'SCHEMA_DEPENDENTS_PRESENT':
-            return publicError('CONFLICT', 'Domain has active dependents.');
-        case 'DATA_MIGRATION_REQUIRED':
-            return publicError('CONFLICT', 'Schema change requires an explicit data migration.');
-        case 'SCHEMA_UPGRADE_INCOMPATIBLE':
-            return publicError('UNSUPPORTED', 'Schema operation is not supported.');
-        case 'BACKEND_FEATURE_UNSUPPORTED':
-            return publicError('UNSUPPORTED', 'Schema operation is not supported.', input.code);
-        case 'SCHEMA_BACKEND_FAILED':
-        case 'SCHEMA_ACTIVATION_FAILED':
-            return publicError('BACKEND_UNAVAILABLE', 'Schema backend is unavailable.', input.code);
-        case 'SCHEMA_INTEGRITY_ERROR':
-            return internal(input);
-    }
-}
-function classifyEvent(input) {
-    switch (input.code) {
-        case 'EVENT_INVALID':
-            return publicError('VALIDATION_ERROR', 'Event request is invalid.', input.code);
-        case 'EVENT_RETENTION_GAP':
-            return publicError('CONFLICT', 'Event retention frontier is no longer available.', input.code);
-        case 'SUBSCRIPTION_UNAVAILABLE':
-            return publicError('CONFLICT', 'Event subscription is unavailable.', input.code);
-        case 'EVENT_BACKEND_FAILED':
-            return publicError('BACKEND_UNAVAILABLE', 'Event transport is unavailable.');
-    }
-}
-function classifyObservability(input) {
-    switch (input.code) {
-        case 'OBSERVABILITY_INVALID':
-            return publicError('VALIDATION_ERROR', 'Journal request is invalid.', input.code);
-        case 'OBSERVABILITY_RETENTION_GAP':
-            return publicError('CONFLICT', 'Journal retention frontier is no longer available.', input.code);
-        case 'OBSERVABILITY_DURABILITY_FAILED':
-        case 'OBSERVABILITY_BACKEND_FAILED':
-            return publicError('BACKEND_UNAVAILABLE', 'Journal is unavailable.');
-    }
-}
-function classifyNetwork(input) {
-    switch (input.code) {
-        case 'NETWORK_INVALID':
-        case 'INVALID_URL':
-            return publicError('VALIDATION_ERROR', 'Network request is invalid.', input.code);
-        case 'UNSUPPORTED_PROTOCOL':
-        case 'UNSUPPORTED_FEATURE':
-            return publicError('UNSUPPORTED', 'Network operation is not supported.', input.code);
-        case 'HOST_POLICY_DENIED':
-            return publicError('ACCESS_DENIED', 'Network target is denied.');
-        case 'TIMEOUT':
-            return publicError('DEADLINE_EXCEEDED', 'Network operation deadline exceeded.', input.code);
-        case 'ABORTED':
-            return publicError('CANCELLED', 'Network operation was cancelled.', input.code);
-        case 'TOO_MANY_REDIRECTS':
-        case 'REQUEST_TOO_LARGE':
-        case 'RESPONSE_BODY_TOO_LARGE':
-            return publicError('LIMIT_EXCEEDED', 'Network operation limit exceeded.', input.code);
-        case 'NETWORK_BACKEND_CONTRACT':
-            return internal(input);
-        case 'DNS_ERROR':
-        case 'CONNECT_ERROR':
-        case 'TLS_ERROR':
-        case 'NETWORK_ERROR':
-            return publicError('BACKEND_UNAVAILABLE', 'Network transport is unavailable.');
-    }
-}
-function publicError(name, message, reason) {
-    const candidate = typeof reason === 'string'
-        ? Object.freeze({ code: reason, details: Object.freeze({}) })
-        : reason;
-    const admitted = errors.reasonOf(candidate);
-    return {
-        code: errors.CODES[name],
-        message,
-        ...(admitted === undefined ? {} : { data: admitted }),
-    };
-}
-function reasonMessage(reason, fallback) {
-    switch (reason?.code) {
-        case 'SCHEMA_NOT_FOUND':
-            return 'Domain was not found.';
-        case 'SCHEMA_ARTIFACT_INVALID':
-        case 'SCHEMA_DEPENDENCY_MISSING':
-            return 'Domain schema is invalid.';
-        case 'SCHEMA_REVISION_CONFLICT':
-            return 'Domain revision conflicts with current state.';
-        case 'SCHEMA_OPERATION_CONFLICT':
-            return 'Schema operation identity conflicts with retained state.';
-        case 'SCHEMA_DEPENDENTS_PRESENT':
-            return 'Domain has active dependents.';
-        case 'DATA_MIGRATION_REQUIRED':
-            return 'Schema change requires an explicit data migration.';
-        case 'BACKEND_FEATURE_UNSUPPORTED':
-        case 'SCHEMA_UPGRADE_INCOMPATIBLE':
-            return 'Schema operation is not supported.';
-        case 'SCHEMA_BACKEND_FAILED':
-        case 'SCHEMA_ACTIVATION_FAILED':
-            return 'Schema backend is unavailable.';
-        default:
-            return fallback;
-    }
+function publicError(name, message) {
+    return { code: errors.CODES[name], message };
 }
 function internal(input) {
     reportInternal(input);
     return publicError('INTERNAL_ERROR', 'Internal application error.');
 }
-function reportUnknownFunction(input) {
-    const cause = input.cause;
-    const error = cause instanceof Error ? cause : undefined;
-    const failureCode = typeof input.details.failureCode === 'string' ? input.details.failureCode : undefined;
-    if (cause === undefined && failureCode === undefined)
-        return;
-    // Never print the message, stack, cause, input, credentials, or backend command.
-    // oxlint-disable-next-line no-console
-    console.error('[server] Function outcome is unknown', {
-        type: error?.constructor.name ?? typeof cause,
-        code: stableCode(cause),
-        failureCode,
-        ...(hostDebugErrors() ? { trail: stableErrorTrail(input.cause) } : {}),
-    });
-}
-function hostDebugErrors() {
-    const runtime = Reflect.get(globalThis, 'process');
-    if (runtime === null || typeof runtime !== 'object')
-        return false;
-    const environment = Reflect.get(runtime, 'env');
-    return (environment !== null &&
-        typeof environment === 'object' &&
-        Reflect.get(environment, 'KERNEL_HOST_DEBUG_ERRORS') === '1');
-}
-function stableErrorTrail(input) {
-    if (!(input instanceof Error))
-        return Object.freeze([]);
-    const current = Object.freeze({
-        type: input.constructor.name,
-        code: stableCode(input),
-        ...('phase' in input && typeof input.phase === 'string' ? { phase: input.phase } : {}),
-        ...(stableSchemaCoordinate(input) === undefined
-            ? {}
-            : { coordinate: stableSchemaCoordinate(input) }),
-    });
-    if (input instanceof AggregateError) {
-        return Object.freeze([current, ...input.errors.flatMap((cause) => stableErrorTrail(cause))]);
-    }
-    return Object.freeze([current, ...stableErrorTrail(input.cause)]);
-}
-function stableSchemaCoordinate(input) {
-    if (stableCode(input) !== 'DOMAIN_DEFINITION_NOT_FOUND')
-        return undefined;
-    const match = /^Definition ([a-z0-9.-]+:[a-z]+\.[A-Za-z][A-Za-z0-9_]*) does not exist\.$/u.exec(input.message);
-    return match?.[1];
-}
 function stableCode(input) {
     if (input !== null && typeof input === 'object' && 'code' in input) {
         return typeof input.code === 'string' ? input.code : undefined;
@@ -313,4 +39,3 @@ function reportInternal(input) {
         code: stableCode(input),
     });
 }
-//# sourceMappingURL=classify.js.map

package/dist/errors/index.d.ts

@@ -2,4 +2,3 @@ export { DeliveryUnavailableError, IssuerKeysUnavailableError } from './availabi
 export { classifyError } from './classify.js';
 export { RequestBodyInvalidError, RequestBodyTooLargeError } from './request-body.js';
 export { ResponseBodyTooLargeError } from './response-body.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/errors/index.js

@@ -2,4 +2,3 @@ export { DeliveryUnavailableError, IssuerKeysUnavailableError } from './availabi
 export { classifyError } from './classify.js';
 export { RequestBodyInvalidError, RequestBodyTooLargeError } from './request-body.js';
 export { ResponseBodyTooLargeError } from './response-body.js';
-//# sourceMappingURL=index.js.map

package/dist/errors/request-body.d.ts

@@ -5,4 +5,3 @@ export declare class RequestBodyTooLargeError extends Error {
 export declare class RequestBodyInvalidError extends Error {
     constructor(message: string);
 }
-//# sourceMappingURL=request-body.d.ts.map

package/dist/errors/request-body.js

@@ -12,4 +12,3 @@ export class RequestBodyInvalidError extends Error {
         this.name = 'RequestBodyInvalidError';
     }
 }
-//# sourceMappingURL=request-body.js.map

package/dist/errors/response-body.d.ts

@@ -2,4 +2,3 @@ export declare class ResponseBodyTooLargeError extends Error {
     readonly maximumBytes: number;
     constructor(maximumBytes: number);
 }
-//# sourceMappingURL=response-body.d.ts.map

package/dist/errors/response-body.js

@@ -6,4 +6,3 @@ export class ResponseBodyTooLargeError extends Error {
         this.name = 'ResponseBodyTooLargeError';
     }
 }
-//# sourceMappingURL=response-body.js.map

package/dist/index.d.ts

@@ -2,5 +2,4 @@ export { createServer, prepareServer } from './server.js';
 export { DeliveryUnavailableError, IssuerKeysUnavailableError } from './errors/index.js';
 export { preparePublicationSnapshot } from './publication/index.js';
 export * as publication from './publication/index.js';
-export type { Application, ApplicationHost, CorsConfig, Handler, HandlerRequest, HealthProbe, InvocationContext, Issuer, exchange, PreparedServer, PublicationSnapshot, PublicationSnapshotInput, PublicationSource, Server, ServerCloseOptions, ServerConfig, ServerLimits, ServerOptions, WebSocketAdapter, WebSocketHandlers, WebSocketLike, WebSocketUpgradeOptions, } from './types.js';
-//# sourceMappingURL=index.d.ts.map
+export type { Application, ApplicationHost, CorsConfig, ExecutionControl, Handler, HandlerRequest, HandlerResult, HandlerStream, HealthProbe, InvocationContext, InvocationSource, RequestBackground, RequestEvidence, RequestSleep, Issuer, exchange, PreparedServer, PublicationSnapshot, PublicationSnapshotInput, PublicationSource, Server, ServerCloseOptions, ServerConfig, ServerLimits, ServerOptions, WebSocketAdapter, WebSocketHandlers, WebSocketLike, WebSocketUpgradeOptions, } from './types.js';

package/dist/index.js

@@ -2,4 +2,3 @@ export { createServer, prepareServer } from './server.js';
 export { DeliveryUnavailableError, IssuerKeysUnavailableError } from './errors/index.js';
 export { preparePublicationSnapshot } from './publication/index.js';
 export * as publication from './publication/index.js';
-//# sourceMappingURL=index.js.map

package/dist/invocation/context.d.ts

@@ -1,7 +1,6 @@
-import type { invocation as protocol } from '@astrale-os/kernel-protocol';
+import type * as protocol from '@astrale-os/kernel-protocol/invocation';
 import type { ActiveOperation, ActiveOperations } from '../lifecycle/index.js';
 import type { ApplicationHost, InvocationContext } from './types.js';
-export declare function invocationContext(operation: ActiveOperation, active: ActiveOperations, host?: ApplicationHost, requestBody?: Uint8Array, idempotencyKey?: protocol.IdempotencyKey, delegate?: InvocationContext['delegate']): InvocationContext;
+export declare function invocationContext(assigned: protocol.InvocationId, operation: ActiveOperation, active: ActiveOperations, host?: ApplicationHost, requestBody?: Uint8Array, idempotencyKey?: protocol.IdempotencyKey): InvocationContext;
 /** Default non-durable timer used when the application host supplies no timer capability. */
 export declare function defaultSleep(durationMs: number): Promise<void>;
-//# sourceMappingURL=context.d.ts.map

package/dist/invocation/context.js

@@ -1,13 +1,13 @@
-export function invocationContext(operation, active, host, requestBody, idempotencyKey, delegate) {
+export function invocationContext(assigned, operation, active, host, requestBody, idempotencyKey) {
     const body = requestBody?.slice();
     return Object.freeze({
+        invocation: assigned,
         execution: Object.freeze({ deadline: operation.deadline, signal: operation.signal }),
         background: (task) => active.background(task, host?.waitUntil),
         sleep: async (durationMs) => {
             await interruptibleSleep(sleepDuration(durationMs), operation.signal, host?.sleep);
         },
         ...(idempotencyKey === undefined ? {} : { idempotencyKey }),
-        ...(delegate === undefined ? {} : { delegate }),
         ...(body === undefined ? {} : { request: Object.freeze({ body: () => body.slice() }) }),
     });
 }
@@ -58,4 +58,3 @@ function sleepDuration(input) {
     }
     return input;
 }
-//# sourceMappingURL=context.js.map

package/dist/invocation/identity.d.ts

@@ -0,0 +1,9 @@
+import type { IssuerId } from '@astrale-os/kernel-core/auth';
+import type * as protocol from '@astrale-os/kernel-protocol/invocation';
+/** Injected source-owned identity allocator captured before Server readiness. */
+export interface InvocationSource {
+    readonly source: IssuerId;
+    next(): string;
+}
+export type NextInvocationId = () => protocol.InvocationId;
+export declare function captureInvocationSource(input: InvocationSource): NextInvocationId;

package/dist/invocation/identity.js

@@ -0,0 +1,11 @@
+import { issuer } from '@astrale-os/kernel-core/auth';
+import * as protocolInvocation from '@astrale-os/kernel-protocol/invocation';
+import { captureMethod } from '../capture.js';
+export function captureInvocationSource(input) {
+    if (input === null || typeof input !== 'object') {
+        throw new TypeError('Server Invocation source is invalid.');
+    }
+    const source = issuer.accept(input.source);
+    const next = captureMethod(input, 'next', 'Server Invocation source is invalid.');
+    return () => protocolInvocation.acceptInvocationId({ source, id: next() });
+}

package/dist/invocation/index.d.ts

@@ -1,4 +1,4 @@
 export { defaultSleep, invocationContext } from './context.js';
+export { captureInvocationSource, type InvocationSource, type NextInvocationId, } from './identity.js';
 export { publicationRouteDecision, type PublicationRouteDecision } from './publication-route.js';
-export type { ApplicationHost, Handler, HandlerRequest, InvocationContext } from './types.js';
-//# sourceMappingURL=index.d.ts.map
+export type { ApplicationHost, ExecutionControl, Handler, HandlerRequest, HandlerResult, HandlerStream, InvocationContext, RequestBackground, RequestEvidence, RequestSleep, } from './types.js';

package/dist/invocation/index.js

@@ -1,3 +1,3 @@
 export { defaultSleep, invocationContext } from './context.js';
+export { captureInvocationSource, } from './identity.js';
 export { publicationRouteDecision } from './publication-route.js';
-//# sourceMappingURL=index.js.map

package/dist/invocation/publication-route.d.ts

@@ -1,12 +1,13 @@
-import type { errors, publication } from '@astrale-os/kernel-protocol';
+import type { ErrorPayload } from '@astrale-os/kernel-protocol/errors';
+import type { Publication } from '@astrale-os/kernel-protocol/publication/publication';
+import type { PublicationRef } from '@astrale-os/kernel-protocol/publication/reference';
 export type PublicationRouteDecision = {
     readonly kind: 'exact';
 } | {
     readonly kind: 'same-schema';
 } | {
     readonly kind: 'rejected';
-    readonly error: errors.ErrorPayload;
+    readonly error: ErrorPayload;
 };
 /** Compare untrusted installed routing evidence with the one captured serving Publication. */
-export declare function publicationRouteDecision(current: publication.Publication, installed: publication.PublicationRef): PublicationRouteDecision;
-//# sourceMappingURL=publication-route.d.ts.map
+export declare function publicationRouteDecision(current: Publication, installed: PublicationRef): PublicationRouteDecision;

package/dist/invocation/publication-route.js

@@ -1,14 +1,16 @@
-import { errors as protocolErrors, invocation, publication as publications, } from '@astrale-os/kernel-protocol';
+import { CODES } from '@astrale-os/kernel-protocol/errors';
+import { SCHEMA_UPGRADE_REQUIRED, SERVICE_TRUST_REQUIRED, } from '@astrale-os/kernel-protocol/invocation/service-reason';
+import { compareReference } from '@astrale-os/kernel-protocol/publication/reference';
 /** Compare untrusted installed routing evidence with the one captured serving Publication. */
 export function publicationRouteDecision(current, installed) {
-    switch (publications.compareReference(current, installed)) {
+    switch (compareReference(current, installed)) {
         case 'exact':
             return Object.freeze({ kind: 'exact' });
         case 'same-schema':
             return Object.freeze({ kind: 'same-schema' });
         case 'schema-drift':
             return rejected('Installed Domain schema requires an explicit upgrade.', Object.freeze({
-                code: invocation.SCHEMA_UPGRADE_REQUIRED,
+                code: SCHEMA_UPGRADE_REQUIRED,
                 details: Object.freeze({
                     origin: installed.origin,
                     installedRevision: installed.revision,
@@ -17,7 +19,7 @@ export function publicationRouteDecision(current, installed) {
             }));
         case 'identity-drift':
             return rejected('Installed Domain Service identity requires explicit trust.', Object.freeze({
-                code: invocation.SERVICE_TRUST_REQUIRED,
+                code: SERVICE_TRUST_REQUIRED,
                 details: Object.freeze({
                     origin: installed.origin,
                     installedIssuer: installed.identity.issuer,
@@ -28,7 +30,7 @@ export function publicationRouteDecision(current, installed) {
             return Object.freeze({
                 kind: 'rejected',
                 error: Object.freeze({
-                    code: protocolErrors.CODES.INVALID_REQUEST,
+                    code: CODES.INVALID_REQUEST,
                     message: 'Routed Publication origin differs from the served Domain.',
                 }),
             });
@@ -37,7 +39,6 @@ export function publicationRouteDecision(current, installed) {
 function rejected(message, data) {
     return Object.freeze({
         kind: 'rejected',
-        error: Object.freeze({ code: protocolErrors.CODES.CONFLICT, message, data }),
+        error: Object.freeze({ code: CODES.CONFLICT, message, data }),
     });
 }
-//# sourceMappingURL=publication-route.js.map

package/dist/invocation/types.d.ts

@@ -1,22 +1,49 @@
 import type { CredentialInput } from '@astrale-os/kernel-core/auth';
-import type { InboundRequestOptions, RequestBackground, RequestSleep } from '@astrale-os/kernel-ports';
-import type { Call, Result } from '@astrale-os/kernel-ports/functions';
-import type { invocation as protocol } from '@astrale-os/kernel-protocol';
+import type { CallableResult } from '@astrale-os/kernel-core/callable';
+import type { Value } from '@astrale-os/kernel-dsl/value';
+import type * as protocol from '@astrale-os/kernel-protocol/invocation';
 import type { PublicationSnapshot } from '../publication/index.js';
 /** Optional platform retention and timer adaptation for one Fetch invocation. */
 export interface ApplicationHost {
     waitUntil(promise: Promise<unknown>): void;
     readonly sleep?: (durationMs: number) => Promise<void>;
 }
+/** Ephemeral execution lifetime for one admitted request. */
+export interface ExecutionControl {
+    readonly deadline: number;
+    readonly signal: AbortSignal;
+}
+/** Register non-durable work with the request owner. */
+export type RequestBackground = (task: () => void | PromiseLike<unknown>) => void;
+/** Request-owner timer bounded by the same cancellation and deadline. */
+export type RequestSleep = (durationMs: number) => Promise<void>;
+/** Exact bounded ingress evidence retained outside portable Function input. */
+export interface RequestEvidence {
+    body(): Uint8Array;
+}
 /** Immutable lifetime and execution conveniences for one admitted dispatch. */
-export interface InvocationContext extends InboundRequestOptions {
+export interface InvocationContext {
+    readonly invocation: protocol.InvocationId;
+    readonly execution: ExecutionControl;
+    readonly idempotencyKey?: protocol.IdempotencyKey;
+    readonly request?: RequestEvidence;
     readonly background: RequestBackground;
     /** Rejects promptly when execution is cancelled or reaches its deadline. */
     readonly sleep: RequestSleep;
 }
+export interface HandlerStream extends AsyncIterable<Value> {
+    cancel(reason?: string): Promise<void>;
+}
+/** Complete semantic result accepted from one ready application Handler. */
+export type HandlerResult = CallableResult<Value, HandlerStream> | {
+    readonly kind: 'redirect';
+    readonly redirect: protocol.Redirection;
+} | {
+    readonly kind: 'miss';
+};
 /** Ready semantic capability invoked by canonical and advertised transport routes. */
 export interface HandlerRequest {
-    readonly call: Call;
+    readonly call: protocol.Call;
     /** Admitted transport correlation syntax, separate from semantic execution options. */
     readonly trace?: protocol.Trace;
     readonly credential?: CredentialInput;
@@ -31,8 +58,5 @@ export interface HandlerRequest {
     readonly context: InvocationContext;
 }
 export interface Handler {
-    dispatch(request: HandlerRequest): Promise<Result | {
-        readonly kind: 'miss';
-    }>;
+    dispatch(request: HandlerRequest): Promise<HandlerResult>;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/invocation/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map