@zlink-systems/framework 0.29.0 → 0.30.0

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.d.ts

@@ -89,6 +89,7 @@ export declare class ZLinkEntrySpotActivation {
      */
     commitServiceActorJoin(actor: ZLinkActor, handoffBacklog?: readonly ZLinkActorHandoffPacket[], signal?: AbortSignal): Promise<void>;
     executeActor<T>(actorId: string, operation: () => Promise<T>): Promise<T>;
+    terminateActor(actorId: string, terminal: () => Promise<void>): Promise<void>;
     /**
      * Entry Spot membership does not have an application admission callback.
      * The shared core round-trip therefore accepts a valid returning Actor and

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

@@ -220,6 +220,9 @@ class ZLinkEntrySpotActivation {
     executeActor(actorId, operation) {
         return this.spotSerialExecutor.executeActor(actorId, operation);
     }
+    terminateActor(actorId, terminal) {
+        return this.spotSerialExecutor.terminateActor(actorId, terminal);
+    }
     /**
      * Entry Spot membership does not have an application admission callback.
      * The shared core round-trip therefore accepts a valid returning Actor and
@@ -284,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,
@@ -297,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';
@@ -104,6 +105,7 @@ export declare class ZLinkSpotNodeRuntimeManager {
     get primaryMeshCompletions(): ZLinkMeshCompletionTable | undefined;
     notifyEntrySpotActorCreated(nodeRid: RoutingId, actor: ZLinkActor, createRequest: ZLinkMessage, signal?: AbortSignal): Promise<import('../../contracts').ZLinkActorCreateResponse | undefined>;
     notifyPrimaryEntrySpotActorJoined(actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
+    terminateActorActivation(actor: ZLinkActor, terminal: () => Promise<void>): Promise<void>;
     notifyPrimaryEntrySpotActorLeft(actor: ZLinkActor, signal?: AbortSignal, actorRef?: ActorRef, membershipEpoch?: bigint): Promise<void>;
     notifyPrimaryEntrySpotActorDisconnected(actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
     notifyEntrySpotActorDisconnected(meshName: string, actor: ZLinkActor, signal?: AbortSignal): Promise<void>;
@@ -115,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);
@@ -542,6 +543,12 @@ class ZLinkSpotNodeRuntimeManager {
         const activation = this.primaryEntryActivation();
         return activation?.notifyJoinActor(actor, signal) ?? Promise.resolve();
     }
+    terminateActorActivation(actor, terminal) {
+        const activation = this.entryActivations.get(actor.context.meshName);
+        return activation === undefined
+            ? terminal()
+            : activation.terminateActor(actor.context.actorId, terminal);
+    }
     notifyPrimaryEntrySpotActorLeft(actor, signal, actorRef, membershipEpoch) {
         const activation = this.primaryEntryActivation();
         return (activation?.notifyLeaveActor(actor, signal, actorRef, membershipEpoch) ?? Promise.resolve());
@@ -598,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 &&
@@ -739,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
@@ -768,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/spots/spot-serial-executor.d.ts

@@ -26,6 +26,7 @@ export declare class ZLinkSpotSerialExecutor {
     executeTimer<T>(timerName: string, operation: () => Promise<T> | T, workOptions?: ZLinkSerialWorkOptions): Promise<T>;
     isTimerExecuting(timerName: string): boolean;
     executeLifecycle<T>(operation: () => Promise<T> | T, workOptions?: ZLinkSerialWorkOptions): Promise<T>;
+    terminateActor(actorId: string, terminal: () => Promise<void>): Promise<void>;
     /**
      * Makes all child queues unreachable and completes them in one synchronous
      * ownership turn. Already accepted work remains drainable.

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

@@ -42,7 +42,8 @@ class ZLinkSpotSerialExecutor {
         return this.spotSerial.execute(operation, workOptions);
     }
     executeActor(actorId, operation, workOptions) {
-        return this.actorExecutor(actorId).execute(() => operation(this.actorSerial(actorId)), workOptions);
+        const serial = this.actorSerial(actorId);
+        return this.actorExecutor(actorId).execute(() => operation(serial), workOptions);
     }
     /** @internal Restores a durable Actor FIFO prefix without starting it. */
     admitActorDurablePrefix(actorId, records) {
@@ -65,6 +66,14 @@ class ZLinkSpotSerialExecutor {
     executeLifecycle(operation, workOptions) {
         return this.spotSerial.execute(operation, { ...workOptions, lane: 'lifecycle' });
     }
+    async terminateActor(actorId, terminal) {
+        const executor = this.actorExecutor(actorId);
+        await executor.close();
+        await terminal();
+        if (this.actorExecutors.get(actorId) === executor)
+            this.actorExecutors.delete(actorId);
+        this.actorSerials.delete(actorId);
+    }
     /**
      * Makes all child queues unreachable and completes them in one synchronous
      * ownership turn. Already accepted work remains drainable.

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.0",
+  "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.0",
-    "@zlink-systems/zlink": "1.17.0"
+    "@zlink-systems/stream-wire": "0.30.0",
+    "@zlink-systems/zlink": "1.19.0"
   }
 }

package/src/contracts/Configuration/Builders.ts

@@ -7,7 +7,6 @@ import type { ZLinkDispatchOptionsBuilder, ZLinkInboundDispatchOptions } from '.
 import type { ZLinkLocationOptions, ZLinkLocationStore, ZLinkRelocationStore } from '../Locations';
 import type { RoutingId, Type } from '../Common';
 import type { ZLinkWorkerOptions } from './RegistrationTypes';
-import type { ZLinkSpotPublisherConfig } from './Configs';
 import type {
   ZLinkActorFactoryBuilder,
   ZLinkInstanceSpotFactoryBuilder,
@@ -120,7 +119,6 @@ export interface ZLinkMeshNodeBuilder {
   setActivationConcurrency(limit: number): this;
   setInstanceSpotIdleTimeout(timeoutMs: number): this;
   configureRouterSocket(): ZLinkMeshNodeSocketConfig;
-  configureSpotPublisher(): ZLinkSpotPublisherConfig;
   peerConnections(): ZLinkMeshPeerConnections;
   setDefaultRequestTimeout(timeoutMs: number): this;
   objects(): ZLinkMeshObjectRoleBuilder;
@@ -180,6 +178,7 @@ export interface ZLinkFanoutChannelBuilder {
   routingId(routingId: string): this;
   setRoutingIdPrefix(prefix: string): this;
   setNoDrop(noDrop?: boolean): this;
+  setSendTimeout(timeoutMs: number): this;
   enableSubscriber(): this;
   subscribe(topic: string): this;
   connect(endpoint: string): this;

package/src/contracts/Configuration/Configs.ts

@@ -19,9 +19,3 @@ export interface ZLinkOutboundRouteConfig {
   targetNodeRid: RoutingId;
   endpoint: string;
 }
-
-export interface ZLinkSpotPublisherConfig {
-  sendHighWaterMark: number;
-  sendTimeoutMs?: number;
-  lingerMs?: number;
-}

package/src/contracts/Configuration/RegistrationBuilders.ts

@@ -27,7 +27,6 @@ import type {
   ZLinkSession,
   ZLinkSessionFactory,
   ZLinkSpot,
-  ZLinkSpotPublisherConfig,
   ZLinkStreamCompressionBuilder,
   ZLinkStreamCompressionCodec,
   ZLinkStreamNodeBuilder,
@@ -53,6 +52,7 @@ import type { ZLinkEndpointConnections } from './Connections';
 import { requireMessageFlowLogMode, requireTraceSampleRate } from './DiagnosticsValidation';
 import { normalizeEndpoint } from './EndpointNotation';
 import { requirePublicFanoutTopic } from './FanoutTopic';
+import { requireValidSendTimeoutMs } from './SendTimeoutValidation';
 import { DEFAULT_STREAM_NODE_MAX_MESSAGE_SIZE } from './InternalDefaults';
 import {
   type ZLinkActorFactoryBuilder,
@@ -519,6 +519,12 @@ class DefaultFanoutChannelBuilder implements ZLinkFanoutChannelBuilder {
     return this;
   }
 
+  setSendTimeout(timeoutMs: number): this {
+    requireValidSendTimeoutMs(`Fanout channel '${this.name}' send timeout`, timeoutMs);
+    this.channel.sendTimeoutMs = timeoutMs;
+    return this;
+  }
+
   enableSubscriber(endpoint?: string): this {
     this.selectSubscriberMode(endpoint === undefined ? 'automatic' : 'manual');
     this.channel.subscriber ??= { manualConnections: [] };
@@ -984,11 +990,6 @@ class DefaultMeshNodeBuilder implements ZLinkMeshNodeBuilder {
     return this.node.router as ZLinkMeshNodeSocketConfig;
   }
 
-  configureSpotPublisher(): ZLinkSpotPublisherConfig {
-    this.node.publisherConfig ??= {};
-    return this.node.publisherConfig as ZLinkSpotPublisherConfig;
-  }
-
   peerConnections(): ZLinkMeshPeerConnections {
     this.node.router ??= {};
     return new DefaultMeshPeerConnections(this.node.router);
@@ -1576,6 +1577,7 @@ interface MutableChannelOptions {
   routingId?: string;
   routingIdPrefix?: string;
   noDrop?: boolean;
+  sendTimeoutMs?: number;
   publisher?: MutablePublisherCapabilityOptions;
   publishHandlers?: ZLinkChannelPublishHandlerRegistration[];
   subscriptions?: string[];
@@ -1607,7 +1609,6 @@ interface MutableClientCapabilityOptions {
 }
 
 interface MutablePublisherCapabilityOptions {
-  sendTimeoutMs?: number;
   bind?: string;
   bindHost?: string;
   advertiseHost?: string;
@@ -1668,11 +1669,6 @@ interface MutableSpotNodeOptions {
   routeSendHandlers?: Array<{ packetName: string; handlerType: Type }>;
   routeRequestHandlers?: Array<{ packetName: string; handlerType: Type }>;
   requestTimeoutMs?: number;
-  publisherConfig?: {
-    sendHighWaterMark?: number;
-    sendTimeoutMs?: number;
-    lingerMs?: number;
-  };
 }
 
 interface MutableObjectFactoryRegistration<T, TImplementation = T, TOptions = unknown> {

package/src/contracts/Configuration/RegistrationTypes.ts

@@ -166,6 +166,7 @@ export interface ZLinkChannelOptions {
   readonly routingId?: string;
   readonly routingIdPrefix?: string;
   readonly noDrop?: boolean;
+  readonly sendTimeoutMs?: number;
   readonly requestTimeoutMs?: number;
   readonly client?: ZLinkClientCapabilityOptions;
   readonly publisher?: ZLinkPublisherCapabilityOptions;
@@ -196,7 +197,6 @@ export interface ZLinkClientCapabilityOptions {
 }
 
 export interface ZLinkPublisherCapabilityOptions {
-  readonly sendTimeoutMs?: number;
   readonly bind?: string;
   readonly bindHost?: string;
   readonly advertiseHost?: string;
@@ -297,11 +297,6 @@ export interface ZLinkSpotNodeOptions {
   readonly routeSendHandlers?: readonly ZLinkRouteMeshSendHandlerRegistration[];
   readonly routeRequestHandlers?: readonly ZLinkRouteMeshRequestHandlerRegistration[];
   readonly requestTimeoutMs?: number;
-  readonly publisherConfig?: {
-    readonly sendHighWaterMark?: number;
-    readonly sendTimeoutMs?: number;
-    readonly lingerMs?: number;
-  };
   readonly entrySpotTimerHandlers?: readonly ZLinkEntrySpotTimerHandlerRegistration[];
   readonly entrySpotPacketHandlers?: readonly ZLinkEntrySpotPacketHandlerRegistration[];
   readonly entrySpotSubscriptionHandlers?: readonly ZLinkEntrySpotSubscriptionHandlerRegistration[];

package/src/contracts/Configuration/RegistrationValidators.ts

@@ -217,9 +217,12 @@ function validateChannelCapabilities(
     if (channel.noDrop !== undefined && typeof channel.noDrop !== 'boolean') {
       throw new ZLinkConfigurationException(`Channel '${channelName}' NoDrop must be a boolean.`);
     }
-    if (channel.noDrop !== undefined && channel.publisher === undefined) {
+    if (
+      (channel.noDrop !== undefined || channel.sendTimeoutMs !== undefined) &&
+      channel.publisher === undefined
+    ) {
       throw new ZLinkConfigurationException(
-        `Channel '${channelName}' NoDrop requires a publisher role.`
+        `Channel '${channelName}': NoDrop and send timeout require the publisher role.`
       );
     }
     if (channel.server !== undefined) {
@@ -235,11 +238,11 @@ function validateChannelCapabilities(
       requirePeerWeight(`channel '${channelName}' server weight`, channel.server.weight);
       requireSocketOptions(`channel '${channelName}' server`, channel.server);
     }
+    requireValidSendTimeoutMs(
+      `channel '${channelName}' publisher sendTimeoutMs`,
+      channel.sendTimeoutMs
+    );
     if (channel.publisher !== undefined) {
-      requireValidSendTimeoutMs(
-        `channel '${channelName}' publisher sendTimeoutMs`,
-        channel.publisher.sendTimeoutMs
-      );
       requireEndpoint(`channel '${channelName}' publisher`, channel.publisher.bind);
       validateListenerNetworkIdentity(
         `channel '${channelName}' publisher`,
@@ -345,10 +348,6 @@ function validateSpotNodes(registration: ZLinkFrameworkRegistration): void {
       `SpotNode '${spotNodeName}' instanceSpotIdleTimeoutMs`,
       spotNode.instanceSpotIdleTimeoutMs
     );
-    requireValidSendTimeoutMs(
-      `SpotNode '${spotNodeName}' publisher sendTimeoutMs`,
-      spotNode.publisherConfig?.sendTimeoutMs
-    );
     validateSpotNodeFactories(spotNodeName, spotNode);
     validateSpotNodeTimers(spotNode);
     if (

package/src/contracts/Configuration/index.ts

@@ -20,12 +20,7 @@ export type {
   ZLinkStreamSocketConfig,
   ZLinkStreamNodeBuilder
 } from './Builders';
-export type {
-  ZLinkOutboundRouteConfig,
-  ZLinkRouteConfig,
-  ZLinkSocketConfig,
-  ZLinkSpotPublisherConfig
-} from './Configs';
+export type { ZLinkOutboundRouteConfig, ZLinkRouteConfig, ZLinkSocketConfig } from './Configs';
 export * from './Connections';
 export * from './ObjectRoles';
 export type {