@zlink-systems/framework 0.30.3 → 0.32.0

package/dist/runtime/spots/spot-handler-registry.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultZLinkInstanceSpotHandlerRegistry = exports.DefaultZLinkSpotHandlerRegistry = void 0;
 exports.applyEntrySpotHandlerRegistrations = applyEntrySpotHandlerRegistrations;
 exports.applySpotHandlerRegistrations = applySpotHandlerRegistrations;
+const HandlerMessageType_1 = require("../../contracts/Common/HandlerMessageType");
 const handler_instance_scope_1 = require("../handlers/handler-instance-scope");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const actors_1 = require("../actors");
@@ -21,16 +22,19 @@ class DefaultZLinkSpotHandlerRegistry {
         if (metadata === undefined || resolvedPacketName === undefined) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidOperation, `Actor packet handler '${handlerType.name}' must declare a packet name.`);
         }
-        return this.addActorPacketRegistration(metadata.kind === 'spotActorSend' ? actors_1.ZLinkActorPacketKind.Send : actors_1.ZLinkActorPacketKind.Request, handlerType, Object, resolvedPacketName);
+        return this.addActorPacketRegistration(metadata.kind === 'spotActorSend' ? actors_1.ZLinkActorPacketKind.Send : actors_1.ZLinkActorPacketKind.Request, handlerType, Object, resolvedPacketName, (0, HandlerMessageType_1.resolveHandlerMessageType)(handlerType));
     }
     addActorPacket(handlerType, actorType) {
         const metadata = (0, Attributes_1.readZLinkDecoratorMetadata)(handlerType).find((entry) => entry.kind === 'spotActorSend' || entry.kind === 'spotActorRequest');
         if (metadata?.packetName === undefined) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidOperation, `Actor packet handler '${handlerType.name}' must declare a packet name.`);
         }
-        return this.addActorPacketRegistration(metadata.kind === 'spotActorSend' ? actors_1.ZLinkActorPacketKind.Send : actors_1.ZLinkActorPacketKind.Request, handlerType, actorType, metadata.packetName);
+        return this.addActorPacketRegistration(metadata.kind === 'spotActorSend' ? actors_1.ZLinkActorPacketKind.Send : actors_1.ZLinkActorPacketKind.Request, handlerType, actorType, metadata.packetName, (0, HandlerMessageType_1.resolveHandlerMessageType)(handlerType));
     }
     addPacket(handlerType, packetName) {
+        return this.addPacketRegistration(handlerType, packetName, (0, HandlerMessageType_1.resolveHandlerMessageType)(handlerType));
+    }
+    addPacketRegistration(handlerType, packetName, messageType) {
         const declared = (0, Attributes_1.readZLinkDecoratorMetadata)(handlerType).find((entry) => entry.kind === 'packet')?.packetName;
         (0, handler_instance_scope_1.prepareHandlerInstance)(this.providerResolver, handlerType);
         const resolvedPacketName = packetName ?? declared ?? handlerType.name;
@@ -39,6 +43,7 @@ class DefaultZLinkSpotHandlerRegistry {
         this.entries.push({
             kind: 'packet',
             handlerType,
+            ...(messageType === undefined ? {} : { messageType: messageType }),
             packetName: resolvedPacketName
         });
         return this;
@@ -46,11 +51,12 @@ class DefaultZLinkSpotHandlerRegistry {
     packet(packetName, handlerType) {
         return this.addPacket(handlerType, packetName);
     }
-    addActorPacketRegistration(kind, handlerType, actorType, packetName) {
+    addActorPacketRegistration(kind, handlerType, actorType, packetName, messageType) {
         (0, handler_instance_scope_1.prepareHandlerInstance)(this.providerResolver, handlerType);
         this.entries.push({
             kind: kind === actors_1.ZLinkActorPacketKind.Send ? 'actorSend' : 'actorRequest',
             handlerType,
+            ...(messageType === undefined ? {} : { messageType: messageType }),
             actorType,
             packetName
         });
@@ -58,17 +64,21 @@ class DefaultZLinkSpotHandlerRegistry {
             kind,
             packetName,
             actorType,
-            handlerType
+            handlerType,
+            messageType: messageType
         });
         return this;
     }
     actorSend(packetName, handlerType, actorType = Object) {
-        return this.addActorPacketRegistration(actors_1.ZLinkActorPacketKind.Send, handlerType, actorType, packetName);
+        return this.addActorPacketRegistration(actors_1.ZLinkActorPacketKind.Send, handlerType, actorType, packetName, (0, HandlerMessageType_1.resolveHandlerMessageType)(handlerType));
     }
     actorRequest(packetName, handlerType, actorType = Object) {
-        return this.addActorPacketRegistration(actors_1.ZLinkActorPacketKind.Request, handlerType, actorType, packetName);
+        return this.addActorPacketRegistration(actors_1.ZLinkActorPacketKind.Request, handlerType, actorType, packetName, (0, HandlerMessageType_1.resolveHandlerMessageType)(handlerType));
     }
     addSubscribe(handlerType, channelName, topic) {
+        return this.addSubscriptionRegistration(handlerType, channelName, topic, (0, HandlerMessageType_1.resolveHandlerMessageType)(handlerType));
+    }
+    addSubscriptionRegistration(handlerType, channelName, topic, messageType) {
         if (channelName.trim().length === 0) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidOperation, 'SPOT subscribe channel name must not be empty.');
         }
@@ -82,7 +92,13 @@ class DefaultZLinkSpotHandlerRegistry {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidOperation, `SPOT subscription '${channelName}/${topic}' is already registered.`);
         }
         (0, handler_instance_scope_1.prepareHandlerInstance)(this.providerResolver, handlerType);
-        this.entries.push({ kind: 'subscribe', handlerType, channelName, topic });
+        this.entries.push({
+            kind: 'subscribe',
+            handlerType,
+            ...(messageType === undefined ? {} : { messageType: messageType }),
+            channelName,
+            topic
+        });
         return this;
     }
     subscribe(channelName, topic, handlerType) {
@@ -123,44 +139,44 @@ exports.DefaultZLinkInstanceSpotHandlerRegistry = DefaultZLinkInstanceSpotHandle
 function applyEntrySpotHandlerRegistrations(registry, entrySpotType, registrations) {
     for (const handler of registrations.actorSendHandlers ?? []) {
         if (handler.entrySpotType === entrySpotType) {
-            registry.addActorPacketRegistration(actors_1.ZLinkActorPacketKind.Send, handler.handlerType, handler.actorType, handler.packetName);
+            registry.addActorPacketRegistration(actors_1.ZLinkActorPacketKind.Send, handler.handlerType, handler.actorType, handler.packetName, handler.messageType);
         }
     }
     for (const handler of registrations.actorRequestHandlers ?? []) {
         if (handler.entrySpotType === entrySpotType) {
-            registry.addActorPacketRegistration(actors_1.ZLinkActorPacketKind.Request, handler.handlerType, handler.actorType, handler.packetName);
+            registry.addActorPacketRegistration(actors_1.ZLinkActorPacketKind.Request, handler.handlerType, handler.actorType, handler.packetName, handler.messageType);
         }
     }
     for (const handler of registrations.packetHandlers ?? []) {
         if (handler.entrySpotType === entrySpotType) {
-            registry.addPacket(handler.handlerType, handler.packetName);
+            registry.addPacketRegistration(handler.handlerType, handler.packetName, handler.messageType);
         }
     }
     for (const handler of registrations.subscriptionHandlers ?? []) {
         if (handler.entrySpotType === entrySpotType) {
-            registry.addSubscribe(handler.handlerType, handler.channelName, handler.topic);
+            registry.addSubscriptionRegistration(handler.handlerType, handler.channelName, handler.topic, handler.messageType);
         }
     }
 }
 function applySpotHandlerRegistrations(registry, spotType, registrations) {
     for (const handler of registrations.actorSendHandlers ?? []) {
         if (isSpotImplementation(handler.spotType, spotType)) {
-            registry.addActorPacketRegistration(actors_1.ZLinkActorPacketKind.Send, handler.handlerType, handler.actorType, handler.packetName);
+            registry.addActorPacketRegistration(actors_1.ZLinkActorPacketKind.Send, handler.handlerType, handler.actorType, handler.packetName, handler.messageType);
         }
     }
     for (const handler of registrations.actorRequestHandlers ?? []) {
         if (isSpotImplementation(handler.spotType, spotType)) {
-            registry.addActorPacketRegistration(actors_1.ZLinkActorPacketKind.Request, handler.handlerType, handler.actorType, handler.packetName);
+            registry.addActorPacketRegistration(actors_1.ZLinkActorPacketKind.Request, handler.handlerType, handler.actorType, handler.packetName, handler.messageType);
         }
     }
     for (const handler of registrations.packetHandlers ?? []) {
         if (isSpotImplementation(handler.spotType, spotType)) {
-            registry.addPacket(handler.handlerType, handler.packetName);
+            registry.addPacketRegistration(handler.handlerType, handler.packetName, handler.messageType);
         }
     }
     for (const handler of registrations.subscriptionHandlers ?? []) {
         if (isSpotImplementation(handler.spotType, spotType)) {
-            registry.addSubscribe(handler.handlerType, handler.channelName, handler.topic);
+            registry.addSubscriptionRegistration(handler.handlerType, handler.channelName, handler.topic, handler.messageType);
         }
     }
 }

package/dist/runtime/spots/spot-manager-public.js

@@ -47,12 +47,13 @@ class ZLinkPublicSpotManager {
         }
     }
     async close(spot, signal) {
+        const deadline = new Date(Date.now() + this.options.defaultTimeoutMs);
         const resolved = await this.options.coordinator.resolveCloseTarget(spot, signal);
         if (resolved === undefined)
             return false;
         const current = resolved.spot;
         if (this.options.isLocalNode(current.meshName, current.nodeRid)) {
-            const closed = await this.options.coordinator.close(spot, (local, beginAuthority) => this.options.local.closeUserWithAuthority(local.meshName, local.spotId, beginAuthority, signal), signal);
+            const closed = await this.options.coordinator.close(spot, (local, beginAuthority) => this.options.local.closeUserWithAuthority(local.meshName, local.spotId, beginAuthority, signal, deadline), signal);
             if (closed)
                 this.options.resolver()?.invalidate?.(spot.spotId);
             return closed;
@@ -73,7 +74,7 @@ class ZLinkPublicSpotManager {
                 authorityOwnerGeneration: snapshot.authorityOwnerGeneration,
                 expectedStoreVersion: snapshot.storeVersion.value
             },
-            deadlineUnixMs: BigInt(Date.now() + timeoutMs)
+            deadlineUnixMs: BigInt(deadline.getTime())
         }, timeoutMs);
         if (result.terminalResult !== 0 || result.tail?.kind !== 'userSpotClose') {
             const message = `Remote User Spot close failed. terminalResult=${result.terminalResult}, failureCode=${result.failureCode}.`;

package/dist/runtime/spots/spot-node-runtime-manager.d.ts

@@ -1,3 +1,4 @@
+import type { RequestRuntime } from '../foundation/request-runtime';
 import type { ZLinkMeshDispatchAdmission } from '../admission';
 import type { ApplicationJobOrigin } from '../application-jobs/contracts';
 import { type ActorRef, type RoutingId, type ZLinkActor, type ZLinkChannelClient, type ZLinkFanoutClient, type ZLinkMeshNodeDescriptor, type ZLinkMessage, type ZLinkMessageSerializer, type ZLinkSpotPublisherClient, ZLinkFrameworkRuntimeState } from '../../contracts';
@@ -19,10 +20,14 @@ import { ApplicationJobQueue } from '../host/application-job-queue';
 import { ZLinkLocationRuntime, type ZLinkLocationEventSink, type ZLinkLocationRuntimeStores } from '../locations';
 import { type ZLinkSubmitResult } from '../messaging/submission-result';
 import type { ZLinkDetachedTaskRunner } from './spot-actor-join-dispatch';
+import { ZLinkEntrySpotActivation } from './spot-entry-activation';
+import { type ZLinkSpotNodeLocationAutoConnectContext } from './spot-node-autoconnect';
 import type { ZLinkSpotRoutedTransport } from './spot-outbound';
 import type { ZLinkSpotRouteResolver } from './spot-routing-internal';
 import type { ZLinkEntryActorRuntime, ZLinkSpotActorHandoffRuntime, ZLinkSpotActorTransferRuntime, ZLinkSpotBoundSessionRuntime } from './spot-runtime-ports';
 export interface ZLinkSpotNodeRuntimeManagerOptions {
+    readonly requests?: RequestRuntime;
+    readonly admission?: import('../admission').ZLinkRuntimeAdmissionGate;
     readonly errorSink: import('../diagnostics/dispatch-error-port').ZLinkDispatchErrorSink;
     readonly listenerRecords?: ZLinkListenerRecords;
     readonly registration: ZLinkFrameworkRegistration;
@@ -54,11 +59,11 @@ export interface ZLinkSpotNodeRuntimeManagerOptions {
     readonly activationConcurrency?: (meshName: string) => ZLinkActivationConcurrency;
 }
 export declare class ZLinkSpotNodeRuntimeManager {
-    private readonly options;
-    private readonly meshNodes;
+    readonly options: ZLinkSpotNodeRuntimeManagerOptions;
+    readonly meshNodes: Map<string, ZLinkBackendMeshNode>;
     private readonly meshPumps;
     private readonly meshCompletions;
-    private readonly entryActivations;
+    readonly entryActivations: Map<string, ZLinkEntrySpotActivation>;
     private readonly entryActivationStarts;
     private readonly publishers;
     private readonly disposal;
@@ -70,8 +75,8 @@ export declare class ZLinkSpotNodeRuntimeManager {
     private readonly runtimeChannelWeights;
     private readonly entrySpotIds;
     private runtimeWeightPublication;
-    private statePublication;
-    private locationAutoConnect?;
+    statePublication: Promise<void>;
+    locationAutoConnect?: ZLinkSpotNodeLocationAutoConnectContext;
     private readonly applicationJobQueue;
     constructor(options: ZLinkSpotNodeRuntimeManagerOptions);
     createTopicMessage(): import("../backend/runtime-values").ZLinkBackendTopicMessage;
@@ -125,7 +130,7 @@ export declare class ZLinkSpotNodeRuntimeManager {
     private dispatchFrameworkRecord;
     dispatchEntrySpotRecord(meshName: string, owner: ReadyRecord, record: ReceiveRecord, admit?: ZLinkMeshDispatchAdmission): Promise<boolean>;
     private ensureEntryActivation;
-    private initializeEntrySpot;
+    initializeEntrySpot(spotNodeName: string, node: ZLinkBackendMeshNode, spotNode: ZLinkSpotNodeOptions): Promise<void>;
     private primaryEntryActivation;
     dispatchEntryActorPacket(origin: ApplicationJobOrigin, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, requestTerminal?: (response: unknown) => Promise<void> | void, messageFollowOrigin?: ZLinkMessageFollowOrigin): Promise<unknown>;
     dispatchEntryActorJoin(meshName: string, actor: ZLinkActor, handoffBacklog?: readonly ZLinkActorHandoffPacket[]): Promise<void>;

package/dist/runtime/spots/spot-node-runtime-manager.js

@@ -148,12 +148,16 @@ class ZLinkSpotNodeRuntimeManager {
             const node = meshAdapter.createMeshNode(this.options.context, {
                 meshName: spotNodeName,
                 routingId,
+                sendHighWaterMark: spotNode.router?.sendHighWaterMark,
+                receiveHighWaterMark: spotNode.router?.receiveHighWaterMark,
                 receiveTimeoutMs: spotNode.router?.receiveTimeoutMs,
                 applicationJobQueue: this.applicationJobQueue,
                 infrastructureTaskRunner: this.options.detachedTaskRunner,
                 applicationJobReceiveFlowFailureSink: this.options.applicationJobReceiveFlowFailureSink,
                 peerAdmissionSealed: () => this.options.peerAdmissionSealed?.(spotNodeName) ?? false
             });
+            if (this.options.requests !== undefined)
+                node.setRequestRuntime?.(this.options.requests);
             if (this.options.dispatchErrors !== undefined) {
                 node.setDispatchErrorReporter?.(this.options.dispatchErrors, spotNodeName);
             }
@@ -685,7 +689,7 @@ class ZLinkSpotNodeRuntimeManager {
         }
         const envelope = (0, channel_envelope_1.decodeChannelEnvelope)(record.parts, undefined, this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true);
         const codecs = { serializers: this.options.registration.messageSerializers };
-        const decodePayload = () => (0, channel_envelope_1.decodeChannelPayload)(envelope, codecs);
+        const decodePayload = (messageType) => (0, channel_envelope_1.decodeChannelPayload)(envelope, codecs, messageType);
         const context = {
             channelName: envelope.header.channelName,
             contentType: envelope.header.contentType
@@ -738,6 +742,7 @@ class ZLinkSpotNodeRuntimeManager {
             return;
         }
         const activation = new spot_entry_activation_1.ZLinkEntrySpotActivation({
+            admission: this.options.admission,
             entrySpotType: spotNode.entrySpotType,
             nativeSpot: node.entrySpot(),
             nativeNode: node,

package/dist/runtime/spots/spot-outbound.d.ts

@@ -1,3 +1,5 @@
+import type { PendingOperation, OperationObserver } from '../foundation/operation-registry';
+import { type ZLinkRequestResult } from '../messaging/request-result';
 import { type RoutingId, type ZLinkChannelClient, type ZLinkChannelRequestCall, type ZLinkPublishCall, type ZLinkSendCall, type ZLinkSpotOutbound, type ZLinkSpotPublisherClient, type ZLinkSpotRequestCall, type ZLinkSpotSendCall } from '../../contracts';
 import type { ZLinkBackendSpot } from '../backend/contracts';
 import { type ZLinkSubmitResult } from '../messaging/submission-result';
@@ -41,6 +43,7 @@ export interface ZLinkSpotAddressCallOptions {
     readonly instanceSpotType?: string;
     readonly initialMeshName?: string;
     readonly timeoutMs?: number;
+    readonly requestOperation?: PendingOperation<unknown>;
     readonly signal?: AbortSignal;
     readonly sourceSpot?: ZLinkBackendSpot;
 }
@@ -55,8 +58,8 @@ export interface ZLinkSpotAddressTransport {
 export interface ZLinkSpotRoutedTransport {
     sendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, message: unknown, options: ZLinkSpotRoutedSendOptions): Promise<ZLinkSubmitResult>;
     sendFromSpotToSpot?(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, message: unknown, options: ZLinkSpotRoutedSendOptions): Promise<ZLinkSubmitResult>;
-    requestToSpot<TReply = unknown>(spotRouteTarget: ZLinkSpotRouteTarget, request: unknown, options: ZLinkSpotRoutedRequestOptions): Promise<TReply>;
-    requestFromSpotToSpot?<TReply = unknown>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: unknown, options: ZLinkSpotRoutedRequestOptions): Promise<TReply>;
+    requestToSpot<TReply = unknown>(spotRouteTarget: ZLinkSpotRouteTarget, request: unknown, options: ZLinkSpotRoutedRequestOptions, destination?: OperationObserver<unknown, unknown>): ZLinkRequestResult<TReply>;
+    requestFromSpotToSpot?<TReply = unknown>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: unknown, options: ZLinkSpotRoutedRequestOptions, destination?: OperationObserver<unknown, unknown>): ZLinkRequestResult<TReply>;
 }
 export interface ZLinkSpotRoutedSendOptions {
     readonly instanceSpot?: boolean;
@@ -64,14 +67,17 @@ export interface ZLinkSpotRoutedSendOptions {
     readonly metadata?: ReadonlyMap<string, string>;
 }
 export interface ZLinkSpotRoutedRequestOptions extends ZLinkSpotRoutedSendOptions {
+    readonly deadlineMs?: number;
     readonly onAdmitted?: () => void;
     readonly timeoutMs?: number;
+    readonly requestOperation?: PendingOperation<unknown>;
     readonly signal?: AbortSignal;
 }
 export interface ZLinkSpotHandleCallOptions {
     readonly onAdmitted?: () => void;
     readonly metadata?: ReadonlyMap<string, string>;
     readonly timeoutMs?: number;
+    readonly requestOperation?: PendingOperation<unknown>;
     readonly signal?: AbortSignal;
     readonly spotRouterChannelIdForMesh?: (meshName: string) => string;
     readonly sourceSpot?: ZLinkBackendSpot;

package/dist/runtime/spots/spot-outbound.js

@@ -155,7 +155,7 @@ function createAddressedSpotRequestCall(serial, transport, spotId, request, sour
         submit(signal) {
             markSubmitted(options);
             rejectSameSpotAsyncRequest(serial, spotId, 'async');
-            return (0, request_result_1.createZLinkRequest)((onAdmitted) => begin(signal, onAdmitted), (pending) => (serial.isCurrentTurn ? pending : (0, workers_1.deliverOnSerial)(serial, pending)));
+            return (0, request_result_1.createZLinkRequest)((onAdmitted) => (0, request_result_1.prepareZLinkRequestReply)(begin(signal, onAdmitted), request_result_1.identityRequestReply), (pending) => (serial.isCurrentTurn ? pending : (0, workers_1.deliverOnSerial)(serial, pending)));
         },
         yield(signal) {
             const turn = (0, execution_1.requireZLinkYieldTurn)();
@@ -272,7 +272,7 @@ function wrapRequestCall(serial, inner) {
             return this;
         },
         submit(signal) {
-            return (0, request_result_1.createZLinkRequest)((onAdmitted) => begin(signal, onAdmitted), (pending) => (serial.isCurrentTurn ? pending : (0, workers_1.deliverOnSerial)(serial, pending)));
+            return (0, request_result_1.createZLinkRequest)((onAdmitted) => (0, request_result_1.prepareZLinkRequestReply)(begin(signal, onAdmitted), request_result_1.identityRequestReply), (pending) => (serial.isCurrentTurn ? pending : (0, workers_1.deliverOnSerial)(serial, pending)));
         },
         yield(signal) {
             const turn = (0, execution_1.requireZLinkYieldTurn)();
@@ -360,7 +360,7 @@ function wrapRoutedSpotRequestCall(serial, transport, spot, request, spotRouterC
         },
         submit(signal) {
             rejectSameSpotAsyncRequest(serial, spot.spotId, 'async');
-            return (0, request_result_1.createZLinkRequest)((onAdmitted) => begin(signal, onAdmitted), (pending) => (serial.isCurrentTurn ? pending : (0, workers_1.deliverOnSerial)(serial, pending)));
+            return (0, request_result_1.createZLinkRequest)((onAdmitted) => (0, request_result_1.prepareZLinkRequestReply)(begin(signal, onAdmitted), request_result_1.identityRequestReply), (pending) => (serial.isCurrentTurn ? pending : (0, workers_1.deliverOnSerial)(serial, pending)));
         },
         yield(signal) {
             const turn = (0, execution_1.requireZLinkYieldTurn)();
@@ -397,7 +397,7 @@ async function sendToSpotHandle(transport, spot, message, options = {}) {
 }
 async function requestToSpotHandle(transport, spot, request, options = {}) {
     const packetName = (0, packet_name_1.resolveFrameworkPacketName)(request, undefined, 'SPOT');
-    const requestResolved = async (resolved) => {
+    const requestResolved = (resolved) => {
         const target = spotRefToSpotRouteTarget(resolved, options.spotRouterChannelIdForMesh);
         const transportOptions = {
             packetName,
@@ -411,7 +411,7 @@ async function requestToSpotHandle(transport, spot, request, options = {}) {
         }
         return transport.requestToSpot(target, request, transportOptions);
     };
-    return requestResolved(await requireSpotRef(spot, options.signal));
+    return (0, request_result_1.mapZLinkRequestReply)(requestResolved(await requireSpotRef(spot, options.signal)));
 }
 async function requireSpotRef(handle, signal) {
     const resolved = await (0, spot_handle_1.resolveSpotHandle)(handle, signal);

package/dist/runtime/spots/spot-route-packet-dispatch.js

@@ -12,6 +12,7 @@ const flow_context_1 = require("../diagnostics/flow-context");
 const serial_work_size_1 = require("../execution/serial-work-size");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const handler_instance_scope_1 = require("../handlers/handler-instance-scope");
+const HandlerMessageType_1 = require("../../contracts/Common/HandlerMessageType");
 const spot_remote_codec_1 = require("./spot-remote-codec");
 const spot_route_replies_1 = require("./spot-route-replies");
 /** D5: reply metadata attached only to framework-self-generated errors. */
@@ -24,9 +25,10 @@ class ZLinkSpotRoutePacketDispatch {
         this.options = options;
     }
     async dispatch(received) {
+        const receivedAt = new Date();
         const directEnvelope = decodeSpotDirectEnvelope(received.parts);
         if (directEnvelope !== undefined) {
-            await this.dispatchSpotDirectEnvelope(received, directEnvelope);
+            await this.dispatchSpotDirectEnvelope(received, directEnvelope, receivedAt);
             return true;
         }
         let envelope;
@@ -77,7 +79,8 @@ class ZLinkSpotRoutePacketDispatch {
             contentType: envelope.header.contentType,
             packetName: envelope.packetName,
             metadata: (0, contracts_1.zlinkMessageMetadata)(envelope.header.metadata),
-            correlationId: envelope.header.correlationId ?? undefined
+            correlationId: envelope.header.correlationId ?? undefined,
+            receivedAt
         };
         try {
             let response;
@@ -88,7 +91,7 @@ class ZLinkSpotRoutePacketDispatch {
                     // Keep the wire payload raw until this Spot has acquired its
                     // execution authority. A rejected or superseded work item must not
                     // pay the deserialization cost.
-                    const payload = (0, channel_envelope_1.decodeChannelPayload)(envelope, this.channelCodecs());
+                    const payload = (0, channel_envelope_1.decodeChannelPayload)(envelope, this.channelCodecs(), (0, HandlerMessageType_1.resolveMessageTypeForDecode)(registrations[0]?.messageType));
                     for (const registration of registrations) {
                         const handler = await (0, handler_instance_scope_1.resolveLifecycleHandler)(spot, registration.handlerType, this.options.providerResolver);
                         (0, application_job_queue_scope_1.releaseApplicationJobPermitBeforeHandler)();
@@ -132,7 +135,7 @@ class ZLinkSpotRoutePacketDispatch {
             return true;
         }
     }
-    async dispatchSpotDirectEnvelope(received, envelope) {
+    async dispatchSpotDirectEnvelope(received, envelope, receivedAt) {
         const replyable = envelope.kind === 1 /* ZLinkChannelMessageKind.Request */ && (0, spot_route_replies_1.hasReplyToken)(received.replyToken);
         const messageKind = replyable
             ? ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Request
@@ -161,13 +164,15 @@ class ZLinkSpotRoutePacketDispatch {
                 const spot = this.options.getTarget();
                 for (const registration of registrations) {
                     const handler = await (0, handler_instance_scope_1.resolveLifecycleHandler)(spot, registration.handlerType, this.options.providerResolver);
-                    (0, application_job_queue_scope_1.releaseApplicationJobPermitBeforeHandler)();
-                    response = await handler.handle(spot, envelope.payload, {
+                    const handlerContext = {
                         channelName: envelope.channelName,
                         packetName: envelope.packetName,
                         metadata: (0, contracts_1.zlinkMessageMetadata)(envelope.metadata),
-                        correlationId: undefined
-                    });
+                        correlationId: undefined,
+                        receivedAt
+                    };
+                    (0, application_job_queue_scope_1.releaseApplicationJobPermitBeforeHandler)();
+                    response = await handler.handle(spot, envelope.payload, handlerContext);
                 }
             }, (0, serial_work_size_1.zlinkSerialWorkOptions)(received.parts[0]?.size() ?? 0, (0, serial_work_size_1.zlinkMetadataByteLength)(envelope.metadata)));
             if (replyable) {

package/dist/runtime/spots/spot-routed-spot-packet-dispatch.d.ts

@@ -1,4 +1,4 @@
-import type { RoutingId, ZLinkSpot } from '../../contracts';
+import type { RoutingId, Type, ZLinkSpot } from '../../contracts';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
 import type { ZLinkApplicationWorkClaim } from '../admission';
 import type { ZLinkDispatchErrorReporter } from '../channels';
@@ -38,9 +38,9 @@ export declare class ZLinkRoutedSpotPacketDispatch {
     private readonly options;
     constructor(options: ZLinkRoutedSpotPacketDispatchOptions);
     send(spotId: RoutingId, packetName: string | undefined, message: unknown, context: ZLinkRoutedSpotPacketContext): Promise<void>;
-    sendEncoded(spotId: RoutingId, packetName: string | undefined, decodePayload: () => unknown, context: ZLinkRoutedSpotPacketContext): Promise<void>;
+    sendEncoded(spotId: RoutingId, packetName: string | undefined, decodePayload: (messageType?: Type) => unknown, context: ZLinkRoutedSpotPacketContext): Promise<void>;
     request<TReply>(spotId: RoutingId, packetName: string | undefined, request: unknown, context: ZLinkRoutedSpotPacketContext): Promise<TReply>;
-    requestEncoded<TReply>(spotId: RoutingId, packetName: string | undefined, decodePayload: () => unknown, context: ZLinkRoutedSpotPacketContext): Promise<TReply>;
+    requestEncoded<TReply>(spotId: RoutingId, packetName: string | undefined, decodePayload: (messageType?: Type) => unknown, context: ZLinkRoutedSpotPacketContext): Promise<TReply>;
     private dispatch;
     private reportFailure;
     private reportMissing;

package/dist/runtime/spots/spot-routed-spot-packet-dispatch.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkRoutedSpotPacketDispatch = void 0;
 const dispatch_error_details_1 = require("../diagnostics/dispatch-error-details");
 const contracts_1 = require("../../contracts");
+const HandlerMessageType_1 = require("../../contracts/Common/HandlerMessageType");
 const ZLinkDispatchOptions_1 = require("../../contracts/Dispatch/ZLinkDispatchOptions");
 const configuration_1 = require("../configuration");
 const framework_errors_internal_1 = require("../framework-errors-internal");
@@ -26,6 +27,7 @@ class ZLinkRoutedSpotPacketDispatch {
         return (await this.dispatch(spotId, packetName, decodePayload, context, true));
     }
     async dispatch(spotId, packetName, decodePayload, context, returnResponse) {
+        const receivedAt = new Date();
         const activation = this.options.resolveActivation(spotId);
         if (activation === undefined) {
             this.reportMissing(spotId, packetName, context, returnResponse);
@@ -87,19 +89,21 @@ class ZLinkRoutedSpotPacketDispatch {
                             (packetName ?? ''));
                 // Decode only after the Spot has acquired both application admission
                 // and its execution authority.
-                const payload = decodePayload();
+                const payload = decodePayload((0, HandlerMessageType_1.resolveMessageTypeForDecode)(currentRegistrations[0]?.messageType));
                 for (const registration of currentRegistrations) {
                     const handler = await (0, handler_instance_scope_1.resolveLifecycleHandler)(current.spot, registration.handlerType, this.options.providerResolver);
                     resolveFirstHandlerTurn?.();
                     resolveFirstHandlerTurn = undefined;
                     context.activationRecord?.onHandlerTurnStarted?.();
-                    (0, application_job_queue_scope_1.releaseApplicationJobPermitBeforeHandler)();
-                    response = await handler.handle(current.spot, payload, {
+                    const handlerContext = {
                         channelName: context.channelName,
                         contentType: context.contentType,
                         packetName: packetName,
-                        metadata: (0, contracts_1.zlinkMessageMetadata)({})
-                    });
+                        metadata: (0, contracts_1.zlinkMessageMetadata)({}),
+                        receivedAt
+                    };
+                    (0, application_job_queue_scope_1.releaseApplicationJobPermitBeforeHandler)();
+                    response = await handler.handle(current.spot, payload, handlerContext);
                 }
             }
             catch (error) {

package/dist/runtime/spots/spot-runtime-ports.d.ts

@@ -12,10 +12,10 @@ export interface ZLinkEntryActorRuntime {
     resolveActor(actorId: string): ZLinkActor | undefined;
     commitActorTransaction(actor: ZLinkActor, onJoined: () => Promise<void>): Promise<void>;
     destroyActor(node: ZLinkBackendSpotNode, entryNodeRid: RoutingId, actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
-    routePacket(actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef): Promise<{
+    routePacket(actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, origin?: ApplicationJobOrigin, requestTerminal?: import('./spot-actor-packet-dispatch').ZLinkActorRequestTerminal, messageFollowOrigin?: ZLinkMessageFollowOrigin): {
         readonly handled: boolean;
         readonly response?: unknown;
-    }>;
+    };
 }
 export interface ZLinkSpotActorTransferRuntime {
     prepareDeferredJoinAccepted(actorId: string, operationId: ZLinkActorJoinOperationId, actorRef: ActorRef, rawReply: Uint8Array, replyContentType?: string): ZLinkDeferredJoinCompletion;

package/dist/runtime/spots/spot-serial-executor.d.ts

@@ -1,4 +1,5 @@
 import { ZLinkUserSpotExecutionMode } from '../../contracts';
+import { ZLinkActorSerialExecutor } from '../actors';
 import type { ZLinkActorHandoffDispatch, ZLinkActorHandoffPrefixAdmission, ZLinkActorHandoffPrefixRecord } from '../actors/actor-handoff';
 import type { ZLinkExecutionBarrier } from '../execution';
 import type { ZLinkSerialSchedulerOptions, ZLinkSerialWorkOptions } from '../execution/serial-execution-queue';
@@ -18,7 +19,7 @@ export declare class ZLinkSpotSerialExecutor {
     private readonly actorOptions?;
     private readonly actorSerials;
     private readonly timerSerials;
-    private readonly actorExecutors;
+    readonly actorExecutors: Map<string, ZLinkActorSerialExecutor>;
     private executionBarrier;
     private closing;
     private closePromise;

package/dist/runtime/spots/spot-serial-turn-executor.js

@@ -100,7 +100,7 @@ class ZLinkSpotSerialTurnExecutor {
      * Queues a one-way turn in serial order. Handler completion is reported
      * through `onError` and never blocks the sender turn.
      */
-    async postOneWay(operation, onError, workOptions = {}, admission = {}, replay) {
+    async postOneWay(operation, onError, workOptions, admission, replay) {
         this.lastActivityAtMs = performance.now();
         let barrierClaim;
         try {
@@ -112,17 +112,13 @@ class ZLinkSpotSerialTurnExecutor {
             if (barrierClaim !== undefined && replay !== undefined) {
                 Object.assign(barrierClaim, { replay: (0, application_job_queue_scope_1.bindApplicationJobPermit)(replay) });
             }
-            if (admission.signal?.aborted === true) {
+            if (admission?.signal?.aborted === true) {
                 throw new DOMException('The operation was aborted.', 'AbortError');
             }
-            const options = {
-                ...workOptions,
-                lane: workOptions.lane ?? 'application'
-            };
             const boundOperation = (0, application_job_queue_scope_1.bindApplicationJobPermit)(operation);
             const submitted = (0, application_job_queue_scope_1.hasApplicationJobPermit)()
-                ? this.scheduler.submitPreAdmitted(boundOperation, options, barrierClaim)
-                : this.scheduler.submit(boundOperation, options, barrierClaim);
+                ? this.scheduler.submitPreAdmitted(boundOperation, workOptions, barrierClaim)
+                : this.scheduler.submit(boundOperation, workOptions, barrierClaim);
             void submitted.catch((error) => {
                 barrierClaim?.release();
                 onError(error);
@@ -187,7 +183,7 @@ class ZLinkSpotSerialTurnExecutor {
     visitPendingApplication(visitor) {
         this.scheduler.visitPendingApplication(visitor);
     }
-    async enqueueApplicationTurn(operation, workOptions = {}, replay, retainWhilePreparing = false) {
+    async enqueueApplicationTurn(operation, workOptions, replay, retainWhilePreparing = false) {
         this.lastActivityAtMs = performance.now();
         let barrierClaim;
         try {
@@ -217,7 +213,7 @@ class ZLinkSpotSerialTurnExecutor {
             throw error;
         }
     }
-    async enqueueFrameworkTurn(operation, workOptions = {}) {
+    async enqueueFrameworkTurn(operation, workOptions) {
         this.lastActivityAtMs = performance.now();
         // Application admission crosses the async barrier boundary before it
         // reaches the scheduler. Give an already-authorized framework turn that
@@ -231,28 +227,30 @@ class ZLinkSpotSerialTurnExecutor {
         return await this.scheduler.submitContinuation(operation);
     }
     submitQueuedTurn(operation, workOptions, barrierClaim) {
-        const options = {
-            ...workOptions,
-            lane: workOptions.lane ?? 'application'
-        };
         const boundOperation = (0, application_job_queue_scope_1.bindApplicationJobPermit)(operation);
         return (0, application_job_queue_scope_1.hasApplicationJobPermit)()
-            ? this.scheduler.submitPreAdmitted(boundOperation, options, barrierClaim)
-            : this.scheduler.submit(boundOperation, options, barrierClaim);
+            ? this.scheduler.submitPreAdmitted(boundOperation, workOptions, barrierClaim)
+            : this.scheduler.submit(boundOperation, workOptions, barrierClaim);
     }
     runQueuedRecord(record) {
         if (record.context instanceof Promise) {
-            return record.context.then((claim) => {
-                Object.assign(record, { context: claim });
-                return this.runQueuedRecord(record);
+            // Branch-local captures keep the synchronous path free of a V8 function context.
+            const executor = this;
+            const work = record;
+            const pending = record.context;
+            return pending.then((claim) => {
+                Object.assign(work, { context: claim });
+                return executor.runQueuedRecord(work);
             });
         }
         const context = record.context;
         if (context?.replay !== undefined && record.operation === context.replay) {
             context.release();
-            return Promise.resolve(this.executionBarrier?.enter()).then((claim) => this.runTurn(record.operation, (value) => record.resolve(value), (error) => record.reject(error), claim, record.release));
+            const executor = this;
+            const work = record;
+            return Promise.resolve(executor.executionBarrier?.enter()).then((claim) => executor.runTurn(work.operation, work.resolve, work.reject, claim, work.release));
         }
-        return this.runTurn(record.operation, (value) => record.resolve(value), (error) => record.reject(error), record.context, record.release);
+        return this.runTurn(record.operation, record.resolve, record.reject, record.context, record.release);
     }
     yieldPromise(pending) {
         const turn = this.currentTurn;
@@ -286,11 +284,7 @@ class ZLinkSpotSerialTurnExecutor {
             turn.releaseBoundExecutionClaim();
             release?.();
         });
-        owner.then(resolve, reject);
-        return Promise.race([
-            owner.then(() => undefined, () => undefined),
-            turn.suspended
-        ]);
+        return Promise.race([owner.then(resolve, reject), turn.suspended]);
     }
     postResume(turn, resume, reject) {
         if (!turn.resumeExecutionClaim()) {