@zlink-systems/framework 0.30.3 → 0.32.0

package/dist/runtime/actors/actor-join-deferred-scope.js

@@ -21,16 +21,16 @@ class ActorJoinRegistrationScope {
     sealAfterHandlerTerminal() {
         this.open = false;
     }
-    async prepareSealedJoins() {
-        await this.prepareSealedJoinsCore();
+    prepareSealedJoins() {
+        return this.prepareSealedJoinsCore();
     }
     async prepareSealedJoinsCore() {
         if (this.prepared) {
             return;
         }
         this.prepared = true;
-        for (const intent of this.intents) {
-            await intent.prepare?.();
+        for (let index = 0; index < this.intents.length; index++) {
+            await this.intents[index].prepare?.();
         }
     }
     async activateSealedJoins() {
@@ -48,8 +48,8 @@ class ActorJoinRegistrationScope {
         await Promise.allSettled(this.intents.map((intent) => intent.discard()));
     }
     async execute() {
-        for (const intent of this.intents) {
-            await intent.execute();
+        for (let index = 0; index < this.intents.length; index++) {
+            await this.intents[index].execute();
         }
     }
 }

package/dist/runtime/actors/actor-local-native-join.d.ts

@@ -23,8 +23,8 @@ export interface ZLinkLocalNativeActorJoinOptions {
 export declare class ZLinkLocalNativeActorJoin {
     private readonly options;
     constructor(options: ZLinkLocalNativeActorJoinOptions);
-    joinSpot(node: ZLinkBackendMeshNode, actor: ZLinkActor, state: ZLinkActorRuntimeState, actorRef: ZLinkBackendActorRef, spotId: RoutingId, spotRouteTarget: ZLinkSpotRouteTarget | undefined, request: Message, timeoutMs: number | undefined, signal: AbortSignal | undefined, completionOperationId?: ZLinkActorJoinOperationId): Promise<ZLinkActorJoinRuntimeResult<Message>>;
-    joinEntrySpot(node: ZLinkBackendMeshNode, actor: ZLinkActor, state: ZLinkActorRuntimeState, actorRef: ZLinkBackendActorRef, nodeRid: RoutingId, spotRouteTarget: ZLinkSpotRouteTarget | undefined, request: Message, timeoutMs: number | undefined, signal: AbortSignal | undefined, completionOperationId?: ZLinkActorJoinOperationId): Promise<ZLinkActorJoinRuntimeResult<Message>>;
+    joinSpot(node: ZLinkBackendMeshNode, actor: ZLinkActor, state: ZLinkActorRuntimeState, actorRef: ZLinkBackendActorRef, spotId: RoutingId, spotRouteTarget: ZLinkSpotRouteTarget | undefined, request: Message, timeoutMs: number | undefined, signal: AbortSignal | undefined, completionOperationId?: ZLinkActorJoinOperationId, deadlineAtMs?: number): Promise<ZLinkActorJoinRuntimeResult<Message>>;
+    joinEntrySpot(node: ZLinkBackendMeshNode, actor: ZLinkActor, state: ZLinkActorRuntimeState, actorRef: ZLinkBackendActorRef, nodeRid: RoutingId, spotRouteTarget: ZLinkSpotRouteTarget | undefined, request: Message, timeoutMs: number | undefined, signal: AbortSignal | undefined, completionOperationId?: ZLinkActorJoinOperationId, deadlineAtMs?: number): Promise<ZLinkActorJoinRuntimeResult<Message>>;
     private joinLocal;
     private waitForJoinCompletion;
     private relocateRemoteActorJoin;

package/dist/runtime/actors/actor-local-native-join.js

@@ -10,6 +10,7 @@ const runtime_values_1 = require("../backend/runtime-values");
 const operation_identity_1 = require("../foundation/operation-identity");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const payload_codec_1 = require("../messaging/payload-codec");
+const actor_request_deadline_1 = require("./actor-request-deadline");
 const routing_id_1 = require("../routing-id");
 const actor_remote_wire_1 = require("./actor-remote-wire");
 const actor_runtime_state_1 = require("./actor-runtime-state");
@@ -22,17 +23,17 @@ class ZLinkLocalNativeActorJoin {
     constructor(options) {
         this.options = options;
     }
-    async joinSpot(node, actor, state, actorRef, spotId, spotRouteTarget, request, timeoutMs, signal, completionOperationId) {
+    async joinSpot(node, actor, state, actorRef, spotId, spotRouteTarget, request, timeoutMs, signal, completionOperationId, deadlineAtMs) {
         if (signal?.aborted === true)
             throw (0, abort_1.createAbortError)();
         const target = requireUserSpotRoute(spotRouteTarget, spotId);
         const remote = !(0, routing_id_1.routingIdsEqual)((0, actor_runtime_state_1.toFrameworkRoutingId)(node.status().routingId), target.targetNodeRid);
         if (remote) {
-            return await this.relocateRemoteActorJoin(node, actor, state, actorRef, target, request, timeoutMs, signal, completionOperationId, false);
+            return await this.relocateRemoteActorJoin(node, actor, state, actorRef, target, request, timeoutMs, signal, completionOperationId, false, deadlineAtMs);
         }
         return await this.joinLocal(node, actor, state, actorRef, target, target.spotId, request, signal);
     }
-    async joinEntrySpot(node, actor, state, actorRef, nodeRid, spotRouteTarget, request, timeoutMs, signal, completionOperationId) {
+    async joinEntrySpot(node, actor, state, actorRef, nodeRid, spotRouteTarget, request, timeoutMs, signal, completionOperationId, deadlineAtMs) {
         if (signal?.aborted === true)
             throw (0, abort_1.createAbortError)();
         const targetNodeRid = spotRouteTarget?.targetNodeRid ?? nodeRid;
@@ -40,7 +41,7 @@ class ZLinkLocalNativeActorJoin {
             (!(0, routing_id_1.routingIdsEqual)((0, actor_runtime_state_1.toFrameworkRoutingId)(node.status().routingId), spotRouteTarget.targetNodeRid) ||
                 !(0, routing_id_1.routingIdsEqual)((0, actor_runtime_state_1.toFrameworkRoutingId)(actorRef.nodeRid), spotRouteTarget.targetNodeRid));
         if (remote) {
-            return await this.relocateRemoteActorJoin(node, actor, state, actorRef, spotRouteTarget, request, timeoutMs, signal, completionOperationId, true);
+            return await this.relocateRemoteActorJoin(node, actor, state, actorRef, spotRouteTarget, request, timeoutMs, signal, completionOperationId, true, deadlineAtMs);
         }
         const target = {
             routerChannelId: spotRouteTarget?.routerChannelId ?? runtimeActorMeshName(actor, state, ''),
@@ -72,7 +73,7 @@ class ZLinkLocalNativeActorJoin {
         const authorityOwnerGeneration = state.locationGeneration ?? actorRef.generation;
         const commit = async (spot) => {
             (0, abort_1.throwIfAborted)(signal);
-            await this.options.locationLifecycle?.commitActorMembership(actorType, currentActor, authorityOwnerGeneration, storeSpotId, spotGeneration, target.spotKind === contracts_1.ZLinkSpotKind.Entry ? contracts_1.ZLinkSpotKind.Entry : contracts_1.ZLinkSpotKind.User, node.status().lifecycleGeneration);
+            await this.options.locationLifecycle?.commitActorMembership(actorType, currentActor, authorityOwnerGeneration, storeSpotId, spotGeneration, target.spotKind === contracts_1.ZLinkSpotKind.Entry ? contracts_1.ZLinkSpotKind.Entry : contracts_1.ZLinkSpotKind.User, node.status().lifecycleGeneration, signal);
             const committedActor = node.restoreActorAuthority(actor.context.actorId, actorType, actorRef.generation, authorityOwnerGeneration, target.spotKind === contracts_1.ZLinkSpotKind.Entry ? undefined : String(target.spotId), spotGeneration, membershipEpoch);
             state.setNativeActorRef(committedActor);
             if (target.spotKind === contracts_1.ZLinkSpotKind.Entry)
@@ -110,14 +111,14 @@ class ZLinkLocalNativeActorJoin {
             reply: response.reply
         };
     }
-    async waitForJoinCompletion(submit, completions, timeoutMs, signal) {
+    async waitForJoinCompletion(submit, completions, timeoutMs, signal, deadlineAtMs) {
         // The operation ID identifies one Core request. Once it is submitted, a
         // NotConnected completion is terminal for that request; resubmitting it
         // could execute the target lifecycle twice after a delayed reply.
-        return submitJoinWhenConnected(() => completions.submit(submit, signal), timeoutMs, signal);
+        return submitJoinWhenConnected(() => completions.submit(submit, signal), timeoutMs, signal, deadlineAtMs);
     }
-    async relocateRemoteActorJoin(node, actor, state, actorRef, target, request, timeoutMs, signal, completionOperationId, entrySpot) {
-        const deadlineAtMs = timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
+    async relocateRemoteActorJoin(node, actor, state, actorRef, target, request, timeoutMs, signal, completionOperationId, entrySpot, deadlineAtMs) {
+        deadlineAtMs ??= timeoutMs === undefined ? undefined : performance.now() + timeoutMs;
         const actorType = state.actorType;
         if (actorType === undefined) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorRouteNotFound, `Actor '${actor.context.actorId}' canonical remote Join identity is not configured.`);
@@ -147,19 +148,20 @@ class ZLinkLocalNativeActorJoin {
             };
         let admissionOperationId;
         const admission = await this.waitForJoinCompletion(() => {
+            const remainingTimeoutMs = (0, actor_request_deadline_1.remainingActorRequestTimeout)(actor.context.actorId, deadlineAtMs);
             const legacyAdmission = canonicalAdmission === undefined
                 ? legacyRemoteActorJoinPayload(actor, state, actorRef, target, request, relocationId)
                 : undefined;
             const operationId = canonicalAdmission === undefined
                 ? entrySpot
-                    ? node.joinActorEntrySpot(actorRef, (0, routing_id_1.toBackendRoutingId)(target.targetNodeRid), legacyAdmission, timeoutMs)
-                    : node.joinActorSpot(actorRef, (0, routing_id_1.toBackendRoutingId)(target.targetNodeRid), (0, routing_id_1.toBackendRoutingId)(target.spotId), target.targetSpotGeneration, legacyAdmission, timeoutMs)
+                    ? node.joinActorEntrySpot(actorRef, (0, routing_id_1.toBackendRoutingId)(target.targetNodeRid), legacyAdmission, remainingTimeoutMs)
+                    : node.joinActorSpot(actorRef, (0, routing_id_1.toBackendRoutingId)(target.targetNodeRid), (0, routing_id_1.toBackendRoutingId)(target.spotId), target.targetSpotGeneration, legacyAdmission, remainingTimeoutMs)
                 : entrySpot
-                    ? node.joinActorEntrySpotCanonical(actorRef, (0, routing_id_1.toBackendRoutingId)(target.targetNodeRid), canonicalAdmission.request, canonicalAdmission.actorFence, canonicalAdmission.local, timeoutMs)
-                    : node.joinActorSpotCanonical(actorRef, (0, routing_id_1.toBackendRoutingId)(target.targetNodeRid), (0, routing_id_1.toBackendRoutingId)(target.spotId), target.targetSpotGeneration, canonicalAdmission.request, canonicalAdmission.actorFence, canonicalAdmission.local, timeoutMs);
+                    ? node.joinActorEntrySpotCanonical(actorRef, (0, routing_id_1.toBackendRoutingId)(target.targetNodeRid), canonicalAdmission.request, canonicalAdmission.actorFence, canonicalAdmission.local, remainingTimeoutMs)
+                    : node.joinActorSpotCanonical(actorRef, (0, routing_id_1.toBackendRoutingId)(target.targetNodeRid), (0, routing_id_1.toBackendRoutingId)(target.spotId), target.targetSpotGeneration, canonicalAdmission.request, canonicalAdmission.actorFence, canonicalAdmission.local, remainingTimeoutMs);
             admissionOperationId = operationId;
             return operationId;
-        }, completions, timeoutMs, signal);
+        }, completions, timeoutMs, signal, deadlineAtMs);
         const control = admission.kindData;
         if (control?.kind !== 'actorJoinCompletion' || control.actor === null) {
             (0, mesh_completion_table_1.closeMeshCompletion)(admission);
@@ -342,9 +344,9 @@ function runtimeActorMeshName(actor, state, fallback) {
     const stateMeshName = state?.meshName;
     return context?.meshName ?? stateMeshName ?? fallback;
 }
-async function submitJoinWhenConnected(submit, timeoutMs, signal) {
-    const deadline = performance.now() +
-        Math.min(timeoutMs ?? LOCAL_JOIN_RESOLUTION_TIMEOUT_MS, LOCAL_JOIN_RESOLUTION_TIMEOUT_MS);
+async function submitJoinWhenConnected(submit, timeoutMs, signal, deadlineAtMs) {
+    const deadline = Math.min(deadlineAtMs ?? Infinity, performance.now() +
+        Math.min(timeoutMs ?? LOCAL_JOIN_RESOLUTION_TIMEOUT_MS, LOCAL_JOIN_RESOLUTION_TIMEOUT_MS));
     for (;;) {
         (0, abort_1.throwIfAborted)(signal);
         try {

package/dist/runtime/actors/actor-mailbox.d.ts

@@ -2,7 +2,7 @@ import { ZLinkSerialExecutionQueue, type ZLinkSerialSchedulerOptions, type ZLink
 export declare class ZLinkActorSerialExecutor {
     private readonly actorId;
     private readonly sourceSpotId;
-    private readonly scheduler;
+    readonly scheduler: ZLinkSerialExecutionQueue;
     constructor(actorId: string, sourceSpotId: unknown, options?: ZLinkSerialSchedulerOptions, sharedOwner?: ZLinkSerialExecutionQueue);
     execute<T>(operation: () => Promise<T> | T, workOptions?: ZLinkSerialWorkOptions): Promise<T>;
     close(): Promise<void>;

package/dist/runtime/actors/actor-remote-joiner.d.ts

@@ -30,8 +30,8 @@ export declare class ZLinkActorNativeJoinCoordinator implements ZLinkActorJoinCo
     constructor(options: ZLinkActorNativeJoinCoordinatorOptions);
     beginDeferredJoin(actor: ZLinkActor, state: ZLinkActorRuntimeState): void;
     abortDeferredJoin(actor: ZLinkActor, state: ZLinkActorRuntimeState): Promise<void>;
-    joinSpot(actor: ZLinkActor, state: ZLinkActorRuntimeState, spotId: RoutingId, request: Message, timeoutMs: number | undefined, signal: AbortSignal | undefined, completionOperationId?: import('../../contracts').ZLinkActorJoinOperationId): Promise<ZLinkActorJoinRuntimeResult<Message>>;
-    joinEntrySpot(actor: ZLinkActor, state: ZLinkActorRuntimeState, nodeRid: RoutingId | undefined, request: Message, timeoutMs: number | undefined, signal: AbortSignal | undefined, completionOperationId?: import('../../contracts').ZLinkActorJoinOperationId): Promise<ZLinkActorJoinRuntimeResult<Message>>;
+    joinSpot(actor: ZLinkActor, state: ZLinkActorRuntimeState, spotId: RoutingId, request: Message, timeoutMs: number | undefined, signal: AbortSignal | undefined, completionOperationId?: import('../../contracts').ZLinkActorJoinOperationId, deadlineAtMs?: number): Promise<ZLinkActorJoinRuntimeResult<Message>>;
+    joinEntrySpot(actor: ZLinkActor, state: ZLinkActorRuntimeState, nodeRid: RoutingId | undefined, request: Message, timeoutMs: number | undefined, signal: AbortSignal | undefined, completionOperationId?: import('../../contracts').ZLinkActorJoinOperationId, deadlineAtMs?: number): Promise<ZLinkActorJoinRuntimeResult<Message>>;
     private withDeferredJoinFinalizer;
     private node;
 }

package/dist/runtime/actors/actor-remote-joiner.js

@@ -39,7 +39,7 @@ class ZLinkActorNativeJoinCoordinator {
     async abortDeferredJoin(actor, state) {
         await this.options.sourceTransfer?.cancelDeferredActorHandoff?.(actor, state);
     }
-    async joinSpot(actor, state, spotId, request, timeoutMs, signal, completionOperationId) {
+    async joinSpot(actor, state, spotId, request, timeoutMs, signal, completionOperationId, deadlineAtMs) {
         (0, abort_1.throwIfAborted)(signal);
         const node = this.node();
         const actorRef = state.nativeActorRef ??
@@ -49,10 +49,10 @@ class ZLinkActorNativeJoinCoordinator {
         let target;
         target = await this.options.spotRouteResolver?.resolve(spotId, signal);
         installResolvedSpotRoute(node, target);
-        const result = await this.localJoin.joinSpot(node, actor, state, actorRef, spotId, target, request, timeoutMs ?? this.options.actorTransferTimeoutMs, signal, completionOperationId);
+        const result = await this.localJoin.joinSpot(node, actor, state, actorRef, spotId, target, request, timeoutMs ?? this.options.actorTransferTimeoutMs, signal, completionOperationId, deadlineAtMs);
         return this.withDeferredJoinFinalizer(actor, state, target, result, completionOperationId);
     }
-    async joinEntrySpot(actor, state, nodeRid, request, timeoutMs, signal, completionOperationId) {
+    async joinEntrySpot(actor, state, nodeRid, request, timeoutMs, signal, completionOperationId, deadlineAtMs) {
         (0, abort_1.throwIfAborted)(signal);
         const node = this.node();
         const actorRef = state.nativeActorRef ??
@@ -74,7 +74,7 @@ class ZLinkActorNativeJoinCoordinator {
             state.entryNodeRid ??
             (0, actor_runtime_state_1.toFrameworkRoutingId)(node.status().routingId);
         const target = resolvedTarget;
-        const result = await this.localJoin.joinEntrySpot(node, actor, state, actorRef, selectedNodeRid, target, request, timeoutMs ?? this.options.actorTransferTimeoutMs, signal, completionOperationId);
+        const result = await this.localJoin.joinEntrySpot(node, actor, state, actorRef, selectedNodeRid, target, request, timeoutMs ?? this.options.actorTransferTimeoutMs, signal, completionOperationId, deadlineAtMs);
         return this.withDeferredJoinFinalizer(actor, state, target, result, completionOperationId);
     }
     withDeferredJoinFinalizer(actor, state, target, result, operationId) {

package/dist/runtime/actors/actor-routed-join-transport.d.ts

@@ -1,3 +1,5 @@
+import type { PendingOperation, OperationObserver } from '../foundation/operation-registry';
+import type { ZLinkRequestResult } from '../messaging/request-result';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkBackendSpot } from '../backend/contracts';
 import type { ZLinkSubmitResult } from '../messaging/submission-result';
@@ -5,7 +7,7 @@ import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
 export interface ZLinkActorRoutedJoinTransport {
     canRouteChannel?(routerChannelId: string): boolean;
     canRoutePacketChannel?(routerChannelId: string): boolean;
-    request<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
+    request<TReply>(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal): ZLinkRequestResult<TReply>;
     submit?(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown): ZLinkSubmitResult | Promise<ZLinkSubmitResult>;
     submitInfrastructure?(routerChannelId: string, targetNodeRid: string, packetName: string | undefined, message: unknown): ZLinkSubmitResult | Promise<ZLinkSubmitResult>;
     sendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, message: unknown, options: {
@@ -13,23 +15,27 @@ export interface ZLinkActorRoutedJoinTransport {
     }): Promise<ZLinkSubmitResult>;
     requestRawToSpot?(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, options: {
         readonly timeoutMs?: number;
+        readonly requestOperation?: PendingOperation<unknown>;
         readonly signal?: AbortSignal;
         readonly onAdmitted?: () => void;
     }): Promise<readonly Message[]>;
     requestToSpot<TReply = unknown>(spotRouteTarget: ZLinkSpotRouteTarget, request: unknown, options: {
         readonly packetName?: string;
         readonly timeoutMs?: number;
+        readonly requestOperation?: PendingOperation<unknown>;
         readonly signal?: AbortSignal;
         readonly onAdmitted?: () => void;
-    }): Promise<TReply>;
+    }, destination?: OperationObserver<unknown, unknown>): ZLinkRequestResult<TReply>;
     requestFromSpotToSpot?<TReply = unknown>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: unknown, options: {
         readonly packetName?: string;
         readonly timeoutMs?: number;
+        readonly requestOperation?: PendingOperation<unknown>;
         readonly signal?: AbortSignal;
         readonly onAdmitted?: () => void;
-    }): Promise<TReply>;
+    }, destination?: OperationObserver<unknown, unknown>): ZLinkRequestResult<TReply>;
     requestRawFromSpotToSpot?(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: Message, options: {
         readonly timeoutMs?: number;
+        readonly requestOperation?: PendingOperation<unknown>;
         readonly signal?: AbortSignal;
         readonly onAdmitted?: () => void;
     }): Promise<readonly Message[]>;

package/dist/runtime/actors/actor-routed-json-request.d.ts

@@ -1,13 +1,16 @@
+import type { PendingOperation } from '../foundation/operation-registry';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
 import type { ZLinkActorRoutedJoinTransport } from './actor-routed-join-transport';
 export declare function tryRequestRoutedJson(transport: ZLinkActorRoutedJoinTransport, target: ZLinkSpotRouteTarget, payload: unknown, options: {
     readonly timeoutMs?: number;
+    readonly requestOperation?: PendingOperation<unknown>;
     readonly signal?: AbortSignal;
     readonly onAdmitted?: () => void;
 }): Promise<boolean>;
 export declare function requestRoutedJsonReply<T>(transport: ZLinkActorRoutedJoinTransport, target: ZLinkSpotRouteTarget, payload: unknown, options: {
     readonly timeoutMs?: number;
+    readonly requestOperation?: PendingOperation<unknown>;
     readonly signal?: AbortSignal;
     readonly onAdmitted?: () => void;
 }, unavailableMessage: string, decode: (replyParts: readonly Message[]) => T): Promise<T>;

package/dist/runtime/actors/actor-runtime-contracts.d.ts

@@ -63,6 +63,6 @@ export interface ZLinkActorJoinCoordinator {
      */
     beginDeferredJoin?(actor: ZLinkActor, state: ZLinkActorRuntimeState): void;
     abortDeferredJoin?(actor: ZLinkActor, state: ZLinkActorRuntimeState): Promise<void>;
-    joinSpot(actor: ZLinkActor, state: ZLinkActorRuntimeState, spotId: RoutingId, request: Message, timeoutMs: number | undefined, signal: AbortSignal | undefined, completionOperationId?: import('../../contracts').ZLinkActorJoinOperationId): Promise<ZLinkActorJoinRuntimeResult<Message>>;
-    joinEntrySpot(actor: ZLinkActor, state: ZLinkActorRuntimeState, nodeRid: RoutingId | undefined, request: Message, timeoutMs: number | undefined, signal: AbortSignal | undefined, completionOperationId?: import('../../contracts').ZLinkActorJoinOperationId): Promise<ZLinkActorJoinRuntimeResult<Message>>;
+    joinSpot(actor: ZLinkActor, state: ZLinkActorRuntimeState, spotId: RoutingId, request: Message, timeoutMs: number | undefined, signal: AbortSignal | undefined, completionOperationId?: import('../../contracts').ZLinkActorJoinOperationId, deadlineAtMs?: number): Promise<ZLinkActorJoinRuntimeResult<Message>>;
+    joinEntrySpot(actor: ZLinkActor, state: ZLinkActorRuntimeState, nodeRid: RoutingId | undefined, request: Message, timeoutMs: number | undefined, signal: AbortSignal | undefined, completionOperationId?: import('../../contracts').ZLinkActorJoinOperationId, deadlineAtMs?: number): Promise<ZLinkActorJoinRuntimeResult<Message>>;
 }

package/dist/runtime/actors/actor-runtime-state.d.ts

@@ -77,7 +77,7 @@ export declare class ZLinkActorRuntimeState {
     private spotMembershipEpochValue;
     private nativeActorRefValue;
     private entryNodeRidValue;
-    private boundSessionValue;
+    boundSessionValue: ZLinkRemoteBoundSessionTarget | undefined;
     private remoteActorPacketTargetValue;
     private createRequestPayloadValue;
     private ownsLocationValue;

package/dist/runtime/actors/spot-actor-dispatch.d.ts

@@ -1,3 +1,4 @@
+import type { ZLinkHandlerMessageType } from '../../contracts/Common/HandlerMessageType';
 import { type Type, type ZLinkActor, type ZLinkActorHandlerRegistry, type ZLinkMessageContext, type ZLinkMessageSerializer, type ZLinkSpot, type ZLinkSpotActorJoinResult } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
@@ -11,6 +12,7 @@ export interface ZLinkActorPacketDescriptor {
     readonly packetName: string;
     readonly actorType: Type<ZLinkActor>;
     readonly handlerType: Type;
+    readonly messageType?: ZLinkHandlerMessageType;
     readonly methodName?: string;
 }
 export declare class ZLinkSpotActorHandlerRegistryRuntime implements ZLinkActorHandlerRegistry {
@@ -39,11 +41,11 @@ export declare class ZLinkSpotActorDispatcher {
     private readonly options;
     constructor(options: ZLinkSpotActorDispatcherOptions);
     dispatchSend<TMessage>(actor: ZLinkActor, packetName: string, message: TMessage, context?: Partial<ZLinkMessageContext>): Promise<void>;
-    dispatchSendDecoded<TMessage>(actor: ZLinkActor, packetName: string, decode: () => TMessage, context?: Partial<ZLinkMessageContext>): Promise<void>;
+    dispatchSendDecoded<TMessage>(actor: ZLinkActor, packetName: string, decode: (messageType?: Type) => TMessage, context?: Partial<ZLinkMessageContext>): Promise<void>;
     dispatchRequest<TRequest, TReply>(actor: ZLinkActor, packetName: string, request: TRequest, context?: Partial<ZLinkMessageContext>): Promise<TReply>;
-    dispatchRequestDecoded<TRequest, TReply>(actor: ZLinkActor, packetName: string, decode: () => TRequest, context?: Partial<ZLinkMessageContext>): Promise<TReply>;
+    dispatchRequestDecoded<TRequest, TReply>(actor: ZLinkActor, packetName: string, decode: (messageType?: Type) => TRequest, context?: Partial<ZLinkMessageContext>): Promise<TReply>;
     dispatchRequestThen<TRequest, TReply, TResult>(actor: ZLinkActor, packetName: string, request: TRequest, context: Partial<ZLinkMessageContext> | undefined, afterReply: (reply: TReply, options: ZLinkSpotActorReplyOptionsSnapshot) => Promise<TResult> | TResult, beforeReply?: (reply: TReply, options: ZLinkSpotActorReplyOptionsSnapshot) => Promise<void> | void): Promise<TResult>;
-    dispatchRequestThenDecoded<TRequest, TReply, TResult>(actor: ZLinkActor, packetName: string, decode: () => TRequest, context: Partial<ZLinkMessageContext> | undefined, afterReply: (reply: TReply, options: ZLinkSpotActorReplyOptionsSnapshot) => Promise<TResult> | TResult, beforeReply?: (reply: TReply, options: ZLinkSpotActorReplyOptionsSnapshot) => Promise<void> | void): Promise<TResult>;
+    dispatchRequestThenDecoded<TRequest, TReply, TResult>(actor: ZLinkActor, packetName: string, decode: (messageType?: Type) => TRequest, context: Partial<ZLinkMessageContext> | undefined, afterReply: (reply: TReply, options: ZLinkSpotActorReplyOptionsSnapshot) => Promise<TResult> | TResult, beforeReply?: (reply: TReply, options: ZLinkSpotActorReplyOptionsSnapshot) => Promise<void> | void): Promise<TResult>;
     admitActorJoin(actor: ZLinkActor, request: Message, commit: () => Promise<void> | void): Promise<ZLinkSpotActorJoinResult>;
     evaluateActorJoin(actor: ZLinkActor, request: Message, contentType?: string): Promise<ZLinkSpotActorJoinResult>;
     commitActorJoin(actor: ZLinkActor, commit: () => Promise<void> | void): Promise<void>;
@@ -52,8 +54,10 @@ export declare class ZLinkSpotActorDispatcher {
     notifyDisconnectActor(actor: ZLinkActor): Promise<void>;
     private requirePacket;
     private ensureActorType;
-    private invokeHandler;
+    invokeHandler<THandler, TResult>(actor: ZLinkActor, descriptor: Pick<ZLinkActorPacketDescriptor, 'handlerType' | 'methodName'>, callback: (handler: THandler, method: THandler extends {
+        handle: infer TMethod;
+    } ? TMethod : never) => Promise<TResult>): Promise<TResult>;
     private execute;
-    private createContext;
+    createContext(packetName: string, context: Partial<ZLinkMessageContext> | undefined): ZLinkMessageContext;
 }
 export {};

package/dist/runtime/actors/spot-actor-dispatch.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkSpotActorDispatcher = exports.ZLinkSpotActorHandlerRegistryRuntime = exports.ZLinkActorPacketKind = void 0;
 const stream_wire_1 = require("@zlink-systems/stream-wire");
 const contracts_1 = require("../../contracts");
+const HandlerMessageType_1 = require("../../contracts/Common/HandlerMessageType");
 const Attributes_1 = require("../../contracts/Handlers/Attributes");
 const configuration_1 = require("../configuration");
 const framework_errors_internal_1 = require("../framework-errors-internal");
@@ -23,6 +24,7 @@ class ZLinkSpotActorHandlerRegistryRuntime {
         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.`);
         }
+        const messageType = (0, HandlerMessageType_1.resolveHandlerMessageType)(handlerType);
         return this.addPacket({
             kind: metadata.kind === 'spotActorSend'
                 ? ZLinkActorPacketKind.Send
@@ -30,37 +32,49 @@ class ZLinkSpotActorHandlerRegistryRuntime {
             packetName: resolvedPacketName,
             actorType: Object,
             handlerType,
+            ...(messageType === undefined ? {} : { messageType }),
             methodName: metadata.methodName
         });
     }
     addPacket(descriptor) {
-        const key = packetKey(descriptor.kind, descriptor.actorType, descriptor.packetName);
-        if (this.packets.has(key)) {
+        const actorTypeName = descriptor.actorType.name;
+        let packets = this.packets.get(descriptor.kind);
+        let actors = packets?.get(descriptor.packetName);
+        if (actors?.has(actorTypeName) === true) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidOperation, `Actor packet '${descriptor.packetName}' for '${descriptor.actorType.name}' is already registered.`);
         }
         const metadata = (0, Attributes_1.readZLinkDecoratorMetadata)(descriptor.handlerType).find((entry) => entry.kind ===
             (descriptor.kind === ZLinkActorPacketKind.Send ? 'spotActorSend' : 'spotActorRequest') &&
             entry.packetName === descriptor.packetName);
-        this.packets.set(key, {
+        if (packets === undefined) {
+            packets = new Map();
+            this.packets.set(descriptor.kind, packets);
+        }
+        if (actors === undefined) {
+            actors = new Map();
+            packets.set(descriptor.packetName, actors);
+        }
+        actors.set(actorTypeName, {
             ...descriptor,
             methodName: descriptor.methodName ?? metadata?.methodName
         });
         return this;
     }
     resolvePacket(kind, actor, packetName) {
+        const actors = this.packets.get(kind)?.get(packetName);
+        if (actors === undefined)
+            return undefined;
         const actorType = actor.constructor;
-        const exact = this.packets.get(packetKey(kind, actorType, packetName));
+        const exact = actors.get(actorType.name);
         if (exact !== undefined) {
             return exact;
         }
-        const wildcard = this.packets.get(packetKey(kind, Object, packetName));
+        const wildcard = actors.get(Object.name);
         if (wildcard !== undefined) {
             return wildcard;
         }
-        for (const descriptor of this.packets.values()) {
-            if (descriptor.kind === kind &&
-                descriptor.packetName === packetName &&
-                actor instanceof descriptor.actorType) {
+        for (const descriptor of actors.values()) {
+            if (actor instanceof descriptor.actorType) {
                 return descriptor;
             }
         }
@@ -73,40 +87,50 @@ class ZLinkSpotActorDispatcher {
     constructor(options) {
         this.options = options;
     }
-    dispatchSend(actor, packetName, message, context = {}) {
+    dispatchSend(actor, packetName, message, context) {
         return this.dispatchSendDecoded(actor, packetName, () => message, context);
     }
-    dispatchSendDecoded(actor, packetName, decode, context = {}) {
+    dispatchSendDecoded(actor, packetName, decode, context) {
         return this.execute(async () => {
             const descriptor = this.requirePacket(ZLinkActorPacketKind.Send, actor, packetName);
-            const message = decode();
-            this.options.onHandlerStart?.();
-            await this.invokeHandler(actor, descriptor, (handler, method) => (0, actor_join_deferred_scope_1.runActorHandlerWithDeferredJoins)(() => method.call(handler, this.options.spot, actor, this.createContext(packetName, context), message)));
+            const message = decode((0, HandlerMessageType_1.resolveMessageTypeForDecode)(descriptor.messageType));
+            await this.invokeHandler(actor, descriptor, (handler, method) => {
+                const handlerContext = this.createContext(packetName, context);
+                return (0, actor_join_deferred_scope_1.runActorHandlerWithDeferredJoins)(() => {
+                    this.options.onHandlerStart?.();
+                    return method.call(handler, this.options.spot, actor, handlerContext, message);
+                });
+            });
         });
     }
-    dispatchRequest(actor, packetName, request, context = {}) {
+    dispatchRequest(actor, packetName, request, context) {
         return this.dispatchRequestThenDecoded(actor, packetName, () => request, context, (reply) => reply);
     }
-    dispatchRequestDecoded(actor, packetName, decode, context = {}) {
+    dispatchRequestDecoded(actor, packetName, decode, context) {
         return this.dispatchRequestThenDecoded(actor, packetName, decode, context, (reply) => reply);
     }
-    dispatchRequestThen(actor, packetName, request, context = {}, afterReply, beforeReply) {
+    dispatchRequestThen(actor, packetName, request, context, afterReply, beforeReply) {
         return this.dispatchRequestThenDecoded(actor, packetName, () => request, context, afterReply, beforeReply);
     }
-    dispatchRequestThenDecoded(actor, packetName, decode, context = {}, afterReply, beforeReply) {
+    dispatchRequestThenDecoded(actor, packetName, decode, context, afterReply, beforeReply) {
         return this.execute(async () => {
             const descriptor = this.requirePacket(ZLinkActorPacketKind.Request, actor, packetName);
-            const request = decode();
-            this.options.onHandlerStart?.();
-            return await this.invokeHandler(actor, descriptor, (handler, method) => (0, actor_join_deferred_scope_1.runActorHandlerWithDeferredJoins)(() => method.call(handler, this.options.spot, actor, this.createContext(packetName, context), request), (reply) => afterReply(reply, {
-                metadata: new Map(),
-                compressPayload: false
-            }), beforeReply === undefined
-                ? undefined
-                : (reply) => beforeReply(reply, {
-                    metadata: new Map(),
+            const request = decode((0, HandlerMessageType_1.resolveMessageTypeForDecode)(descriptor.messageType));
+            return await this.invokeHandler(actor, descriptor, (handler, method) => {
+                const handlerContext = this.createContext(packetName, context);
+                return (0, actor_join_deferred_scope_1.runActorHandlerWithDeferredJoins)(() => {
+                    this.options.onHandlerStart?.();
+                    return method.call(handler, this.options.spot, actor, handlerContext, request);
+                }, (reply) => afterReply(reply, {
+                    metadata: contracts_1.ZLinkMessageMetadataEmpty.values,
                     compressPayload: false
-                })));
+                }), beforeReply === undefined
+                    ? undefined
+                    : (reply) => beforeReply(reply, {
+                        metadata: contracts_1.ZLinkMessageMetadataEmpty.values,
+                        compressPayload: false
+                    }));
+            });
         });
     }
     admitActorJoin(actor, request, commit) {
@@ -158,8 +182,8 @@ class ZLinkSpotActorDispatcher {
         }
         throw actorDispatchHandlerNotFound(`Actor handler '${descriptor.handlerType.name}' expects actor '${descriptor.actorType.name}'.`);
     }
-    async invokeHandler(actor, descriptor, callback) {
-        return await (0, handler_instance_scope_1.runWithLifecycleHandler)(actor, descriptor.handlerType, this.options.providerResolver, (resolved) => {
+    invokeHandler(actor, descriptor, callback) {
+        return (0, handler_instance_scope_1.runWithLifecycleHandler)(actor, descriptor.handlerType, this.options.providerResolver, (resolved) => {
             const methodName = descriptor.methodName ?? 'handle';
             const method = resolved[methodName];
             if (typeof method !== 'function') {
@@ -176,19 +200,17 @@ class ZLinkSpotActorDispatcher {
     }
     createContext(packetName, context) {
         return {
-            meshName: context.meshName,
-            channelName: context.channelName,
+            meshName: context?.meshName,
+            channelName: context?.channelName,
             packetName,
-            contentType: context.contentType,
-            metadata: context.metadata ?? contracts_1.ZLinkMessageMetadataEmpty,
-            correlationId: context.correlationId
+            contentType: context?.contentType,
+            metadata: context?.metadata ?? contracts_1.ZLinkMessageMetadataEmpty,
+            correlationId: context?.correlationId,
+            receivedAt: context?.receivedAt ?? new Date()
         };
     }
 }
 exports.ZLinkSpotActorDispatcher = ZLinkSpotActorDispatcher;
-function packetKey(kind, actorType, packetName) {
-    return `${kind}:${actorType.name}:${packetName}`;
-}
 function actorDispatchHandlerNotFound(message) {
     return (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorDispatchHandlerNotFound, message);
 }

package/dist/runtime/admission.d.ts

@@ -1,6 +1,7 @@
 import { ZLinkFrameworkInternalErrorKind } from './framework-errors-internal';
+import { type ReceiveRecord } from './foundation/service-runtime-contracts';
 /** Runs host admission inside the domain's request completion boundary. */
-export type ZLinkMeshDispatchAdmission = (dispatch: () => void | Promise<void>, onRejected?: (error: unknown) => void | Promise<void>) => void | Promise<void>;
+export type ZLinkMeshDispatchAdmission = <TReceiver = void, TContext = void>(dispatch: (this: TReceiver, context: TContext) => void | Promise<void>, onRejected?: (this: TReceiver, error: unknown, context: TContext) => void | Promise<void>, receiver?: TReceiver, context?: TContext) => void | Promise<void>;
 /** 소비한 배열 prefix가 정리 조건에 도달했는지 판정합니다. */
 export declare function shouldCompactBackingArray(head: number, length: number): boolean;
 export declare class ZLinkRuntimeAdmissionGate {
@@ -13,17 +14,18 @@ export declare class ZLinkRuntimeAdmissionGate {
     constructor(ownerAdmissionOpen?: () => boolean);
     get acceptsNewWork(): boolean;
     register(meshName: string): void;
-    accepts(meshName: string): boolean;
+    accepts(meshName: string, kind?: ReceiveRecord['kind']): boolean;
     pending(meshName: string): number;
     seal(meshName: string, reason?: ZLinkFrameworkInternalErrorKind): void;
     close(): void;
-    claim(meshName: string, operation: string): ZLinkApplicationWorkClaim;
+    claim(meshName: string, operation: string, kind?: ReceiveRecord['kind']): ZLinkApplicationWorkClaim;
     /**
      * Runs one admitted unit of work. Work that completes synchronously leaves
      * admission in the same turn; asynchronous work leaves it from the single
      * continuation on its result.
      */
-    run<T>(meshName: string, operation: string, work: () => T | Promise<T>, onRejected?: (error: unknown) => T | Promise<T>): T | Promise<T>;
+    run<T, TReceiver = void, TContext = void>(meshName: string, operation: string, work: (this: TReceiver, context: TContext) => T | Promise<T>, kind?: ReceiveRecord['kind'], onRejected?: (this: TReceiver, error: unknown, context: TContext) => T | Promise<T>, receiver?: TReceiver, context?: TContext): T | Promise<T>;
+    private isOpen;
     private enter;
     awaitZero(meshName: string, signal?: AbortSignal): Promise<void>;
     requireRequest(operation: string, meshName?: string): void;

package/dist/runtime/admission.js

@@ -4,6 +4,7 @@ exports.ZLinkRuntimeAdmissionGate = void 0;
 exports.shouldCompactBackingArray = shouldCompactBackingArray;
 const framework_errors_internal_1 = require("./framework-errors-internal");
 const abort_1 = require("./abort");
+const service_runtime_contracts_1 = require("./foundation/service-runtime-contracts");
 const BACKING_ARRAY_COMPACTION_MIN_HEAD = 1024;
 /** 소비한 배열 prefix가 정리 조건에 도달했는지 판정합니다. */
 function shouldCompactBackingArray(head, length) {
@@ -40,8 +41,8 @@ class ZLinkRuntimeAdmissionGate {
             });
         }
     }
-    accepts(meshName) {
-        return this.ownerAdmissionOpen() && !this.requireState(meshName).sealed;
+    accepts(meshName, kind) {
+        return this.isOpen(this.requireState(meshName), kind);
     }
     pending(meshName) {
         return this.requireState(meshName).active;
@@ -57,8 +58,8 @@ class ZLinkRuntimeAdmissionGate {
             state.sealedReason = framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RuntimeShutdown;
         }
     }
-    claim(meshName, operation) {
-        const state = this.enter(meshName, operation);
+    claim(meshName, operation, kind) {
+        const state = this.enter(meshName, operation, kind);
         let closed = false;
         return {
             close: () => {
@@ -74,18 +75,20 @@ class ZLinkRuntimeAdmissionGate {
      * admission in the same turn; asynchronous work leaves it from the single
      * continuation on its result.
      */
-    run(meshName, operation, work, onRejected) {
+    run(meshName, operation, work, kind, onRejected, receiver, context) {
         let state;
         let result;
         try {
-            state = this.enter(meshName, operation);
+            state = this.enter(meshName, operation, kind);
         }
         catch (error) {
             // The domain owns admission rejection completion, just as it owns handler failure.
-            return onRejected === undefined ? Promise.reject(error) : onRejected(error);
+            return onRejected === undefined
+                ? Promise.reject(error)
+                : onRejected.call(receiver, error, context);
         }
         try {
-            result = work();
+            result = work.call(receiver, context);
         }
         catch (error) {
             exitAdmission(state);
@@ -103,9 +106,17 @@ class ZLinkRuntimeAdmissionGate {
             throw error;
         });
     }
-    enter(meshName, operation) {
+    isOpen(state, kind) {
+        return (!state.sealed &&
+            (kind === service_runtime_contracts_1.ReceiveKind.NodeSend ||
+                kind === service_runtime_contracts_1.ReceiveKind.NodeRequest ||
+                kind === service_runtime_contracts_1.ReceiveKind.ChannelSend ||
+                kind === service_runtime_contracts_1.ReceiveKind.ChannelRequest ||
+                this.ownerAdmissionOpen()));
+    }
+    enter(meshName, operation, kind) {
         const state = this.requireState(meshName);
-        if (this.ownerAdmissionOpen() && !state.sealed) {
+        if (this.isOpen(state, kind)) {
             state.active += 1;
             return state;
         }