@zlink-systems/framework 0.29.1 → 0.30.1

package/dist/runtime/channels/local-spot-route-transport.d.ts

@@ -5,5 +5,5 @@ export declare class ZLinkLocalSpotRouteTransport {
     private readonly defaultRequestTimeoutMs;
     constructor(dispatcher: ZLinkLocalSpotRouteDispatcher | undefined, defaultRequestTimeoutMs: number | undefined);
     send(routerChannelId: string, spotId: RoutingId, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<void>;
-    request<TReply>(routerChannelId: string, spotId: RoutingId, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
+    request<TReply>(routerChannelId: string, spotId: RoutingId, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<TReply>;
 }

package/dist/runtime/channels/local-spot-route-transport.js

@@ -18,12 +18,13 @@ class ZLinkLocalSpotRouteTransport {
             metadata
         });
     }
-    request(routerChannelId, spotId, packetName, request, timeoutMs, signal) {
+    request(routerChannelId, spotId, packetName, request, timeoutMs, signal, onAdmitted) {
         if (this.dispatcher === undefined) {
             throw new configuration_1.ZLinkConfigurationException(`Route channel '${routerChannelId}' could not dispatch local SPOT request.`);
         }
         const pending = this.dispatcher.request(spotId, packetName, request, {
             channelName: routerChannelId,
+            onAdmitted,
             signal
         });
         const effectiveTimeoutMs = timeoutMs ?? this.defaultRequestTimeoutMs;

package/dist/runtime/channels/router-socket-spot-route-transport.d.ts

@@ -7,6 +7,6 @@ export declare class ZLinkRouterSocketSpotRouteTransport {
     private readonly sockets;
     constructor(sockets: ZLinkChannelSocketRegistry);
     send(target: ZLinkSpotRouteTarget, parts: readonly Message[], flags: ZLinkBackendSendFlags): Promise<void>;
-    request<TReply>(target: ZLinkSpotRouteTarget, parts: readonly Message[], codecs: ZLinkChannelEnvelopeCodecRegistry | undefined, flags: ZLinkBackendSendFlags, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
-    requestRaw(target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]>;
+    request<TReply>(target: ZLinkSpotRouteTarget, parts: readonly Message[], codecs: ZLinkChannelEnvelopeCodecRegistry | undefined, flags: ZLinkBackendSendFlags, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<TReply>;
+    requestRaw(target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<readonly Message[]>;
 }

package/dist/runtime/channels/router-socket-spot-route-transport.js

@@ -17,10 +17,10 @@ class ZLinkRouterSocketSpotRouteTransport {
             (0, channel_envelope_1.closeMessages)(parts);
         }
     }
-    async request(target, parts, codecs, flags, timeoutMs, signal) {
+    async request(target, parts, codecs, flags, timeoutMs, signal, onAdmitted) {
         const router = this.sockets.routeRouter(target.routerChannelId);
         void flags;
-        const operation = router.requestToSpot(target.targetNodeRid, target.spotId, parts, timeoutMs);
+        const operation = router.requestToSpot(target.targetNodeRid, target.spotId, parts, timeoutMs, onAdmitted);
         const replyParts = await (0, abort_1.awaitWithAbort)(operation, signal, () => {
             void operation.then(channel_envelope_1.closeMessages, () => undefined);
         });
@@ -32,9 +32,9 @@ class ZLinkRouterSocketSpotRouteTransport {
             (0, channel_envelope_1.closeMessages)(parts);
         }
     }
-    async requestRaw(target, request, timeoutMs, signal) {
+    async requestRaw(target, request, timeoutMs, signal, onAdmitted) {
         const router = this.sockets.routeRouter(target.routerChannelId);
-        const operation = router.requestToSpot(target.targetNodeRid, target.spotId, [request], timeoutMs);
+        const operation = router.requestToSpot(target.targetNodeRid, target.spotId, [request], timeoutMs, onAdmitted);
         return await (0, abort_1.awaitWithAbort)(operation, signal, () => {
             void operation.then(channel_envelope_1.closeMessages, () => undefined);
         });

package/dist/runtime/channels/source-spot-router.d.ts

@@ -4,7 +4,7 @@ import type { ZLinkSpotRouteTarget } from '../spots/spot-routing-internal';
 export declare class ZLinkSourceSpotRouter {
     private readonly defaultRequestTimeoutMs;
     constructor(defaultRequestTimeoutMs: number | undefined);
-    request<TReply>(sourceSpot: ZLinkBackendSpot, target: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
+    request<TReply>(sourceSpot: ZLinkBackendSpot, target: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<TReply>;
     send(sourceSpot: ZLinkBackendSpot, target: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<void>;
-    requestRaw(sourceSpot: ZLinkBackendSpot, target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]>;
+    requestRaw(sourceSpot: ZLinkBackendSpot, target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<readonly Message[]>;
 }

package/dist/runtime/channels/source-spot-router.js

@@ -9,12 +9,12 @@ class ZLinkSourceSpotRouter {
     constructor(defaultRequestTimeoutMs) {
         this.defaultRequestTimeoutMs = defaultRequestTimeoutMs;
     }
-    async request(sourceSpot, target, packetName, request, timeoutMs, signal) {
+    async request(sourceSpot, target, packetName, request, timeoutMs, signal, onAdmitted) {
         (0, abort_1.throwIfAborted)(signal);
         const parts = [
             (0, spot_direct_envelope_1.encodeSpotDirectEnvelope)(1 /* ZLinkChannelMessageKind.Request */, target.routerChannelId, packetName, request)
         ];
-        const operation = sourceSpot.requestToSpot(target.targetNodeRid, target.spotId, parts, timeoutMs ?? this.defaultRequestTimeoutMs);
+        const operation = sourceSpot.requestToSpot(target.targetNodeRid, target.spotId, parts, timeoutMs ?? this.defaultRequestTimeoutMs, onAdmitted);
         const replyParts = await (0, abort_1.awaitWithAbort)(operation, signal, () => {
             void operation.then(channel_envelope_1.closeMessages, () => undefined);
         });
@@ -37,9 +37,9 @@ class ZLinkSourceSpotRouter {
             (0, channel_envelope_1.closeMessages)(parts);
         }
     }
-    async requestRaw(sourceSpot, target, request, timeoutMs, signal) {
+    async requestRaw(sourceSpot, target, request, timeoutMs, signal, onAdmitted) {
         (0, abort_1.throwIfAborted)(signal);
-        const operation = sourceSpot.requestToSpot(target.targetNodeRid, target.spotId, request, timeoutMs ?? this.defaultRequestTimeoutMs);
+        const operation = sourceSpot.requestToSpot(target.targetNodeRid, target.spotId, request, timeoutMs ?? this.defaultRequestTimeoutMs, onAdmitted);
         return await (0, abort_1.awaitWithAbort)(operation, signal, () => {
             void operation.then(channel_envelope_1.closeMessages, () => undefined);
         });

package/dist/runtime/channels/spot-node-route-transport.d.ts

@@ -8,6 +8,6 @@ export declare class ZLinkSpotNodeRouteTransport {
     private readonly targets;
     constructor(registration: ZLinkFrameworkRegistration, targets: ZLinkSpotRouteTargetResolver);
     send(target: ZLinkSpotRouteTarget, parts: readonly Message[]): Promise<boolean>;
-    request<TReply>(target: ZLinkSpotRouteTarget, parts: readonly Message[], codecs: ZLinkChannelEnvelopeCodecRegistry | undefined, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply> | undefined;
-    requestRaw(target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]> | undefined;
+    request<TReply>(target: ZLinkSpotRouteTarget, parts: readonly Message[], codecs: ZLinkChannelEnvelopeCodecRegistry | undefined, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<TReply> | undefined;
+    requestRaw(target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<readonly Message[]> | undefined;
 }

package/dist/runtime/channels/spot-node-route-transport.js

@@ -24,14 +24,14 @@ class ZLinkSpotNodeRouteTransport {
             (0, channel_envelope_1.closeMessages)(parts);
         }
     }
-    request(target, parts, codecs, timeoutMs, signal) {
+    request(target, parts, codecs, timeoutMs, signal, onAdmitted) {
         const router = this.targets.spotNodeRouter(target.routerChannelId);
         if (router === undefined) {
             return undefined;
         }
         const effectiveTimeoutMs = timeoutMs ?? this.registration.requestTimeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS;
         (0, abort_1.throwIfAborted)(signal);
-        const operation = router.requestToSpot(target.targetNodeRid, target.spotId, parts, effectiveTimeoutMs);
+        const operation = router.requestToSpot(target.targetNodeRid, target.spotId, parts, effectiveTimeoutMs, onAdmitted);
         return (0, abort_1.awaitWithAbort)(operation, signal, () => {
             void operation.then(channel_envelope_1.closeMessages, () => undefined);
         }).then((replyParts) => {
@@ -44,14 +44,14 @@ class ZLinkSpotNodeRouteTransport {
             }
         });
     }
-    requestRaw(target, request, timeoutMs, signal) {
+    requestRaw(target, request, timeoutMs, signal, onAdmitted) {
         const router = this.targets.spotNodeRouter(target.routerChannelId);
         if (router === undefined) {
             return undefined;
         }
         const effectiveTimeoutMs = timeoutMs ?? this.registration.requestTimeoutMs ?? Registration_1.DEFAULT_REQUEST_TIMEOUT_MS;
         (0, abort_1.throwIfAborted)(signal);
-        const operation = router.requestToSpot(target.targetNodeRid, target.spotId, request, effectiveTimeoutMs);
+        const operation = router.requestToSpot(target.targetNodeRid, target.spotId, request, effectiveTimeoutMs, onAdmitted);
         return (0, abort_1.awaitWithAbort)(operation, signal, () => {
             void operation.then(channel_envelope_1.closeMessages, () => undefined);
         });

package/dist/runtime/channels/spot-route-bridge-transport.d.ts

@@ -8,7 +8,7 @@ export declare class ZLinkSpotRouteBridgeTransport {
     constructor(bridges: ReadonlyMap<string, ZLinkBackendSpotRouteBridge>, defaultRequestTimeoutMs: number | undefined);
     has(routerChannelId: string): boolean;
     send(target: ZLinkSpotRouteTarget, parts: readonly Message[]): Promise<void>;
-    request<TReply>(target: ZLinkSpotRouteTarget, parts: readonly Message[], codecs: ZLinkChannelEnvelopeCodecRegistry | undefined, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
-    requestRaw(target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]>;
+    request<TReply>(target: ZLinkSpotRouteTarget, parts: readonly Message[], codecs: ZLinkChannelEnvelopeCodecRegistry | undefined, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<TReply>;
+    requestRaw(target: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<readonly Message[]>;
     private requireBridge;
 }

package/dist/runtime/channels/spot-route-bridge-transport.js

@@ -24,11 +24,11 @@ class ZLinkSpotRouteBridgeTransport {
             (0, channel_envelope_1.closeMessages)(parts);
         }
     }
-    async request(target, parts, codecs, timeoutMs, signal) {
+    async request(target, parts, codecs, timeoutMs, signal, onAdmitted) {
         const bridge = this.requireBridge(target.routerChannelId);
         const operation = (0, channel_multipart_1.appendParts)(bridge.request(target.routerChannelId, target.targetNodeRid, target.spotId), parts)
             .timeout(timeoutMs ?? 0)
-            .submit();
+            .submit(onAdmitted);
         const replyParts = await (0, abort_1.awaitWithAbort)(operation, signal, () => {
             void operation.then(channel_envelope_1.closeMessages, () => undefined);
         });
@@ -40,13 +40,13 @@ class ZLinkSpotRouteBridgeTransport {
             (0, channel_envelope_1.closeMessages)(parts);
         }
     }
-    requestRaw(target, request, timeoutMs, signal) {
+    requestRaw(target, request, timeoutMs, signal, onAdmitted) {
         const bridge = this.requireBridge(target.routerChannelId);
         const operation = bridge
             .request(target.routerChannelId, target.targetNodeRid, target.spotId)
             .message(request)
             .timeout(timeoutMs ?? this.defaultRequestTimeoutMs ?? 0)
-            .submit();
+            .submit(onAdmitted);
         return (0, abort_1.awaitWithAbort)(operation, signal, () => {
             void operation.then(channel_envelope_1.closeMessages, () => undefined);
         });

package/dist/runtime/channels/spot-route-dispatch-strategy.d.ts

@@ -13,6 +13,7 @@ export interface ZLinkLocalSpotRouteDispatcher {
     request<TReply>(spotId: RoutingId, packetName: string | undefined, request: unknown, context: {
         readonly channelName: string;
         readonly signal?: AbortSignal;
+        readonly onAdmitted?: () => void;
         readonly metadata?: ReadonlyMap<string, string>;
     }): Promise<TReply>;
 }
@@ -39,10 +40,10 @@ export declare class ZLinkSpotRouteDispatchStrategy {
     canRoutePacketChannel(routerChannelId: string): boolean;
     routeSendToSpot(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<void>;
     private routeSendToSpotScoped;
-    routeRequestToSpot<TReply>(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<TReply>;
+    routeRequestToSpot<TReply>(spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>, onAdmitted?: () => void): Promise<TReply>;
     private routeRequestToSpotScoped;
-    routeRequestFromSpotToSpot<TReply>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal): Promise<TReply>;
+    routeRequestFromSpotToSpot<TReply>(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, request: unknown, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<TReply>;
     routeSendFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, packetName: string | undefined, message: unknown, metadata?: ReadonlyMap<string, string>): Promise<void>;
-    routeRequestRawFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]>;
-    routeRequestRawToSpot(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal): Promise<readonly Message[]>;
+    routeRequestRawFromSpotToSpot(sourceSpot: ZLinkBackendSpot, spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<readonly Message[]>;
+    routeRequestRawToSpot(spotRouteTarget: ZLinkSpotRouteTarget, request: Message, timeoutMs: number | undefined, signal?: AbortSignal, onAdmitted?: () => void): Promise<readonly Message[]>;
 }

package/dist/runtime/channels/spot-route-dispatch-strategy.js

@@ -70,58 +70,58 @@ class ZLinkSpotRouteDispatchStrategy {
         }
         await this.routerSocketTransport.send(spotRouteTarget, parts, ZLINK_SEND_DONT_WAIT);
     }
-    routeRequestToSpot(spotRouteTarget, packetName, request, timeoutMs, signal, metadata) {
-        return (0, flow_context_1.runWithOutboundFlow)(this.options.flowCreationEnabled?.() ?? true, () => this.routeRequestToSpotScoped(spotRouteTarget, packetName, request, timeoutMs, signal, metadata));
+    routeRequestToSpot(spotRouteTarget, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
+        return (0, flow_context_1.runWithOutboundFlow)(this.options.flowCreationEnabled?.() ?? true, () => this.routeRequestToSpotScoped(spotRouteTarget, packetName, request, timeoutMs, signal, metadata, onAdmitted));
     }
-    async routeRequestToSpotScoped(spotRouteTarget, packetName, request, timeoutMs, signal, metadata) {
+    async routeRequestToSpotScoped(spotRouteTarget, packetName, request, timeoutMs, signal, metadata, onAdmitted) {
         (0, abort_1.throwIfAborted)(signal);
         const localSpotRouteNode = this.targets.localRouteNode(spotRouteTarget);
         if (localSpotRouteNode !== undefined) {
-            return this.localTransport.request(spotRouteTarget.routerChannelId, spotRouteTarget.spotId, packetName, request, timeoutMs, signal);
+            return this.localTransport.request(spotRouteTarget.routerChannelId, spotRouteTarget.spotId, packetName, request, timeoutMs, signal, onAdmitted);
         }
         const codecs = (0, channel_framework_packets_1.codecsForFrameworkPacket)(packetName, this.options.codecs);
         const parts = (0, channel_envelope_1.encodeChannelEnvelopeParts)(1 /* ZLinkChannelMessageKind.Request */, spotRouteTarget.routerChannelId, packetName, request, timeoutMs, undefined, codecs, undefined, this.options.flowCreationEnabled?.() ?? true, metadata);
         if (this.targets.hasNamedSpotNode(spotRouteTarget.routerChannelId)) {
-            const namedSpotNodeRequest = this.spotNodeTransport.request(spotRouteTarget, parts, codecs, timeoutMs, signal);
+            const namedSpotNodeRequest = this.spotNodeTransport.request(spotRouteTarget, parts, codecs, timeoutMs, signal, onAdmitted);
             if (namedSpotNodeRequest !== undefined)
                 return namedSpotNodeRequest;
         }
         if (this.bridgeTransport.has(spotRouteTarget.routerChannelId)) {
-            return this.bridgeTransport.request(spotRouteTarget, parts, codecs, timeoutMs, signal);
+            return this.bridgeTransport.request(spotRouteTarget, parts, codecs, timeoutMs, signal, onAdmitted);
         }
         if (this.targets.hasBoundRouteRouter(spotRouteTarget.routerChannelId)) {
-            return this.routerSocketTransport.request(spotRouteTarget, parts, codecs, ZLINK_SEND_DONT_WAIT, timeoutMs, signal);
+            return this.routerSocketTransport.request(spotRouteTarget, parts, codecs, ZLINK_SEND_DONT_WAIT, timeoutMs, signal, onAdmitted);
         }
-        const spotNodeRequest = this.spotNodeTransport.request(spotRouteTarget, parts, codecs, timeoutMs, signal);
+        const spotNodeRequest = this.spotNodeTransport.request(spotRouteTarget, parts, codecs, timeoutMs, signal, onAdmitted);
         if (spotNodeRequest !== undefined) {
             return spotNodeRequest;
         }
-        return this.routerSocketTransport.request(spotRouteTarget, parts, codecs, 0, timeoutMs, signal);
+        return this.routerSocketTransport.request(spotRouteTarget, parts, codecs, 0, timeoutMs, signal, onAdmitted);
     }
-    routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal) {
-        return this.sourceSpotRouter.request(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal);
+    routeRequestFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal, onAdmitted) {
+        return this.sourceSpotRouter.request(sourceSpot, spotRouteTarget, packetName, request, timeoutMs, signal, onAdmitted);
     }
     async routeSendFromSpotToSpot(sourceSpot, spotRouteTarget, packetName, message, metadata) {
         await this.sourceSpotRouter.send(sourceSpot, spotRouteTarget, packetName, message, metadata);
     }
-    routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal) {
-        return this.sourceSpotRouter.requestRaw(sourceSpot, spotRouteTarget, request, timeoutMs, signal);
+    routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, timeoutMs, signal, onAdmitted) {
+        return this.sourceSpotRouter.requestRaw(sourceSpot, spotRouteTarget, request, timeoutMs, signal, onAdmitted);
     }
-    async routeRequestRawToSpot(spotRouteTarget, request, timeoutMs, signal) {
+    async routeRequestRawToSpot(spotRouteTarget, request, timeoutMs, signal, onAdmitted) {
         (0, abort_1.throwIfAborted)(signal);
         if (this.targets.hasNamedSpotNode(spotRouteTarget.routerChannelId)) {
-            const namedSpotNodeRequest = this.spotNodeTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal);
+            const namedSpotNodeRequest = this.spotNodeTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal, onAdmitted);
             if (namedSpotNodeRequest !== undefined)
                 return namedSpotNodeRequest;
         }
         if (this.bridgeTransport.has(spotRouteTarget.routerChannelId)) {
-            return this.bridgeTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal);
+            return this.bridgeTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal, onAdmitted);
         }
-        const spotNodeRequest = this.spotNodeTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal);
+        const spotNodeRequest = this.spotNodeTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal, onAdmitted);
         if (spotNodeRequest !== undefined) {
             return spotNodeRequest;
         }
-        return this.routerSocketTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal);
+        return this.routerSocketTransport.requestRaw(spotRouteTarget, request, timeoutMs, signal, onAdmitted);
     }
 }
 exports.ZLinkSpotRouteDispatchStrategy = ZLinkSpotRouteDispatchStrategy;

package/dist/runtime/diagnostics/message-flow.d.ts

@@ -10,6 +10,7 @@ export interface ZLinkDiagnosticsContext {
     readonly sourceMeshGeneration: bigint;
 }
 export declare const DEFAULT_ZLINK_DIAGNOSTICS: ZLinkDiagnosticsOptions;
+export declare const telemetryLogger: import("@opentelemetry/api-logs").Logger;
 export declare function effectiveMessageFlow(ctx: ZLinkDiagnosticsContext): ZLinkMessageFlowLogMode;
 export declare function createMessageFlowModeCell(dispatch: {
     diagnostics?: ZLinkDiagnosticsOptions;

package/dist/runtime/diagnostics/message-flow.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ZLinkMessageFlowTracer = exports.DEFAULT_ZLINK_DIAGNOSTICS = void 0;
+exports.ZLinkMessageFlowTracer = exports.telemetryLogger = exports.DEFAULT_ZLINK_DIAGNOSTICS = void 0;
 exports.effectiveMessageFlow = effectiveMessageFlow;
 exports.createMessageFlowModeCell = createMessageFlowModeCell;
 exports.createDiagnosticsContext = createDiagnosticsContext;
@@ -18,7 +18,7 @@ exports.DEFAULT_ZLINK_DIAGNOSTICS = {
     sampleRate: 1,
     includeMessageSizes: false
 };
-const telemetryLogger = api_logs_1.logs.getLogger('@zlink-systems/framework');
+exports.telemetryLogger = api_logs_1.logs.getLogger('@zlink-systems/framework');
 const telemetryTracer = api_1.trace.getTracer('@zlink-systems/framework');
 let diagnosticsGeneration = 0n;
 function effectiveMessageFlow(ctx) {
@@ -165,7 +165,7 @@ class ZLinkMessageFlowTracer {
     publishToLogger(record) {
         try {
             const severityNumber = record.eventId === DISPATCH_ERROR_EVENT_ID ? api_logs_1.SeverityNumber.ERROR : api_logs_1.SeverityNumber.INFO;
-            telemetryLogger.emit({
+            exports.telemetryLogger.emit({
                 eventName: record.eventId,
                 timestamp: record.timestamp,
                 severityNumber,

package/dist/runtime/execution/serial-execution-queue.d.ts

@@ -1,5 +1,6 @@
 export type ZLinkSerialWorkLane = 'application' | 'lifecycle';
 export interface ZLinkSerialWorkOptions {
+    readonly onAdmitted?: () => void;
     readonly lane?: ZLinkSerialWorkLane;
     readonly payloadBytes?: number;
     readonly metadataBytes?: number;

package/dist/runtime/execution/serial-execution-queue.js

@@ -181,6 +181,7 @@ class ZLinkSerialExecutionQueue {
             release();
             throw error;
         }
+        options.onAdmitted?.();
         this.scheduleDrain();
         return result;
     }

package/dist/runtime/foundation/actor-join-recovery-codec.js

@@ -56,7 +56,7 @@ function encodeCanonicalActorJoinRecoverySavedWork(input) {
     const request = Buffer.from(input.request);
     const replyContentType = operationId === undefined
         ? null
-        : requireText(input.replyContentType, 'Actor Join reply content type');
+        : (nullableText(input.replyContentType ?? null, 'Actor Join reply content type') ?? null);
     const metadata = encodeMetadataJson({
         Request: {
             ActorId: requireText(input.actorId, 'Actor id'),
@@ -167,7 +167,7 @@ function decodeCanonicalActorJoinRecoverySavedWork(encoded) {
     const operationLow = integer(metadata.OperationIdLow, 'OperationIdLow');
     const hasOperation = operationHigh !== 0n || operationLow !== 0n;
     const replyContentType = nullableText(metadata.ReplyContentType, 'ReplyContentType');
-    if (hasOperation !== (replyContentType !== undefined)) {
+    if (!hasOperation && replyContentType !== undefined) {
         throw new TypeError('Canonical Actor Join recovery reply identity is invalid.');
     }
     const targetNodeRid = base64(metadata.TargetNodeRid, 'TargetNodeRid');

package/dist/runtime/foundation/durable-service-request.d.ts

@@ -0,0 +1,14 @@
+export interface PeerRouteObservation {
+    readonly generation?: bigint;
+    readonly ready: boolean;
+}
+export interface DurableServiceRequestPort {
+    readonly requestStopSignal?: AbortSignal;
+    observePeerRoute(target: string): PeerRouteObservation;
+    observePeerRouteChanged(listener: (target: string) => void): () => void;
+    observePeerConnectionIntentRemoved(listener: (target: string) => void): () => void;
+    requestService(target: string, parts: readonly Uint8Array[], timeoutMs: number, onAdmitted?: () => void): Promise<readonly Buffer[]>;
+}
+/** Actor model §8.1: a ready edge or a typed transport failure owns replay. */
+export declare function requestDurableService(port: DurableServiceRequestPort, target: string, parts: readonly Uint8Array[], deadlineMs: number, operationKind: string, signal?: AbortSignal, onSubmitted?: (signal: AbortSignal) => Promise<void>): Promise<readonly Buffer[]>;
+export declare function durableRequestCanReplay(error: unknown): boolean;

package/dist/runtime/foundation/durable-service-request.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestDurableService = requestDurableService;
+exports.durableRequestCanReplay = durableRequestCanReplay;
+const abort_1 = require("../abort");
+const runtime_values_1 = require("../backend/runtime-values");
+const framework_errors_internal_1 = require("../framework-errors-internal");
+/** Actor model §8.1: a ready edge or a typed transport failure owns replay. */
+async function requestDurableService(port, target, parts, deadlineMs, operationKind, signal, onSubmitted) {
+    let wasAdmitted = false;
+    const stop = new AbortController();
+    const exhausted = (cause) => (0, framework_errors_internal_1.createInternalFrameworkException)(wasAdmitted
+        ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.DeadlineExceeded
+        : framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, `${operationKind} exhausted its end-to-end deadline.`, true, cause);
+    const timer = setTimeout(() => stop.abort(exhausted()), Math.max(0, Math.ceil(deadlineMs - performance.now())));
+    const unobserveIntent = port.observePeerConnectionIntentRemoved((rid) => {
+        if (rid === target)
+            stop.abort((0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RouteNotConnected, `${operationKind} target node lifecycle ended.`, true));
+    });
+    const cancellation = AbortSignal.any([
+        stop.signal,
+        ...(signal === undefined ? [] : [signal]),
+        ...(port.requestStopSignal === undefined ? [] : [port.requestStopSignal])
+    ]);
+    try {
+        for (;;) {
+            cancellation.throwIfAborted();
+            const remainingMs = Math.ceil(deadlineMs - performance.now());
+            if (remainingMs <= 0)
+                throw exhausted();
+            let changed;
+            const transition = new Promise((resolve) => {
+                changed = resolve;
+            });
+            let submittedGeneration;
+            const attemptStop = new AbortController();
+            const attemptSignal = AbortSignal.any([cancellation, attemptStop.signal]);
+            const unobserveRoute = port.observePeerRouteChanged((rid) => {
+                if (rid !== target)
+                    return;
+                const route = port.observePeerRoute(target);
+                if (submittedGeneration === undefined
+                    ? route.ready
+                    : route.generation !== undefined && route.generation !== submittedGeneration) {
+                    changed();
+                    attemptStop.abort();
+                }
+            });
+            try {
+                const route = port.observePeerRoute(target);
+                if (!route.ready) {
+                    await (0, abort_1.awaitWithAbort)(transition, cancellation);
+                    continue;
+                }
+                submittedGeneration = route.generation;
+                const reply = port.requestService(target, parts, remainingMs, () => {
+                    wasAdmitted = true;
+                });
+                const request = onSubmitted === undefined
+                    ? reply
+                    : Promise.race([
+                        reply,
+                        Promise.resolve()
+                            .then(() => onSubmitted(attemptSignal))
+                            .then(() => reply)
+                    ]);
+                const result = await (0, abort_1.awaitWithAbort)(Promise.race([request.then((parts) => ({ parts })), transition.then(() => undefined)]), cancellation);
+                if (result !== undefined)
+                    return result.parts;
+            }
+            catch (error) {
+                cancellation.throwIfAborted();
+                if (!durableRequestCanReplay(error))
+                    throw error;
+                if ((0, runtime_values_1.isZLinkBackendResultError)(error) && error.operation === 'request')
+                    wasAdmitted = true;
+            }
+            finally {
+                attemptStop.abort();
+                unobserveRoute();
+            }
+        }
+    }
+    finally {
+        clearTimeout(timer);
+        unobserveIntent();
+    }
+}
+function durableRequestCanReplay(error) {
+    if (!(0, runtime_values_1.isZLinkBackendResultError)(error))
+        return false;
+    return error.operation === 'request'
+        ? error.result === runtime_values_1.RequestResult.NotConnected || error.result === runtime_values_1.RequestResult.TimedOut
+        : error.result === runtime_values_1.SubmitResult.NotConnected ||
+            error.result === runtime_values_1.SubmitResult.NotFound ||
+            error.result === runtime_values_1.SubmitResult.NotAdmitted ||
+            error.result === runtime_values_1.SubmitResult.Backpressured;
+}

package/dist/runtime/foundation/operation-identity.d.ts

@@ -10,5 +10,6 @@ export type ZLinkOperationIdentityKey = string & {
     readonly [operationKeyBrand]: true;
 };
 export declare function operationIdentityKey(operationId: ZLinkOperationIdentity128): ZLinkOperationIdentityKey;
+export declare function validateOperationIdentity(operationId: ZLinkOperationIdentity128): void;
 export declare function createRandomOperationIdentity(source?: (size: number) => Buffer): ZLinkOperationIdentity128;
 export {};

package/dist/runtime/foundation/operation-identity.js

@@ -2,18 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLINK_NATIVE_CORRELATION_OPERATION_NAMESPACE = exports.OPERATION_IDENTITY_BYTES = void 0;
 exports.operationIdentityKey = operationIdentityKey;
+exports.validateOperationIdentity = validateOperationIdentity;
 exports.createRandomOperationIdentity = createRandomOperationIdentity;
 const stream_wire_1 = require("@zlink-systems/stream-wire");
 const node_crypto_1 = require("node:crypto");
 exports.OPERATION_IDENTITY_BYTES = 16;
 exports.ZLINK_NATIVE_CORRELATION_OPERATION_NAMESPACE = 2n;
 function operationIdentityKey(operationId) {
+    validateOperationIdentity(operationId);
+    return `${operationId.high.toString(16)}:${operationId.low.toString(16)}`;
+}
+function validateOperationIdentity(operationId) {
     requireUnsigned64(operationId.high, 'operationId.high');
     requireUnsigned64(operationId.low, 'operationId.low');
     if (operationId.high === 0n && operationId.low === 0n) {
         throw new RangeError('Operation identity must not be all zero.');
     }
-    return `${operationId.high.toString(16)}:${operationId.low.toString(16)}`;
 }
 function createRandomOperationIdentity(source = node_crypto_1.randomBytes) {
     for (;;) {

package/dist/runtime/foundation/raw-service-mesh-runtime.d.ts

@@ -17,6 +17,7 @@ export interface RawServiceRequestResult {
 /** An M6A application frame already owned by the Framework runtime. */
 type ServiceApplicationPayloadInput = ServiceApplicationPayload | Buffer;
 export interface RawServiceIngressRecord {
+    readonly onAdmitted?: () => void;
     readonly command: number;
     readonly flags: number;
     readonly sourceRoutingId: string;
@@ -29,6 +30,8 @@ export interface RawServiceIngressRecord {
 }
 export type RawServiceIngressHandler = (record: RawServiceIngressRecord) => RawServicePumpResult | undefined | Promise<RawServicePumpResult | undefined>;
 export interface RawServiceMeshRuntimeOptions {
+    readonly onReceiveReady?: () => void;
+    readonly infrastructureTaskRunner?: import('../spots/spot-actor-join-dispatch').ZLinkDetachedTaskRunner;
     readonly onPendingOperationsChanged?: () => void;
     readonly descriptor: ServiceNodeDescriptor;
     readonly resolveAdvertisedEndpoint?: (boundEndpoint: string) => string;
@@ -61,6 +64,7 @@ export declare class RawServiceMeshRuntime {
     private readonly expectedPeers;
     private readonly endpointOnlyPeers;
     private readonly peerConnectionIntentRemoved;
+    private readonly peerRouteChanged;
     /**
      * The last observed Core selected route of each RID (Core ROUTER §10.1):
      * RID -> route generation. Only `observeSelectedRoutes` replaces it.
@@ -68,8 +72,16 @@ export declare class RawServiceMeshRuntime {
     private selectedRoutes;
     private readonly bindingPort;
     private readonly applicationJobQueue;
+    private readonly nodeMailboxOwner;
     private readonly peerAdmissionSealed?;
     private readonly applicationJobStop;
+    private receiveAcquisition?;
+    private receivePermit?;
+    private receiveRotation?;
+    private readonly controlSends;
+    private infrastructureFailure?;
+    private readonly onReceiveReady?;
+    private readonly infrastructureTaskRunner?;
     private readonly onPeerNotRequired?;
     private readonly onPeerDisconnected?;
     private readonly onProtocolError?;
@@ -80,6 +92,7 @@ export declare class RawServiceMeshRuntime {
     private router?;
     private nextCorrelation;
     private serviceIngress?;
+    private serviceIngressAccepts?;
     private closed;
     constructor(options: RawServiceMeshRuntimeOptions);
     start(): void;
@@ -90,6 +103,11 @@ export declare class RawServiceMeshRuntime {
     disconnectPeer(endpoint: string, nodeRoutingId: string, lifecycleGeneration?: bigint): void;
     disconnectPeerEndpoint(endpoint: string): void;
     observePeerConnectionIntentRemoved(listener: (nodeRoutingId: string) => void): () => void;
+    observePeerRoute(nodeRoutingId: string): import('./durable-service-request').PeerRouteObservation;
+    get requestStopSignal(): AbortSignal;
+    observePeerRouteChanged(listener: (nodeRoutingId: string) => void): () => void;
+    hasSelectedPeerRoute(nodeRoutingId: string): boolean;
+    private notifyPeerRouteChanged;
     private notifyPeerConnectionIntentRemoved;
     announcePeer(nodeRoutingId: string): Promise<boolean>;
     isPeerRouteReady(nodeRoutingId: string, lifecycleGeneration?: bigint): boolean;
@@ -100,17 +118,18 @@ export declare class RawServiceMeshRuntime {
         readonly channelWeight?: number;
         readonly state?: 'draining';
     }): Promise<void>;
+    private publishLocalDescriptor;
     replaceDiscoveredNotRequired(descriptors: readonly ServiceNodeDescriptor[]): void;
     isObjectClientNodeDirectTarget(nodeRoutingId: string): boolean;
-    sendToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput): Promise<boolean>;
+    sendToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput): boolean | Promise<boolean>;
     sendToChannel(channelName: string, payload: ServiceApplicationPayloadInput): Promise<SubmitResult>;
-    requestToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput, timeoutMs: number): PendingOperation<RawServiceRequestResult>;
-    requestToChannel(channelName: string, payload: ServiceApplicationPayloadInput, timeoutMs: number): PendingOperation<RawServiceRequestResult>;
+    requestToNode(targetNodeRoutingId: string, payload: ServiceApplicationPayloadInput, timeoutMs: number, onAdmitted?: () => void): PendingOperation<RawServiceRequestResult>;
+    requestToChannel(channelName: string, payload: ServiceApplicationPayloadInput, timeoutMs: number, onAdmitted?: () => void): PendingOperation<RawServiceRequestResult>;
     private selectChannelTarget;
-    setServiceIngress(handler: RawServiceIngressHandler): void;
+    setServiceIngress(handler: RawServiceIngressHandler, accepts?: (command: number) => boolean): void;
     reserveLocalIngress(signal?: AbortSignal): Promise<ApplicationIngressRecordOwner>;
     sendService(targetNodeRoutingId: string, parts: readonly Uint8Array[]): Promise<boolean>;
-    requestService(targetNodeRoutingId: string, parts: readonly Uint8Array[], timeoutMs: number): Promise<readonly Buffer[]>;
+    requestService(targetNodeRoutingId: string, parts: readonly Uint8Array[], timeoutMs: number, onAdmitted?: () => void): Promise<readonly Buffer[]>;
     replyService(record: Pick<RawServiceIngressRecord, 'sourceRoutingId' | 'sourceRoute' | 'requestSequence' | 'reply'>, parts: readonly Uint8Array[]): void;
     reply(request: ServiceMailboxRecord, payload: ServiceApplicationPayloadInput, terminalResult?: number, failureCode?: number): void;
     pumpOne(nowMs?: number, observe?: RawServicePumpObserver): Promise<RawServicePumpResult>;
@@ -118,12 +137,18 @@ export declare class RawServiceMeshRuntime {
     /** Returns whether a receive budget ended before no-data; idle ticks only maintain peers. */
     pumpBatch(receiveReady?: boolean, routeReady?: boolean): Promise<boolean>;
     private receiveOne;
+    private finishReceive;
     private reportProtocolError;
     private replyGenericProtocolError;
     private processReceived;
+    private receiveProtocolFailure;
+    private processAdmission;
+    private processLiveness;
+    private processApplicationReceived;
+    private enqueueOrdinaryRecord;
     expireOperations(nowMs: number, turnDeadlineMs: number): number;
     get pendingOperationCount(): number;
-    tickLiveness(nowMs?: number): Promise<ServiceLivenessTick>;
+    tickLiveness(nowMs?: number): ServiceLivenessTick;
     /**
      * The socket's one route observer (Core ROUTER §10.1). It replaces the
      * observation with Core's selected-route snapshot, ends the admission of
@@ -144,6 +169,12 @@ export declare class RawServiceMeshRuntime {
     private selectBilateralConnection;
     private removePeer;
     private requireStarted;
+    private sendControl;
+    private submitControl;
+    private startControlSend;
+    private reportInfrastructureFailure;
+    private observeInfrastructureFailure;
     private send;
+    private sendFailure;
 }
 export {};