@zlink-systems/framework 0.11.0 → 0.13.0

package/dist/runtime/channels/channel-receive-loops.js

@@ -152,20 +152,15 @@ class ZLinkChannelReceiveLoop {
                 this.roundRobin?.setReady(this.receiveOwner, false);
                 this.roundRobin?.release(this.receiveOwner);
                 batch.reset();
-                await waitReceiveLoopIdle();
+                if (!await this.poller.waitForReadable(capacitySignal))
+                    break;
                 continue;
             }
             const applicationJobPermit = await this.acquirePermit(capacitySignal);
             if (applicationJobPermit === undefined)
                 break;
-            if (!this.poller.wait(0)) {
-                applicationJobPermit.releaseAfterInternalProcessing();
-                this.roundRobin?.setReady(this.receiveOwner, false);
-                this.roundRobin?.release(this.receiveOwner);
-                batch.reset();
-                await waitReceiveLoopIdle();
-                continue;
-            }
+            // Readiness can become stale while admission waits. The nonblocking
+            // recv below owns the empty-result check and returns the permit then.
             this.roundRobin?.setReady(this.receiveOwner, true);
             if (this.roundRobin?.tryAcquire(this.receiveOwner) === false) {
                 applicationJobPermit.releaseAfterInternalProcessing();
@@ -183,12 +178,14 @@ class ZLinkChannelReceiveLoop {
             }
             const received = this.router.recv(1);
             if (received == null) {
+                this.poller.markDrained();
                 applicationJobPermit.releaseAfterInternalProcessing();
                 releaseRawReceive();
                 this.roundRobin?.setReady(this.receiveOwner, false);
                 this.roundRobin?.release(this.receiveOwner);
                 batch.reset();
-                await waitReceiveLoopIdle();
+                if (!await this.poller.waitForReadable(capacitySignal))
+                    break;
                 continue;
             }
             const receivedBytes = messageBytes(received.parts);
@@ -345,20 +342,13 @@ class ZLinkSubscriberReceiveLoop {
                 this.roundRobin?.setReady(this.receiveOwner, false);
                 this.roundRobin?.release(this.receiveOwner);
                 batch.reset();
-                await waitReceiveLoopIdle();
+                if (!await this.poller.waitForReadable(capacitySignal))
+                    break;
                 continue;
             }
             const applicationJobPermit = await this.acquirePermit(capacitySignal);
             if (applicationJobPermit === undefined)
                 break;
-            if (!this.poller.wait(0)) {
-                applicationJobPermit.releaseAfterInternalProcessing();
-                this.roundRobin?.setReady(this.receiveOwner, false);
-                this.roundRobin?.release(this.receiveOwner);
-                batch.reset();
-                await waitReceiveLoopIdle();
-                continue;
-            }
             this.roundRobin?.setReady(this.receiveOwner, true);
             if (this.roundRobin?.tryAcquire(this.receiveOwner) === false) {
                 applicationJobPermit.releaseAfterInternalProcessing();
@@ -375,14 +365,16 @@ class ZLinkSubscriberReceiveLoop {
                 continue;
             }
             const topicMessage = this.adapter.createTopicMessage();
-            if (!this.subscriber.subscribe(topicMessage)) {
+            if (!this.subscriber.subscribe(topicMessage, 1)) {
+                this.poller.markDrained();
                 applicationJobPermit.releaseAfterInternalProcessing();
                 releaseRawReceive();
                 topicMessage.close();
                 this.roundRobin?.setReady(this.receiveOwner, false);
                 this.roundRobin?.release(this.receiveOwner);
                 batch.reset();
-                await waitReceiveLoopIdle();
+                if (!await this.poller.waitForReadable(capacitySignal))
+                    break;
                 continue;
             }
             const receivedBytes = messageBytes(topicMessage.parts);
@@ -526,14 +518,8 @@ class ZLinkRouteReceiveLoop {
                 this.roundRobin?.setReady(this.receiveOwner, false);
                 this.roundRobin?.release(this.receiveOwner);
                 batch.reset();
-                await waitReceiveLoopIdle();
-                continue;
-            }
-            if (!this.poller.wait(0)) {
-                this.roundRobin?.setReady(this.receiveOwner, false);
-                this.roundRobin?.release(this.receiveOwner);
-                batch.reset();
-                await waitReceiveLoopIdle();
+                if (!await this.poller.waitForReadable(capacitySignal))
+                    break;
                 continue;
             }
             this.roundRobin?.setReady(this.receiveOwner, true);
@@ -551,11 +537,13 @@ class ZLinkRouteReceiveLoop {
             }
             const received = this.router.recv(1);
             if (received == null) {
+                this.poller.markDrained();
                 releaseRawReceive();
                 this.roundRobin?.setReady(this.receiveOwner, false);
                 this.roundRobin?.release(this.receiveOwner);
                 batch.reset();
-                await waitReceiveLoopIdle();
+                if (!await this.poller.waitForReadable(capacitySignal))
+                    break;
                 continue;
             }
             const receivedBytes = messageBytes(received.parts);
@@ -659,11 +647,11 @@ class ZLinkRouteReceiveLoop {
 }
 exports.ZLinkRouteReceiveLoop = ZLinkRouteReceiveLoop;
 const RECEIVE_BATCH_MESSAGE_LIMIT = 64;
-const RECEIVE_BATCH_BYTE_LIMIT = 4n * 1024n * 1024n;
+const RECEIVE_BATCH_BYTE_LIMIT = 4 * 1024 * 1024;
 const RECEIVE_BATCH_TIME_LIMIT_MS = 2;
 class ZLinkReceiveBatchBudget {
     messages = 0;
-    bytes = 0n;
+    bytes = 0;
     startedAt = performance.now();
     record(bytes) {
         this.messages += 1;
@@ -678,51 +666,23 @@ class ZLinkReceiveBatchBudget {
     }
     reset() {
         this.messages = 0;
-        this.bytes = 0n;
+        this.bytes = 0;
         this.startedAt = performance.now();
     }
 }
-class ZLinkSharedIdleWaiter {
-    delayMs;
-    pending;
-    resolvePending;
-    wake = () => {
-        const resolve = this.resolvePending;
-        this.pending = undefined;
-        this.resolvePending = undefined;
-        resolve?.();
-    };
-    constructor(delayMs) {
-        this.delayMs = delayMs;
-    }
-    wait() {
-        if (this.pending !== undefined)
-            return this.pending;
-        this.pending = new Promise((resolve) => {
-            this.resolvePending = resolve;
-        });
-        setTimeout(this.wake, this.delayMs);
-        return this.pending;
-    }
-}
-const CHANNEL_RECEIVE_IDLE_POLL_INTERVAL_MS = 5;
-const receiveLoopIdleWaiter = new ZLinkSharedIdleWaiter(CHANNEL_RECEIVE_IDLE_POLL_INTERVAL_MS);
-function waitReceiveLoopIdle() {
-    return receiveLoopIdleWaiter.wait();
-}
 function waitReceiveLoopTurn() {
     return new Promise(resolve => setImmediate(resolve));
 }
 function messageBytes(parts) {
-    return parts.reduce((sum, part) => sum + messagePartBytes(part), 0n);
+    return parts.reduce((sum, part) => sum + messagePartBytes(part), 0);
 }
 function messagePartBytes(part) {
     if (part === undefined) {
-        return 0n;
+        return 0;
     }
     const size = part.size;
     if (typeof size === 'function') {
-        return BigInt(size.call(part));
+        return size.call(part);
     }
-    return BigInt(part.data().byteLength);
+    return part.data().byteLength;
 }

package/dist/runtime/channels/channel-socket-registry.js

@@ -999,8 +999,10 @@ class ZLinkChannelSocketRegistry {
             if (!connection.readablePoller.wait(0))
                 return;
             const received = connection.dealer.recv(1);
-            if (received === undefined)
+            if (received === undefined) {
+                connection.readablePoller.markDrained();
                 return;
+            }
             try {
                 if (received.parts.length !== 1
                     || !(0, client_server_service_wire_1.isClientServerControlFrame)(received.parts[0].data())) {

package/dist/runtime/channels/channel-transports.d.ts

@@ -62,10 +62,11 @@ export declare class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTrans
     private readonly manualNodeTarget?;
     private readonly localNodeSubmit?;
     private readonly metrics?;
+    private readonly flowCreationEnabled;
     constructor(manager: () => ZLinkChannelTransportRuntime | undefined, routeChannelPredicate?: ((routerChannelId: string) => boolean) | undefined, meshRuntime?: (() => {
         readonly meshNode: (meshName: string) => ZLinkBackendMeshNode | undefined;
         readonly meshCompletionTable: (meshName: string) => ZLinkMeshCompletionTable | undefined;
-    } | undefined) | undefined, codecs?: ZLinkChannelEnvelopeCodecRegistry | undefined, manualNodeTarget?: ((meshName: string, targetNodeRid: string) => boolean | undefined) | undefined, localNodeSubmit?: ((meshName: string, sourceNodeRid: string, parts: readonly MessageLike[]) => ZLinkSubmitResult) | undefined, metrics?: ZLinkRuntimeMetrics | undefined);
+    } | undefined) | undefined, codecs?: ZLinkChannelEnvelopeCodecRegistry | undefined, manualNodeTarget?: ((meshName: string, targetNodeRid: string) => boolean | undefined) | undefined, localNodeSubmit?: ((meshName: string, sourceNodeRid: string, parts: readonly MessageLike[]) => ZLinkSubmitResult) | undefined, metrics?: ZLinkRuntimeMetrics | undefined, flowCreationEnabled?: () => boolean);
     canRouteChannel(routerChannelId: string): boolean;
     canRoutePacketChannel(routerChannelId: string): boolean;
     submit(meshName: string, targetNodeRid: string, packetName: string | undefined, message: unknown, signal?: AbortSignal, metadata?: ReadonlyMap<string, string>): Promise<ZLinkSubmitResult>;

package/dist/runtime/channels/channel-transports.js

@@ -22,7 +22,8 @@ class ZLinkRuntimeRouteTransport {
     manualNodeTarget;
     localNodeSubmit;
     metrics;
-    constructor(manager, routeChannelPredicate = undefined, meshRuntime = undefined, codecs, manualNodeTarget, localNodeSubmit, metrics) {
+    flowCreationEnabled;
+    constructor(manager, routeChannelPredicate = undefined, meshRuntime = undefined, codecs, manualNodeTarget, localNodeSubmit, metrics, flowCreationEnabled = () => true) {
         this.manager = manager;
         this.routeChannelPredicate = routeChannelPredicate;
         this.meshRuntime = meshRuntime;
@@ -30,6 +31,7 @@ class ZLinkRuntimeRouteTransport {
         this.manualNodeTarget = manualNodeTarget;
         this.localNodeSubmit = localNodeSubmit;
         this.metrics = metrics;
+        this.flowCreationEnabled = flowCreationEnabled;
     }
     canRouteChannel(routerChannelId) {
         const manager = this.manager();
@@ -46,10 +48,10 @@ class ZLinkRuntimeRouteTransport {
     async submit(meshName, targetNodeRid, packetName, message, signal, metadata) {
         // Call-scoped flow (spec 27 §4): the envelope flow pair lives only for
         // the duration of this outbound call, never in the caller's context.
-        return (0, flow_context_1.runWithOutboundFlow)(true, () => this.submitNode(meshName, targetNodeRid, packetName, message, signal, metadata, false));
+        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.submitNode(meshName, targetNodeRid, packetName, message, signal, metadata, false));
     }
     async submitInfrastructure(meshName, targetNodeRid, packetName, message, signal, metadata) {
-        return (0, flow_context_1.runWithOutboundFlow)(true, () => this.submitNode(meshName, targetNodeRid, packetName, message, signal, metadata, true));
+        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.submitNode(meshName, targetNodeRid, packetName, message, signal, metadata, true));
     }
     async submitNode(meshName, targetNodeRid, packetName, message, signal, metadata, allowObjectClientTarget) {
         const node = this.meshNode(meshName);
@@ -78,7 +80,7 @@ class ZLinkRuntimeRouteTransport {
         }
     }
     request(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata) {
-        return (0, flow_context_1.runWithOutboundFlow)(true, () => this.requestScoped(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata));
+        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.requestScoped(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata));
     }
     async requestScoped(meshName, targetNodeRid, packetName, request, timeoutMs, signal, metadata) {
         const node = this.meshNode(meshName);
@@ -94,7 +96,7 @@ class ZLinkRuntimeRouteTransport {
         return this.decodeMeshReply(meshName, completion);
     }
     submitToChannel(meshName, channelName, packetName, message, signal, metadata) {
-        return (0, flow_context_1.runWithOutboundFlow)(true, () => this.submitToChannelScoped(meshName, channelName, packetName, message, signal, metadata));
+        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.submitToChannelScoped(meshName, channelName, packetName, message, signal, metadata));
     }
     async submitToChannelScoped(meshName, channelName, packetName, message, signal, metadata) {
         (0, abort_1.throwIfAborted)(signal);
@@ -113,7 +115,7 @@ class ZLinkRuntimeRouteTransport {
         }
     }
     requestToChannel(meshName, channelName, packetName, request, timeoutMs, signal, metadata) {
-        return (0, flow_context_1.runWithOutboundFlow)(true, () => this.requestToChannelScoped(meshName, channelName, packetName, request, timeoutMs, signal, metadata));
+        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.requestToChannelScoped(meshName, channelName, packetName, request, timeoutMs, signal, metadata));
     }
     async requestToChannelScoped(meshName, channelName, packetName, request, timeoutMs, signal, metadata) {
         (0, abort_1.throwIfAborted)(signal);
@@ -149,7 +151,7 @@ class ZLinkRuntimeRouteTransport {
         }
     }
     sendToSpot(spotRouteTarget, message, options) {
-        return (0, flow_context_1.runWithOutboundFlow)(true, () => this.sendToSpotScoped(spotRouteTarget, message, options));
+        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.sendToSpotScoped(spotRouteTarget, message, options));
     }
     async sendToSpotScoped(spotRouteTarget, message, options) {
         const node = this.meshNode(spotRouteTarget.routerChannelId);
@@ -182,7 +184,7 @@ class ZLinkRuntimeRouteTransport {
         return { status: submission_result_1.ZLinkSubmitStatus.Submitted };
     }
     requestToSpot(spotRouteTarget, request, options) {
-        return (0, flow_context_1.runWithOutboundFlow)(true, () => this.requestToSpotScoped(spotRouteTarget, request, options));
+        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.requestToSpotScoped(spotRouteTarget, request, options));
     }
     async requestToSpotScoped(spotRouteTarget, request, options) {
         const meshName = spotRouteTarget.routerChannelId;
@@ -218,7 +220,7 @@ class ZLinkRuntimeRouteTransport {
         return this.requireManager().routeRequestRawFromSpotToSpot(sourceSpot, spotRouteTarget, request, options.timeoutMs, options.signal);
     }
     requestRawToSpot(spotRouteTarget, request, options) {
-        return (0, flow_context_1.runWithOutboundFlow)(true, () => this.requestRawToSpotScoped(spotRouteTarget, request, options));
+        return (0, flow_context_1.runWithOutboundFlow)(this.flowCreationEnabled(), () => this.requestRawToSpotScoped(spotRouteTarget, request, options));
     }
     async requestRawToSpotScoped(spotRouteTarget, request, options) {
         const meshName = spotRouteTarget.routerChannelId;
@@ -299,7 +301,7 @@ class ZLinkRuntimeRouteTransport {
         return table;
     }
     encodeMessage(kind, channelName, packetName, message, timeoutMs, metadata) {
-        return (0, channel_envelope_1.encodeChannelEnvelopeParts)(kind, channelName, packetName, message, timeoutMs, undefined, this.codecs, undefined, true, metadata);
+        return (0, channel_envelope_1.encodeChannelEnvelopeParts)(kind, channelName, packetName, message, timeoutMs, undefined, this.codecs, undefined, this.flowCreationEnabled(), metadata);
     }
     async waitForMeshReply(meshName, completionPromise) {
         const completion = await completionPromise;

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

@@ -4,22 +4,15 @@ export interface ZLinkSerialWorkOptions {
     readonly payloadBytes?: number;
     readonly metadataBytes?: number;
 }
-/** Internal per-owner reservation limits, never a shared ingress budget. */
+/** Internal per-owner fairness settings; ingress capacity belongs to the host queue. */
 export interface ZLinkSerialSchedulerOptions {
-    readonly applicationMessageCapacity?: number;
-    readonly applicationByteCapacity?: number;
-    readonly lifecycleMessageCapacity?: number;
-    readonly lifecycleByteCapacity?: number;
     readonly ownerTimeBudget?: number;
     readonly lifecycleBurstLimit?: number;
-    readonly fixedWorkByteCost?: number;
-    readonly capacityError?: (lane: ZLinkSerialWorkLane) => unknown;
 }
-export declare const ZLINK_DEFAULT_SERIAL_SCHEDULER_OPTIONS: Required<Omit<ZLinkSerialSchedulerOptions, 'capacityError'>>;
+export declare const ZLINK_DEFAULT_SERIAL_SCHEDULER_OPTIONS: Required<ZLinkSerialSchedulerOptions>;
 export interface ZLinkSerialWorkRecord<T> {
     readonly acceptedSequence: bigint;
     readonly lane: ZLinkSerialWorkLane;
-    readonly byteCost: number;
     readonly operation: () => Promise<T> | T;
     readonly context?: unknown;
     resolve(value: T): void;
@@ -35,8 +28,7 @@ export interface ZLinkSerialWorkPreparation {
 }
 /**
  * One event-loop serial execution queue per Spot, Actor mailbox, or Stream session.
- * Its reservations are owner-local and span queued plus running work until the
- * execution owner reaches its terminal transition.
+ * Application work carries the host permit through the queue until the handler starts.
  */
 export declare class ZLinkSerialExecutionQueue {
     private readonly executeRecord;
@@ -44,8 +36,6 @@ export declare class ZLinkSerialExecutionQueue {
     private readonly lifecycle;
     private readonly ownerTimeBudget;
     private readonly lifecycleBurstLimit;
-    private readonly fixedWorkByteCost;
-    private readonly capacityError;
     private nextAcceptedSequence;
     private draining;
     private drainScheduled;
@@ -58,14 +48,12 @@ export declare class ZLinkSerialExecutionQueue {
     submit<T>(operation: () => Promise<T> | T, options?: ZLinkSerialWorkOptions, context?: unknown): Promise<T>;
     submitDetached<T>(operation: () => Promise<T> | T, onError: (error: unknown) => void, options?: ZLinkSerialWorkOptions, context?: unknown): void;
     /**
-     * Enqueues a continuation for an already-reserved owner turn. It preserves
-     * application FIFO order without taking a second owner-local reservation.
+     * Enqueues a continuation for an already-admitted owner turn.
      */
     submitContinuation<T>(operation: () => Promise<T> | T, context?: unknown): Promise<T>;
     /**
      * Enqueues work that already owns the host-wide application job permit.
-     * Its owner-local reservation transfers from the mailbox without a second
-     * capacity decision and remains held through handler terminal completion.
+     * It remains held through handler terminal completion.
      */
     submitPreAdmitted<T>(operation: () => Promise<T> | T, options?: ZLinkSerialWorkOptions, context?: unknown): Promise<T>;
     snapshot(): {
@@ -79,7 +67,6 @@ export declare class ZLinkSerialExecutionQueue {
     /** Stops new submissions while allowing the accepted FIFO to finish. */
     close(): Promise<void>;
     private admit;
-    private byteCost;
     private scheduleDrain;
     private drain;
     private selectNext;

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

@@ -2,19 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZLinkSerialExecutionQueue = exports.ZLINK_DEFAULT_SERIAL_SCHEDULER_OPTIONS = void 0;
 exports.ZLINK_DEFAULT_SERIAL_SCHEDULER_OPTIONS = Object.freeze({
-    applicationMessageCapacity: 1_024,
-    applicationByteCapacity: 64 * 1024 * 1024,
-    lifecycleMessageCapacity: 128,
-    lifecycleByteCapacity: 4 * 1024 * 1024,
     ownerTimeBudget: 10,
     lifecycleBurstLimit: 8,
-    fixedWorkByteCost: 256
 });
-const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
 /**
  * One event-loop serial execution queue per Spot, Actor mailbox, or Stream session.
- * Its reservations are owner-local and span queued plus running work until the
- * execution owner reaches its terminal transition.
+ * Application work carries the host permit through the queue until the handler starts.
  */
 class ZLinkSerialExecutionQueue {
     executeRecord;
@@ -22,8 +15,6 @@ class ZLinkSerialExecutionQueue {
     lifecycle;
     ownerTimeBudget;
     lifecycleBurstLimit;
-    fixedWorkByteCost;
-    capacityError;
     nextAcceptedSequence = 1n;
     draining = false;
     drainScheduled = false;
@@ -35,20 +26,12 @@ class ZLinkSerialExecutionQueue {
     constructor(executeRecord, options = {}) {
         this.executeRecord = executeRecord;
         const configured = { ...exports.ZLINK_DEFAULT_SERIAL_SCHEDULER_OPTIONS, ...options };
-        validatePositive(configured.applicationMessageCapacity, 'applicationMessageCapacity');
-        validatePositive(configured.applicationByteCapacity, 'applicationByteCapacity');
-        validatePositive(configured.lifecycleMessageCapacity, 'lifecycleMessageCapacity');
-        validatePositive(configured.lifecycleByteCapacity, 'lifecycleByteCapacity');
         validateNonNegative(configured.ownerTimeBudget, 'ownerTimeBudget');
         validatePositive(configured.lifecycleBurstLimit, 'lifecycleBurstLimit');
-        validatePositive(configured.fixedWorkByteCost, 'fixedWorkByteCost');
-        this.application = createLane(configured.applicationMessageCapacity, configured.applicationByteCapacity);
-        this.lifecycle = createLane(configured.lifecycleMessageCapacity, configured.lifecycleByteCapacity);
+        this.application = createLane();
+        this.lifecycle = createLane();
         this.ownerTimeBudget = configured.ownerTimeBudget;
         this.lifecycleBurstLimit = configured.lifecycleBurstLimit;
-        this.fixedWorkByteCost = configured.fixedWorkByteCost;
-        this.capacityError = options.capacityError
-            ?? (lane => new Error(`The ${lane} execution queue is full.`));
     }
     submit(operation, options = {}, context) {
         try {
@@ -62,12 +45,11 @@ class ZLinkSerialExecutionQueue {
         void this.submit(operation, options, context).catch(onError);
     }
     /**
-     * Enqueues a continuation for an already-reserved owner turn. It preserves
-     * application FIFO order without taking a second owner-local reservation.
+     * Enqueues a continuation for an already-admitted owner turn.
      */
     submitContinuation(operation, context) {
         try {
-            return this.admit(operation, { lane: 'application' }, context, 'none');
+            return this.admit(operation, { lane: 'application' }, context);
         }
         catch (error) {
             return Promise.reject(error);
@@ -75,29 +57,26 @@ class ZLinkSerialExecutionQueue {
     }
     /**
      * Atomically transfers an already-accepted durable FIFO prefix into this
-     * owner queue. Admission failures remain synchronous so the durable owner
-     * cannot publish a restore linearization point for a prefix that was never
-     * queued.
+     * owner queue.
      *
      * @internal
      */
     admitDurablePrefix(operation, options = {}, context, preparation) {
-        return this.admit(operation, { ...options, lane: 'application' }, context, 'transferred', preparation);
+        return this.admit(operation, { ...options, lane: 'application' }, context, preparation);
     }
     /**
      * Enqueues work that already owns the host-wide application job permit.
-     * Its owner-local reservation transfers from the mailbox without a second
-     * capacity decision and remains held through handler terminal completion.
+     * It remains held through handler terminal completion.
      */
     submitPreAdmitted(operation, options = {}, context) {
-        return this.admit(operation, options, context, 'transferred');
+        return this.admit(operation, options, context);
     }
     snapshot() {
         return {
-            applicationMessages: this.application.messageCount,
-            applicationBytes: this.application.byteCount,
-            lifecycleMessages: this.lifecycle.messageCount,
-            lifecycleBytes: this.lifecycle.byteCount
+            applicationMessages: this.application.records.length,
+            applicationBytes: 0,
+            lifecycleMessages: this.lifecycle.records.length,
+            lifecycleBytes: 0
         };
     }
     get hasPendingWork() {
@@ -115,18 +94,11 @@ class ZLinkSerialExecutionQueue {
         this.closed = true;
         return this.whenIdle();
     }
-    admit(operation, options, context, reservationMode = 'enforce-capacity', preparation) {
+    admit(operation, options, context, preparation) {
         if (this.closed)
             throw new Error('The serial execution queue is closed.');
         const lane = options.lane ?? 'application';
-        const reservationHeld = reservationMode !== 'none';
-        const byteCost = reservationHeld ? this.byteCost(options) : 0;
         const target = lane === 'application' ? this.application : this.lifecycle;
-        if (reservationMode === 'enforce-capacity' && !reserve(target, byteCost)) {
-            throw this.capacityError(lane);
-        }
-        if (reservationMode === 'transferred')
-            reserveTransferred(target, byteCost);
         let settled = false;
         let released = false;
         let resolveResult;
@@ -139,8 +111,6 @@ class ZLinkSerialExecutionQueue {
             if (released)
                 return;
             released = true;
-            if (reservationHeld)
-                releaseReservation(target, byteCost);
         };
         const resolve = (value) => {
             if (settled)
@@ -157,7 +127,6 @@ class ZLinkSerialExecutionQueue {
         const record = {
             acceptedSequence: 0n,
             lane,
-            byteCost,
             operation,
             context,
             preparation,
@@ -185,18 +154,6 @@ class ZLinkSerialExecutionQueue {
         this.scheduleDrain();
         return result;
     }
-    byteCost(options) {
-        const payloadBytes = options.payloadBytes ?? 0;
-        const metadataBytes = options.metadataBytes ?? 0;
-        validateNonNegative(payloadBytes, 'payloadBytes');
-        validateNonNegative(metadataBytes, 'metadataBytes');
-        if (payloadBytes > MAX_SAFE_INTEGER - metadataBytes)
-            return MAX_SAFE_INTEGER;
-        const payloadAndMetadata = payloadBytes + metadataBytes;
-        return payloadAndMetadata > MAX_SAFE_INTEGER - this.fixedWorkByteCost
-            ? MAX_SAFE_INTEGER
-            : payloadAndMetadata + this.fixedWorkByteCost;
-    }
     scheduleDrain() {
         if (this.drainScheduled || this.draining)
             return;
@@ -370,32 +327,11 @@ class ZLinkSerialExecutionQueue {
     }
 }
 exports.ZLinkSerialExecutionQueue = ZLinkSerialExecutionQueue;
-function createLane(messageCapacity, byteCapacity) {
+function createLane() {
     return {
-        records: [],
-        messageCapacity,
-        byteCapacity,
-        messageCount: 0,
-        byteCount: 0
+        records: []
     };
 }
-function reserve(lane, byteCost) {
-    if (lane.messageCount >= lane.messageCapacity
-        || byteCost > lane.byteCapacity - lane.byteCount) {
-        return false;
-    }
-    lane.messageCount += 1;
-    lane.byteCount += byteCost;
-    return true;
-}
-function reserveTransferred(lane, byteCost) {
-    lane.messageCount += 1;
-    lane.byteCount += byteCost;
-}
-function releaseReservation(lane, byteCost) {
-    lane.messageCount -= 1;
-    lane.byteCount -= byteCost;
-}
 function validatePositive(value, field) {
     if (!Number.isSafeInteger(value) || value < 1) {
         throw new RangeError(`${field} must be a positive safe integer.`);

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

@@ -11,8 +11,6 @@ export declare class EventLoopResourceStack {
 export type EventLoopTask = () => void | Promise<void>;
 /** Keeps infrastructure progress independent from awaiting application handlers. */
 export declare class EventLoopWorkQueues {
-    private readonly infrastructureLimit;
-    private readonly applicationLimit;
     private readonly infrastructure;
     private infrastructureHead;
     private infrastructureCount;
@@ -22,7 +20,6 @@ export declare class EventLoopWorkQueues {
     private infrastructureScheduled;
     private applicationScheduled;
     private accepting;
-    constructor(infrastructureLimit: number, applicationLimit: number);
     submitInfrastructure(task: EventLoopTask): boolean;
     submitApplication(task: EventLoopTask): boolean;
     stopAdmission(): void;

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

@@ -37,8 +37,6 @@ async function closeResources(resources) {
 }
 /** Keeps infrastructure progress independent from awaiting application handlers. */
 class EventLoopWorkQueues {
-    infrastructureLimit;
-    applicationLimit;
     infrastructure = [];
     infrastructureHead = 0;
     infrastructureCount = 0;
@@ -48,15 +46,8 @@ class EventLoopWorkQueues {
     infrastructureScheduled = false;
     applicationScheduled = false;
     accepting = true;
-    constructor(infrastructureLimit, applicationLimit) {
-        this.infrastructureLimit = infrastructureLimit;
-        this.applicationLimit = applicationLimit;
-        if (infrastructureLimit < 1 || applicationLimit < 1) {
-            throw new RangeError('Queue limits must be positive.');
-        }
-    }
     submitInfrastructure(task) {
-        if (!this.accepting || this.infrastructureCount >= this.infrastructureLimit)
+        if (!this.accepting)
             return false;
         this.infrastructure.push(task);
         this.infrastructureCount += 1;
@@ -64,7 +55,7 @@ class EventLoopWorkQueues {
         return true;
     }
     submitApplication(task) {
-        if (!this.accepting || this.applicationCount >= this.applicationLimit)
+        if (!this.accepting)
             return false;
         this.application.push(task);
         this.applicationCount += 1;

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

@@ -10,10 +10,6 @@ export declare class OperationCancelledError extends Error {
     readonly operationId: bigint;
     constructor(operationId: bigint, message?: string);
 }
-export declare class OperationCapacityExceededError extends Error {
-    readonly maxPendingOperations: number;
-    constructor(maxPendingOperations: number);
-}
 export interface PendingOperation<T> {
     readonly id: bigint;
     readonly promise: Promise<T>;
@@ -21,14 +17,12 @@ 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 maxPendingOperations;
-    static readonly DEFAULT_MAX_PENDING_OPERATIONS = 4096;
     private readonly entries;
     private nextId;
     private generation;
     private closed;
-    constructor(clock?: OperationClock, maxPendingOperations?: number);
-    reserve(timeoutMs: number, timeoutOwner?: 'registry' | 'sender'): PendingOperation<T>;
+    constructor(clock?: OperationClock);
+    register(timeoutMs: number, timeoutOwner?: 'registry' | 'sender'): PendingOperation<T>;
     complete(id: bigint, value: T): boolean;
     fail(id: bigint, reason: unknown): boolean;
     private failCore;