@zlink-systems/framework 0.30.0 → 0.30.2

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/flow-context.js

@@ -9,7 +9,6 @@ exports.createInboundFlow = createInboundFlow;
 const node_async_hooks_1 = require("node:async_hooks");
 const node_crypto_1 = require("node:crypto");
 const FLOW_UUID_BYTES = 16;
-const FLOW_UUID_VARIANT_BYTE = 8;
 /**
  * Spec 27 §3 defines the flow_origin value set as lowercase
  * (`inbound|timer|application|lifecycle`); every language emits these exact
@@ -70,13 +69,26 @@ function createInboundFlow(flowId, flowOrigin, createIfAbsent, streamSessionId)
     }
     return { flowId: flowId ?? createFlowId(), flowOrigin: flowOrigin ?? 'Inbound', streamSessionId };
 }
+/**
+ * UUIDv7 with a dedicated counter (RFC 9562 §6.2 method 1): the 48-bit
+ * millisecond timestamp, then a 42-bit counter that starts at a random value
+ * and spans `rand_a` and the top of `rand_b`, then 32 random bits drawn once
+ * per process. Flow ids stay unique within the process without drawing
+ * random bytes for every message.
+ */
+const flowRandom = (0, node_crypto_1.randomBytes)(FLOW_UUID_BYTES);
+const FLOW_COUNTER_SPAN = 2 ** 42;
+let flowCounter = flowRandom.readUIntBE(0, 6) % FLOW_COUNTER_SPAN;
+const FLOW_ID_TAIL = flowRandom.toString('hex', FLOW_UUID_BYTES - 4);
 function createFlowId() {
-    const bytes = (0, node_crypto_1.randomBytes)(FLOW_UUID_BYTES);
+    const counter = flowCounter;
+    flowCounter = (flowCounter + 1) % FLOW_COUNTER_SPAN;
     // Date.now() is always within 48 bits, which is exactly the UUIDv7
     // timestamp field.
-    bytes.writeUIntBE(Date.now(), 0, 6);
-    bytes[6] = 0x70 | (bytes[6] & 0x0f);
-    bytes[FLOW_UUID_VARIANT_BYTE] = 0x80 | (bytes[FLOW_UUID_VARIANT_BYTE] & 0x3f);
-    const hex = bytes.toString('hex');
-    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+    const timestamp = Date.now().toString(16).padStart(12, '0');
+    const randA = Math.floor(counter / 2 ** 30); // 12 bits
+    const randB = counter % 2 ** 30; // 30 bits after the 2 variant bits
+    const variantHigh = (0x8000 | Math.floor(randB / 2 ** 16)).toString(16);
+    const randBLow = (randB % 2 ** 16).toString(16).padStart(4, '0');
+    return `${timestamp.slice(0, 8)}-${timestamp.slice(8)}-7${randA.toString(16).padStart(3, '0')}-${variantHigh}-${randBLow}${FLOW_ID_TAIL}`;
 }

package/dist/runtime/diagnostics/index.js

@@ -18,7 +18,6 @@ exports.ZLinkLocationMonitoringEventEmitter = exports.ZLinkLocationRuntimeMonito
 exports.isRelocationDebugEnabled = isRelocationDebugEnabled;
 exports.relocationDebug = relocationDebug;
 exports.emitActorOwnerLeaseObservation = emitActorOwnerLeaseObservation;
-const node_async_hooks_1 = require("node:async_hooks");
 const state_lane_1 = require("../execution/state-lane");
 const routing_id_1 = require("../routing-id");
 const internal_event_contracts_1 = require("./internal-event-contracts");
@@ -29,7 +28,6 @@ Object.defineProperty(exports, "ZLinkLocationRouteEventKind", { enumerable: true
 Object.defineProperty(exports, "ZLinkLocationSpotEventKind", { enumerable: true, get: function () { return internal_event_contracts_2.ZLinkLocationSpotEventKind; } });
 Object.defineProperty(exports, "ZLinkSocketNativeEventType", { enumerable: true, get: function () { return internal_event_contracts_2.ZLinkSocketNativeEventType; } });
 const ZLINK_DISCONNECT_REASON_HANDSHAKE_FAILED = 3;
-const detachedStateLaneResource = new node_async_hooks_1.AsyncResource('zlink:location-runtime-monitoring-source');
 function isRelocationDebugEnabled() {
     return process.env.ZLINK_DEBUG_FRAMEWORK_RELOCATION === '1';
 }
@@ -113,7 +111,7 @@ class ZLinkLocationRuntimeMonitoringSource {
         let topology;
         let serviceSummary;
         try {
-            [status, topology, serviceSummary] = await startOutsideStateLane(() => Promise.all([
+            [status, topology, serviceSummary] = await (0, state_lane_1.startOutsideStateLane)(() => Promise.all([
                 this.query.getStatus(signal),
                 this.query.listTopology({}, undefined, signal),
                 this.query.listServiceSummaries({}, undefined, signal)
@@ -121,7 +119,7 @@ class ZLinkLocationRuntimeMonitoringSource {
         }
         catch (error) {
             if (await this.lane.run(() => this.markStoreFailureCore())) {
-                await startOutsideStateLane(() => this.publisher.publish({
+                await (0, state_lane_1.startOutsideStateLane)(() => this.publisher.publish({
                     sourceName: this.registration.sourceName,
                     timestamp: new Date(),
                     event: internal_event_contracts_1.ZLinkLocationRuntimeEventKind.StoreFailure
@@ -130,7 +128,7 @@ class ZLinkLocationRuntimeMonitoringSource {
             return;
         }
         if (await this.lane.run(() => this.markStoreRecoveredCore())) {
-            await startOutsideStateLane(() => this.publisher.publish({
+            await (0, state_lane_1.startOutsideStateLane)(() => this.publisher.publish({
                 sourceName: this.registration.sourceName,
                 timestamp: new Date(),
                 event: internal_event_contracts_1.ZLinkLocationRuntimeEventKind.StoreRecovered
@@ -157,7 +155,7 @@ class ZLinkLocationRuntimeMonitoringSource {
         const previous = await this.lane.run(() => this.previousSnapshotCore(event));
         if (current === previous)
             return;
-        await startOutsideStateLane(() => publishLocationRuntimeChange(this.publisher, this.registration.sourceName, event, snapshot));
+        await (0, state_lane_1.startOutsideStateLane)(() => publishLocationRuntimeChange(this.publisher, this.registration.sourceName, event, snapshot));
         await this.lane.run(() => this.updateSnapshotCore(event, current));
     }
     previousSnapshotCore(event) {
@@ -352,9 +350,6 @@ async function publishLocationRuntimeChange(publisher, sourceName, event, snapsh
             };
     await publisher.publish(runtimeEvent);
 }
-function startOutsideStateLane(work) {
-    return detachedStateLaneResource.runInAsyncScope(work);
-}
 function stableSnapshot(value) {
     return JSON.stringify(value, (_key, item) => (typeof item === 'bigint' ? item.toString() : item));
 }

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

@@ -12,6 +12,12 @@ export interface ZLinkDiagnosticsContext {
 export declare const DEFAULT_ZLINK_DIAGNOSTICS: ZLinkDiagnosticsOptions;
 export declare const telemetryLogger: import("@opentelemetry/api-logs").Logger;
 export declare function effectiveMessageFlow(ctx: ZLinkDiagnosticsContext): ZLinkMessageFlowLogMode;
+/**
+ * Message-flow tracing is on at Normal and Detailed only (04-flow-correlation
+ * §4). Below it no flow ID is created, validated, captured or propagated. This
+ * is the one decision every flow processing point reads.
+ */
+export declare function messageFlowTracingEnabled(mode: ZLinkMessageFlowLogMode): boolean;
 export declare function createMessageFlowModeCell(dispatch: {
     diagnostics?: ZLinkDiagnosticsOptions;
 } | undefined): ZLinkMessageFlowModeCell;
@@ -22,7 +28,9 @@ export declare function flowIfEnabled(flow: ZLinkMessageFlowTracer | undefined,
 export interface ZLinkMessageFlowTracePoint {
     trace(flowInput: MessageFlowInput): void;
 }
+export declare function traceSessionBindingControlDrop(flow: ZLinkMessageFlowTracer | undefined, sourceRid: string, actorId: string, packetName: string, errorReason: 'location_unavailable' | 'stale_target', error?: unknown): void;
 type MessageFlowInput = Omit<ZLinkRuntimeMessageFlowEvent, 'effectiveMode' | 'flowId' | 'flowOrigin'> & {
+    readonly severity?: 'warning';
     readonly effectiveMode?: ZLinkMessageFlowLogMode;
     readonly flowId?: string;
     readonly flowOrigin?: import('../../contracts').ZLinkFlowOrigin;

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

@@ -2,9 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkMessageFlowTracer = exports.telemetryLogger = exports.DEFAULT_ZLINK_DIAGNOSTICS = void 0;
 exports.effectiveMessageFlow = effectiveMessageFlow;
+exports.messageFlowTracingEnabled = messageFlowTracingEnabled;
 exports.createMessageFlowModeCell = createMessageFlowModeCell;
 exports.createDiagnosticsContext = createDiagnosticsContext;
 exports.flowIfEnabled = flowIfEnabled;
+exports.traceSessionBindingControlDrop = traceSessionBindingControlDrop;
 const api_1 = require("@opentelemetry/api");
 const api_logs_1 = require("@opentelemetry/api-logs");
 const contracts_1 = require("../../contracts");
@@ -24,6 +26,14 @@ let diagnosticsGeneration = 0n;
 function effectiveMessageFlow(ctx) {
     return ctx.liveMode.mode;
 }
+/**
+ * Message-flow tracing is on at Normal and Detailed only (04-flow-correlation
+ * §4). Below it no flow ID is created, validated, captured or propagated. This
+ * is the one decision every flow processing point reads.
+ */
+function messageFlowTracingEnabled(mode) {
+    return contracts_1.MESSAGE_FLOW_MODE_RANK[mode] >= contracts_1.MESSAGE_FLOW_MODE_RANK.normal;
+}
 function createMessageFlowModeCell(dispatch) {
     return { mode: dispatch?.diagnostics?.messageFlow ?? 'errors' };
 }
@@ -53,6 +63,21 @@ function flowIfEnabled(flow, outcome, result, flowId, sourceMeshGeneration) {
             ? flow
             : undefined;
 }
+function traceSessionBindingControlDrop(flow, sourceRid, actorId, packetName, errorReason, error) {
+    const point = flowIfEnabled(flow, ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Dropped);
+    if (point === undefined)
+        return;
+    point.trace({
+        outcome: ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Dropped,
+        surface: ZLinkDispatchOptions_1.ZLinkDispatchErrorSurface.StreamSession,
+        messageKind: ZLinkDispatchOptions_1.ZLinkDispatchMessageKind.Control,
+        sourceRid,
+        actorId,
+        packetName,
+        errorReason,
+        ...(0, dispatch_error_details_1.dispatchErrorDetails)(error)
+    });
+}
 class ZLinkMessageFlowTracer {
     ctx;
     errorSink;
@@ -100,7 +125,7 @@ class ZLinkMessageFlowTracer {
         }
     }
     flowCreationEnabled() {
-        return effectiveMessageFlow(this.ctx) !== 'off';
+        return messageFlowTracingEnabled(effectiveMessageFlow(this.ctx));
     }
     trace(flowInput) {
         const effectiveMode = effectiveMessageFlow(this.ctx);
@@ -164,12 +189,16 @@ class ZLinkMessageFlowTracer {
     }
     publishToLogger(record) {
         try {
-            const severityNumber = record.eventId === DISPATCH_ERROR_EVENT_ID ? api_logs_1.SeverityNumber.ERROR : api_logs_1.SeverityNumber.INFO;
+            const severity = record.severity === 'warning'
+                ? 'WARN'
+                : record.eventId === DISPATCH_ERROR_EVENT_ID
+                    ? 'ERROR'
+                    : 'INFO';
             exports.telemetryLogger.emit({
                 eventName: record.eventId,
                 timestamp: record.timestamp,
-                severityNumber,
-                severityText: record.eventId === DISPATCH_ERROR_EVENT_ID ? 'ERROR' : 'INFO',
+                severityNumber: api_logs_1.SeverityNumber[severity],
+                severityText: severity,
                 body: structuredLogBody(record),
                 attributes: structuredLogAttributes(record)
             });
@@ -205,6 +234,7 @@ class ZLinkMessageFlowTracer {
 exports.ZLinkMessageFlowTracer = ZLinkMessageFlowTracer;
 function toTelemetryRecord(flow, messageSizeBytes, durationSeconds) {
     return {
+        severity: flow.severity,
         eventId: flow.outcome === ZLinkDispatchOptions_1.ZLinkRuntimeMessageFlowOutcome.Error
             ? DISPATCH_ERROR_EVENT_ID
             : MESSAGE_FLOW_EVENT_ID,
@@ -243,7 +273,7 @@ function toTelemetryRecord(flow, messageSizeBytes, durationSeconds) {
 function traceAttributes(record) {
     const attributes = {};
     for (const [name, value] of Object.entries(record)) {
-        if (value === undefined || name === 'timestamp')
+        if (value === undefined || name === 'timestamp' || name === 'severity')
             continue;
         attributes[toSnakeCase(name)] = value instanceof Date ? value.toISOString() : value;
     }

package/dist/runtime/diagnostics/runtime-metrics.d.ts

@@ -20,8 +20,8 @@ export interface ZLinkRuntimeMetricMeshSnapshot {
         readonly channelName: string;
         readonly readyMembers: number;
     }>;
-    readonly actorCapacity: ZLinkRuntimeMetricCapacity;
-    readonly spotCapacity: ZLinkRuntimeMetricCapacity;
+    readonly actorCapacity?: ZLinkRuntimeMetricCapacity;
+    readonly spotCapacity?: ZLinkRuntimeMetricCapacity;
     readonly spotTypeCapacities: ReadonlyArray<ZLinkRuntimeMetricSpotTypeCapacity>;
     readonly activation: {
         readonly active: number;

package/dist/runtime/diagnostics/runtime-metrics.js

@@ -286,14 +286,16 @@ class MetricRegistry {
         }
         else if (name.startsWith('zlink.object.capacity.')) {
             const field = metricSuffix(name);
-            result.observe(capacityValue(snapshot.actorCapacity, field), {
-                ...mesh,
-                capacity_scope: 'actor'
-            });
-            result.observe(capacityValue(snapshot.spotCapacity, field), {
-                ...mesh,
-                capacity_scope: 'spot'
-            });
+            if (snapshot.actorCapacity !== undefined)
+                result.observe(capacityValue(snapshot.actorCapacity, field), {
+                    ...mesh,
+                    capacity_scope: 'actor'
+                });
+            if (snapshot.spotCapacity !== undefined)
+                result.observe(capacityValue(snapshot.spotCapacity, field), {
+                    ...mesh,
+                    capacity_scope: 'spot'
+                });
         }
         else if (name.startsWith('zlink.spot.type.capacity.')) {
             const field = metricSuffix(name);

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

@@ -20,6 +20,7 @@ export declare class ZLinkSpotSerialTurn {
     private suspendedResolve;
     private suspendedPromise;
     private suspendSignaled;
+    private yieldUsed;
     private owner;
     private frameworkOperationsBlocked;
     constructor(postResume: (turn: ZLinkSpotSerialTurn, resume: () => void, reject: (reason: unknown) => void) => boolean, executionClaim: ZLinkExecutionBarrierClaim | undefined, yieldAllowed: boolean);
@@ -34,6 +35,7 @@ export declare class ZLinkSpotSerialTurn {
     blockFrameworkOperations(): void;
     ensureFrameworkOperationAllowed(): void;
     resetSuspension(): void;
+    admitYield(): void;
     yieldPromise<T>(pending: Promise<T>): Promise<T>;
     /** Suspends a turn only for a Framework-owned lifecycle boundary. */
     yieldFrameworkPromise<T>(pending: Promise<T>): Promise<T>;
@@ -47,14 +49,14 @@ export declare function captureZLinkSpotSerialTurn(executor?: ZLinkSpotSerialTur
 export declare function currentZLinkSpotSerialSourceId(): unknown;
 export declare function requireZLinkYieldTurn(capturedTurn?: ZLinkSpotSerialTurn): ZLinkSpotSerialTurn;
 export interface ZLinkCapturedExecutionTurn {
-    yieldPromise<T>(pending: Promise<T>): Promise<T>;
+    yieldPromise<T>(operation: () => Promise<T>): Promise<T>;
     post(callback: () => void): void;
 }
 export declare function captureZLinkExecutionTurn(): ZLinkCapturedExecutionTurn | undefined;
 export declare function isCurrentZLinkSpotSerialTurn(executor: ZLinkSpotSerialTurnExecutorLike): boolean;
 export interface ZLinkExecutionBarrierSeal {
     readonly generation: bigint;
-    readonly kind: 'close' | 'relocation';
+    readonly kind: 'close' | 'relocation' | 'activation';
 }
 export interface ZLinkExecutionBarrierClaim {
     release(): void;

package/dist/runtime/execution/index.js

@@ -11,7 +11,6 @@ exports.requireZLinkYieldTurn = requireZLinkYieldTurn;
 exports.captureZLinkExecutionTurn = captureZLinkExecutionTurn;
 exports.isCurrentZLinkSpotSerialTurn = isCurrentZLinkSpotSerialTurn;
 const node_async_hooks_1 = require("node:async_hooks");
-const configuration_1 = require("../configuration");
 const abort_1 = require("../abort");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 var state_lane_1 = require("./state-lane");
@@ -36,6 +35,7 @@ class ZLinkSpotSerialTurn {
     suspendedResolve;
     suspendedPromise;
     suspendSignaled = false;
+    yieldUsed = false;
     owner;
     frameworkOperationsBlocked = false;
     constructor(postResume, executionClaim, yieldAllowed) {
@@ -79,22 +79,34 @@ class ZLinkSpotSerialTurn {
         }
     }
     resetSuspension() {
+        this.yieldUsed = false;
         this.suspendSignaled = false;
         this.suspendedResolve = undefined;
         this.suspendedPromise = undefined;
     }
-    async yieldPromise(pending) {
-        if (!this.yieldAllowed) {
-            throw new configuration_1.ZLinkConfigurationException('yield requires a SpotWide User Spot or Instance Spot application handler.');
+    admitYield() {
+        const current = spotSerialTurnStorage.getStore();
+        if (current?.turn !== this ||
+            !this.yieldAllowed ||
+            !current.executor.isActiveTurn(this, current.turnId) ||
+            this.yieldUsed) {
+            throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidOperation, 'Yield requires the current SpotWide application turn and may be used only once per turn.');
         }
+        this.yieldUsed = true;
+    }
+    async yieldPromise(pending) {
+        this.admitYield();
         return await this.yieldFrameworkPromise(pending);
     }
     /** Suspends a turn only for a Framework-owned lifecycle boundary. */
     async yieldFrameworkPromise(pending) {
         this.signalSuspended();
-        const result = await pending;
-        await this.awaitResumePermit();
-        return result;
+        try {
+            return await pending;
+        }
+        finally {
+            await this.awaitResumePermit();
+        }
     }
     async resumeOwnerUntilNextYield() {
         const owner = this.owner;
@@ -146,9 +158,10 @@ function currentZLinkSpotSerialSourceId() {
 }
 function requireZLinkYieldTurn(capturedTurn) {
     const turn = capturedTurn ?? captureZLinkSpotSerialTurn();
-    if (turn === undefined || !turn.yieldAllowed) {
-        throw new configuration_1.ZLinkConfigurationException('yield requires a SpotWide User Spot or Instance Spot application handler.');
+    if (turn === undefined) {
+        throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.InvalidOperation, 'Yield requires a current SpotWide application turn.');
     }
+    turn.admitYield();
     return turn;
 }
 function captureZLinkExecutionTurn() {
@@ -157,7 +170,17 @@ function captureZLinkExecutionTurn() {
         return undefined;
     }
     return {
-        yieldPromise: (pending) => current.turn.yieldPromise(pending),
+        yieldPromise: (operation) => {
+            const turn = requireZLinkYieldTurn(current.turn);
+            let pending;
+            try {
+                pending = operation();
+            }
+            catch (error) {
+                pending = Promise.reject(error);
+            }
+            return turn.yieldFrameworkPromise(pending);
+        },
         post: (callback) => {
             void current.executor.post(callback);
         }

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

@@ -1,5 +1,8 @@
 export type ZLinkSerialWorkLane = 'application' | 'lifecycle';
 export interface ZLinkSerialWorkOptions {
+    readonly onAdmitted?: () => void;
+    /** Transfers an unstarted durable record out of this FIFO in the owner turn. */
+    readonly onWithdrawable?: (withdraw: () => boolean) => void;
     readonly lane?: ZLinkSerialWorkLane;
     readonly payloadBytes?: number;
     readonly metadataBytes?: number;
@@ -66,7 +69,9 @@ export declare class ZLinkSerialExecutionQueue {
     submitPreAdmitted<T>(operation: () => Promise<T> | T, options?: ZLinkSerialWorkOptions, context?: unknown): Promise<T>;
     /** Holds lifecycle FIFO through an operation result while its application turns can run. */
     submitLifecycleOperation<T>(operation: () => Promise<T> | T, context?: ZLinkSerialLifecycleContext): Promise<T>;
+    get retainsApplicationForLifecycle(): boolean;
     visitPendingApplication(visitor: (record: ZLinkSerialWorkRecord<unknown>) => void): void;
+    get hasPendingDurableApplication(): boolean;
     get hasPendingWork(): boolean;
     whenIdle(): Promise<void>;
     /** Stops new submissions while allowing the accepted FIFO to finish. */