@zlink-systems/framework 0.25.0 → 0.26.0

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

@@ -210,7 +210,7 @@ export interface ZLinkBackendMeshNode {
         timeoutMs?: number;
         applicationMetadata?: Buffer;
     }): MeshOperationId;
-    sendActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, parts: MessageLike | readonly MessageLike[], flags?: number, actorFence?: ZLinkBackendActorSessionSendFence): Promise<SubmitResult>;
+    sendActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, parts: MessageLike | readonly MessageLike[], flags?: number): Promise<SubmitResult>;
     closeActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, timeoutMs?: number): MeshOperationId;
     leaveActor(actor: ZLinkBackendActorRef, expectedMembershipEpoch: bigint, timeoutMs?: number): MeshOperationId;
     setReadyHandler(handler: (readyDomains: number) => number): void;
@@ -237,14 +237,8 @@ export interface ZLinkBackendActorRef {
     readonly actorId: string;
     readonly generation: bigint;
 }
-export interface ZLinkBackendActorSessionSendFence {
-    readonly targetNodeGeneration: bigint;
-    readonly authorityOwnerGeneration: bigint;
-    readonly ownerLeaseGeneration: bigint;
-}
 export interface ZLinkBackendActorSessionNode {
-    actorNodeGeneration?(actor: ZLinkBackendActorRef): bigint | undefined;
-    sendActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, parts: readonly Message[], flags: number, actorFence?: ZLinkBackendActorSessionSendFence): Promise<ZLinkSubmitResult>;
+    sendActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, parts: readonly Message[], flags: number): Promise<ZLinkSubmitResult>;
     closeActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, timeoutMs: number, signal?: AbortSignal): Promise<void>;
 }
 export interface ZLinkBackendActorRecvInfo {
@@ -446,7 +440,6 @@ export interface ZLinkBackendSpot extends ZLinkBackendObject {
     recvActorLifecycle(flags: ZLinkBackendRecvFlags): unknown | null;
     drainReply(): number;
     drainChannelReply(subjectHandle: bigint): number;
-    recvRoute(result: Received, flags: ZLinkBackendRecvFlags): boolean;
     setDispatchHandler(handler: (info: ZLinkBackendSpotDispatchInfo) => void): void;
     requestToChannel(channelName: string, payload: Message | readonly Message[], timeoutMs?: number): Promise<readonly Message[]>;
     sendToChannel(channelName: string, payload: Message | readonly Message[]): Promise<void>;
@@ -486,7 +479,6 @@ export interface ZLinkMonitoringBackendAdapter {
     openSocketMonitor(socket: ZLinkBackendSocket): ZLinkBackendSocketMonitor;
 }
 export interface ZLinkBackendAdapterFactory {
-    createReceived(): Received;
     createTopicMessage(): TopicMessage;
     createChannelAdapter(): ZLinkChannelBackendAdapter;
     createMeshAdapter(): ZLinkMeshBackendAdapter;

package/dist/runtime/backend/mesh-actor-session-node-adapter.js

@@ -4,17 +4,10 @@ exports.meshActorSessionNodeAdapter = meshActorSessionNodeAdapter;
 const runtime_values_1 = require("./runtime-values");
 const submission_result_1 = require("../messaging/submission-result");
 const mesh_completion_table_1 = require("./mesh-completion-table");
-const routing_id_1 = require("../routing-id");
 function meshActorSessionNodeAdapter(node, completions) {
     return {
-        actorNodeGeneration(actor) {
-            const status = node.status();
-            return (0, routing_id_1.routingIdsEqual)(status.routingId, actor.nodeRid)
-                ? status.lifecycleGeneration
-                : undefined;
-        },
-        async sendActorBoundSession(actor, expectedBindingGeneration, parts, flags, actorFence) {
-            const result = await node.sendActorBoundSession(actor, expectedBindingGeneration, parts, flags, actorFence);
+        async sendActorBoundSession(actor, expectedBindingGeneration, parts, flags) {
+            const result = await node.sendActorBoundSession(actor, expectedBindingGeneration, parts, flags);
             switch (result) {
                 case runtime_values_1.SubmitResult.Ok:
                     return { status: submission_result_1.ZLinkSubmitStatus.Submitted };

package/dist/runtime/backend/node/node-backend-adapter-factory.d.ts

@@ -1,8 +1,7 @@
 import type { TopicMessage } from '@zlink-systems/zlink';
-import type { ZLinkBackendAdapterFactory, ZLinkBackendReceived, ZLinkChannelBackendAdapter, ZLinkMonitoringBackendAdapter, ZLinkStreamBackendAdapter } from '../contracts';
+import type { ZLinkBackendAdapterFactory, ZLinkChannelBackendAdapter, ZLinkMonitoringBackendAdapter, ZLinkStreamBackendAdapter } from '../contracts';
 import { ZLinkNodeMeshBackendAdapter } from './node-mesh-backend-adapter';
 export declare class ZLinkNodeBackendAdapterFactory implements ZLinkBackendAdapterFactory {
-    createReceived(): ZLinkBackendReceived;
     createTopicMessage(): TopicMessage;
     createChannelAdapter(): ZLinkChannelBackendAdapter;
     createMeshAdapter(): ZLinkNodeMeshBackendAdapter;

package/dist/runtime/backend/node/node-backend-adapter-factory.js

@@ -6,9 +6,6 @@ const node_monitor_backend_adapter_1 = require("./node-monitor-backend-adapter")
 const node_socket_backend_adapter_1 = require("./node-socket-backend-adapter");
 const node_mesh_backend_adapter_1 = require("./node-mesh-backend-adapter");
 class ZLinkNodeBackendAdapterFactory {
-    createReceived() {
-        return new node_backend_adapter_support_1.zlink.Received();
-    }
     createTopicMessage() {
         return new node_backend_adapter_support_1.zlink.TopicMessage();
     }
@@ -51,7 +48,8 @@ class ZLinkNodeChannelBackendAdapter {
 }
 class ZLinkNodeStreamBackendAdapter {
     createStreamSocket(context) {
-        const socket = node_backend_adapter_support_1.zlink.createStreamSocket(asNodeContext(context));
+        const nodeContext = asNodeContext(context);
+        const socket = node_backend_adapter_support_1.zlink.createStreamSocket(nodeContext);
         socket.options.recvMode = node_backend_adapter_support_1.zlink.StreamRecvMode.Packet;
         return (0, node_socket_backend_adapter_1.wrapSocket)(socket, true);
     }
@@ -93,20 +91,8 @@ class ZLinkNodeBackendContext {
         this.nativeInstance.resetCoreHwmBudgetMetrics();
     }
     async dispose() {
-        // Terminal cleanup shuts the context down before terminating it, the same
-        // sequence the .NET reference binding runs inside `Context.Dispose()`
-        // (`zlink_ctx_shutdown` then `zlink_ctx_term`). Without the shutdown signal
-        // termination can block forever waiting on the reaper even after every
-        // socket this runtime owns has been closed.
-        try {
-            this.nativeInstance.shutdown();
-        }
-        catch (error) {
-            if (!(0, node_backend_adapter_support_1.isContextTerminatedError)(error)) {
-                throw error;
-            }
-        }
-        await (0, node_backend_adapter_support_1.closeWithBusyRetry)(this.nativeInstance);
+        // Binding Context.close() shuts down and then terminates the native context.
+        (0, node_backend_adapter_support_1.closeBindingHandle)(this.nativeInstance);
     }
     close() {
         this.nativeInstance.close();

package/dist/runtime/backend/node/node-backend-adapter-support.d.ts

@@ -35,15 +35,18 @@ interface ZLinkBindingRequestSubmitOperation {
 }
 export declare function isBindingNotFound(error: unknown): boolean;
 export declare function isRouteRecvRetryable(error: unknown): boolean;
-export declare function isPollerInterruptedError(error: unknown): boolean;
 export declare function submitBindingPublish(operation: ZLinkBindingPublishOperation, payload: unknown): void;
 export declare function submitBindingReply(operation: ZLinkBindingReplyOperation, payload: unknown): void;
 export declare function submitBindingAsyncSend(operation: ZLinkBindingAsyncSendOperation, payload: unknown): Promise<void>;
 export declare function submitBindingSyncSend(operation: ZLinkBindingAsyncSendOperation, payload: unknown): void;
 export declare function submitBindingRequest(operation: ZLinkBindingRequestOperation, payload: unknown, timeoutMs: number | undefined): Promise<readonly unknown[]>;
-export declare function closeWithBusyRetry(target: {
+/**
+ * Closes a binding handle once. An already closed or terminated handle counts as
+ * closed. A busy close propagates to the caller.
+ */
+export declare function closeBindingHandle(target: {
     close(): void;
-}): Promise<void>;
+}): void;
 export declare function isContextTerminatedError(error: unknown): boolean;
 export declare function disableSocketLinger(target: unknown): void;
 export declare function toNativeRoutingId(routingId: unknown): unknown;

package/dist/runtime/backend/node/node-backend-adapter-support.js

@@ -3,13 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.zlink = void 0;
 exports.isBindingNotFound = isBindingNotFound;
 exports.isRouteRecvRetryable = isRouteRecvRetryable;
-exports.isPollerInterruptedError = isPollerInterruptedError;
 exports.submitBindingPublish = submitBindingPublish;
 exports.submitBindingReply = submitBindingReply;
 exports.submitBindingAsyncSend = submitBindingAsyncSend;
 exports.submitBindingSyncSend = submitBindingSyncSend;
 exports.submitBindingRequest = submitBindingRequest;
-exports.closeWithBusyRetry = closeWithBusyRetry;
+exports.closeBindingHandle = closeBindingHandle;
 exports.isContextTerminatedError = isContextTerminatedError;
 exports.disableSocketLinger = disableSocketLinger;
 exports.toNativeRoutingId = toNativeRoutingId;
@@ -32,9 +31,6 @@ function isRouteRecvRetryable(error) {
                 error.result === exports.zlink.RecvResult.InvalidHandle) &&
             isNativeBadAddress(error)));
 }
-function isPollerInterruptedError(error) {
-    return error instanceof exports.zlink.RecvError && error.nativeErrno === 4;
-}
 function isNativeBadAddress(error) {
     return error.nativeErrno === 14 || /Bad address/i.test(String(error.message ?? ''));
 }
@@ -126,30 +122,18 @@ async function submitBindingRequest(operation, payload, timeoutMs) {
         throw translateBindingResultError(error);
     }
 }
-async function closeWithBusyRetry(target) {
-    let lastError;
-    for (let attempt = 0; attempt < 8; attempt++) {
-        try {
-            target.close();
-            return;
-        }
-        catch (error) {
-            if (isSuccessfulOrAlreadyShutdownCloseError(error)) {
-                return;
-            }
-            if (!isBusyCloseError(error)) {
-                throw error;
-            }
-            lastError = error;
-            await new Promise((resolve) => setImmediate(resolve));
-        }
+/**
+ * Closes a binding handle once. An already closed or terminated handle counts as
+ * closed. A busy close propagates to the caller.
+ */
+function closeBindingHandle(target) {
+    try {
+        target.close();
+    }
+    catch (error) {
+        if (!isSuccessfulOrAlreadyShutdownCloseError(error))
+            throw error;
     }
-    throw lastError;
-}
-function isBusyCloseError(error) {
-    return (error instanceof Error &&
-        'code' in error &&
-        [401, 404].includes(error.code));
 }
 function isSuccessfulOrAlreadyShutdownCloseError(error) {
     return (isContextTerminatedError(error) ||

package/dist/runtime/backend/node/node-event-loop-poller.d.ts

@@ -9,7 +9,7 @@ export declare class ZLinkNodeEventLoopPoller {
     private readonly events;
     private readableHandler;
     private disposed;
-    constructor(socket: Socket, pollCompletion: boolean, readableHandler: () => void);
+    constructor(socket: Socket, pollCompletion: boolean, readableHandler: () => void, pollRoute?: boolean);
     setReadableHandler(handler: () => void): void;
     dispose(): void;
     private readonly onReady;

package/dist/runtime/backend/node/node-event-loop-poller.js

@@ -12,12 +12,16 @@ class ZLinkNodeEventLoopPoller {
     events = node_backend_adapter_support_1.zlink.createPollEvents(1);
     readableHandler;
     disposed = false;
-    constructor(socket, pollCompletion, readableHandler) {
+    constructor(socket, pollCompletion, readableHandler, pollRoute = false) {
         this.readableHandler = readableHandler;
         try {
             const pollEvents = [node_backend_adapter_support_1.zlink.PollEventFlag.PollIn];
             if (pollCompletion)
                 pollEvents.push(node_backend_adapter_support_1.zlink.PollEventFlag.PollCompletion);
+            // A ROUTER selected-route change (Core ROUTER §10.1) wakes the same
+            // handler, whose owner is the socket's one route observer.
+            if (pollRoute)
+                pollEvents.push(node_backend_adapter_support_1.zlink.PollEventFlag.PollRoute);
             this.poller.add(socket, pollEvents, 0);
             socket.setReadableHandler(this.onReady);
         }
@@ -41,7 +45,9 @@ class ZLinkNodeEventLoopPoller {
         if (this.disposed)
             return;
         const ready = this.poller.wait(this.events, 0);
-        if (ready === 0 || this.events.hasEvent(0, node_backend_adapter_support_1.zlink.PollEventFlag.PollIn)) {
+        if (ready === 0 ||
+            this.events.hasEvent(0, node_backend_adapter_support_1.zlink.PollEventFlag.PollIn) ||
+            this.events.hasEvent(0, node_backend_adapter_support_1.zlink.PollEventFlag.PollRoute)) {
             this.readableHandler();
         }
     };

package/dist/runtime/backend/node/node-raw-binding-port.d.ts

@@ -1,6 +1,6 @@
 import { type Context } from '@zlink-systems/zlink';
 import type { ZLinkRawBindingPort, ZLinkRawHostPort } from '../raw-binding-port';
-export type { ZLinkRawBindingPort, ZLinkRawDealerPort, ZLinkRawHostPort, ZLinkRawMonitorPort, ZLinkRawMonitorRecord, ZLinkRawReceivedRecord, ZLinkRawRouterPort, ZLinkRawSocketPort } from '../raw-binding-port';
+export type { ZLinkRawBindingPort, ZLinkRawDealerPort, ZLinkRawHostPort, ZLinkRawMonitorPort, ZLinkRawMonitorRecord, ZLinkRawReceivedRecord, ZLinkRawRouterPort, ZLinkRawRouterRoute, ZLinkRawSocketPort } from '../raw-binding-port';
 export declare class ZLinkNodeRawBindingPort implements ZLinkRawBindingPort {
     private readonly sharedContext?;
     private readonly routerReceiveTimeoutMs?;

package/dist/runtime/backend/node/node-raw-binding-port.js

@@ -85,9 +85,9 @@ class NodeRawSocketPort {
     monitors = new Set();
     eventLoopPoller;
     closed = false;
-    constructor(socket) {
+    constructor(socket, pollRoute = false) {
         this.socket = socket;
-        this.eventLoopPoller = new node_event_loop_poller_1.ZLinkNodeEventLoopPoller(socket, true, () => { });
+        this.eventLoopPoller = new node_event_loop_poller_1.ZLinkNodeEventLoopPoller(socket, true, () => { }, pollRoute);
     }
     setReadableHandler(handler) {
         this.requireOpen();
@@ -183,7 +183,7 @@ class NodeRawRouterPort extends NodeRawSocketPort {
         this.socket.disconnectRid(bindingRoutingId(routingId));
     }
     constructor(socket, receiveTimeoutMs) {
-        super(socket);
+        super(socket, true);
         socket.options.handover = true;
         socket.options.mandatory = true;
         socket.options.probe = true;
@@ -223,6 +223,13 @@ class NodeRawRouterPort extends NodeRawSocketPort {
             throw (0, node_backend_adapter_support_1.translateBindingResultError)(error);
         }
     }
+    routesSnapshot() {
+        this.requireOpen();
+        return this.socket.routesSnapshot().map((route) => ({
+            routingId: route.routingId.toString(),
+            routeGeneration: route.routeGeneration
+        }));
+    }
     receive(dontWait = false) {
         this.requireOpen();
         return receiveRecord(this.socket, dontWait, () => {
@@ -344,6 +351,7 @@ function receiveRecord(socket, dontWait, nextRequestSequence, reply) {
         return {
             sourceRid,
             sourceRoute,
+            routeGeneration: received.routeGeneration,
             ...(requestSeq === undefined ? {} : { requestSeq }),
             ...(receivedReply === undefined
                 ? {}

package/dist/runtime/backend/node/node-raw-mesh-backend.d.ts

@@ -4,13 +4,13 @@ import type { ZLinkDispatchErrorReporter } from '../../channels/dispatch-error-r
 import type { MeshOperationId, MeshPeerEntry, MeshPublisher, ReadyBatch, ReadyRecord, ReceiveBatch, ServiceSpot, StreamSessionService } from '../../foundation/service-runtime-contracts';
 import { type RawServiceRequestResult } from '../../foundation/raw-service-mesh-runtime';
 import { type ServiceApplicationPayload } from '../../foundation/service-wire-m6a-codec';
-import { type ServiceAsyncInstanceActivationAuthority, type ServiceInstanceApplicationLifecycle, type ServicePendingInstanceActivation, type ServiceSpotMessageFollowSeal, type ServiceUserSpotOperationHandler, type ServiceUserSpotOperationResult } from '../../foundation/service-stateful-runtime';
+import { ServiceStatefulRuntime, type ServiceAsyncInstanceActivationAuthority, type ServiceInstanceApplicationLifecycle, type ServicePendingInstanceActivation, type ServiceSpotMessageFollowSeal, type ServiceUserSpotOperationHandler, type ServiceUserSpotOperationResult } from '../../foundation/service-stateful-runtime';
 import type { ServiceActorRef, ServiceSpotState } from '../../foundation/service-stateful-registry';
 import type { ServiceActorCreateRecord, ServiceDirectSpotRouteFence, ServiceInstanceActivationTarget, ServiceInstanceRouteFence, ServiceSpotRouteFence, ServiceUserSpotCloseRecord, ServiceUserSpotCreateRecord } from '../../foundation/service-stateful-wire-codec';
 import type { ServiceInstanceActivationRecoveryEnvelope } from '../../foundation/service-instance-activation-recovery-codec';
 import type { ServiceNodeDescriptor } from '../../foundation/service-topology-registry';
 import type { RoutingId } from '../../../contracts';
-import type { ZLinkBackendActorRef, ZLinkBackendActorSessionSendFence, ZLinkBackendObjectPlacement, ZLinkBackendMeshNode } from '../contracts';
+import type { ZLinkBackendActorRef, ZLinkBackendObjectPlacement, ZLinkBackendMeshNode } from '../contracts';
 import type { ZLinkRawBindingPort } from '../raw-binding-port';
 import type { ApplicationJobQueuePort } from '../../application-jobs/contracts';
 /**
@@ -54,6 +54,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     private protocolError?;
     private messageFollowHandler?;
     private dispatchErrors?;
+    private spotAdmissionProvider?;
     private readonly peerDisconnectedHandlers;
     constructor(meshName: string, routingId: string | undefined, bindingPort: ZLinkRawBindingPort, applicationJobQueue?: ApplicationJobQueuePort | undefined, applicationJobReceiveFlowFailureSink?: ((error: unknown) => void) | undefined, peerAdmissionSealed?: (() => boolean) | undefined);
     configureObjectPlacement(options: {
@@ -69,6 +70,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
         readonly owner: string;
     }) => void): void;
     setDispatchErrorReporter(reporter: ZLinkDispatchErrorReporter): void;
+    setSpotAdmissionProvider(provider: Parameters<ServiceStatefulRuntime['setSpotAdmissionProvider']>[0]): void;
     setProtocolErrorHandler(handler: (record: {
         readonly sourceNodeRid: string;
         readonly request: boolean;
@@ -229,7 +231,7 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     actorRequestToActor(source: ZLinkBackendActorRef, target: ZLinkBackendActorRef, parts: MessageLike | readonly MessageLike[], options?: {
         readonly timeoutMs?: number;
     }): MeshOperationId;
-    sendActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, parts: MessageLike | readonly MessageLike[], _flags?: number, actorFence?: ZLinkBackendActorSessionSendFence): Promise<SubmitResultValue>;
+    sendActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, parts: MessageLike | readonly MessageLike[], _flags?: number): Promise<SubmitResultValue>;
     closeActorBoundSession(actor: ZLinkBackendActorRef, expectedBindingGeneration: bigint, timeoutMs?: number): MeshOperationId;
     leaveActor(actor: ZLinkBackendActorRef, expectedMembershipEpoch: bigint, timeoutMs?: number): MeshOperationId;
     createStreamSessionService(stream: unknown): StreamSessionService;
@@ -261,10 +263,11 @@ export declare class ZLinkNodeRawMeshBackend implements ZLinkBackendMeshNode {
     private requireNotStarted;
 }
 /**
- * Classifies a generic node/channel request rejection into a completion
- * terminal. Spec 32-framework-error-model:91-92 — a reply that could not be
- * decoded (ServiceWireProtocolError from the reply parser) is a protocol
- * failure, not connection loss; only genuine transport rejections collapse to
- * NotConnected.
+ * The one classification of a failed node/channel/stateful request into its
+ * completion terminal. A binding REQUEST result is Core's decision and is kept
+ * as is; a submit failure retains its Core meaning at the request boundary.
+ * A reply that could not be decoded is a protocol
+ * failure (spec 32-framework-error-model:91-92). The failure code is a wire
+ * code, so a Core result carries 0.
  */
-export declare function genericOperationFailure(error: unknown): RawServiceRequestResult;
+export declare function requestFailureResult(error: unknown): RawServiceRequestResult;

package/dist/runtime/backend/node/node-raw-mesh-backend.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkNodeRawMeshBackend = void 0;
-exports.genericOperationFailure = genericOperationFailure;
+exports.requestFailureResult = requestFailureResult;
 const node_crypto_1 = require("node:crypto");
 const promises_1 = require("node:timers/promises");
 const stream_wire_1 = require("@zlink-systems/stream-wire");
 const node_socket_backend_adapter_1 = require("./node-socket-backend-adapter");
+const node_backend_adapter_support_1 = require("./node-backend-adapter-support");
 const contracts_1 = require("../../../contracts");
 const framework_errors_internal_1 = require("../../framework-errors-internal");
 const zlink_1 = require("@zlink-systems/zlink");
@@ -25,7 +26,7 @@ const MULTIPART_PACKET_NAME = service_wire_constants_generated_1.SERVICE_FRAMEWO
 const MULTIPART_CONTENT_TYPE = service_wire_constants_generated_1.SERVICE_FRAMEWORK_MULTIPART_CONTENT_TYPE;
 const FATAL_UTF8 = new TextDecoder('utf-8', { fatal: true });
 const MAX_DRAIN_RECORDS = 64;
-// Preserve the existing monitor/admission/liveness cadence. Only the binding
+// Preserve the existing route observation/admission/liveness cadence. Only the binding
 // readable handler admits receive work; this timer never probes the socket.
 const MESH_BACKEND_MAINTENANCE_INTERVAL_MS = 1;
 /**
@@ -82,6 +83,7 @@ class ZLinkNodeRawMeshBackend {
     protocolError;
     messageFollowHandler;
     dispatchErrors;
+    spotAdmissionProvider;
     peerDisconnectedHandlers = new Set();
     constructor(meshName, routingId, bindingPort, applicationJobQueue, applicationJobReceiveFlowFailureSink, peerAdmissionSealed) {
         this.meshName = meshName;
@@ -114,6 +116,10 @@ class ZLinkNodeRawMeshBackend {
         this.dispatchErrors = reporter;
         this.stateful?.setDispatchErrorReporter(reporter, this.meshName);
     }
+    setSpotAdmissionProvider(provider) {
+        this.spotAdmissionProvider = provider;
+        this.stateful?.setSpotAdmissionProvider(provider);
+    }
     setProtocolErrorHandler(handler) {
         this.protocolError = handler;
     }
@@ -210,6 +216,9 @@ class ZLinkNodeRawMeshBackend {
         });
         runtime.start();
         this.stateful = new service_stateful_runtime_1.ServiceStatefulRuntime(runtime, descriptor.nodeRoutingId, descriptor.lifecycleGeneration);
+        if (this.spotAdmissionProvider !== undefined) {
+            this.stateful.setSpotAdmissionProvider(this.spotAdmissionProvider);
+        }
         if (this.dispatchErrors !== undefined) {
             this.stateful.setDispatchErrorReporter(this.dispatchErrors, this.meshName);
         }
@@ -688,8 +697,8 @@ class ZLinkNodeRawMeshBackend {
     actorRequestToActor(source, target, parts, options) {
         return this.observeStateful(service_runtime_contracts_1.OperationKind.ActorRequest, this.requireStateful().requestToActor(target, this.peerGeneration(String(target.nodeRid)), target.generation, encodeMultipart(parts), options?.timeoutMs ?? 30_000, source));
     }
-    async sendActorBoundSession(actor, expectedBindingGeneration, parts, _flags, actorFence) {
-        return (await this.requireStateful().sendBoundSession(actor, expectedBindingGeneration, encodeMultipart(parts), actorFence));
+    async sendActorBoundSession(actor, expectedBindingGeneration, parts, _flags) {
+        return (await this.requireStateful().sendBoundSession(actor, expectedBindingGeneration, encodeMultipart(parts)));
     }
     closeActorBoundSession(actor, expectedBindingGeneration, timeoutMs = 30_000) {
         const binding = this.requireStateful().registry.binding(actor);
@@ -804,12 +813,12 @@ class ZLinkNodeRawMeshBackend {
     }
     observeCompletion(low, operationKind, promise) {
         const id = { high: 1n, low };
-        void promise.then((result) => this.enqueueCompletion(id, operationKind, result), (error) => this.enqueueCompletion(id, operationKind, genericOperationFailure(error)));
+        void promise.then((result) => this.enqueueCompletion(id, operationKind, result), (error) => this.enqueueCompletion(id, operationKind, requestFailureResult(error)));
         return id;
     }
     observeStateful(operationKind, pending) {
         const id = { high: 2n, low: pending.id };
-        void pending.promise.then((result) => this.enqueueCompletion(id, operationKind, result), (error) => this.enqueueCompletion(id, operationKind, statefulOperationFailure(error)));
+        void pending.promise.then((result) => this.enqueueCompletion(id, operationKind, result), (error) => this.enqueueCompletion(id, operationKind, requestFailureResult(error)));
         return id;
     }
     enqueueImmediateFailure(operationKind, terminalResult) {
@@ -1519,38 +1528,61 @@ function readyDomain(domain) {
     return domain === 'infrastructure' ? service_runtime_contracts_1.ReadyDomain.Infrastructure : service_runtime_contracts_1.ReadyDomain.Application;
 }
 /**
- * Classifies a generic node/channel request rejection into a completion
- * terminal. Spec 32-framework-error-model:91-92 — a reply that could not be
- * decoded (ServiceWireProtocolError from the reply parser) is a protocol
- * failure, not connection loss; only genuine transport rejections collapse to
- * NotConnected.
+ * The one classification of a failed node/channel/stateful request into its
+ * completion terminal. A binding REQUEST result is Core's decision and is kept
+ * as is; a submit failure retains its Core meaning at the request boundary.
+ * A reply that could not be decoded is a protocol
+ * failure (spec 32-framework-error-model:91-92). The failure code is a wire
+ * code, so a Core result carries 0.
  */
-function genericOperationFailure(error) {
+function requestFailureResult(error) {
+    const failure = (0, node_backend_adapter_support_1.translateBindingResultError)(error);
+    if ((0, runtime_values_1.isZLinkBackendResultError)(failure)) {
+        return {
+            terminalResult: failure.operation === 'request' ? failure.result : submitFailureTerminal(failure.result),
+            failureCode: 0
+        };
+    }
     //  requestProtocolError(16): the schema terminal-failure-integrity rule
-    //  forbids a typed terminal (104) with failure none, so the synthesized
-    //  decode-failure pair is 104+16; genuine transport loss stays 109+0.
-    return error instanceof service_wire_m6a_codec_1.ServiceWireProtocolError
-        ? { terminalResult: zlink_1.RequestResult.ProtocolError, failureCode: 16 }
-        : { terminalResult: zlink_1.RequestResult.NotConnected, failureCode: 0 };
-}
-function statefulOperationFailure(error) {
-    if (error instanceof contracts_1.ZLinkFrameworkException) {
-        return (0, framework_errors_internal_1.internalFrameworkWireReply)(error);
+    //  forbids a typed terminal (104) with failure none.
+    if (failure instanceof service_wire_m6a_codec_1.ServiceWireProtocolError) {
+        return { terminalResult: zlink_1.RequestResult.ProtocolError, failureCode: 16 };
     }
-    if (error instanceof operation_registry_1.OperationTimeoutError) {
-        return { terminalResult: zlink_1.RequestResult.TimedOut, failureCode: 0 };
+    if (failure instanceof contracts_1.ZLinkFrameworkException) {
+        return (0, framework_errors_internal_1.internalFrameworkWireReply)(failure);
     }
-    if ((0, runtime_values_1.isZLinkBackendResultError)(error)) {
-        return {
-            terminalResult: error.result,
-            failureCode: error.nativeErrno ?? 0
-        };
+    if (failure instanceof operation_registry_1.OperationTimeoutError) {
+        return { terminalResult: zlink_1.RequestResult.TimedOut, failureCode: 0 };
     }
-    if (error instanceof operation_registry_1.OperationCancelledError) {
+    if (failure instanceof operation_registry_1.OperationCancelledError) {
         return { terminalResult: zlink_1.RequestResult.NotConnected, failureCode: 0 };
     }
     return { terminalResult: zlink_1.RequestResult.InternalError, failureCode: 17 };
 }
+function submitFailureTerminal(result) {
+    switch (result) {
+        case zlink_1.SubmitResult.Backpressured:
+            return zlink_1.RequestResult.Backpressured;
+        case zlink_1.SubmitResult.NotConnected:
+            return zlink_1.RequestResult.NotConnected;
+        case zlink_1.SubmitResult.NotFound:
+            return zlink_1.RequestResult.NotFound;
+        case zlink_1.SubmitResult.NotAdmitted:
+            return zlink_1.RequestResult.Rejected;
+        case zlink_1.SubmitResult.InvalidHandle:
+        case zlink_1.SubmitResult.InvalidArgument:
+        case zlink_1.SubmitResult.ThreadViolation:
+            return zlink_1.RequestResult.InvalidArgument;
+        case zlink_1.SubmitResult.InvalidState:
+            return zlink_1.RequestResult.InvalidState;
+        case zlink_1.SubmitResult.NotSupported:
+            return zlink_1.RequestResult.NotSupported;
+        case zlink_1.SubmitResult.Terminated:
+            return zlink_1.RequestResult.Terminated;
+        default:
+            return zlink_1.RequestResult.InternalError;
+    }
+}
 function encodeMultipart(parts) {
     const values = Array.isArray(parts) ? parts : [parts];
     if (values.length === 0)

package/dist/runtime/backend/node/node-socket-backend-adapter.js

@@ -20,7 +20,7 @@ function wrapSocket(nativeInstance, pollCompletion) {
         async dispose() {
             eventLoopPoller?.dispose();
             (0, node_backend_adapter_support_1.disableSocketLinger)(nativeInstance);
-            await (0, node_backend_adapter_support_1.closeWithBusyRetry)(nativeInstance);
+            (0, node_backend_adapter_support_1.closeBindingHandle)(nativeInstance);
         },
         close() {
             eventLoopPoller?.dispose();

package/dist/runtime/backend/raw-binding-port.d.ts

@@ -2,6 +2,11 @@ export interface ZLinkRawReceivedRecord {
     readonly sourceRid: string;
     readonly sourceRoute: Uint8Array;
     readonly requestSeq?: bigint;
+    /**
+     * Core selected-route generation of the ROUTER route that delivered this
+     * record (Core ROUTER §10.1); 0n for a non-ROUTER receive. Equality only.
+     */
+    readonly routeGeneration: bigint;
     readonly reply?: (parts: readonly Uint8Array[]) => void;
     readonly parts: readonly Buffer[];
     /** Releases the ordinary Framework-owned receive record exactly once. */
@@ -33,6 +38,11 @@ export interface ZLinkRawMonitorPort {
     statusReady(): boolean;
     close(): void;
 }
+/** One row of the ROUTER selected-route snapshot (Core ROUTER §10.1). */
+export interface ZLinkRawRouterRoute {
+    readonly routingId: string;
+    readonly routeGeneration: bigint;
+}
 export interface ZLinkRawRouterPort extends ZLinkRawSocketPort {
     disconnectRid?(routingId: string): void;
     localEndpoint(): string;
@@ -41,6 +51,8 @@ export interface ZLinkRawRouterPort extends ZLinkRawSocketPort {
     send(targetRid: string, parts: readonly Uint8Array[]): Promise<void>;
     request(targetRid: string, parts: readonly Uint8Array[], timeoutMs: number): Promise<readonly Buffer[]>;
     receive(dontWait?: boolean): ZLinkRawReceivedRecord | undefined;
+    /** The selected route of every RID. The socket's one route observer calls it. */
+    routesSnapshot(): readonly ZLinkRawRouterRoute[];
 }
 export interface ZLinkRawDealerPort extends ZLinkRawSocketPort {
     setRoutingId(routingId: string): void;

package/dist/runtime/channels/channel-clients.d.ts

@@ -18,7 +18,6 @@ export declare class DefaultZLinkFanoutClient implements ZLinkFanoutClient {
     constructor(registration: ZLinkFrameworkRegistration, transport?: ZLinkChannelClientTransportSource | undefined);
     publish(channelName: string, event: unknown): ZLinkFanoutPublishCall;
     publish(channelName: string, topic: string, event: unknown): ZLinkFanoutPublishCall;
-    getListenerStatus(channelName: string): import('../../contracts').ZLinkFanoutListenerStatus;
     private requirePublisherChannel;
     private requireTransport;
 }

package/dist/runtime/channels/channel-clients.js

@@ -64,14 +64,6 @@ class DefaultZLinkFanoutClient {
             status: (await this.requireTransport().publish(channelName, topic, packetName, event, signal)).status
         }));
     }
-    getListenerStatus(channelName) {
-        this.requirePublisherChannel(channelName);
-        const status = this.requireTransport().getFanoutListenerStatus?.(channelName);
-        if (status === undefined) {
-            throw new configuration_1.ZLinkConfigurationException(`Fanout publisher '${channelName}' has not reported a bound listener.`);
-        }
-        return status;
-    }
     requirePublisherChannel(channelName) {
         if (!this.registration.fanoutPublishers.has(channelName)) {
             throw new configuration_1.ZLinkConfigurationException(`Channel '${channelName}' does not have a publisher capability.`);

package/dist/runtime/channels/channel-outbound-operations.js

@@ -39,11 +39,7 @@ class ZLinkChannelOutboundOperations {
         (0, abort_1.throwIfAborted)(signal);
         const dealer = await this.sockets.awaitClientDealerForOutbound(channelName, signal);
         if (dealer === undefined) {
-            return {
-                status: this.sockets.hasKnownClientServerTargets(channelName)
-                    ? submission_result_1.ZLinkSubmitStatus.RouteNotConnected
-                    : submission_result_1.ZLinkSubmitStatus.TargetNotFound
-            };
+            return { status: submission_result_1.ZLinkSubmitStatus.RouteNotConnected };
         }
         const parts = (0, channel_envelope_1.encodeChannelEnvelopeParts)(3 /* ZLinkChannelMessageKind.Command */, channelName, packetName, message, undefined, undefined, this.codecs, undefined, this.dispatchServices.flowCreationEnabled(), metadata);
         try {
@@ -108,11 +104,7 @@ class ZLinkChannelOutboundOperations {
             // Binding timeouts are whole milliseconds; rounding down keeps the call's deadline.
             const remainingMs = deadlineAtMs === undefined ? undefined : Math.floor(deadlineAtMs - performance.now());
             if (dealer === undefined || (remainingMs !== undefined && remainingMs <= 0)) {
-                throw (0, framework_errors_internal_1.createInternalFrameworkException)(this.sockets.hasKnownClientServerTargets(channelName)
-                    ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected
-                    : framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestTargetNotFound, this.sockets.hasKnownClientServerTargets(channelName)
-                    ? `Channel '${channelName}' has known ClientServer targets but no ready server.`
-                    : `Channel '${channelName}' has no ready ClientServer server.`);
+                throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, `Channel '${channelName}' has no ready ClientServer server.`);
             }
             const serverRid = this.sockets.selectedClientServerRid(channelName, dealer);
             selectedServerRid = serverRid;