@zlink-systems/framework 0.30.1 → 0.30.3

package/dist/runtime/channels/fanout-location-runtime.d.ts

@@ -30,7 +30,7 @@ export declare class ZLinkFanoutLocationRuntime {
         lifecycleGeneration: bigint;
         descriptorRevision: bigint;
         advertisedEndpoint: string;
-        state: "error" | "preparing" | "serving" | "retiring" | "stopped";
+        state: "error" | "preparing" | "serving" | "stopped" | "retiring";
     }[] | undefined;
     private isAutomaticSubscriber;
     reclaimOwnerRows(signal?: AbortSignal): Promise<void>;

package/dist/runtime/channels/fanout-location-runtime.js

@@ -112,7 +112,7 @@ class ZLinkFanoutLocationRuntime {
                 ownerId: owner.ownerId,
                 leaseGeneration: owner.leaseGeneration
             };
-            const result = await this.store.updateFanoutPublisher(candidate, Locations_1.ZLinkLocationWriteIntent.Takeover, signal);
+            const result = await this.locationRuntime.writeDescriptor((writeSignal) => this.store.updateFanoutPublisher(candidate, Locations_1.ZLinkLocationWriteIntent.Takeover, writeSignal), signal);
             if (result.status !== Locations_1.ZLinkLocationWriteStatus.Stored) {
                 throw new configuration_1.ZLinkConfigurationException(`Fanout publisher '${channelName}' descriptor recovery was fenced.`);
             }
@@ -135,7 +135,7 @@ class ZLinkFanoutLocationRuntime {
             }
             const current = await this.lane.run(() => this.localDescriptors.get(channelName));
             if (current !== undefined) {
-                const result = await this.store.updateFanoutPublisher(current, Locations_1.ZLinkLocationWriteIntent.Renew, signal);
+                const result = await this.locationRuntime.writeDescriptor((writeSignal) => this.store.updateFanoutPublisher(current, Locations_1.ZLinkLocationWriteIntent.Renew, writeSignal), signal);
                 if (result.status !== Locations_1.ZLinkLocationWriteStatus.Stored) {
                     throw new configuration_1.ZLinkConfigurationException(`Fanout publisher '${channelName}' descriptor renewal was fenced.`);
                 }
@@ -169,7 +169,7 @@ class ZLinkFanoutLocationRuntime {
                 leaseGeneration: owner.leaseGeneration,
                 updatedAt: new Date(0)
             };
-            const result = await this.store.updateFanoutPublisher(descriptor, Locations_1.ZLinkLocationWriteIntent.NewClaim, signal);
+            const result = await this.locationRuntime.writeDescriptor((writeSignal) => this.store.updateFanoutPublisher(descriptor, Locations_1.ZLinkLocationWriteIntent.NewClaim, writeSignal), signal);
             if (result.status !== Locations_1.ZLinkLocationWriteStatus.Stored) {
                 throw new configuration_1.ZLinkConfigurationException(`Fanout publisher '${channelName}' descriptor claim failed with '${result.status}'.`);
             }

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);
         }
@@ -169,6 +192,11 @@ function isCurrentZLinkSpotSerialTurn(executor) {
         current.executor === executor &&
         executor.isActiveTurn(current.turn, current.turnId));
 }
+function createExecutionBarrierAdmissionException(seal, message) {
+    return (0, framework_errors_internal_1.createInternalFrameworkException)(seal.kind === 'close'
+        ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestTargetNotFound
+        : framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, message);
+}
 /**
  * Seals application-lane admission and waits for every active Promise turn to
  * finish. A seal generation prevents a stale abort from reopening a newer
@@ -192,14 +220,9 @@ class ZLinkExecutionBarrier {
     }
     enter() {
         if (this.committedSeal !== undefined) {
-            throw (0, framework_errors_internal_1.createInternalFrameworkException)(this.committedSeal.kind === 'close'
-                ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestRejected
-                : framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, 'ZLink execution barrier is committed.');
+            throw createExecutionBarrierAdmissionException(this.committedSeal, 'ZLink execution barrier is committed.');
         }
         if (this.currentSeal !== undefined) {
-            if (this.currentSeal.kind === 'close') {
-                throw (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestRejected, 'ZLink execution barrier is sealed for Close.');
-            }
             return new Promise((resolve, reject) => {
                 this.admissionWaiters.push({ resolve, reject });
             });
@@ -279,9 +302,7 @@ class ZLinkExecutionBarrier {
             return false;
         this.currentSeal = undefined;
         this.committedSeal = seal;
-        const error = (0, framework_errors_internal_1.createInternalFrameworkException)(seal.kind === 'close'
-            ? framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.RequestRejected
-            : framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.SpotMoving, 'ZLink execution barrier is committed.');
+        const error = createExecutionBarrierAdmissionException(seal, 'ZLink execution barrier is committed.');
         for (const waiter of this.admissionWaiters)
             waiter.reject(error);
         this.admissionWaiters.length = 0;

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

@@ -1,6 +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;
@@ -67,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. */

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

@@ -84,12 +84,20 @@ class ZLinkSerialExecutionQueue {
     submitLifecycleOperation(operation, context) {
         return this.admit(operation, { lane: 'lifecycle' }, context, undefined, true);
     }
+    get retainsApplicationForLifecycle() {
+        return this.activeLifecycle?.context !== undefined;
+    }
     visitPendingApplication(visitor) {
         for (const record of this.application.records) {
             if (record.mailbox === undefined)
                 visitor(record);
         }
     }
+    get hasPendingDurableApplication() {
+        // Every application record accepted behind durable work inherits durable
+        // ownership, so the tail answers this without scanning the FIFO.
+        return this.application.records.at(-1)?.preparation !== undefined;
+    }
     get hasPendingWork() {
         return (this.consumer?.running === true ||
             this.activeRecord !== undefined ||
@@ -182,6 +190,17 @@ class ZLinkSerialExecutionQueue {
             throw error;
         }
         options.onAdmitted?.();
+        options.onWithdrawable?.(() => {
+            const index = target.records.indexOf(record);
+            if (index < 0)
+                return false;
+            target.records.splice(index, 1);
+            record.preparationController?.abort(new Error('Durable record transferred to another handoff.'));
+            record.preparation?.cancel();
+            resolve(undefined);
+            release();
+            return true;
+        });
         this.scheduleDrain();
         return result;
     }
@@ -199,10 +218,10 @@ class ZLinkSerialExecutionQueue {
         if (consumer.scheduled || consumer.running)
             return;
         consumer.scheduled = true;
-        queueMicrotask(() => {
+        (0, state_lane_1.startOutsideStateLane)(() => queueMicrotask(() => {
             consumer.scheduled = false;
             void this.drain();
-        });
+        }));
     }
     /** Notifications carry no payload, admission sequence, result Promise, or host permit. */
     enqueueMailboxTurn(operation) {

package/dist/runtime/execution/state-lane.d.ts

@@ -1,5 +1,7 @@
 type ZLinkStateLaneWork<T> = () => Promise<T> | T;
 export declare function isStructuralGuardEnabled(): boolean;
+/** Detaches lane ownership while preserving the caller's other execution contexts. */
+export declare function startOutsideStateLane<T>(work: () => T): T;
 /**
  * Single-owner execution lane for a component's mutable state.
  *

package/dist/runtime/execution/state-lane.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkStateLane = void 0;
 exports.isStructuralGuardEnabled = isStructuralGuardEnabled;
+exports.startOutsideStateLane = startOutsideStateLane;
 exports.guardStateLaneCompletion = guardStateLaneCompletion;
 exports.trackDiagnosticCompletion = trackDiagnosticCompletion;
 exports.debugPendingWorkNames = debugPendingWorkNames;
@@ -11,8 +12,16 @@ const UNKNOWN_DIAGNOSTIC_CALLER = '<unknown caller>';
 function isStructuralGuardEnabled() {
     return process.env.ZLINK_NODE_STRUCTURAL_GUARD === '1' || process.env.NODE_ENV === 'test';
 }
+/** Detaches lane ownership while preserving the caller's other execution contexts. */
+function startOutsideStateLane(work) {
+    return currentLaneStorage.exit(() => diagnosticTurnStorage === undefined ? work() : diagnosticTurnStorage.exit(work));
+}
 const currentLaneStorage = new node_async_hooks_1.AsyncLocalStorage();
 const diagnosticPending = isStructuralGuardEnabled() ? new Map() : undefined;
+const diagnosticLaneIds = isStructuralGuardEnabled()
+    ? new WeakMap()
+    : undefined;
+let nextDiagnosticLane = 0;
 let nextDiagnosticWork = 0;
 const diagnosticTurnStorage = diagnosticPending === undefined ? undefined : new node_async_hooks_1.AsyncLocalStorage();
 /**
@@ -127,15 +136,24 @@ if (isStructuralGuardEnabled()) {
     });
     const run = ZLinkStateLane.prototype.run;
     ZLinkStateLane.prototype.run = function (work) {
-        const completion = run.call(this, () => runDiagnosticTurn(this, work));
-        return guardStateLaneCompletion(trackDiagnosticCompletion(completion, `state lane ${diagnosticWorkName(work)}`), 'another state lane completion', this);
+        const release = registerDiagnosticWork(`${diagnosticLaneName(this)} ${diagnosticWorkName(work)}`);
+        let completion;
+        try {
+            completion = run.call(this, () => runDiagnosticTurn(this, work, release.description));
+        }
+        catch (error) {
+            release();
+            throw error;
+        }
+        void completion.then(release, release);
+        return guardStateLaneCompletion(completion, `another state lane completion [${release.description}]`, this);
     };
     const tryPost = ZLinkStateLane.prototype.tryPost;
     ZLinkStateLane.prototype.tryPost = function (work) {
-        const release = registerDiagnosticWork(`state lane post ${diagnosticWorkName(work)}`);
+        const release = registerDiagnosticWork(`${diagnosticLaneName(this)} post ${diagnosticWorkName(work)}`);
         const accepted = tryPost.call(this, () => {
             try {
-                const result = runDiagnosticTurn(this, work);
+                const result = runDiagnosticTurn(this, work, release.description);
                 if (result instanceof Promise)
                     return result.finally(release);
                 release();
@@ -151,8 +169,8 @@ if (isStructuralGuardEnabled()) {
         return accepted;
     };
 }
-function runDiagnosticTurn(lane, work) {
-    const turn = { lane, active: true };
+function runDiagnosticTurn(lane, work, description) {
+    const turn = { lane, description, active: true };
     return diagnosticTurnStorage.run(turn, () => {
         try {
             const result = work();
@@ -178,7 +196,8 @@ function guardStateLaneCompletion(completion, label, owner) {
                 return (onFulfilled, onRejected) => {
                     const current = ZLinkStateLane.current;
                     if (current !== undefined && current !== owner) {
-                        throw new Error(`A state lane turn cannot wait for ${label}.`);
+                        throw new Error(`A state lane turn cannot wait for ${label}. ` +
+                            `current turn: ${diagnosticTurnStorage?.getStore()?.description ?? UNKNOWN_DIAGNOSTIC_CALLER}`);
                     }
                     return target.then(onFulfilled, onRejected);
                 };
@@ -205,16 +224,25 @@ function debugPendingWorkNames() {
 function diagnosticWorkName(work) {
     return work.name.length > 0 ? work.name : '<anonymous>';
 }
+function diagnosticLaneName(lane) {
+    let id = diagnosticLaneIds.get(lane);
+    if (id === undefined) {
+        id = ++nextDiagnosticLane;
+        diagnosticLaneIds.set(lane, id);
+    }
+    return `state lane #${id}`;
+}
 function registerDiagnosticWork(name) {
     if (diagnosticPending === undefined)
-        return () => undefined;
+        return Object.assign(() => undefined, { description: name });
     const id = ++nextDiagnosticWork;
     const frames = new Error().stack?.split('\n').slice(2) ?? [];
     const caller = frames
         .find((frame) => !frame.includes('state-lane.') && !frame.includes('serial-execution-queue.'))
         ?.trim() ?? UNKNOWN_DIAGNOSTIC_CALLER;
-    diagnosticPending.set(id, `${name} ${caller}`);
-    return () => {
+    const description = `${name} ${caller}`;
+    diagnosticPending.set(id, description);
+    return Object.assign(() => {
         diagnosticPending.delete(id);
-    };
+    }, { description });
 }