@zlink-systems/framework 0.26.0 → 0.27.0

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkSerialExecutionQueue = exports.ZLINK_DEFAULT_SERIAL_SCHEDULER_OPTIONS = void 0;
+const abort_1 = require("../abort");
+const state_lane_1 = require("./state-lane");
 exports.ZLINK_DEFAULT_SERIAL_SCHEDULER_OPTIONS = Object.freeze({
     ownerTimeBudget: 10,
     lifecycleBurstLimit: 8
@@ -73,8 +75,12 @@ class ZLinkSerialExecutionQueue {
         return this.admit(operation, options, context);
     }
     /** Holds lifecycle FIFO through an operation result while its application turns can run. */
-    submitLifecycleOperation(operation) {
-        return this.admit(operation, { lane: 'lifecycle' }, undefined, undefined, true);
+    submitLifecycleOperation(operation, context) {
+        return this.admit(operation, { lane: 'lifecycle' }, context, undefined, true);
+    }
+    visitPendingApplication(visitor) {
+        for (const record of this.application.records)
+            visitor(record);
     }
     get hasPendingWork() {
         return (this.draining ||
@@ -96,6 +102,9 @@ class ZLinkSerialExecutionQueue {
     closeAdmission() {
         this.closed = true;
     }
+    get admissionClosed() {
+        return this.closed;
+    }
     admit(operation, options, context, preparation, operationEnvelope = false) {
         if (this.closed)
             throw new Error('The serial execution queue is closed.');
@@ -238,16 +247,14 @@ class ZLinkSerialExecutionQueue {
                 }
                 if (this.shouldYield()) {
                     this.claimStartedAt = undefined;
-                    await macrotaskBoundary();
+                    await (0, abort_1.macrotaskBoundary)();
                 }
             }
         }
         finally {
             this.draining = false;
             this.claimStartedAt = undefined;
-            if (!waitingForPreparation &&
-                (this.application.records.length > 0 ||
-                    (this.activeLifecycle === undefined && this.lifecycle.records.length > 0))) {
+            if (!waitingForPreparation && this.selectNext() !== undefined) {
                 this.scheduleDrain();
             }
             else {
@@ -258,7 +265,11 @@ class ZLinkSerialExecutionQueue {
         }
     }
     selectNext() {
-        const applicationReady = this.application.records.length > 0;
+        const lifecycleOwner = this.activeLifecycle?.context;
+        const applicationRecord = lifecycleOwner === undefined
+            ? this.application.records[0]
+            : this.application.records.find((record) => lifecycleOwner.canExecuteApplication(record));
+        const applicationReady = applicationRecord !== undefined;
         const lifecycleReady = this.activeLifecycle === undefined && this.lifecycle.records.length > 0;
         if (!applicationReady && !lifecycleReady)
             return undefined;
@@ -266,15 +277,17 @@ class ZLinkSerialExecutionQueue {
             return { lane: 'lifecycle', record: this.lifecycle.records[0] };
         }
         if (!lifecycleReady) {
-            return { lane: 'application', record: this.application.records[0] };
+            return { lane: 'application', record: applicationRecord };
         }
         if (!this.lifecycleDebt && this.lifecycleStreak < this.lifecycleBurstLimit) {
             return { lane: 'lifecycle', record: this.lifecycle.records[0] };
         }
-        return { lane: 'application', record: this.application.records[0] };
+        return { lane: 'application', record: applicationRecord };
     }
     takeSelected(selection) {
-        const record = selection.lane === 'lifecycle' ? this.takeLifecycle() : this.takeApplication();
+        const record = selection.lane === 'lifecycle'
+            ? this.takeLifecycle()
+            : this.takeApplication(selection.record);
         if (record !== selection.record) {
             throw new Error('The selected serial work record changed before owner claim.');
         }
@@ -289,10 +302,13 @@ class ZLinkSerialExecutionQueue {
         this.activeLifecycle = record;
         return record;
     }
-    takeApplication() {
+    takeApplication(selected) {
         this.lifecycleStreak = 0;
         this.lifecycleDebt = false;
-        return this.application.records.shift();
+        if (this.application.records[0] === selected)
+            return this.application.records.shift();
+        const index = this.application.records.indexOf(selected);
+        return this.application.records.splice(index, 1)[0];
     }
     startPreparation(record) {
         const preparation = record.preparation;
@@ -355,6 +371,32 @@ class ZLinkSerialExecutionQueue {
     }
 }
 exports.ZLinkSerialExecutionQueue = ZLinkSerialExecutionQueue;
+if ((0, state_lane_1.isStructuralGuardEnabled)()) {
+    const submit = ZLinkSerialExecutionQueue.prototype.submit;
+    ZLinkSerialExecutionQueue.prototype.submit = function (operation, options = {}, context) {
+        return (0, state_lane_1.guardStateLaneCompletion)((0, state_lane_1.trackDiagnosticCompletion)(submit.call(this, operation, options, context), `serial ${options.lane ?? 'application'} ${(0, state_lane_1.diagnosticWorkName)(operation)}`), 'serial completion');
+    };
+    const submitPreAdmitted = ZLinkSerialExecutionQueue.prototype.submitPreAdmitted;
+    ZLinkSerialExecutionQueue.prototype.submitPreAdmitted = function (operation, options = {}, context) {
+        return (0, state_lane_1.guardStateLaneCompletion)((0, state_lane_1.trackDiagnosticCompletion)(submitPreAdmitted.call(this, operation, options, context), `serial ${options.lane ?? 'application'} ${(0, state_lane_1.diagnosticWorkName)(operation)}`), 'serial completion');
+    };
+    const submitContinuation = ZLinkSerialExecutionQueue.prototype.submitContinuation;
+    ZLinkSerialExecutionQueue.prototype.submitContinuation = function (operation, context) {
+        return (0, state_lane_1.guardStateLaneCompletion)((0, state_lane_1.trackDiagnosticCompletion)(submitContinuation.call(this, operation, context), `serial continuation ${(0, state_lane_1.diagnosticWorkName)(operation)}`), 'serial completion');
+    };
+    const admitDurablePrefix = ZLinkSerialExecutionQueue.prototype.admitDurablePrefix;
+    ZLinkSerialExecutionQueue.prototype.admitDurablePrefix = function (operation, options = {}, context, preparation) {
+        return (0, state_lane_1.guardStateLaneCompletion)((0, state_lane_1.trackDiagnosticCompletion)(admitDurablePrefix.call(this, operation, options, context, preparation), `serial durable ${(0, state_lane_1.diagnosticWorkName)(operation)}`), 'serial completion');
+    };
+    const submitLifecycleOperation = ZLinkSerialExecutionQueue.prototype.submitLifecycleOperation;
+    ZLinkSerialExecutionQueue.prototype.submitLifecycleOperation = function (operation) {
+        return (0, state_lane_1.guardStateLaneCompletion)((0, state_lane_1.trackDiagnosticCompletion)(submitLifecycleOperation.call(this, operation), `serial lifecycle ${(0, state_lane_1.diagnosticWorkName)(operation)}`), 'serial completion');
+    };
+    const whenIdle = ZLinkSerialExecutionQueue.prototype.whenIdle;
+    ZLinkSerialExecutionQueue.prototype.whenIdle = function () {
+        return (0, state_lane_1.guardStateLaneCompletion)(whenIdle.call(this), 'serial completion');
+    };
+}
 function createLane() {
     return {
         records: []
@@ -370,6 +412,3 @@ function validateNonNegative(value, field) {
         throw new RangeError(`${field} must be a non-negative safe integer.`);
     }
 }
-function macrotaskBoundary() {
-    return new Promise((resolve) => setImmediate(resolve));
-}

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

@@ -1,4 +1,5 @@
 type ZLinkStateLaneWork<T> = () => Promise<T> | T;
+export declare function isStructuralGuardEnabled(): boolean;
 /**
  * Single-owner execution lane for a component's mutable state.
  *
@@ -7,7 +8,6 @@ type ZLinkStateLaneWork<T> = () => Promise<T> | T;
  * Actor serial executors, which also own lifecycle and relocation concerns.
  */
 export declare class ZLinkStateLane {
-    private static readonly currentLaneStorage;
     private readonly mailbox;
     private draining;
     private drainPromise;
@@ -25,4 +25,11 @@ export declare class ZLinkStateLane {
     private scheduleDrain;
     private drain;
 }
+/** Applied only by debug-installed wrappers; release completions keep their original identity. */
+export declare function guardStateLaneCompletion<T>(completion: Promise<T>, label: string, owner?: ZLinkStateLane): Promise<T>;
+export declare function trackDiagnosticCompletion<T>(completion: Promise<T>, name: string): Promise<T>;
+export declare function debugPendingWorkNames(): string[];
+export declare function diagnosticWorkName(work: {
+    readonly name: string;
+}): string;
 export {};

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

@@ -1,7 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkStateLane = void 0;
+exports.isStructuralGuardEnabled = isStructuralGuardEnabled;
+exports.guardStateLaneCompletion = guardStateLaneCompletion;
+exports.trackDiagnosticCompletion = trackDiagnosticCompletion;
+exports.debugPendingWorkNames = debugPendingWorkNames;
+exports.diagnosticWorkName = diagnosticWorkName;
 const node_async_hooks_1 = require("node:async_hooks");
+const UNKNOWN_DIAGNOSTIC_CALLER = '<unknown caller>';
+function isStructuralGuardEnabled() {
+    return process.env.ZLINK_NODE_STRUCTURAL_GUARD === '1' || process.env.NODE_ENV === 'test';
+}
+const currentLaneStorage = new node_async_hooks_1.AsyncLocalStorage();
+const diagnosticPending = isStructuralGuardEnabled() ? new Map() : undefined;
+let nextDiagnosticWork = 0;
+const diagnosticTurnStorage = diagnosticPending === undefined ? undefined : new node_async_hooks_1.AsyncLocalStorage();
 /**
  * Single-owner execution lane for a component's mutable state.
  *
@@ -10,13 +23,12 @@ const node_async_hooks_1 = require("node:async_hooks");
  * Actor serial executors, which also own lifecycle and relocation concerns.
  */
 class ZLinkStateLane {
-    static currentLaneStorage = new node_async_hooks_1.AsyncLocalStorage();
     mailbox = [];
     draining = false;
     drainPromise;
     closed = false;
     static get current() {
-        return ZLinkStateLane.currentLaneStorage.getStore();
+        return currentLaneStorage.getStore();
     }
     get isOnLane() {
         return ZLinkStateLane.current === this;
@@ -86,7 +98,7 @@ class ZLinkStateLane {
                     return;
                 }
                 try {
-                    await ZLinkStateLane.currentLaneStorage.run(this, work);
+                    await currentLaneStorage.run(this, work);
                 }
                 catch {
                     // Posted callbacks own their errors. One failure must not strand later work.
@@ -103,3 +115,106 @@ class ZLinkStateLane {
     }
 }
 exports.ZLinkStateLane = ZLinkStateLane;
+// Install the structural check only in diagnostic processes. The release run()
+// method and its returned Promise are left untouched.
+if (isStructuralGuardEnabled()) {
+    Object.defineProperty(ZLinkStateLane, 'current', {
+        configurable: true,
+        get: () => {
+            const turn = diagnosticTurnStorage?.getStore();
+            return turn?.active === true ? turn.lane : undefined;
+        }
+    });
+    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 tryPost = ZLinkStateLane.prototype.tryPost;
+    ZLinkStateLane.prototype.tryPost = function (work) {
+        const release = registerDiagnosticWork(`state lane post ${diagnosticWorkName(work)}`);
+        const accepted = tryPost.call(this, () => {
+            try {
+                const result = runDiagnosticTurn(this, work);
+                if (result instanceof Promise)
+                    return result.finally(release);
+                release();
+                return result;
+            }
+            catch (error) {
+                release();
+                throw error;
+            }
+        });
+        if (!accepted)
+            release();
+        return accepted;
+    };
+}
+function runDiagnosticTurn(lane, work) {
+    const turn = { lane, active: true };
+    return diagnosticTurnStorage.run(turn, () => {
+        try {
+            const result = work();
+            if (result instanceof Promise) {
+                return result.finally(() => {
+                    turn.active = false;
+                });
+            }
+            turn.active = false;
+            return result;
+        }
+        catch (error) {
+            turn.active = false;
+            throw error;
+        }
+    });
+}
+/** Applied only by debug-installed wrappers; release completions keep their original identity. */
+function guardStateLaneCompletion(completion, label, owner) {
+    return new Proxy(completion, {
+        get(target, property) {
+            if (property === 'then') {
+                return (onFulfilled, onRejected) => {
+                    const current = ZLinkStateLane.current;
+                    if (current !== undefined && current !== owner) {
+                        throw new Error(`A state lane turn cannot wait for ${label}.`);
+                    }
+                    return target.then(onFulfilled, onRejected);
+                };
+            }
+            if (property === 'catch') {
+                return (onRejected) => guardStateLaneCompletion(target.catch(onRejected), label, owner);
+            }
+            if (property === 'finally') {
+                return (onFinally) => guardStateLaneCompletion(target.finally(onFinally), label, owner);
+            }
+            const value = Reflect.get(target, property, target);
+            return typeof value === 'function' ? value.bind(target) : value;
+        }
+    });
+}
+function trackDiagnosticCompletion(completion, name) {
+    const release = registerDiagnosticWork(name);
+    void completion.then(release, release);
+    return completion;
+}
+function debugPendingWorkNames() {
+    return [...(diagnosticPending?.values() ?? [])];
+}
+function diagnosticWorkName(work) {
+    return work.name.length > 0 ? work.name : '<anonymous>';
+}
+function registerDiagnosticWork(name) {
+    if (diagnosticPending === undefined)
+        return () => undefined;
+    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 () => {
+        diagnosticPending.delete(id);
+    };
+}

package/dist/runtime/foundation/actor-join-recovery-codec.d.ts

@@ -1,4 +1,7 @@
 import type { RoutingId, ZLinkActorJoinOperationId } from '../../contracts';
+export declare const SHA256_DIGEST_BYTES = 32;
+export declare const RECREATE_RELOCATION_CONTENT_TYPE = "application/vnd.zlink.actor-relocation.recreate";
+export declare const SNAPSHOT_RELOCATION_CONTENT_TYPE = "application/vnd.zlink.actor-relocation.snapshot";
 export interface CanonicalActorJoinRecoveryRequest {
     readonly actorId: string;
     readonly actorType: string;

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

@@ -1,24 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SNAPSHOT_RELOCATION_CONTENT_TYPE = exports.RECREATE_RELOCATION_CONTENT_TYPE = exports.SHA256_DIGEST_BYTES = void 0;
 exports.canonicalActorJoinHandoffId = canonicalActorJoinHandoffId;
 exports.encodeCanonicalActorJoinRecoverySavedWork = encodeCanonicalActorJoinRecoverySavedWork;
 exports.decodeCanonicalActorJoinRecoverySavedWork = decodeCanonicalActorJoinRecoverySavedWork;
 exports.routingIdBytes = routingIdBytes;
+const stream_wire_1 = require("@zlink-systems/stream-wire");
 const node_crypto_1 = require("node:crypto");
-const routing_id_1 = require("../routing-id");
 const service_wire_pilot_codec_generated_1 = require("../protocol/service_wire_pilot_codec.generated");
+const routing_id_1 = require("../routing-id");
 const service_stateful_wire_codec_1 = require("./service-stateful-wire-codec");
+const ACTOR_ID_DIGEST_MAX_BYTES = 0xffff;
+exports.SHA256_DIGEST_BYTES = 32;
 const RECOVERY_PACKET_NAME = '__zlink.actor.routed_join.recovery';
 const RECOVERY_CONTENT_TYPE = 'application/x-zlink-actor-routed-join-recovery-v1';
 const MAXIMUM_METADATA_BYTES = 256 * 1024;
 const FRAMEWORK_METADATA_UPPER_BOUND_BYTES = 64 * 1024;
 const ACCEPTED_JOURNAL_UPPER_BOUND_BYTES = 16 * 1024 * 1024;
 const SNAPSHOT_APPLICATION_STATE_RESERVATION_BYTES = 64 * 1024 * 1024;
-const RECREATE_RELOCATION_CONTENT_TYPE = 'application/vnd.zlink.actor-relocation.recreate';
-const SNAPSHOT_RELOCATION_CONTENT_TYPE = 'application/vnd.zlink.actor-relocation.snapshot';
+exports.RECREATE_RELOCATION_CONTENT_TYPE = 'application/vnd.zlink.actor-relocation.recreate';
+exports.SNAPSHOT_RELOCATION_CONTENT_TYPE = 'application/vnd.zlink.actor-relocation.snapshot';
 function canonicalActorJoinHandoffId(input) {
     const actor = textBytes(input.actorId, 'actorId');
-    if (actor.byteLength > 0xffff)
+    if (actor.byteLength > ACTOR_ID_DIGEST_MAX_BYTES)
         throw new RangeError('Actor id exceeds u16 bytes.');
     const digest = (0, node_crypto_1.createHash)('sha256')
         .update(Buffer.concat([
@@ -65,7 +69,7 @@ function encodeCanonicalActorJoinRecoverySavedWork(input) {
             RelocationChecksumCrc32c: 0,
             RelocationAggregateId: canonicalUuid(input.relocationId),
             RelocationAggregateGeneration: 1n,
-            RelocationInventoryDigest: Buffer.alloc(32).toString('base64'),
+            RelocationInventoryDigest: Buffer.alloc(exports.SHA256_DIGEST_BYTES).toString('base64'),
             RequestContentType: requireText(input.requestContentType, 'Actor Join request content type'),
             Request: '',
             HandoffFrames: [],
@@ -258,14 +262,14 @@ function predictedRelocationPayloadBytes(requestBytes, relocationContentType) {
     if (!Number.isSafeInteger(requestBytes) || requestBytes < 0) {
         throw new RangeError('Actor Join request size is invalid.');
     }
-    if (relocationContentType !== RECREATE_RELOCATION_CONTENT_TYPE &&
-        relocationContentType !== SNAPSHOT_RELOCATION_CONTENT_TYPE) {
+    if (relocationContentType !== exports.RECREATE_RELOCATION_CONTENT_TYPE &&
+        relocationContentType !== exports.SNAPSHOT_RELOCATION_CONTENT_TYPE) {
         throw new TypeError('Actor Join relocation content type is invalid.');
     }
     return (FRAMEWORK_METADATA_UPPER_BOUND_BYTES +
         ACCEPTED_JOURNAL_UPPER_BOUND_BYTES +
         requestBytes +
-        (relocationContentType === SNAPSHOT_RELOCATION_CONTENT_TYPE
+        (relocationContentType === exports.SNAPSHOT_RELOCATION_CONTENT_TYPE
             ? SNAPSHOT_APPLICATION_STATE_RESERVATION_BYTES
             : 0));
 }
@@ -281,7 +285,7 @@ function requireText(value, name) {
     return value;
 }
 function nonZeroU64(value, name) {
-    if (value < 1n || value > 0xffffffffffffffffn)
+    if (value < 1n || value > stream_wire_1.UINT64_MAX)
         throw new RangeError(`${name} is invalid.`);
     return value;
 }
@@ -293,7 +297,7 @@ function u16(value) {
     return result;
 }
 function u64(value) {
-    if (value < 0n || value > 0xffffffffffffffffn)
+    if (value < 0n || value > stream_wire_1.UINT64_MAX)
         throw new RangeError('u64');
     const result = Buffer.alloc(8);
     result.writeBigUInt64BE(value);
@@ -317,7 +321,7 @@ function integer(value, name) {
     if (typeof value !== 'string' || !/^\d+$/u.test(value))
         throw new TypeError(`${name} is invalid.`);
     const parsed = BigInt(value);
-    if (parsed > 0xffffffffffffffffn)
+    if (parsed > stream_wire_1.UINT64_MAX)
         throw new TypeError(`${name} exceeds u64.`);
     return parsed;
 }

package/dist/runtime/foundation/event-loop-resources.d.ts

@@ -8,27 +8,5 @@ export declare class EventLoopResourceStack {
     own<T extends CloseableResource>(resource: T): T;
     close(): Promise<void>;
 }
-export type EventLoopTask = () => void | Promise<void>;
-/** Keeps infrastructure progress independent from awaiting application handlers. */
-export declare class EventLoopWorkQueues {
-    private readonly infrastructure;
-    private infrastructureHead;
-    private infrastructureCount;
-    private readonly application;
-    private applicationHead;
-    private applicationCount;
-    private infrastructureScheduled;
-    private applicationScheduled;
-    private accepting;
-    submitInfrastructure(task: EventLoopTask): boolean;
-    submitApplication(task: EventLoopTask): boolean;
-    stopAdmission(): void;
-    private scheduleInfrastructure;
-    private drainInfrastructure;
-    private scheduleApplication;
-    private drainApplication;
-    private takeInfrastructure;
-    private takeApplication;
-    private compactInfrastructure;
-    private compactApplication;
-}
+export declare function closeResources(resources: readonly CloseableResource[]): Promise<void>;
+export declare function finishResourceCleanup(failures: readonly unknown[]): void;

package/dist/runtime/foundation/event-loop-resources.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventLoopWorkQueues = exports.EventLoopResourceStack = void 0;
-const execution_1 = require("../execution");
+exports.EventLoopResourceStack = void 0;
+exports.closeResources = closeResources;
+exports.finishResourceCleanup = finishResourceCleanup;
 /** Closes owned runtime resources once, in reverse acquisition order. */
 class EventLoopResourceStack {
     resources = [];
@@ -31,124 +32,10 @@ async function closeResources(resources) {
             failures.push(error);
         }
     }
+    finishResourceCleanup(failures);
+}
+function finishResourceCleanup(failures) {
     if (failures.length > 0) {
         throw new AggregateError(failures, 'Event-loop resource cleanup failed.');
     }
 }
-/** Keeps infrastructure progress independent from awaiting application handlers. */
-class EventLoopWorkQueues {
-    infrastructure = [];
-    infrastructureHead = 0;
-    infrastructureCount = 0;
-    application = [];
-    applicationHead = 0;
-    applicationCount = 0;
-    infrastructureScheduled = false;
-    applicationScheduled = false;
-    accepting = true;
-    submitInfrastructure(task) {
-        if (!this.accepting)
-            return false;
-        this.infrastructure.push(task);
-        this.infrastructureCount += 1;
-        this.scheduleInfrastructure();
-        return true;
-    }
-    submitApplication(task) {
-        if (!this.accepting)
-            return false;
-        this.application.push(task);
-        this.applicationCount += 1;
-        this.scheduleApplication();
-        return true;
-    }
-    stopAdmission() {
-        this.accepting = false;
-    }
-    scheduleInfrastructure() {
-        if (this.infrastructureScheduled)
-            return;
-        this.infrastructureScheduled = true;
-        queueMicrotask(() => this.drainInfrastructure());
-    }
-    drainInfrastructure() {
-        this.infrastructureScheduled = false;
-        const task = this.takeInfrastructure();
-        if (task === undefined)
-            return;
-        try {
-            const result = (0, execution_1.runZLinkExecutionArea)('infrastructure', task);
-            if (result instanceof Promise)
-                void result.catch(() => undefined);
-        }
-        finally {
-            if (this.infrastructureCount > 0)
-                this.scheduleInfrastructure();
-        }
-    }
-    scheduleApplication() {
-        if (this.applicationScheduled)
-            return;
-        this.applicationScheduled = true;
-        queueMicrotask(() => void this.drainApplication());
-    }
-    async drainApplication() {
-        try {
-            const task = this.takeApplication();
-            if (task !== undefined) {
-                await (0, execution_1.runZLinkExecutionArea)('application', task);
-            }
-        }
-        catch {
-            // Handler failure is reported by the dispatch owner; it does not stop this queue.
-        }
-        finally {
-            this.applicationScheduled = false;
-            if (this.applicationCount > 0)
-                this.scheduleApplication();
-        }
-    }
-    takeInfrastructure() {
-        const task = this.infrastructure[this.infrastructureHead];
-        if (task === undefined)
-            return undefined;
-        this.infrastructure[this.infrastructureHead] = undefined;
-        this.infrastructureHead += 1;
-        this.infrastructureCount -= 1;
-        this.compactInfrastructure();
-        return task;
-    }
-    takeApplication() {
-        const task = this.application[this.applicationHead];
-        if (task === undefined)
-            return undefined;
-        this.application[this.applicationHead] = undefined;
-        this.applicationHead += 1;
-        this.applicationCount -= 1;
-        this.compactApplication();
-        return task;
-    }
-    compactInfrastructure() {
-        if (this.infrastructureCount === 0) {
-            this.infrastructure.length = 0;
-            this.infrastructureHead = 0;
-        }
-        else if (this.infrastructureHead >= 1024 &&
-            this.infrastructureHead * 2 >= this.infrastructure.length) {
-            this.infrastructure.splice(0, this.infrastructureHead);
-            this.infrastructureHead = 0;
-        }
-    }
-    compactApplication() {
-        if (this.applicationCount === 0) {
-            this.application.length = 0;
-            this.applicationHead = 0;
-        }
-        else if (this.applicationHead >= 1024 &&
-            this.applicationHead * 2 >= this.application.length) {
-            this.application.splice(0, this.applicationHead);
-            this.applicationHead = 0;
-        }
-    }
-}
-exports.EventLoopWorkQueues = EventLoopWorkQueues;

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

@@ -1,3 +1,5 @@
+export declare const OPERATION_IDENTITY_BYTES = 16;
+export declare const ZLINK_NATIVE_CORRELATION_OPERATION_NAMESPACE = 2n;
 export interface ZLinkOperationIdentity128 {
     readonly high: bigint;
     readonly low: bigint;

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

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZLINK_NATIVE_CORRELATION_OPERATION_NAMESPACE = exports.OPERATION_IDENTITY_BYTES = void 0;
 exports.operationIdentityKey = operationIdentityKey;
 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) {
     requireUnsigned64(operationId.high, 'operationId.high');
     requireUnsigned64(operationId.low, 'operationId.low');
@@ -13,13 +17,13 @@ function operationIdentityKey(operationId) {
 }
 function createRandomOperationIdentity(source = node_crypto_1.randomBytes) {
     for (;;) {
-        const bytes = source(16);
-        if (bytes.length !== 16) {
-            throw new RangeError('Operation identity entropy source must return exactly 16 bytes.');
+        const bytes = source(exports.OPERATION_IDENTITY_BYTES);
+        if (bytes.length !== exports.OPERATION_IDENTITY_BYTES) {
+            throw new RangeError(`Operation identity entropy source must return exactly ${exports.OPERATION_IDENTITY_BYTES} bytes.`);
         }
         const operationId = {
             high: bytes.readBigUInt64BE(0),
-            low: bytes.readBigUInt64BE(8)
+            low: bytes.readBigUInt64BE(stream_wire_1.UINT64_BYTES)
         };
         if (operationId.high !== 0n || operationId.low !== 0n) {
             return operationId;
@@ -27,7 +31,7 @@ function createRandomOperationIdentity(source = node_crypto_1.randomBytes) {
     }
 }
 function requireUnsigned64(value, name) {
-    if (typeof value !== 'bigint' || value < 0n || value > 0xffffffffffffffffn) {
+    if (typeof value !== 'bigint' || value < 0n || value > stream_wire_1.UINT64_MAX) {
         throw new RangeError(`${name} must be an unsigned 64-bit integer.`);
     }
 }

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

@@ -1,6 +1,5 @@
 export interface OperationClock {
-    setTimeout(callback: () => void, delayMs: number): unknown;
-    clearTimeout(handle: unknown): void;
+    now(): number;
 }
 export declare class OperationTimeoutError extends Error {
     readonly operationId: bigint;
@@ -17,20 +16,19 @@ export interface PendingOperation<T> {
 /** Owns request completion so reply, timeout, cancellation, and shutdown race safely. */
 export declare class OperationRegistry<T> {
     private readonly clock;
+    private readonly onPendingChanged?;
     private readonly entries;
     private nextId;
-    private generation;
+    private deadlineCursor?;
     private closed;
-    constructor(clock?: OperationClock);
+    constructor(clock?: OperationClock, onPendingChanged?: (() => void) | undefined);
     register(timeoutMs: number, timeoutOwner?: 'registry' | 'sender'): PendingOperation<T>;
     complete(id: bigint, value: T): boolean;
     fail(id: bigint, reason: unknown): boolean;
-    private failCore;
     cancel(id: bigint, message?: string): boolean;
     isPending(id: bigint): boolean;
     close(reason?: string): void;
     get size(): number;
-    private rejectIfCurrent;
+    expire(nowMs: number, turnDeadlineMs: number): number;
     private take;
-    private clearTimer;
 }