@zlink-systems/framework 0.25.0 → 0.27.0

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

@@ -13,7 +13,7 @@ export declare const ZLINK_DEFAULT_SERIAL_SCHEDULER_OPTIONS: Required<ZLinkSeria
 export interface ZLinkSerialWorkRecord<T> {
     readonly acceptedSequence: bigint;
     readonly lane: ZLinkSerialWorkLane;
-    readonly operation: () => Promise<T> | T;
+    operation: () => Promise<T> | T;
     readonly context?: unknown;
     resolve(value: T): void;
     reject(reason: unknown): void;
@@ -21,6 +21,10 @@ export interface ZLinkSerialWorkRecord<T> {
     release(): void;
     fail(reason: unknown): void;
 }
+/** The active lifecycle owner decides which existing application records can run. */
+export interface ZLinkSerialLifecycleContext {
+    canExecuteApplication(record: ZLinkSerialWorkRecord<unknown>): boolean;
+}
 /** Readiness work that must complete without claiming the serial owner. */
 export interface ZLinkSerialWorkPreparation {
     prepare(signal: AbortSignal): Promise<void>;
@@ -34,6 +38,7 @@ export declare class ZLinkSerialExecutionQueue {
     private readonly executeRecord;
     private readonly application;
     private readonly lifecycle;
+    private activeLifecycle?;
     private readonly ownerTimeBudget;
     private readonly lifecycleBurstLimit;
     private nextAcceptedSequence;
@@ -56,16 +61,16 @@ export declare class ZLinkSerialExecutionQueue {
      * It remains held through handler terminal completion.
      */
     submitPreAdmitted<T>(operation: () => Promise<T> | T, options?: ZLinkSerialWorkOptions, context?: unknown): Promise<T>;
-    snapshot(): {
-        readonly applicationMessages: number;
-        readonly applicationBytes: number;
-        readonly lifecycleMessages: number;
-        readonly lifecycleBytes: number;
-    };
+    /** Holds lifecycle FIFO through an operation result while its application turns can run. */
+    submitLifecycleOperation<T>(operation: () => Promise<T> | T, context?: ZLinkSerialLifecycleContext): Promise<T>;
+    visitPendingApplication(visitor: (record: ZLinkSerialWorkRecord<unknown>) => void): void;
     get hasPendingWork(): boolean;
     whenIdle(): Promise<void>;
     /** Stops new submissions while allowing the accepted FIFO to finish. */
     close(): Promise<void>;
+    /** Stops admission within the lifecycle operation that owns this queue's close. */
+    closeAdmission(): void;
+    get admissionClosed(): boolean;
     private admit;
     private scheduleDrain;
     private drain;

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
@@ -13,6 +15,7 @@ class ZLinkSerialExecutionQueue {
     executeRecord;
     application;
     lifecycle;
+    activeLifecycle;
     ownerTimeBudget;
     lifecycleBurstLimit;
     nextAcceptedSequence = 1n;
@@ -71,16 +74,19 @@ class ZLinkSerialExecutionQueue {
     submitPreAdmitted(operation, options = {}, context) {
         return this.admit(operation, options, context);
     }
-    snapshot() {
-        return {
-            applicationMessages: this.application.records.length,
-            applicationBytes: 0,
-            lifecycleMessages: this.lifecycle.records.length,
-            lifecycleBytes: 0
-        };
+    /** Holds lifecycle FIFO through an operation result while its application turns can run. */
+    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 || this.application.records.length > 0 || this.lifecycle.records.length > 0);
+        return (this.draining ||
+            this.activeLifecycle !== undefined ||
+            this.application.records.length > 0 ||
+            this.lifecycle.records.length > 0);
     }
     whenIdle() {
         if (!this.hasPendingWork)
@@ -89,10 +95,17 @@ class ZLinkSerialExecutionQueue {
     }
     /** Stops new submissions while allowing the accepted FIFO to finish. */
     close() {
-        this.closed = true;
+        this.closeAdmission();
         return this.whenIdle();
     }
-    admit(operation, options, context, preparation) {
+    /** Stops admission within the lifecycle operation that owns this queue's close. */
+    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.');
         const lane = options.lane ?? 'application';
@@ -109,6 +122,15 @@ class ZLinkSerialExecutionQueue {
             if (released)
                 return;
             released = true;
+            if (this.activeLifecycle === record) {
+                this.activeLifecycle = undefined;
+                if (this.application.records.length > 0 || this.lifecycle.records.length > 0) {
+                    this.scheduleDrain();
+                }
+                else if (!this.draining) {
+                    this.resolveIdleWaiters();
+                }
+            }
         };
         const resolve = (value) => {
             if (settled)
@@ -126,6 +148,7 @@ class ZLinkSerialExecutionQueue {
             acceptedSequence: 0n,
             lane,
             operation,
+            operationEnvelope,
             context,
             preparation,
             preparationState: preparation === undefined ? 'ready' : 'idle',
@@ -197,7 +220,24 @@ class ZLinkSerialExecutionQueue {
                 }
                 this.claimStartedAt ??= performance.now();
                 try {
-                    await this.executeRecord(record);
+                    if (record.operationEnvelope) {
+                        try {
+                            const outcome = record.operation();
+                            void Promise.resolve(outcome).then((value) => {
+                                record.resolve(value);
+                                record.release();
+                            }, (error) => {
+                                record.reject(error);
+                                record.release();
+                            });
+                        }
+                        catch (error) {
+                            record.fail(error);
+                        }
+                    }
+                    else {
+                        await this.executeRecord(record);
+                    }
                 }
                 catch (error) {
                     record.fail(error);
@@ -207,42 +247,47 @@ 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.lifecycle.records.length > 0)) {
+            if (!waitingForPreparation && this.selectNext() !== undefined) {
                 this.scheduleDrain();
             }
             else {
-                if (this.application.records.length === 0 && this.lifecycle.records.length === 0) {
+                if (!this.hasPendingWork) {
                     this.resolveIdleWaiters();
                 }
             }
         }
     }
     selectNext() {
-        const applicationReady = this.application.records.length > 0;
-        const lifecycleReady = this.lifecycle.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;
         if (!applicationReady) {
             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.');
         }
@@ -253,12 +298,17 @@ class ZLinkSerialExecutionQueue {
         if (this.application.records.length > 0 && this.lifecycleStreak >= this.lifecycleBurstLimit) {
             this.lifecycleDebt = true;
         }
-        return this.lifecycle.records.shift();
+        const record = this.lifecycle.records.shift();
+        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;
@@ -321,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: []
@@ -336,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;