@zlink-systems/framework 0.11.0 → 0.13.0

package/src/runtime/channels/channel-receive-loops.ts

@@ -12,6 +12,8 @@ import {
   closeMessages
 } from './channel-envelope';
 import { tryDecodeChannelHeader } from './channel-envelope-inspection';
+// 같은 계약을 두 곳에 두지 않는다 — channel-multipart가 소유한다.
+import type { ZLinkMultipartAsyncSubmitOperation } from './channel-multipart';
 import type { ZLinkChannelEnvelopeHeader } from './channel-envelope';
 import {
   ZLinkReceiveTaskTracker,
@@ -39,10 +41,6 @@ interface ZLinkMultipartSubmitOperation extends ZLinkMultipartOperation<ZLinkMul
   submit(): unknown;
 }
 
-interface ZLinkMultipartAsyncSubmitOperation extends ZLinkMultipartOperation<ZLinkMultipartAsyncSubmitOperation> {
-  submit(): Promise<void>;
-}
-
 type ZLinkMultipartReplyOperation = ZLinkMultipartSubmitOperation;
 
 interface ZLinkChannelRequestDispatchLoop {
@@ -254,19 +252,13 @@ export 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();
@@ -284,12 +276,13 @@ export 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);
@@ -479,19 +472,11 @@ export 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();
@@ -508,14 +493,15 @@ export 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 as readonly Message[]);
@@ -679,14 +665,7 @@ export 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);
@@ -704,11 +683,12 @@ export 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);
@@ -821,15 +801,15 @@ export class 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 {
   private messages = 0;
-  private bytes = 0n;
+  private bytes = 0;
   private startedAt = performance.now();
 
-  record(bytes: bigint): boolean {
+  record(bytes: number): boolean {
     this.messages += 1;
     this.bytes += bytes;
     return this.messages >= RECEIVE_BATCH_MESSAGE_LIMIT
@@ -844,58 +824,27 @@ class ZLinkReceiveBatchBudget {
 
   reset(): void {
     this.messages = 0;
-    this.bytes = 0n;
+    this.bytes = 0;
     this.startedAt = performance.now();
   }
 }
 
-class ZLinkSharedIdleWaiter {
-  private pending?: Promise<void>;
-  private resolvePending?: () => void;
-  private readonly wake = (): void => {
-    const resolve = this.resolvePending;
-    this.pending = undefined;
-    this.resolvePending = undefined;
-    resolve?.();
-  };
-
-  constructor(private readonly delayMs: number) {}
-
-  wait(): Promise<void> {
-    if (this.pending !== undefined) return this.pending;
-    this.pending = new Promise<void>((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(): Promise<void> {
-  return receiveLoopIdleWaiter.wait();
-}
-
 function waitReceiveLoopTurn(): Promise<void> {
   return new Promise<void>(resolve => setImmediate(resolve));
 }
 
 
-function messageBytes(parts: readonly Message[]): bigint {
-  return parts.reduce((sum, part) => sum + messagePartBytes(part), 0n);
+function messageBytes(parts: readonly Message[]): number {
+  return parts.reduce((sum, part) => sum + messagePartBytes(part), 0);
 }
 
-function messagePartBytes(part: Message | undefined): bigint {
+function messagePartBytes(part: Message | undefined): number {
   if (part === undefined) {
-    return 0n;
+    return 0;
   }
   const size = (part as Message & { size?: () => number }).size;
   if (typeof size === 'function') {
-    return BigInt(size.call(part));
+    return size.call(part);
   }
-  return BigInt(part.data().byteLength);
+  return part.data().byteLength;
 }

package/src/runtime/channels/channel-socket-registry.ts

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

package/src/runtime/channels/channel-transports.ts

@@ -281,7 +281,8 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
       sourceNodeRid: string,
       parts: readonly MessageLike[]
     ) => ZLinkSubmitResult,
-    private readonly metrics?: ZLinkRuntimeMetrics
+    private readonly metrics?: ZLinkRuntimeMetrics,
+    private readonly flowCreationEnabled: () => boolean = () => true
   ) {}
 
   canRouteChannel(routerChannelId: string): boolean {
@@ -308,7 +309,7 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
   ): Promise<ZLinkSubmitResult> {
     // 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 runWithOutboundFlow(true, () => this.submitNode(
+    return runWithOutboundFlow(this.flowCreationEnabled(), () => this.submitNode(
       meshName,
       targetNodeRid,
       packetName,
@@ -327,7 +328,7 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
     signal?: AbortSignal,
     metadata?: ReadonlyMap<string, string>
   ): Promise<ZLinkSubmitResult> {
-    return runWithOutboundFlow(true, () => this.submitNode(
+    return runWithOutboundFlow(this.flowCreationEnabled(), () => this.submitNode(
       meshName,
       targetNodeRid,
       packetName,
@@ -399,7 +400,7 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
     signal?: AbortSignal,
     metadata?: ReadonlyMap<string, string>
   ): Promise<TReply> {
-    return runWithOutboundFlow(true, () => this.requestScoped<TReply>(
+    return runWithOutboundFlow(this.flowCreationEnabled(), () => this.requestScoped<TReply>(
       meshName,
       targetNodeRid,
       packetName,
@@ -468,7 +469,7 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
     signal?: AbortSignal,
     metadata?: ReadonlyMap<string, string>
   ): Promise<ZLinkSubmitResult> {
-    return runWithOutboundFlow(true, () => this.submitToChannelScoped(
+    return runWithOutboundFlow(this.flowCreationEnabled(), () => this.submitToChannelScoped(
       meshName,
       channelName,
       packetName,
@@ -521,7 +522,7 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
     signal?: AbortSignal,
     metadata?: ReadonlyMap<string, string>
   ): Promise<TReply> {
-    return runWithOutboundFlow(true, () => this.requestToChannelScoped<TReply>(
+    return runWithOutboundFlow(this.flowCreationEnabled(), () => this.requestToChannelScoped<TReply>(
       meshName,
       channelName,
       packetName,
@@ -614,7 +615,10 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
       readonly metadata?: ReadonlyMap<string, string>;
     }
   ): Promise<ZLinkSubmitResult> {
-    return runWithOutboundFlow(true, () => this.sendToSpotScoped(spotRouteTarget, message, options));
+    return runWithOutboundFlow(
+      this.flowCreationEnabled(),
+      () => this.sendToSpotScoped(spotRouteTarget, message, options)
+    );
   }
 
   private async sendToSpotScoped(
@@ -712,7 +716,10 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
       readonly metadata?: ReadonlyMap<string, string>;
     }
   ): Promise<TReply> {
-    return runWithOutboundFlow(true, () => this.requestToSpotScoped<TReply>(spotRouteTarget, request, options));
+    return runWithOutboundFlow(
+      this.flowCreationEnabled(),
+      () => this.requestToSpotScoped<TReply>(spotRouteTarget, request, options)
+    );
   }
 
   private async requestToSpotScoped<TReply = unknown>(
@@ -819,7 +826,10 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
     request: Message,
     options: { readonly timeoutMs?: number; readonly signal?: AbortSignal }
   ): Promise<readonly Message[]> {
-    return runWithOutboundFlow(true, () => this.requestRawToSpotScoped(spotRouteTarget, request, options));
+    return runWithOutboundFlow(
+      this.flowCreationEnabled(),
+      () => this.requestRawToSpotScoped(spotRouteTarget, request, options)
+    );
   }
 
   private async requestRawToSpotScoped(
@@ -963,7 +973,7 @@ export class ZLinkRuntimeRouteTransport implements ZLinkRouteClientTransport {
       undefined,
       this.codecs,
       undefined,
-      true,
+      this.flowCreationEnabled(),
       metadata
     );
   }

package/src/runtime/execution/serial-execution-queue.ts

@@ -6,36 +6,20 @@ export interface ZLinkSerialWorkOptions {
   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 const ZLINK_DEFAULT_SERIAL_SCHEDULER_OPTIONS: Required<
-  Omit<ZLinkSerialSchedulerOptions, 'capacityError'>
-> = Object.freeze({
-  applicationMessageCapacity: 1_024,
-  applicationByteCapacity: 64 * 1024 * 1024,
-  lifecycleMessageCapacity: 128,
-  lifecycleByteCapacity: 4 * 1024 * 1024,
+export const ZLINK_DEFAULT_SERIAL_SCHEDULER_OPTIONS: Required<ZLinkSerialSchedulerOptions> = Object.freeze({
   ownerTimeBudget: 10,
   lifecycleBurstLimit: 8,
-  fixedWorkByteCost: 256
 });
 
-const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
-
 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;
@@ -61,26 +45,17 @@ type SerialWorkRecord<T> = Omit<ZLinkSerialWorkRecord<T>, 'acceptedSequence'> &
 
 interface ZLinkSerialAdmissionLane {
   readonly records: Array<SerialWorkRecord<unknown>>;
-  readonly messageCapacity: number;
-  readonly byteCapacity: number;
-  messageCount: number;
-  byteCount: number;
 }
 
-type ZLinkSerialReservationMode = 'enforce-capacity' | 'transferred' | 'none';
-
 /**
  * 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 class ZLinkSerialExecutionQueue {
   private readonly application: ZLinkSerialAdmissionLane;
   private readonly lifecycle: ZLinkSerialAdmissionLane;
   private readonly ownerTimeBudget: number;
   private readonly lifecycleBurstLimit: number;
-  private readonly fixedWorkByteCost: number;
-  private readonly capacityError: (lane: ZLinkSerialWorkLane) => unknown;
   private nextAcceptedSequence = 1n;
   private draining = false;
   private drainScheduled = false;
@@ -95,26 +70,12 @@ export class ZLinkSerialExecutionQueue {
     options: ZLinkSerialSchedulerOptions = {}
   ) {
     const configured = { ...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<T>(
@@ -139,15 +100,14 @@ export class ZLinkSerialExecutionQueue {
   }
 
   /**
-   * 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> {
     try {
-      return this.admit(operation, { lane: 'application' }, context, 'none');
+      return this.admit(operation, { lane: 'application' }, context);
     } catch (error) {
       return Promise.reject(error);
     }
@@ -155,9 +115,7 @@ export 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
    */
@@ -171,22 +129,20 @@ export class ZLinkSerialExecutionQueue {
       operation,
       { ...options, lane: 'application' },
       context,
-      'transferred',
       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<T>(
     operation: () => Promise<T> | T,
     options: ZLinkSerialWorkOptions = {},
     context?: unknown
   ): Promise<T> {
-    return this.admit(operation, options, context, 'transferred');
+    return this.admit(operation, options, context);
   }
 
   snapshot(): {
@@ -196,10 +152,10 @@ export class ZLinkSerialExecutionQueue {
     readonly lifecycleBytes: number;
   } {
     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
     };
   }
 
@@ -224,19 +180,11 @@ export class ZLinkSerialExecutionQueue {
     operation: () => Promise<T> | T,
     options: ZLinkSerialWorkOptions,
     context?: unknown,
-    reservationMode: ZLinkSerialReservationMode = 'enforce-capacity',
     preparation?: ZLinkSerialWorkPreparation
   ): Promise<T> {
     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!: (value: T | PromiseLike<T>) => void;
@@ -248,7 +196,6 @@ export class ZLinkSerialExecutionQueue {
     const release = (): void => {
       if (released) return;
       released = true;
-      if (reservationHeld) releaseReservation(target, byteCost);
     };
     const resolve = (value: T): void => {
       if (settled) return;
@@ -263,7 +210,6 @@ export class ZLinkSerialExecutionQueue {
     const record: SerialWorkRecord<T> = {
       acceptedSequence: 0n,
       lane,
-      byteCost,
       operation,
       context,
       preparation,
@@ -291,18 +237,6 @@ export class ZLinkSerialExecutionQueue {
     return result;
   }
 
-  private byteCost(options: ZLinkSerialWorkOptions): number {
-    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;
-  }
-
   private scheduleDrain(): void {
     if (this.drainScheduled || this.draining) return;
     this.drainScheduled = true;
@@ -485,38 +419,12 @@ export class ZLinkSerialExecutionQueue {
   }
 }
 
-function createLane(messageCapacity: number, byteCapacity: number): ZLinkSerialAdmissionLane {
+function createLane(): ZLinkSerialAdmissionLane {
   return {
-    records: [],
-    messageCapacity,
-    byteCapacity,
-    messageCount: 0,
-    byteCount: 0
+    records: []
   };
 }
 
-function reserve(lane: ZLinkSerialAdmissionLane, byteCost: number): boolean {
-  if (
-    lane.messageCount >= lane.messageCapacity
-    || byteCost > lane.byteCapacity - lane.byteCount
-  ) {
-    return false;
-  }
-  lane.messageCount += 1;
-  lane.byteCount += byteCost;
-  return true;
-}
-
-function reserveTransferred(lane: ZLinkSerialAdmissionLane, byteCost: number): void {
-  lane.messageCount += 1;
-  lane.byteCount += byteCost;
-}
-
-function releaseReservation(lane: ZLinkSerialAdmissionLane, byteCost: number): void {
-  lane.messageCount -= 1;
-  lane.byteCount -= byteCost;
-}
-
 function validatePositive(value: number, field: string): void {
   if (!Number.isSafeInteger(value) || value < 1) {
     throw new RangeError(`${field} must be a positive safe integer.`);

package/src/runtime/foundation/event-loop-resources.ts

@@ -51,17 +51,8 @@ export class EventLoopWorkQueues {
   private applicationScheduled = false;
   private accepting = true;
 
-  constructor(
-    private readonly infrastructureLimit: number,
-    private readonly applicationLimit: number
-  ) {
-    if (infrastructureLimit < 1 || applicationLimit < 1) {
-      throw new RangeError('Queue limits must be positive.');
-    }
-  }
-
   submitInfrastructure(task: EventLoopTask): boolean {
-    if (!this.accepting || this.infrastructureCount >= this.infrastructureLimit) return false;
+    if (!this.accepting) return false;
     this.infrastructure.push(task);
     this.infrastructureCount += 1;
     this.scheduleInfrastructure();
@@ -69,7 +60,7 @@ export class EventLoopWorkQueues {
   }
 
   submitApplication(task: EventLoopTask): boolean {
-    if (!this.accepting || this.applicationCount >= this.applicationLimit) return false;
+    if (!this.accepting) return false;
     this.application.push(task);
     this.applicationCount += 1;
     this.scheduleApplication();

package/src/runtime/foundation/operation-registry.ts

@@ -17,13 +17,6 @@ export class OperationCancelledError extends Error {
   }
 }
 
-export class OperationCapacityExceededError extends Error {
-  constructor(readonly maxPendingOperations: number) {
-    super(`Operation capacity ${maxPendingOperations} is exhausted.`);
-    this.name = 'OperationCapacityExceededError';
-  }
-}
-
 export interface PendingOperation<T> {
   readonly id: bigint;
   readonly promise: Promise<T>;
@@ -50,31 +43,18 @@ const systemClock: OperationClock = {
 
 /** Owns request completion so reply, timeout, cancellation, and shutdown race safely. */
 export class OperationRegistry<T> {
-  static readonly DEFAULT_MAX_PENDING_OPERATIONS = 4_096;
-
   private readonly entries = new Map<bigint, Entry<T>>();
   private nextId = 1n;
   private generation = 1n;
   private closed = false;
 
-  constructor(
-    private readonly clock: OperationClock = systemClock,
-    private readonly maxPendingOperations = OperationRegistry.DEFAULT_MAX_PENDING_OPERATIONS
-  ) {
-    if (!Number.isSafeInteger(maxPendingOperations) || maxPendingOperations <= 0) {
-      throw new RangeError('maxPendingOperations must be a positive safe integer.');
-    }
-  }
+  constructor(private readonly clock: OperationClock = systemClock) {}
 
-  reserve(timeoutMs: number, timeoutOwner: 'registry' | 'sender' = 'registry'): PendingOperation<T> {
+  register(timeoutMs: number, timeoutOwner: 'registry' | 'sender' = 'registry'): PendingOperation<T> {
     if (this.closed) throw new Error('Operation registry is closed.');
     if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
       throw new RangeError('timeoutMs must be a non-negative finite number.');
     }
-    if (this.entries.size >= this.maxPendingOperations) {
-      throw new OperationCapacityExceededError(this.maxPendingOperations);
-    }
-
     const id = this.nextId++;
     const generation = this.generation;
     let resolve!: Entry<T>['resolve'];