@zlink-systems/framework 0.29.1 → 0.30.0

package/dist/runtime/locations/resolvers.d.ts

@@ -1,6 +1,6 @@
 import type { ActorRef, RoutingId, SpotId } from '../../contracts/Common';
 import { type SpotHandle, type ZLinkActorSpotHandleResolver, type ZLinkSpotHandleResolver, type ResolvedSpotHandle } from '../spots/spot-handle';
-import type { ZLinkSpotRouteResolver, ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
+import type { ZLinkSpotRouteResolver, ZLinkSpotRouteTarget, ZLinkInstanceReactivationRoute } from '../spots/spot-routing-internal';
 import { ZLinkFrameworkRuntimeState, ZLinkLocationRole, type ZLinkActorLocation, type ZLinkActorLocationKey, type ZLinkLocationReadiness, type ZLinkLocationRuntimeQuery, type ZLinkPeerLocation, type ZLinkPeerLocationFilter, type ZLinkPeerLocationResolver, type ZLinkRouteLocation, type ZLinkRouteLocationKey, type ZLinkSpotLocation, type ZLinkSpotLocationKey } from './internal-location-contracts';
 import type { ZLinkActorLocationStore, ZLinkAuthorityStore, ZLinkMeshNodeLocationStore, ZLinkPeerLocationStore, ZLinkRouteLocationStore, ZLinkSpotLocationStore } from './internal-store-contracts';
 import { ZLinkOwnerLeaseTracker } from './lease-tracker';
@@ -135,6 +135,7 @@ export declare class ZLinkAuthoritySpotRouteResolver implements ZLinkSpotRouteRe
     private readonly routeEpochs;
     private readonly activeResolutions;
     constructor(store: ZLinkAuthorityStore, routerChannelIdForMesh: (meshName: string) => string, fallback?: ZLinkSpotRouteResolver | undefined, leaseTracker?: ZLinkOwnerLeaseTracker | undefined, routeCacheMaxAgeMs?: number, monotonicNowMs?: () => number, targetNodeStateResolver?: ((meshName: string, nodeRid: RoutingId, expectedLifecycleGeneration: bigint, signal?: AbortSignal) => Promise<ZLinkFrameworkRuntimeState | undefined>) | undefined);
+    resolve(spotId: RoutingId, signal: AbortSignal | undefined, instanceIntent: true): Promise<ZLinkSpotRouteTarget | ZLinkInstanceReactivationRoute>;
     resolve(spotId: RoutingId, signal?: AbortSignal): Promise<ZLinkSpotRouteTarget>;
     invalidate(spotId: RoutingId): void;
     private invalidateCore;

package/dist/runtime/locations/resolvers.js

@@ -583,7 +583,7 @@ class ZLinkAuthoritySpotRouteResolver {
         this.monotonicNowMs = monotonicNowMs;
         this.targetNodeStateResolver = targetNodeStateResolver;
     }
-    async resolve(spotId, signal) {
+    async resolve(spotId, signal, instanceIntent) {
         const key = String(spotId);
         const prepared = await this.lane.run(() => this.beginResolutionCore(key));
         try {
@@ -606,6 +606,15 @@ class ZLinkAuthoritySpotRouteResolver {
                             leaseGeneration: current.ownerLeaseGeneration
                         }, signal);
                     if (remainingLeaseMs !== undefined && remainingLeaseMs <= 0) {
+                        if (instanceIntent === true && ready?.kind === 'instance_spot') {
+                            return {
+                                kind: 'coldActivation',
+                                spotId,
+                                spotKind: Spots_1.ZLinkSpotKind.Instance,
+                                meshName: ready.ownerMeshName,
+                                stableType: ready.stableType
+                            };
+                        }
                         throw new Errors_1.ZLinkFrameworkException(Errors_1.ZLinkFrameworkErrorKind.Unavailable, `SPOT '${spotId}' Ready authority owner lease is unavailable.`);
                     }
                     const target = {

package/dist/runtime/messaging/submission-result.d.ts

@@ -10,7 +10,7 @@ export declare enum ZLinkSubmitStatus {
 export interface ZLinkSubmitResult {
     readonly status: ZLinkSubmitStatus;
 }
-/** Projects immediate refusal and pending admission failure from their Core phase. */
+/** Projects typed submit failure; capacity refusal has no admission wait token. */
 export declare function submitToRequestResult(result: number, phase: 'submit' | 'completion'): number;
 export declare function classifySubmitResult(result: number, operation: string, phase?: 'submit' | 'completion'): ZLinkSubmitResult;
 export declare function requireOneWayCompletion(result: ZLinkSubmitResult, operation: string, notFoundKind?: ZLinkFrameworkInternalErrorKind): void;

package/dist/runtime/messaging/submission-result.js

@@ -19,13 +19,13 @@ var ZLinkSubmitStatus;
     ZLinkSubmitStatus["RouteNotConnected"] = "routeNotConnected";
     ZLinkSubmitStatus["Shutdown"] = "shutdown";
 })(ZLinkSubmitStatus || (exports.ZLinkSubmitStatus = ZLinkSubmitStatus = {}));
-/** Projects immediate refusal and pending admission failure from their Core phase. */
+/** Projects typed submit failure; capacity refusal has no admission wait token. */
 function submitToRequestResult(result, phase) {
     switch (result) {
         case runtime_values_1.SubmitResult.Ok:
             return runtime_values_1.RequestResult.Ok;
         case runtime_values_1.SubmitResult.Backpressured:
-            return phase === 'submit' ? runtime_values_1.RequestResult.NotConnected : runtime_values_1.RequestResult.TimedOut;
+            return runtime_values_1.RequestResult.NotConnected;
         case runtime_values_1.SubmitResult.NotConnected:
             return runtime_values_1.RequestResult.NotConnected;
         case runtime_values_1.SubmitResult.NotFound:

package/dist/runtime/spots/formal-remote-actor-admission-registry.d.ts

@@ -1,3 +1,4 @@
+import type { ApplicationJobOrigin } from '../application-jobs/contracts';
 import type { ActorRef, RoutingId, ZLinkActor, ZLinkActorJoinOperationId } from '../../contracts';
 import type { ZLinkRemoteBoundSessionTarget } from '../actors/actor-runtime-state';
 import type { ZLinkDeferredJoinCompletion } from '../actors/deferred-join-completion';
@@ -10,6 +11,7 @@ import type { ZLinkActorRequestTerminal } from './spot-actor-packet-dispatch';
  * how long the underlying buffer stays valid.
  */
 export interface ZLinkParkedActorArrival {
+    readonly origin: ApplicationJobOrigin;
     readonly header: Buffer;
     readonly payload: Buffer;
     readonly returnResponse: boolean;

package/dist/runtime/spots/index.d.ts

@@ -1,3 +1,4 @@
+import type { ApplicationJobOrigin } from '../application-jobs/contracts';
 import type { ActorRef, RoutingId, Type, ZLinkMessageSerializer, ZLinkInstanceSpot, ZLinkActor, ZLinkChannelClient, ZLinkFanoutClient, ZLinkSpot, ZLinkSpotActorJoinResult, ZLinkSpotInfo, ZLinkSpotPublisherClient } from '../../contracts';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
 import type { ZLinkSpotActorRequestHandlerRegistration, ZLinkSpotActorSendHandlerRegistration, ZLinkSpotPacketHandlerRegistration, ZLinkSpotSubscriptionHandlerRegistration, ZLinkSpotTimerHandlerRegistration } from '../../contracts/Configuration/RegistrationTypes';
@@ -55,7 +56,7 @@ export interface ZLinkSpotManagerOptions {
     readonly entrySpotCallbacks?: {
         onLeaveActor(actor: ZLinkActor, signal?: AbortSignal, actorRef?: ActorRef, membershipEpoch?: bigint): Promise<void>;
     };
-    readonly dispatchEntryActorPacket?: (actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, requestTerminal?: (response: unknown) => Promise<void> | void, messageFollowOrigin?: ZLinkMessageFollowOrigin) => Promise<unknown>;
+    readonly dispatchEntryActorPacket?: (origin: ApplicationJobOrigin, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, requestTerminal?: (response: unknown) => Promise<void> | void, messageFollowOrigin?: ZLinkMessageFollowOrigin) => Promise<unknown>;
     /**
      * Commits a stateful MeshNode Actor return to the Entry Spot after the
      * stateful reply has committed Core membership.
@@ -200,7 +201,7 @@ export declare class DefaultZLinkSpotManager {
     beginActorTransfer(spotId: RoutingId, actorId: string): Promise<void>;
     cancelActorTransfer(spotId: RoutingId, actorId: string): Promise<void>;
     notifyJoinedSpotActorDisconnected(spotId: RoutingId, actor: ZLinkActor, signal?: AbortSignal): Promise<boolean>;
-    dispatchRoutedActorPacket(spotId: RoutingId, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef): Promise<unknown>;
+    dispatchRoutedActorPacket(origin: ApplicationJobOrigin, spotId: RoutingId, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef): Promise<unknown>;
     dispatchRoutedSpotSend(spotId: RoutingId, packetName: string | undefined, message: unknown, context: {
         readonly channelName: string;
         readonly contentType?: string;
@@ -220,7 +221,7 @@ export declare class DefaultZLinkSpotManager {
     dispatchMeshInstance(meshName: string, owner: ReadyRecord, record: ReceiveRecord): Promise<void>;
     private reportInstanceDispatchFailure;
     private traceInstanceMessage;
-    dispatchMeshActor(meshName: string, owner: ReadyRecord, record: ReceiveRecord): Promise<void>;
+    dispatchMeshActor(origin: ApplicationJobOrigin, meshName: string, owner: ReadyRecord, record: ReceiveRecord): Promise<void>;
     dispatchMeshActorJoin(meshName: string, owner: ReadyRecord, record: ReceiveRecord): Promise<void>;
     private dispatchMeshActorJoinCore;
     dispatchMeshSpotControl(meshName: string, owner: ReadyRecord, record: ReceiveRecord): Promise<void>;

package/dist/runtime/spots/index.js

@@ -860,20 +860,20 @@ class DefaultZLinkSpotManager {
     async notifyJoinedSpotActorDisconnected(spotId, actor, signal) {
         return await this.actorMembership.notifyJoinedActorDisconnected(spotId, actor, signal);
     }
-    dispatchRoutedActorPacket(spotId, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef) {
+    dispatchRoutedActorPacket(origin, spotId, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef) {
         const activation = this.activations.resolveUnique(spotId);
         if (activation === undefined) {
             throw new configuration_1.ZLinkConfigurationException(`Spot '${spotId}' is not active.`);
         }
-        return this.dispatchActorPacket(activation, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef);
+        return this.dispatchActorPacket(origin, activation, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef);
     }
     /** @internal Replays a record already owned by the Actor handoff queue. */
-    dispatchRoutedActorPacketDirect(spotId, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef) {
+    dispatchRoutedActorPacketDirect(origin, spotId, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef) {
         const activation = this.activations.resolveUnique(spotId);
         if (activation === undefined) {
             throw new configuration_1.ZLinkConfigurationException(`Spot '${spotId}' is not active.`);
         }
-        return this.activationLifecycle.dispatchActorPacketDirect(activation, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef);
+        return this.activationLifecycle.dispatchActorPacketDirect(origin, activation, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef);
     }
     /** @internal Atomically restores one durable packet prefix to an Actor FIFO. */
     admitRoutedActorPacketPrefix(spotId, actorId, records) {
@@ -1071,7 +1071,7 @@ class DefaultZLinkSpotManager {
             errorReason
         });
     }
-    async dispatchMeshActor(meshName, owner, record) {
+    async dispatchMeshActor(origin, meshName, owner, record) {
         const spotId = owner.spotId;
         const entrySpotId = this.options.entryNodeRidProvider?.() ?? this.options.entryNodeRid;
         const targetsEntrySpot = spotId === null || (entrySpotId !== undefined && spotId === entrySpotId);
@@ -1115,8 +1115,8 @@ class DefaultZLinkSpotManager {
                 throw new Error(`Actor '${actor.actorId}' target transfer reconciliation is not complete.`);
             }
             const response = targetsEntrySpot
-                ? await this.options.dispatchEntryActorPacket?.(actor.actorId, record.parts, request, undefined, ownerActorRef, requestTerminal, record.messageFollowOrigin)
-                : await this.dispatchMeshActorPacket(meshName, spotId, actor.actorId, record.parts, request, ownerActorRef, requestTerminal, record.messageFollowOrigin);
+                ? await this.options.dispatchEntryActorPacket?.(origin, actor.actorId, record.parts, request, undefined, ownerActorRef, requestTerminal, record.messageFollowOrigin)
+                : await this.dispatchMeshActorPacket(origin, meshName, spotId, actor.actorId, record.parts, request, ownerActorRef, requestTerminal, record.messageFollowOrigin);
             if (targetsEntrySpot && this.options.dispatchEntryActorPacket === undefined) {
                 throw new configuration_1.ZLinkConfigurationException('MeshNode Entry Spot Actor dispatch is not configured.');
             }
@@ -1631,7 +1631,7 @@ class DefaultZLinkSpotManager {
                                 if (this.options.dispatchEntryActorPacket === undefined) {
                                     throw new Error('Entry Spot saved handoff replay requires its Actor packet runtime.');
                                 }
-                                return await this.options.dispatchEntryActorPacket(entryActor.context.actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef);
+                                return await this.options.dispatchEntryActorPacket('remote', entryActor.context.actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef);
                             }, (index) => this.options.runtimeEventPublisher?.publish({
                                 sourceName: 'zlink.framework.actor-handoff',
                                 timestamp: new Date(),
@@ -1790,7 +1790,7 @@ class DefaultZLinkSpotManager {
                 };
                 const completeTargetReady = async () => {
                     if (pendingTransfer !== undefined) {
-                        const handoffResults = await (0, actor_handoff_1.replayActorHandoffBacklog)(pendingTransfer.handoffBacklog, (parts, returnResponse, remoteBoundSessionTarget, _fallbackActorRef) => this.dispatchActorPacket(activation, actor.context.actorId, parts, returnResponse, remoteBoundSessionTarget, undefined), (index) => this.options.runtimeEventPublisher?.publish({
+                        const handoffResults = await (0, actor_handoff_1.replayActorHandoffBacklog)(pendingTransfer.handoffBacklog, (parts, returnResponse, remoteBoundSessionTarget, _fallbackActorRef) => this.dispatchActorPacket('remote', activation, actor.context.actorId, parts, returnResponse, remoteBoundSessionTarget, undefined), (index) => this.options.runtimeEventPublisher?.publish({
                             sourceName: 'zlink.framework.actor-handoff',
                             timestamp: new Date(),
                             marker: 'backlog_enqueued',
@@ -2033,8 +2033,8 @@ class DefaultZLinkSpotManager {
             throw new configuration_1.ZLinkConfigurationException('Spot type is not registered as a spot factory.');
         }
     }
-    async dispatchActorPacket(activation, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin) {
-        return await this.activationLifecycle.dispatchActorPacket(activation, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin);
+    async dispatchActorPacket(origin, activation, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin) {
+        return await this.activationLifecycle.dispatchActorPacket(origin, activation, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin);
     }
     /**
      * Spec 15 §4.2 relocation temporary queue: drains every arrival parked
@@ -2050,7 +2050,7 @@ class DefaultZLinkSpotManager {
         const drained = this.formalRemoteActorAdmissions.completeMigration(transferId);
         for (const arrival of drained) {
             try {
-                const response = await this.dispatchActorPacket(activation, actor.context.actorId, [runtime_message_1.ZLinkBufferMessage.from(arrival.header), runtime_message_1.ZLinkBufferMessage.from(arrival.payload)], arrival.returnResponse, arrival.remoteBoundSessionTarget, arrival.fallbackActorRef, arrival.requestTerminal);
+                const response = await this.dispatchActorPacket(arrival.origin, activation, actor.context.actorId, [runtime_message_1.ZLinkBufferMessage.from(arrival.header), runtime_message_1.ZLinkBufferMessage.from(arrival.payload)], arrival.returnResponse, arrival.remoteBoundSessionTarget, arrival.fallbackActorRef, arrival.requestTerminal);
                 arrival.resolve(response);
             }
             catch (error) {
@@ -2058,12 +2058,12 @@ class DefaultZLinkSpotManager {
             }
         }
     }
-    async dispatchMeshActorPacket(meshName, spotId, actorId, parts, returnResponse, fallbackActorRef, requestTerminal, messageFollowOrigin) {
+    async dispatchMeshActorPacket(origin, meshName, spotId, actorId, parts, returnResponse, fallbackActorRef, requestTerminal, messageFollowOrigin) {
         const activation = this.activations.resolve(meshName, spotId);
         if (activation === undefined) {
             throw new configuration_1.ZLinkConfigurationException(`Spot '${String(spotId)}' is not active in mesh '${meshName}'.`);
         }
-        return await this.dispatchActorPacket(activation, actorId, parts, returnResponse, undefined, fallbackActorRef, requestTerminal, messageFollowOrigin);
+        return await this.dispatchActorPacket(origin, activation, actorId, parts, returnResponse, undefined, fallbackActorRef, requestTerminal, messageFollowOrigin);
     }
 }
 exports.DefaultZLinkSpotManager = DefaultZLinkSpotManager;

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

@@ -1,3 +1,4 @@
+import type { ApplicationJobOrigin } from '../application-jobs/contracts';
 import type { ActorRef, RoutingId, Type, ZLinkActor, ZLinkChannelClient, ZLinkFanoutClient, ZLinkMessageSerializer, ZLinkInstanceSpot, ZLinkSpot, ZLinkSpotPublisherClient } from '../../contracts';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
 import type { ZLinkRuntimeAdmissionGate } from '../admission';
@@ -82,7 +83,7 @@ export declare class ZLinkSpotActivationLifecycle {
     /** Returns the OnClosing failure, which cleanup records and does not rethrow. */
     cleanupClosedActivation(activation: ZLinkSpotActivation, reason?: ZLinkSpotCloseReason, deadline?: Date): Promise<unknown>;
     cleanupFailedIncarnation(activation: ZLinkSpotActivation): Promise<void>;
-    dispatchActorPacket(activation: ZLinkSpotActivation, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, requestTerminal?: (response: unknown) => Promise<void> | void, messageFollowOrigin?: ZLinkMessageFollowOrigin): Promise<unknown>;
+    dispatchActorPacket(origin: ApplicationJobOrigin, activation: ZLinkSpotActivation, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, requestTerminal?: (response: unknown) => Promise<void> | void, messageFollowOrigin?: ZLinkMessageFollowOrigin): Promise<unknown>;
     private runCreateLifecycle;
     private cleanupActivation;
     private runCleanup;

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

@@ -477,12 +477,12 @@ class ZLinkSpotActivationLifecycle {
     async cleanupFailedIncarnation(activation) {
         await this.cleanupActivation(activation, activation.meshName, false, undefined, contracts_1.ZLinkSpotCloseReason.ExplicitClose, undefined, true);
     }
-    async dispatchActorPacket(activation, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin) {
-        return await this.actorAdmission.dispatchActorPacket(activation, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin);
+    async dispatchActorPacket(origin, activation, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin) {
+        return await this.actorAdmission.dispatchActorPacket(origin, activation, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin);
     }
     /** @internal Dispatches a held Actor record after its handoff owner releases it. */
-    dispatchActorPacketDirect(activation, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef) {
-        return this.actorAdmission.dispatchActorPacketDirect(activation, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef);
+    dispatchActorPacketDirect(origin, activation, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef) {
+        return this.actorAdmission.dispatchActorPacketDirect(origin, activation, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef);
     }
     /** @internal Atomically restores one durable Actor packet prefix. */
     admitActorPacketPrefix(activation, actorId, records) {

package/dist/runtime/spots/spot-actor-admission-coordinator.d.ts

@@ -1,3 +1,4 @@
+import type { ApplicationJobOrigin } from '../application-jobs/contracts';
 import type { ActorRef } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkMessageFollowOrigin } from '../foundation/service-runtime-contracts';
@@ -10,7 +11,7 @@ type AdmissionOptions = Pick<ZLinkSpotActivationLifecycleOptions, 'actorHandoffR
 export declare class ZLinkSpotActorAdmissionCoordinator {
     private readonly options;
     constructor(options: AdmissionOptions);
-    dispatchActorPacket(activation: ZLinkSpotActivation, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, requestTerminal?: (response: unknown) => Promise<void> | void, messageFollowOrigin?: ZLinkMessageFollowOrigin): Promise<unknown>;
+    dispatchActorPacket(origin: ApplicationJobOrigin, activation: ZLinkSpotActivation, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, requestTerminal?: (response: unknown) => Promise<void> | void, messageFollowOrigin?: ZLinkMessageFollowOrigin): Promise<unknown>;
     attachNativeActorJoinDispatch(activation: ZLinkSpotActivation, nativeSpot: ZLinkBackendSpot | undefined): ZLinkSpotActorJoinDispatch | undefined;
     private dispatchActorPacketInActorTurn;
     private commitTransferredActorTransaction;

package/dist/runtime/spots/spot-actor-admission-coordinator.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkSpotActorAdmissionCoordinator = void 0;
+const application_job_queue_scope_1 = require("../application-jobs/application-job-queue-scope");
 const actor_handoff_1 = require("../actors/actor-handoff");
 const routing_id_1 = require("../routing-id");
 const spot_actor_join_dispatch_1 = require("./spot-actor-join-dispatch");
@@ -10,11 +11,11 @@ class ZLinkSpotActorAdmissionCoordinator {
     constructor(options) {
         this.options = options;
     }
-    async dispatchActorPacket(activation, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin) {
-        const handoff = this.options.actorHandoffRuntime?.capture(actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, undefined, messageFollowOrigin, (replayedParts, replayReturnResponse, replayRemoteBoundSessionTarget, replayFallbackActorRef) => this.dispatchActorPacketDirect(activation, actorId, replayedParts, replayReturnResponse, replayRemoteBoundSessionTarget, replayFallbackActorRef));
+    async dispatchActorPacket(origin, activation, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin) {
+        const handoff = this.options.actorHandoffRuntime?.capture(origin, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, undefined, messageFollowOrigin, (replayedParts, replayReturnResponse, replayRemoteBoundSessionTarget, replayFallbackActorRef) => this.dispatchActorPacketDirect(origin, activation, actorId, replayedParts, replayReturnResponse, replayRemoteBoundSessionTarget, replayFallbackActorRef));
         if (handoff !== undefined)
             return await handoff;
-        return await this.dispatchActorPacketDirect(activation, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal);
+        return await this.dispatchActorPacketDirect(origin, activation, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal);
     }
     attachNativeActorJoinDispatch(activation, nativeSpot) {
         if (nativeSpot === undefined)
@@ -39,7 +40,7 @@ class ZLinkSpotActorAdmissionCoordinator {
                 commitTransferredActor: (actor, backlog, sealedSession) => this.commitTransferredActorTransaction(activation, actor, backlog, sealedSession)
             },
             packets: {
-                handle: (delivery) => this.dispatchActorPacket(activation, delivery.actorId, delivery.parts, delivery.returnResponse, delivery.remoteBoundSessionTarget, delivery.fallbackActorRef),
+                handle: (delivery) => this.dispatchActorPacket('remote', activation, delivery.actorId, delivery.parts, delivery.returnResponse, delivery.remoteBoundSessionTarget, delivery.fallbackActorRef),
                 bindRemoteSession: (actor, sourceNodeRid, sourceSessionRid) => {
                     const node = this.options.nativeSpotNodeProvider?.(activation.meshName);
                     if (node === undefined || (0, routing_id_1.routingIdsEqual)(sourceNodeRid, node.routingId))
@@ -63,8 +64,8 @@ class ZLinkSpotActorAdmissionCoordinator {
         return nativeDispatch;
     }
     /** @internal Dispatches a coordinator-owned replay without recapturing it. */
-    dispatchActorPacketDirect(activation, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, requestTerminal) {
-        return activation.executeActor(actorId, (actorSerial) => this.dispatchActorPacketInActorTurn(activation, actorSerial, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal));
+    dispatchActorPacketDirect(origin, activation, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, requestTerminal) {
+        return activation.executeActor(actorId, (actorSerial) => this.dispatchActorPacketInActorTurn(origin, activation, actorSerial, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal));
     }
     /**
      * Atomically restores one durable packet prefix at the Actor FIFO tail.
@@ -75,7 +76,7 @@ class ZLinkSpotActorAdmissionCoordinator {
      */
     admitActorPacketPrefix(activation, actorId, records) {
         const terminals = activation.admitActorDurablePrefix(actorId, records.map((record) => ({
-            operation: (executeChild) => record.drain((parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef) => executeChild((actorSerial) => this.dispatchActorPacketInActorTurn(activation, actorSerial, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef))),
+            operation: (executeChild) => record.drain((parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef) => executeChild((actorSerial) => this.dispatchActorPacketInActorTurn((0, application_job_queue_scope_1.currentApplicationJobOrigin)(), activation, actorSerial, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef))),
             preparation: record.preparation,
             workOptions: { payloadBytes: record.payloadBytes }
         })));
@@ -89,7 +90,7 @@ class ZLinkSpotActorAdmissionCoordinator {
         });
         return { terminal };
     }
-    dispatchActorPacketInActorTurn(activation, actorSerial, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, requestTerminal) {
+    dispatchActorPacketInActorTurn(origin, activation, actorSerial, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, requestTerminal) {
         return new spot_actor_packet_dispatch_1.ZLinkSpotActorPacketDispatch({
             spot: activation.spot,
             spotId: () => String(activation.spotId),
@@ -107,7 +108,7 @@ class ZLinkSpotActorAdmissionCoordinator {
             messageSerializers: this.options.messageSerializers,
             dispatchErrors: this.options.dispatchErrors,
             routeToActorJoinPrewarm: this.options.routeToActorJoinPrewarm
-        }).dispatch(actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal);
+        }).dispatch(origin, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal);
     }
     async commitTransferredActorTransaction(activation, actor, backlog, sealedSession) {
         const transfer = this.options.actorTransferRuntime;
@@ -140,7 +141,7 @@ class ZLinkSpotActorAdmissionCoordinator {
         }
     }
     async replayActorBacklog(activation, actor, backlog) {
-        return await (0, actor_handoff_1.replayActorHandoffBacklog)(backlog, (parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef) => this.dispatchActorPacketDirect(activation, actor.context.actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef), (index) => this.options.runtimeEventPublisher?.publish({
+        return await (0, actor_handoff_1.replayActorHandoffBacklog)(backlog, (parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef) => this.dispatchActorPacketDirect('remote', activation, actor.context.actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef), (index) => this.options.runtimeEventPublisher?.publish({
             sourceName: 'zlink.framework.actor-handoff',
             timestamp: new Date(),
             marker: 'backlog_enqueued',

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

@@ -1,3 +1,4 @@
+import type { ApplicationJobOrigin } from '../application-jobs/contracts';
 import type { ActorRef, RoutingId, ZLinkActor, ZLinkMessageSerializer, ZLinkSpot } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkRemoteBoundSessionTarget } from '../actors';
@@ -17,6 +18,7 @@ export interface ZLinkActorRequestTerminal {
 }
 /** One admitted Actor packet and the routing context that must move with it. */
 export interface ZLinkActorPacketDelivery {
+    readonly origin: ApplicationJobOrigin;
     readonly actorId: string;
     readonly parts: readonly Message[];
     readonly returnResponse: boolean;
@@ -35,6 +37,7 @@ export interface ZLinkActorPacketDelivery {
  * unchanged.
  */
 export type ZLinkRouteToActorJoinPrewarm = (actorId: string, objectGeneration: bigint, arrival: {
+    readonly origin: ApplicationJobOrigin;
     readonly header: Buffer;
     readonly payload: Buffer;
     readonly returnResponse: boolean;
@@ -69,7 +72,7 @@ interface ZLinkSpotActorPacketDispatchOptions {
 export declare class ZLinkSpotActorPacketDispatch {
     private readonly options;
     constructor(options: ZLinkSpotActorPacketDispatchOptions);
-    dispatch(actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, requestTerminal?: ZLinkActorRequestTerminal): Promise<unknown>;
+    dispatch(origin: ApplicationJobOrigin, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, requestTerminal?: ZLinkActorRequestTerminal): Promise<unknown>;
     dispatchDelivery(delivery: ZLinkActorPacketDelivery): Promise<unknown>;
     private handleMissingActor;
     /**

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

@@ -17,8 +17,9 @@ class ZLinkSpotActorPacketDispatch {
     constructor(options) {
         this.options = options;
     }
-    dispatch(actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, requestTerminal) {
+    dispatch(origin, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, requestTerminal) {
         return this.dispatchDelivery({
+            origin,
             actorId,
             parts,
             returnResponse,
@@ -71,7 +72,7 @@ class ZLinkSpotActorPacketDispatch {
             }
             const actor = this.options.resolveActor(actorId);
             if (actor === undefined) {
-                return this.handleMissingActor(actorId, parts, header, messageKind, action, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal);
+                return this.handleMissingActor(delivery.origin, actorId, parts, header, messageKind, action, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal);
             }
             if (header.name === actors_1.ZLINK_REMOTE_ACTOR_SESSION_DISCONNECTED_PACKET) {
                 await this.options.onDisconnectActor(actor);
@@ -81,7 +82,7 @@ class ZLinkSpotActorPacketDispatch {
             return this.dispatchActorPacket(actor, actorId, decodePayload, header, messageKind, action, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, requestDeadlineUnixMs, (0, serial_work_size_1.zlinkSerialWorkOptions)(parts[1].data().byteLength, (0, serial_work_size_1.zlinkMetadataByteLength)(header.metadata)));
         });
     }
-    async handleMissingActor(actorId, parts, header, messageKind, action, returnResponse, fallbackBoundSessionTarget, fallbackActorRef, requestTerminal) {
+    async handleMissingActor(origin, actorId, parts, header, messageKind, action, returnResponse, fallbackBoundSessionTarget, fallbackActorRef, requestTerminal) {
         if (this.options.routeToActorJoinPrewarm !== undefined &&
             fallbackActorRef !== undefined &&
             parts.length >= 2 &&
@@ -90,7 +91,7 @@ class ZLinkSpotActorPacketDispatch {
             //  forever with no reply route. Fall through to the existing
             //  missing-actor handling for that shape instead.
             (messageKind !== ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.ActorRequest || requestTerminal !== undefined)) {
-            const parked = this.parkForActorJoinPrewarm(actorId, parts, messageKind, returnResponse, fallbackBoundSessionTarget, fallbackActorRef, requestTerminal);
+            const parked = this.parkForActorJoinPrewarm(origin, actorId, parts, messageKind, returnResponse, fallbackBoundSessionTarget, fallbackActorRef, requestTerminal);
             if (parked !== undefined)
                 return parked;
         }
@@ -126,7 +127,7 @@ class ZLinkSpotActorPacketDispatch {
      * arrival survives independently of the original {@link Message}
      * lifetime.
      */
-    parkForActorJoinPrewarm(actorId, parts, messageKind, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal) {
+    parkForActorJoinPrewarm(origin, actorId, parts, messageKind, returnResponse, remoteBoundSessionTarget, fallbackActorRef, requestTerminal) {
         const isRequest = messageKind === ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.ActorRequest;
         let resolve = () => undefined;
         let reject = () => undefined;
@@ -154,6 +155,7 @@ class ZLinkSpotActorPacketDispatch {
                 }
             }, { prepare: requestTerminal.prepare });
         const route = this.options.routeToActorJoinPrewarm(actorId, fallbackActorRef.objectGeneration, {
+            origin,
             header: Buffer.from(parts[0].data()),
             payload: Buffer.from(parts[1].data()),
             returnResponse,

package/dist/runtime/spots/spot-actor-packet-drain.js

@@ -83,6 +83,7 @@ class ZLinkSpotActorPacketDrain {
             }
             else {
                 await this.options.actorPacketHandler({
+                    origin: 'remote',
                     actorId,
                     parts,
                     returnResponse: false,
@@ -131,6 +132,7 @@ class ZLinkSpotActorPacketDrain {
     async dispatchNoBindActorRequest(info, actorId, parts, actorRef) {
         try {
             const response = await this.options.actorPacketHandler?.({
+                origin: 'remote',
                 actorId,
                 parts,
                 returnResponse: true,

package/dist/runtime/spots/spot-actor-packet-relay-dispatch.js

@@ -69,6 +69,7 @@ class ZLinkSpotActorPacketRelayDispatch {
                 actorPacketRelay.messageFollowContext !== undefined &&
                 remoteBoundSessionTarget !== undefined;
             const response = await this.options.actorPacketHandler({
+                origin: 'remote',
                 actorId: actorPacketRelay.actorId,
                 parts: [header, payload],
                 returnResponse: !followedBoundSessionReply,

package/dist/runtime/spots/spot-entry-activation.js

@@ -287,7 +287,8 @@ class ZLinkEntrySpotActivation {
     }
     async dispatchActorPacket(delivery) {
         const { actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, messageFollowOrigin } = delivery;
-        const handoff = this.options.actorHandoffRuntime?.capture(actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, undefined, messageFollowOrigin, (replayedParts, replayReturnResponse, replayRemoteBoundSessionTarget, replayFallbackActorRef) => this.spotSerialExecutor.executeActor(actorId, () => this.dispatchActorPacketInsideMailbox({
+        const handoff = this.options.actorHandoffRuntime?.capture(delivery.origin, actorId, parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef, undefined, messageFollowOrigin, (replayedParts, replayReturnResponse, replayRemoteBoundSessionTarget, replayFallbackActorRef) => this.spotSerialExecutor.executeActor(actorId, () => this.dispatchActorPacketInsideMailbox({
+            origin: delivery.origin,
             actorId,
             parts: replayedParts,
             returnResponse: replayReturnResponse,
@@ -300,6 +301,7 @@ class ZLinkEntrySpotActivation {
     }
     async replayActorBacklog(actor, backlog) {
         return await (0, actor_handoff_1.replayActorHandoffBacklog)(backlog, (parts, returnResponse, remoteBoundSessionTarget, fallbackActorRef) => this.spotSerialExecutor.executeActor(actor.context.actorId, () => this.dispatchActorPacketInsideMailbox({
+            origin: 'remote',
             actorId: actor.context.actorId,
             parts,
             returnResponse,

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

@@ -1,3 +1,4 @@
+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';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkProviderResolver } from '../../contracts/Common/ZLinkProviderResolver';
@@ -116,7 +117,7 @@ export declare class ZLinkSpotNodeRuntimeManager {
     private ensureEntryActivation;
     private initializeEntrySpot;
     private primaryEntryActivation;
-    dispatchEntryActorPacket(actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, requestTerminal?: (response: unknown) => Promise<void> | void, messageFollowOrigin?: ZLinkMessageFollowOrigin): Promise<unknown>;
+    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>;
     executeEntryActor<T>(meshName: string, actorId: string, operation: () => Promise<T>): Promise<T>;
     publish(meshName: string, channelName: string, topic: string, packetName: string | undefined, event: Message, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;

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

@@ -17,7 +17,6 @@ const channel_clients_1 = require("../channels/channel-clients");
 const channel_envelope_1 = require("../channels/channel-envelope");
 const configuration_1 = require("../configuration");
 const flow_context_1 = require("../diagnostics/flow-context");
-const execution_1 = require("../execution");
 const service_runtime_contracts_1 = require("../foundation/service-runtime-contracts");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const application_job_queue_1 = require("../host/application-job-queue");
@@ -146,6 +145,7 @@ class ZLinkSpotNodeRuntimeManager {
                 routingId,
                 receiveTimeoutMs: spotNode.router?.receiveTimeoutMs,
                 applicationJobQueue: this.applicationJobQueue,
+                infrastructureTaskRunner: this.options.detachedTaskRunner,
                 applicationJobReceiveFlowFailureSink: this.options.applicationJobReceiveFlowFailureSink,
                 peerAdmissionSealed: () => this.options.peerAdmissionSealed?.(spotNodeName) ?? false
             });
@@ -177,6 +177,7 @@ class ZLinkSpotNodeRuntimeManager {
             let pump;
             const completions = new mesh_completion_table_1.ZLinkMeshCompletionTable();
             try {
+                node.setCompletionHandler((terminal, materialize) => completions.complete(terminal, materialize));
                 node.setBind(bind);
                 if (spotNode.router?.advertiseHost !== undefined) {
                     node.setAdvertiseHost(spotNode.router.advertiseHost);
@@ -604,15 +605,6 @@ class ZLinkSpotNodeRuntimeManager {
         this.meshCompletions.clear();
     }
     async dispatchMeshRecord(meshName, owner, record) {
-        if (record.kind === service_runtime_contracts_1.ReceiveKind.Completion) {
-            (0, execution_1.requireZLinkInfrastructureExecutionArea)();
-            const completions = this.meshCompletions.get(meshName);
-            if (completions === undefined) {
-                throw new configuration_1.ZLinkConfigurationException(`MeshNode '${meshName}' received a completion before its completion table was registered.`);
-            }
-            completions.complete(record);
-            return;
-        }
         const node = this.meshNodes.get(meshName);
         const targetsEntrySpot = owner.spotId === null ||
             (node !== undefined &&
@@ -745,7 +737,7 @@ class ZLinkSpotNodeRuntimeManager {
     primaryEntryActivation() {
         return this.entryActivations.values().next().value;
     }
-    async dispatchEntryActorPacket(actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin) {
+    async dispatchEntryActorPacket(origin, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, requestTerminal, messageFollowOrigin) {
         let activation = this.primaryEntryActivation();
         if (activation === undefined) {
             const candidates = this.options.primaryMeshName === undefined
@@ -774,6 +766,7 @@ class ZLinkSpotNodeRuntimeManager {
             throw new configuration_1.ZLinkConfigurationException('Entry Spot actor packet dispatch requires an Entry Spot.');
         }
         return await activation.dispatchActorPacket({
+            origin,
             actorId,
             parts,
             returnResponse,

package/dist/runtime/spots/spot-routing-internal.d.ts

@@ -1,6 +1,7 @@
 import type { RoutingId } from '../../contracts/Common';
 import type { ZLinkFrameworkRuntimeState, ZLinkSpotKind } from '../../contracts';
 export interface ZLinkSpotRouteResolver {
+    resolve(spotId: RoutingId, signal: AbortSignal | undefined, instanceIntent: true): Promise<ZLinkSpotRouteTarget | ZLinkInstanceReactivationRoute>;
     resolve(spotId: RoutingId, signal?: AbortSignal): Promise<ZLinkSpotRouteTarget>;
     invalidate?(spotId: RoutingId): void;
 }
@@ -26,3 +27,8 @@ export interface ZLinkSpotRouteTarget {
     /** Current state of the owning MeshNode, when the route was resolved from Location Store. */
     readonly targetNodeState?: ZLinkFrameworkRuntimeState;
 }
+export interface ZLinkInstanceReactivationRoute extends Pick<ZLinkSpotRouteTarget, 'spotId' | 'spotKind' | 'stableType'> {
+    readonly kind: 'coldActivation';
+    readonly meshName: string;
+    readonly stableType: string;
+}

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

@@ -1,3 +1,4 @@
+import type { ApplicationJobOrigin } from '../application-jobs/contracts';
 import type { ActorRef, RoutingId, ZLinkActor, ZLinkActorJoinOperationId, ZLinkSpot } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
 import type { ZLinkMessageFollowOrigin } from '../foundation/service-runtime-contracts';
@@ -44,5 +45,5 @@ export interface ZLinkSpotBoundSessionRuntime {
     sendActorError(actorId: string, packetName: string, requestSeq: bigint, error: unknown, metadata: ReadonlyMap<string, string>, fallbackBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, actorRef?: ActorRef, signal?: AbortSignal): Promise<void>;
 }
 export interface ZLinkSpotActorHandoffRuntime {
-    capture(actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, deadlineUnixMs?: number, messageFollowOrigin?: ZLinkMessageFollowOrigin, provisionalReplay?: ZLinkActorHandoffDispatch): Promise<unknown> | undefined;
+    capture(origin: ApplicationJobOrigin, actorId: string, parts: readonly Message[], returnResponse?: boolean, remoteBoundSessionTarget?: ZLinkRemoteBoundSessionTarget, fallbackActorRef?: ActorRef, deadlineUnixMs?: number, messageFollowOrigin?: ZLinkMessageFollowOrigin, provisionalReplay?: ZLinkActorHandoffDispatch): Promise<unknown> | undefined;
 }

package/dist/runtime/streams/stream-session-runtime.js

@@ -759,7 +759,7 @@ class ZLinkStreamSessionNodeRuntime {
             let packet;
             let packetTransferred = false;
             try {
-                permit = await this.options.applicationJobQueue.acquire(signal);
+                permit = await this.options.applicationJobQueue.acquire(signal, 'remote');
                 if (this.isReceiveStopped(signal)) {
                     permit.releaseAfterInternalProcessing();
                     break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zlink-systems/framework",
-  "version": "0.29.1",
+  "version": "0.30.0",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
@@ -19,7 +19,7 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/api-logs": "^0.221.0",
-    "@zlink-systems/stream-wire": "0.29.1",
-    "@zlink-systems/zlink": "1.17.0"
+    "@zlink-systems/stream-wire": "0.30.0",
+    "@zlink-systems/zlink": "1.19.0"
   }
 }