@zlink-systems/framework 0.29.0 → 0.30.0

package/dist/contracts/Configuration/Builders.d.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, ZLinkUserSpotFactoryBuilder } from './ObjectRoles';
 import type { ZLinkRequestHandler, ZLinkRouteRequestHandler, ZLinkRouteSendHandler, ZLinkSendHandler } from '../Handlers';
 export interface ZLinkFrameworkOptions {
@@ -96,7 +95,6 @@ export interface ZLinkMeshNodeBuilder {
     setActivationConcurrency(limit: number): this;
     setInstanceSpotIdleTimeout(timeoutMs: number): this;
     configureRouterSocket(): ZLinkMeshNodeSocketConfig;
-    configureSpotPublisher(): ZLinkSpotPublisherConfig;
     peerConnections(): ZLinkMeshPeerConnections;
     setDefaultRequestTimeout(timeoutMs: number): this;
     objects(): ZLinkMeshObjectRoleBuilder;
@@ -136,6 +134,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/dist/contracts/Configuration/Configs.d.ts

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

package/dist/contracts/Configuration/RegistrationBuilders.js

@@ -10,6 +10,7 @@ const ConfigurationException_1 = require("./ConfigurationException");
 const DiagnosticsValidation_1 = require("./DiagnosticsValidation");
 const EndpointNotation_1 = require("./EndpointNotation");
 const FanoutTopic_1 = require("./FanoutTopic");
+const SendTimeoutValidation_1 = require("./SendTimeoutValidation");
 const InternalDefaults_1 = require("./InternalDefaults");
 const ObjectRoles_1 = require("./ObjectRoles");
 const RegistrationBuilderPolicy_1 = require("./RegistrationBuilderPolicy");
@@ -374,6 +375,11 @@ class DefaultFanoutChannelBuilder {
         this.channel.noDrop = noDrop;
         return this;
     }
+    setSendTimeout(timeoutMs) {
+        (0, SendTimeoutValidation_1.requireValidSendTimeoutMs)(`Fanout channel '${this.name}' send timeout`, timeoutMs);
+        this.channel.sendTimeoutMs = timeoutMs;
+        return this;
+    }
     enableSubscriber(endpoint) {
         this.selectSubscriberMode(endpoint === undefined ? 'automatic' : 'manual');
         this.channel.subscriber ??= { manualConnections: [] };
@@ -758,10 +764,6 @@ class DefaultMeshNodeBuilder {
         this.node.router ??= {};
         return this.node.router;
     }
-    configureSpotPublisher() {
-        this.node.publisherConfig ??= {};
-        return this.node.publisherConfig;
-    }
     peerConnections() {
         this.node.router ??= {};
         return new DefaultMeshPeerConnections(this.node.router);

package/dist/contracts/Configuration/RegistrationTypes.d.ts

@@ -139,6 +139,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;
@@ -167,7 +168,6 @@ export interface ZLinkClientCapabilityOptions {
     readonly maxMessageSize?: number;
 }
 export interface ZLinkPublisherCapabilityOptions {
-    readonly sendTimeoutMs?: number;
     readonly bind?: string;
     readonly bindHost?: string;
     readonly advertiseHost?: string;
@@ -243,11 +243,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/dist/contracts/Configuration/RegistrationValidators.js

@@ -155,8 +155,9 @@ function validateChannelCapabilities(channels, peerLocationConfigured) {
         if (channel.noDrop !== undefined && typeof channel.noDrop !== 'boolean') {
             throw new ConfigurationException_1.ZLinkConfigurationException(`Channel '${channelName}' NoDrop must be a boolean.`);
         }
-        if (channel.noDrop !== undefined && channel.publisher === undefined) {
-            throw new ConfigurationException_1.ZLinkConfigurationException(`Channel '${channelName}' NoDrop requires a publisher role.`);
+        if ((channel.noDrop !== undefined || channel.sendTimeoutMs !== undefined) &&
+            channel.publisher === undefined) {
+            throw new ConfigurationException_1.ZLinkConfigurationException(`Channel '${channelName}': NoDrop and send timeout require the publisher role.`);
         }
         if (channel.server !== undefined) {
             requireEndpoint(`channel '${channelName}' server`, channel.server.bind);
@@ -167,8 +168,8 @@ function validateChannelCapabilities(channels, peerLocationConfigured) {
             requirePeerWeight(`channel '${channelName}' server weight`, channel.server.weight);
             requireSocketOptions(`channel '${channelName}' server`, channel.server);
         }
+        (0, SendTimeoutValidation_1.requireValidSendTimeoutMs)(`channel '${channelName}' publisher sendTimeoutMs`, channel.sendTimeoutMs);
         if (channel.publisher !== undefined) {
-            (0, SendTimeoutValidation_1.requireValidSendTimeoutMs)(`channel '${channelName}' publisher sendTimeoutMs`, channel.publisher.sendTimeoutMs);
             requireEndpoint(`channel '${channelName}' publisher`, channel.publisher.bind);
             validateListenerNetworkIdentity(`channel '${channelName}' publisher`, channel.publisher.bindHost, channel.publisher.advertiseHost);
             validateFanoutPublisherIdentity(channelName, channel.routingId, channel.routingIdPrefix, peerLocationConfigured);
@@ -220,7 +221,6 @@ function validateSpotNodes(registration) {
         }
         validateSpotNodeCapability(`SpotNode '${spotNodeName}' pubSub`, spotNode.pubSub);
         requireNonNegativeSafeInteger(`SpotNode '${spotNodeName}' instanceSpotIdleTimeoutMs`, spotNode.instanceSpotIdleTimeoutMs);
-        (0, SendTimeoutValidation_1.requireValidSendTimeoutMs)(`SpotNode '${spotNodeName}' publisher sendTimeoutMs`, spotNode.publisherConfig?.sendTimeoutMs);
         validateSpotNodeFactories(spotNodeName, spotNode);
         validateSpotNodeTimers(spotNode);
         if (spotNode.objectRole === 'client' &&

package/dist/contracts/Configuration/index.d.ts

@@ -1,5 +1,5 @@
 export type { ZLinkClientServerChannelClientBuilder, ZLinkClientServerChannelRoleBuilder, ZLinkClientServerChannelServerBuilder, ZLinkFanoutChannelBuilder, ZLinkFrameworkOptions, ZLinkMeshChannelBuilder, ZLinkMeshChannelClientBuilder, ZLinkMeshChannelServerBuilder, ZLinkMeshObjectClientBuilder, ZLinkMeshObjectRoleBuilder, ZLinkMeshObjectServerBuilder, ZLinkMeshNodeBuilder, ZLinkMeshNodeSocketConfig, ZLinkMeshPeerConnection, ZLinkMeshPeerConnections, ZLinkNetworkOptions, ZLinkMetadataPolicyBuilder, ZLinkStreamCompressionBuilder, 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 { ZLinkApplicationJobQueueOptions, ZLinkCoreHwmOptions, ZLinkWorkerOptions } from './RegistrationTypes';

package/dist/internal.d.ts

@@ -1,5 +1,6 @@
 /** Test and companion-package integration surface. It is not exported by package.json. */
 export * from './index';
+export { requireValidSendTimeoutMs } from './contracts/Configuration/SendTimeoutValidation';
 export * from './runtime/diagnostics';
 export * from './runtime/host';
 export * from './runtime/admission';

package/dist/internal.js

@@ -14,9 +14,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.requirePublicWeight = exports.isValidCapacity = exports.isValidListenerPort = exports.isValidPositiveCapacity = exports.isValidPublicWeight = exports.ZLINK_MAX_CAPACITY = exports.ZLINK_MAX_PUBLIC_WEIGHT = exports.MAX_LISTENER_PORT = exports.ZLINK_MAX_STABLE_TYPE_BYTES = exports.ZLINK_RELOCATION_MAX_BLOB_REFERENCE_BYTES = exports.ZLinkLocationWriteStatus = exports.ZLinkLocationWriteIntent = exports.ZLinkRouteKind = exports.ZLinkLocationKind = exports.ZLinkLocationAutoConnectType = void 0;
+exports.requirePublicWeight = exports.isValidCapacity = exports.isValidListenerPort = exports.isValidPositiveCapacity = exports.isValidPublicWeight = exports.ZLINK_MAX_CAPACITY = exports.ZLINK_MAX_PUBLIC_WEIGHT = exports.MAX_LISTENER_PORT = exports.ZLINK_MAX_STABLE_TYPE_BYTES = exports.ZLINK_RELOCATION_MAX_BLOB_REFERENCE_BYTES = exports.ZLinkLocationWriteStatus = exports.ZLinkLocationWriteIntent = exports.ZLinkRouteKind = exports.ZLinkLocationKind = exports.ZLinkLocationAutoConnectType = exports.requireValidSendTimeoutMs = void 0;
 /** Test and companion-package integration surface. It is not exported by package.json. */
 __exportStar(require("./index"), exports);
+var SendTimeoutValidation_1 = require("./contracts/Configuration/SendTimeoutValidation");
+Object.defineProperty(exports, "requireValidSendTimeoutMs", { enumerable: true, get: function () { return SendTimeoutValidation_1.requireValidSendTimeoutMs; } });
 __exportStar(require("./runtime/diagnostics"), exports);
 __exportStar(require("./runtime/host"), exports);
 __exportStar(require("./runtime/admission"), exports);

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

@@ -1,5 +1,6 @@
 import { type ActorRef, type RoutingId } from '../../contracts';
 import type { Message } from '../../contracts/Common/Message';
+import type { ApplicationJobOrigin } from '../application-jobs/contracts';
 import type { ZLinkMessageFollowOrigin } from '../foundation/service-runtime-contracts';
 import { ZLinkFrameworkInternalErrorKind } from '../framework-errors-internal';
 import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
@@ -56,7 +57,7 @@ export interface ZLinkActorHandoffPreparedReplayAdmission {
     run<T>(operation: () => Promise<T>): Promise<T>;
     cancel(): void;
 }
-export type ZLinkActorHandoffReplayPreparation = (signal: AbortSignal) => Promise<ZLinkActorHandoffPreparedReplayAdmission>;
+export type ZLinkActorHandoffReplayPreparation = (signal: AbortSignal, origin: ApplicationJobOrigin) => Promise<ZLinkActorHandoffPreparedReplayAdmission>;
 export interface ZLinkActorHandoffPrefixAdmission {
     /** Completes after every child callback reaches its real terminal. */
     readonly terminal: Promise<void>;
@@ -141,7 +142,7 @@ export declare class ZLinkActorHandoffCoordinator {
      */
     failPending(actorId: string, reason: unknown): void;
     cancel(actorId: string): void;
-    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;
     snapshot(actorId: string): readonly ZLinkActorHandoffPacket[];
     snapshotCoreBacklog(actorId: string): readonly ZLinkActorHandoffPacket[];
     /**

package/dist/runtime/actors/actor-handoff.js

@@ -247,7 +247,7 @@ class ZLinkActorHandoffCoordinator {
                     try {
                         await waitForHandoffReplayStart(release.start, signal);
                         if (release.preparation !== undefined) {
-                            const next = await release.preparation(signal);
+                            const next = await release.preparation(signal, pending.origin);
                             if (signal.aborted) {
                                 next.cancel();
                                 throw signal.reason;
@@ -422,7 +422,7 @@ class ZLinkActorHandoffCoordinator {
             pending.reject?.(error);
         }
     }
-    capture(actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, deadlineUnixMs, messageFollowOrigin, provisionalReplay) {
+    capture(origin, actorId, parts, returnResponse = false, remoteBoundSessionTarget, fallbackActorRef, deadlineUnixMs, messageFollowOrigin, provisionalReplay) {
         const incomingContext = (0, actor_message_follow_context_1.actorMessageFollowContext)(fallbackActorRef);
         const originalDeadlineUnixMs = deadlineUnixMs ?? incomingContext?.deadlineUnixMs ?? packetDeadlineUnixMs(parts);
         const handoff = this.active.get(actorId);
@@ -456,7 +456,7 @@ class ZLinkActorHandoffCoordinator {
                 this.reportRequestFrame(actorId, packet);
             }
             if (!returnResponse) {
-                handoff.pending.push({ packet });
+                handoff.pending.push({ packet, origin });
                 // The durable handoff now owns this record. Return the ingress permit
                 // before waiting for a later replay, which must acquire its own fresh
                 // application-job permit.
@@ -494,7 +494,12 @@ class ZLinkActorHandoffCoordinator {
                 }, RELOCATION_REPLY_RETENTION_MS);
                 route.deadline.unref();
                 this.replyRoutes.set(source.replyRouteId, route);
-                handoff.pending.push({ packet: requestPacket, resolve, reject });
+                handoff.pending.push({
+                    packet: requestPacket,
+                    origin,
+                    resolve,
+                    reject
+                });
             });
             (0, application_job_queue_scope_1.releaseApplicationJobPermitForDurableHandoff)();
             if (handoff.prefixRelease !== undefined) {

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

@@ -27,6 +27,7 @@ export interface ZLinkActorManagerOptions {
     readonly actorRefResolver?: ZLinkActorRuntimeLocationLookup;
     readonly actorCreatedNotifier?: (nodeRid: RoutingId, actor: ZLinkActor, createRequest: ZLinkMessage, signal?: AbortSignal) => Promise<ZLinkActorCreateResponse | undefined>;
     readonly actorDestroyedCleanup?: (actorId: string) => void;
+    readonly terminateActorActivation?: (actor: ZLinkActor, terminal: () => Promise<void>) => Promise<void>;
     readonly publishActorAuthority?: (actorType: string, actorRef: ActorRef, ownerNodeGeneration: bigint, signal?: AbortSignal) => Promise<void>;
     readonly locationLifecycle?: ZLinkLocationLifecycle;
     readonly boundSessionFactory?: ZLinkActorBoundSessionFactory;

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

@@ -55,6 +55,8 @@ export declare class DefaultZLinkActorManager implements ZLinkActorManager {
     completeCoreRelocationSource(actorId: string): Promise<void>;
     private finalizeActorState;
     private finalizeDestroyedActor;
+    private terminateActor;
+    private awaitActorDestroy;
     getOrCreateActor(actorId: string, actorType: string, signal?: AbortSignal): Promise<ZLinkActor>;
     getOrCreateWithNativeRef(actorId: string, actorType: string, actorRef: ZLinkBackendActorRef, createRequest?: unknown, signal?: AbortSignal): Promise<ZLinkActor>;
     getOrCreateActorResult(actorId: string, actorType: string, createRequest?: unknown, signal?: AbortSignal): Promise<ZLinkActorLocalCreateResult>;

package/dist/runtime/actors/index.js

@@ -11,6 +11,7 @@ const runtime_metrics_1 = require("../diagnostics/runtime-metrics");
 const execution_1 = require("../execution");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const handler_instance_scope_1 = require("../handlers/handler-instance-scope");
+const actor_execution_context_1 = require("./actor-execution-context");
 const payload_codec_1 = require("../messaging/payload-codec");
 const actor_creation_1 = require("./actor-creation");
 const actor_runtime_state_1 = require("./actor-runtime-state");
@@ -139,7 +140,7 @@ class DefaultZLinkActorManager {
         const entryNodeRid = state.entryNodeRid ?? current.nodeRid;
         if (node === undefined || completions === undefined)
             return false;
-        const destroyTask = state.getOrStartDestroy(entryNodeRid, async (nativeRef) => {
+        const destroyTask = state.getOrStartDestroy(entryNodeRid, (nativeRef) => this.terminateActor(state, async () => {
             if (nativeRef !== undefined) {
                 const completion = await completions.submit(() => node.destroyActor(nativeRef, 0), signal);
                 try {
@@ -161,9 +162,9 @@ class DefaultZLinkActorManager {
                 await this.options.locationLifecycle?.releaseActor(state.actorType, actor.actorId, current);
             }
             await this.finalizeDestroyedActor(actor.actorId, state);
-        });
+        }));
         try {
-            await destroyTask;
+            await this.awaitActorDestroy(state, destroyTask);
         }
         catch (error) {
             state.clearFailedDestroy(destroyTask);
@@ -381,6 +382,20 @@ class DefaultZLinkActorManager {
             this.options.metrics?.change(runtime_metrics_1.METRIC_NAMES.ActorCount, -1);
         }
     }
+    terminateActor(state, terminal) {
+        const actor = state.actor;
+        const completion = actor === undefined || this.options.terminateActorActivation === undefined
+            ? terminal()
+            : this.options.terminateActorActivation(actor, terminal);
+        return completion;
+    }
+    awaitActorDestroy(state, completion) {
+        if ((0, actor_execution_context_1.currentZLinkActorExecution)()?.actorId === state.actorId) {
+            this.detachedTaskRunner.runDetached('Actor terminal cleanup', () => completion);
+            return Promise.resolve();
+        }
+        return completion;
+    }
     async getOrCreateActor(actorId, actorType, signal) {
         this.rememberActorMeshFromType(actorId, actorType);
         const result = await this.createOrGet(actorId, actorType, false, undefined, signal);
@@ -429,7 +444,7 @@ class DefaultZLinkActorManager {
         if (state.isJoined) {
             throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.ActorRouteNotFound, `Actor '${actor.context.actorId}' must leave its current SPOT before destroy.`);
         }
-        const destroyTask = state.getOrStartDestroy(entryNodeRid, async (actorRef) => {
+        const destroyTask = state.getOrStartDestroy(entryNodeRid, (actorRef) => this.terminateActor(state, async () => {
             const destroyedActorRef = actorRef === undefined ? undefined : (0, actor_runtime_state_1.toFrameworkActorRef)(actorRef, state.meshName ?? '');
             if (actorRef !== undefined) {
                 await node.destroyActor(actorRef, 0, destroySignal);
@@ -439,9 +454,9 @@ class DefaultZLinkActorManager {
                 await this.options.locationLifecycle?.releaseActor(state.actorType, actor.context.actorId, destroyedActorRef);
             }
             await this.finalizeDestroyedActor(actor.context.actorId, state);
-        });
+        }));
         try {
-            await destroyTask;
+            await this.awaitActorDestroy(state, destroyTask);
         }
         catch (error) {
             state.clearFailedDestroy(destroyTask);

package/dist/runtime/application-jobs/application-ingress-record-owner.d.ts

@@ -1,4 +1,4 @@
-import type { ApplicationJobPermitPort, ApplicationJobQueuePort } from './contracts';
+import type { ApplicationJobOrigin, ApplicationJobPermitPort, ApplicationJobQueuePort } from './contracts';
 export type ApplicationJobRecordDomain = 'application' | 'infrastructure';
 export interface IngressRecordPort {
     close(): void;
@@ -30,6 +30,7 @@ export declare class ApplicationJobRecordLease implements ApplicationJobPermitPo
     private detachedForHandlerTurn;
     private jobReleased;
     constructor(shared: SharedIngressRecordState, permit: ApplicationJobPermitPort);
+    get origin(): ApplicationJobOrigin;
     markApplicationQueued(): void;
     detachForHandlerTurn(): void;
     releaseBeforeHandler(): void;
@@ -45,6 +46,7 @@ declare class SharedIngressRecordState {
     private jobCount;
     private initialPermit?;
     private recordClosed;
+    readonly origin: ApplicationJobOrigin;
     constructor(queue: ApplicationJobQueuePort, initialPermit: ApplicationJobPermitPort, record: IngressRecordPort);
     retainOwner(): void;
     releaseOwner(): void;

package/dist/runtime/application-jobs/application-ingress-record-owner.js

@@ -68,6 +68,9 @@ class ApplicationJobRecordLease {
         this.shared = shared;
         this.permit = permit;
     }
+    get origin() {
+        return this.shared.origin;
+    }
     markApplicationQueued() {
         // The owner classifies and marks the child atomically when it is created;
         // downstream dispatch must not mutate queue accounting a second time.
@@ -114,9 +117,11 @@ class SharedIngressRecordState {
     jobCount = 0;
     initialPermit;
     recordClosed = false;
+    origin;
     constructor(queue, initialPermit, record) {
         this.queue = queue;
         this.record = record;
+        this.origin = initialPermit.origin;
         this.initialPermit = initialPermit;
     }
     retainOwner() {
@@ -138,7 +143,7 @@ class SharedIngressRecordState {
         return this.createJob(permit, domain);
     }
     acquirePermit(signal) {
-        return this.queue.acquire(signal);
+        return this.queue.acquire(signal, this.origin);
     }
     createJob(permit, domain) {
         this.jobCount += 1;

package/dist/runtime/application-jobs/application-job-queue-scope.d.ts

@@ -1,4 +1,4 @@
-import type { ApplicationJobPermitPort } from './contracts';
+import type { ApplicationJobOrigin, ApplicationJobPermitPort } from './contracts';
 /**
  * Carries the host-owned queue permit through internal async dispatch without
  * leaking capacity ownership into public handler contracts.
@@ -8,6 +8,8 @@ export declare function runWithApplicationJobPermit<TResult>(permit: Application
 export declare function releaseApplicationJobPermitBeforeHandler(): void;
 /** True while dispatch already owns the host-wide application job permit. */
 export declare function hasApplicationJobPermit(): boolean;
+/** Keeps the ingress origin when a durable record later reacquires its permit. */
+export declare function currentApplicationJobOrigin(): ApplicationJobOrigin;
 /** Re-enters the captured permit scope when a serial executor runs later. */
 export declare function bindApplicationJobPermit<TResult, TArgument>(callback: (argument?: TArgument) => Promise<TResult> | TResult): (argument?: TArgument) => Promise<TResult> | TResult;
 /**

package/dist/runtime/application-jobs/application-job-queue-scope.js

@@ -4,6 +4,7 @@ exports.runWithApplicationJobPermit = runWithApplicationJobPermit;
 exports.releaseApplicationJobPermitBeforeHandler = releaseApplicationJobPermitBeforeHandler;
 exports.releaseApplicationJobPermitForDurableHandoff = releaseApplicationJobPermitForDurableHandoff;
 exports.hasApplicationJobPermit = hasApplicationJobPermit;
+exports.currentApplicationJobOrigin = currentApplicationJobOrigin;
 exports.bindApplicationJobPermit = bindApplicationJobPermit;
 exports.detachApplicationJobPermit = detachApplicationJobPermit;
 const node_async_hooks_1 = require("node:async_hooks");
@@ -36,6 +37,10 @@ function releaseApplicationJobPermitForDurableHandoff() {
 function hasApplicationJobPermit() {
     return applicationJobPermitScope.getStore() !== undefined;
 }
+/** Keeps the ingress origin when a durable record later reacquires its permit. */
+function currentApplicationJobOrigin() {
+    return applicationJobPermitScope.getStore().permit.origin;
+}
 /** Re-enters the captured permit scope when a serial executor runs later. */
 function bindApplicationJobPermit(callback) {
     const scope = applicationJobPermitScope.getStore();

package/dist/runtime/application-jobs/contracts.d.ts

@@ -1,4 +1,6 @@
+export type ApplicationJobOrigin = 'local' | 'remote';
 export interface ApplicationJobPermitPort {
+    readonly origin: ApplicationJobOrigin;
     markApplicationQueued(): void;
     /** Transfers ingress-record cleanup to a detached exact-target handler turn. */
     detachForHandlerTurn?(): void;
@@ -6,7 +8,9 @@ export interface ApplicationJobPermitPort {
     releaseAfterInternalProcessing(): void;
 }
 export interface ApplicationJobQueuePort {
-    acquire(signal?: AbortSignal): Promise<ApplicationJobPermitPort>;
+    acquire(signal: AbortSignal | undefined, origin: ApplicationJobOrigin): Promise<ApplicationJobPermitPort>;
+    /** Returns a grant now, or registers one FIFO waiter that later calls resume. */
+    acquireOrResume(resume: (permit: ApplicationJobPermitPort) => void, reject: (reason: unknown) => void, signal: AbortSignal | undefined, origin: ApplicationJobOrigin): ApplicationJobPermitPort | undefined;
     registerReceiveFlowTarget?(identity: object, applyState: (state: 'running' | 'paused') => void, failureSink?: (error: unknown) => void): boolean;
     unregisterReceiveFlowTarget?(identity: object): void;
     pressureState?(): 'running' | 'paused';

package/dist/runtime/backend/contracts/index.d.ts

@@ -1,5 +1,5 @@
 import type { RequestResult, SubmitResult, ZLinkBackendMessageLike, ZLinkBackendMonitorEventType, ZLinkBackendReceived, ZLinkBackendTopicMessage } from '../runtime-values';
-import type { CoreHwmBudgetSnapshot } from '@zlink-systems/zlink';
+import type { CoreHwmBudgetSnapshot, ReceiveFlowState } from '@zlink-systems/zlink';
 import { type ZLinkBackendRecvFlags, type ZLinkBackendSendFlags } from '../runtime-values';
 export * from '../runtime-values';
 type MessageLike = ZLinkBackendMessageLike;
@@ -10,10 +10,11 @@ import type { MeshNodeStatus, MeshOperationId, MeshPeerEntry, MeshPublisher, Rea
 import type { RoutingId } from '../../../contracts';
 import type { ZLinkCoreHwmOptions } from '../../../contracts/Configuration';
 import type { ZLinkSubmitResult } from '../../messaging/submission-result';
+import type { ZLinkMeshCompletionHandler } from '../mesh-completion-table';
 import type { Message } from '../../../contracts/Common/Message';
 import type { ServiceSpotMessageFollowSeal, ServiceUserSpotOperationHandler, ServiceUserSpotOperationResult } from '../../foundation/service-stateful-runtime';
 import type { ServiceApplicationPayload } from '../../foundation/service-wire-m6a-codec';
-import type { ServiceActorCreateRecord, ServiceDirectSpotRouteFence, ServiceInstanceRouteFence, ServiceUserSpotCloseRecord, ServiceUserSpotCreateRecord } from '../../foundation/service-stateful-wire-codec';
+import type { ServiceActorCreateRecord, ServiceDirectSpotRouteFence, ServiceInstanceRouteFence, ServiceInstanceColdActivationTarget, ServiceUserSpotCloseRecord, ServiceUserSpotCreateRecord } from '../../foundation/service-stateful-wire-codec';
 export declare const ZLINK_BACKEND_SPOT_ROUTE_BRIDGE_ROUTE_WITH_CHANNEL_INBOUND = 3;
 export type ZLinkBackendMeshNodeStatus = MeshNodeStatus;
 export type ZLinkBackendMeshPeerEntry = MeshPeerEntry;
@@ -66,20 +67,8 @@ export interface ZLinkBackendMeshNode {
     }): void;
     selectObjectPlacement(stableType: string): ZLinkBackendObjectPlacement;
     instanceSpotPlacementTypes?(): readonly string[];
-    sendToMissingInstanceSpot(target: {
-        readonly targetNodeRid: string;
-        readonly targetNodeGeneration: bigint;
-        readonly targetSpotId: string;
-        readonly stableType: string;
-        readonly descriptorVersion: string;
-    }, parts: ZLinkBackendMessageLike | readonly ZLinkBackendMessageLike[], deadlineUnixMs: bigint, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): Promise<SubmitResult>;
-    requestToMissingInstanceSpot(target: {
-        readonly targetNodeRid: string;
-        readonly targetNodeGeneration: bigint;
-        readonly targetSpotId: string;
-        readonly stableType: string;
-        readonly descriptorVersion: string;
-    }, parts: ZLinkBackendMessageLike | readonly ZLinkBackendMessageLike[], deadlineUnixMs: bigint, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): MeshOperationId;
+    sendToMissingInstanceSpot(target: ServiceInstanceColdActivationTarget, parts: ZLinkBackendMessageLike | readonly ZLinkBackendMessageLike[], deadlineUnixMs: bigint, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): Promise<SubmitResult>;
+    requestToMissingInstanceSpot(target: ServiceInstanceColdActivationTarget, parts: ZLinkBackendMessageLike | readonly ZLinkBackendMessageLike[], deadlineUnixMs: bigint, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>): MeshOperationId;
     sendToInstanceSpot(route: ServiceInstanceRouteFence, parts: MessageLike | readonly MessageLike[], sourceSpotId?: string, metadata?: ReadonlyMap<string, string>, instanceIntent?: boolean): Promise<SubmitResult>;
     requestInstanceSpot(route: ServiceInstanceRouteFence, parts: MessageLike | readonly MessageLike[], timeoutMs?: number, sourceSpotId?: string, metadata?: ReadonlyMap<string, string>, instanceIntent?: boolean): MeshOperationId;
     registerUserSpotOperationHandler(handler: ServiceUserSpotOperationHandler): void;
@@ -215,6 +204,7 @@ export interface ZLinkBackendMeshNode {
     closeActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, timeoutMs?: number): MeshOperationId;
     leaveActor(actor: ZLinkBackendActorRef, expectedMembershipEpoch: bigint, timeoutMs?: number): MeshOperationId;
     setReadyHandler(handler: (readyDomains: number) => number): void;
+    setCompletionHandler(handler: ZLinkMeshCompletionHandler): void;
     createReadyBatch(capacity: number): ReadyBatch;
     createReceiveBatch(messageCapacity: number, partCapacity: number): ReceiveBatch;
     drainReady(domains: number, batch: ReadyBatch, flags?: number): {
@@ -278,7 +268,6 @@ export interface ZLinkBackendSocket extends ZLinkBackendObject {
     readonly lastEndpoint?: string;
     bind(endpoint: string): void;
     setChannelName(channelName: string): void;
-    setReceiveFlowState?(state: 0 | 1): void;
     dispose(): Promise<void>;
 }
 export interface ZLinkBackendConnectableSocket extends ZLinkBackendSocket {
@@ -286,7 +275,7 @@ export interface ZLinkBackendConnectableSocket extends ZLinkBackendSocket {
     disconnect(endpoint: string): void;
 }
 export interface ZLinkBackendDealerSocket extends ZLinkBackendConnectableSocket {
-    setReceiveFlowState(state: 0 | 1): void;
+    receiveAdmission?: import('../../foundation/service-liveness-registry').ServiceLivenessConnection;
     setRoutingId(routingId: RoutingId): void;
     peerWeight: number;
     sendHighWaterMark: number;
@@ -311,7 +300,7 @@ export interface ZLinkBackendRequestOperation {
     submit(): Promise<readonly Message[]>;
 }
 export interface ZLinkBackendRouterSocket extends ZLinkBackendConnectableSocket {
-    setReceiveFlowState(state: 0 | 1): void;
+    setReceiveFlowState(state: ReceiveFlowState): void;
     /** Enables the native probe handshake for manually configured routes. */
     setProbe(enabled: boolean): void;
     peerWeight: number;
@@ -330,6 +319,7 @@ export interface ZLinkBackendRouterSocket extends ZLinkBackendConnectableSocket
     reply(routingId: RoutingId, replyToken: unknown, message: Message | readonly Message[]): void;
 }
 export interface ZLinkBackendPublisherSocket extends ZLinkBackendSocket {
+    lingerMs: number;
     sendTimeoutMs: number;
     sendHighWaterMark: number;
     noDrop: boolean;
@@ -447,6 +437,7 @@ export interface ZLinkMeshBackendAdapter {
         readonly trustProfile?: string;
         readonly applicationJobQueue: import('../../application-jobs/contracts').ApplicationJobQueuePort;
         readonly applicationJobReceiveFlowFailureSink?: (error: unknown) => void;
+        readonly infrastructureTaskRunner?: import('../../spots/spot-actor-join-dispatch').ZLinkDetachedTaskRunner;
         readonly peerAdmissionSealed?: () => boolean;
     }): ZLinkBackendMeshNode;
 }

package/dist/runtime/backend/mesh-completion-table.d.ts

@@ -12,20 +12,22 @@ export interface ZLinkMeshCompletion {
     readonly kindData: ReceiveKindData | null;
     readonly parts: Message[];
 }
+export type ZLinkMeshCompletionTerminal = Pick<ReceiveRecord, 'operationId' | 'terminalResult'>;
+export type ZLinkMeshCompletionHandler = (terminal: ZLinkMeshCompletionTerminal, materialize: () => ReceiveRecord) => void;
 export declare class ZLinkMeshCompletionTable {
     private readonly onDiagnostic?;
     private readonly pending;
     private disposed;
     constructor(onDiagnostic?: ((diagnostic: ZLinkMeshCompletionDiagnostic) => void) | undefined);
     /**
-     * Submits and registers without yielding control to the event loop. Mesh
-     * completion dispatch is asynchronous, so a completion cannot overtake the
-     * registration. The table therefore does not need to retain responses that
-     * arrived before their waiter.
+     * Reserves the dispatcher slot before transport submission. The backend
+     * observes native terminals through Promises, so identity binding finishes
+     * before the terminal callback can run, without an infrastructure pump.
      */
     submit(operation: () => MeshOperationId, signal?: AbortSignal): Promise<ZLinkMeshCompletion>;
     private isDisposed;
     complete(record: ReceiveRecord): void;
+    complete(record: ZLinkMeshCompletionTerminal, materialize: () => ReceiveRecord): void;
     dispose(reason?: unknown): void;
     get pendingCount(): number;
 }

package/dist/runtime/backend/mesh-completion-table.js

@@ -12,10 +12,9 @@ class ZLinkMeshCompletionTable {
         this.onDiagnostic = onDiagnostic;
     }
     /**
-     * Submits and registers without yielding control to the event loop. Mesh
-     * completion dispatch is asynchronous, so a completion cannot overtake the
-     * registration. The table therefore does not need to retain responses that
-     * arrived before their waiter.
+     * Reserves the dispatcher slot before transport submission. The backend
+     * observes native terminals through Promises, so identity binding finishes
+     * before the terminal callback can run, without an infrastructure pump.
      */
     submit(operation, signal) {
         if (this.isDisposed()) {
@@ -24,17 +23,8 @@ class ZLinkMeshCompletionTable {
         if (signal?.aborted === true) {
             return Promise.reject(signal.reason ?? new DOMException('The operation was aborted.', 'AbortError'));
         }
-        const operationId = operation();
-        // The backend submission callback can synchronously re-enter `dispose()`.
-        // TypeScript's control-flow analysis cannot observe mutation through it.
-        if (this.disposed) {
-            return Promise.reject(new Error('Mesh completion table is disposed.'));
-        }
-        const key = (0, operation_identity_1.operationIdentityKey)(operationId);
-        if (this.pending.has(key)) {
-            return Promise.reject(new Error(`Mesh operation '${key}' is already pending.`));
-        }
         return new Promise((resolve, reject) => {
+            let key = Symbol();
             const abort = () => {
                 this.pending.delete(key);
                 reject(signal?.reason ?? new DOMException('The operation was aborted.', 'AbortError'));
@@ -44,17 +34,37 @@ class ZLinkMeshCompletionTable {
                 return;
             }
             signal?.addEventListener('abort', abort, { once: true });
-            this.pending.set(key, {
+            const entry = {
                 resolve,
                 reject,
                 removeAbort: signal === undefined ? undefined : () => signal.removeEventListener('abort', abort)
-            });
+            };
+            this.pending.set(key, entry);
+            try {
+                const operationId = operation();
+                // dispose/abort can consume the reserved slot during submission.
+                if (!this.pending.delete(key))
+                    return;
+                key = (0, operation_identity_1.operationIdentityKey)(operationId);
+                if (this.pending.has(key)) {
+                    throw new Error(`Mesh operation '${key}' is already pending.`);
+                }
+                this.pending.set(key, entry);
+            }
+            catch (error) {
+                // Remove only this submission's slot; a duplicate identity retains
+                // the original waiter.
+                if (this.pending.get(key) === entry)
+                    this.pending.delete(key);
+                entry.removeAbort?.();
+                reject(error);
+            }
         });
     }
     isDisposed() {
         return this.disposed;
     }
-    complete(record) {
+    complete(record, materialize) {
         const key = (0, operation_identity_1.operationIdentityKey)(record.operationId);
         const pending = this.pending.get(key);
         if (pending === undefined) {
@@ -68,7 +78,7 @@ class ZLinkMeshCompletionTable {
         this.pending.delete(key);
         pending.removeAbort?.();
         try {
-            pending.resolve(retainCompletion(record));
+            pending.resolve(retainCompletion(materialize === undefined ? record : materialize()));
         }
         catch (error) {
             pending.reject(error);