@zlink-systems/framework 0.11.0 → 0.12.0

package/src/contracts/Configuration/RegistrationTypes.ts

@@ -104,16 +104,13 @@ export interface ZLinkLocationRegistration {
 /**
  * CPU worker-thread pool settings. I/O workers do not consume this pool.
  * `minThreads` keeps a warm baseline, `maxThreads` bounds active CPU jobs,
- * `idleTimeoutMs` reclaims workers above the baseline, and `maxQueueLength`
- * bounds queued jobs. The registration normalizer supplies defaults when a
- * JavaScript caller omits a field: `0`, `max(2, availableParallelism())`,
- * `30000`, and `1024`, respectively.
+ * `idleTimeoutMs` reclaims workers above the baseline. The registration
+ * normalizer supplies defaults when a JavaScript caller omits a field.
  */
 export interface ZLinkWorkerOptions {
   readonly minThreads: number;
   readonly maxThreads: number;
   readonly idleTimeoutMs: number;
-  readonly maxQueueLength: number;
 }
 
 export interface ZLinkCodecSerializerRegistration {

package/src/contracts/Configuration/RegistrationValidators.ts

@@ -97,7 +97,6 @@ function validateWorkerOptions(worker: ZLinkWorkerOptions | undefined): void {
   requireNonNegativeInteger('Worker minThreads', worker.minThreads);
   requirePositiveInteger('Worker maxThreads', worker.maxThreads);
   requireNonNegativeInteger('Worker idleTimeoutMs', worker.idleTimeoutMs);
-  requirePositiveInteger('Worker maxQueueLength', worker.maxQueueLength);
   if (worker.maxThreads < worker.minThreads) {
     throw new ZLinkConfigurationException(
       'Worker maxThreads must be greater than or equal to minThreads.'

package/src/contracts/Errors/ZLinkFrameworkException.ts

@@ -6,13 +6,12 @@ export enum ZLinkFrameworkErrorKind {
   NotConfigured = 3,
   Rejected = 4,
   Unavailable = 5,
-  CapacityExceeded = 6,
-  DeadlineExceeded = 7,
-  ShuttingDown = 8,
-  ProtocolError = 9,
-  InvalidOperation = 10,
-  DataLost = 11,
-  InternalFailure = 12
+  DeadlineExceeded = 6,
+  ShuttingDown = 7,
+  ProtocolError = 8,
+  InvalidOperation = 9,
+  DataLost = 10,
+  InternalFailure = 11
 }
 
 export class ZLinkFrameworkException extends Error {

package/src/runtime/actors/actor-client.ts

@@ -916,7 +916,7 @@ function submitted(): ZLinkSubmitResult {
 //  the reply comes from a remote target, so a fine framework failure code
 //  refines the coarse terminal, and a terminal-only conflict/busy is the
 //  target's owner/queue state (retryable stale/Unavailable), never a
-//  source-owned CapacityExceeded. Backpressure never appears on this reply
+//  source-owned queue exhaustion. Backpressure never appears on this reply
 //  path. Internal kinds are preserved so the stale-actor re-resolve retry
 //  (isStaleActorError) keeps working.
 function actorFailureCodeKind(

package/src/runtime/actors/actor-mailbox.ts

@@ -5,10 +5,6 @@ import {
   type ZLinkSerialWorkOptions,
   type ZLinkSerialWorkRecord
 } from '../execution/serial-execution-queue';
-import {
-  ZLinkFrameworkInternalErrorKind,
-  createInternalFrameworkException
-} from '../framework-errors-internal';
 import { runZLinkActorExecution } from './actor-execution-context';
 import {
   bindApplicationJobPermit,
@@ -25,14 +21,7 @@ export class ZLinkActorSerialExecutor {
   ) {
     this.scheduler = new ZLinkSerialExecutionQueue(
       (record) => this.runRecord(record),
-      {
-        ...options,
-        capacityError: options?.capacityError ?? (() =>
-          createInternalFrameworkException(
-            ZLinkFrameworkInternalErrorKind.WorkerQueueFull,
-            'Actor execution queue capacity was exceeded.'
-          ))
-      }
+      options
     );
   }
 

package/src/runtime/backend/contracts/index.ts

@@ -578,6 +578,8 @@ export interface ZLinkBackendSubscriberSocket extends ZLinkBackendConnectableSoc
 
 export interface ZLinkBackendReadablePoller {
   wait(timeoutMs: number): boolean;
+  waitForReadable(signal?: AbortSignal): Promise<boolean>;
+  markDrained(): void;
   dispose(): void;
 }
 

package/src/runtime/backend/mesh-completion-table.ts

@@ -1,16 +1,11 @@
 import { ZLinkBufferMessage as Message } from './runtime-message';
+import type { Message as ZLinkMessage } from '../../contracts/Common/Message';
 import type {
   MeshOperationId,
   ReceiveKindData,
   ReceiveRecord
 } from '../foundation/service-runtime-contracts';
 import { operationIdentityKey } from '../foundation/operation-identity';
-import {
-  ZLinkFrameworkErrorKind,
-  ZLinkFrameworkException
-} from '../../contracts';
-
-export const ZLINK_MESH_COMPLETION_CAPACITY = 4_096;
 
 export interface ZLinkMeshCompletionDiagnostic {
   readonly kind: 'unknownOrLate';
@@ -36,14 +31,7 @@ export class ZLinkMeshCompletionTable {
   private readonly pending = new Map<string, PendingCompletion>();
   private disposed = false;
 
-  constructor(
-    private readonly maxPendingOperations = ZLINK_MESH_COMPLETION_CAPACITY,
-    private readonly onDiagnostic?: (diagnostic: ZLinkMeshCompletionDiagnostic) => void
-  ) {
-    if (!Number.isSafeInteger(maxPendingOperations) || maxPendingOperations <= 0) {
-      throw new RangeError('maxPendingOperations must be a positive safe integer.');
-    }
-  }
+  constructor(private readonly onDiagnostic?: (diagnostic: ZLinkMeshCompletionDiagnostic) => void) {}
 
   /**
    * Submits and registers without yielding control to the event loop. Mesh
@@ -63,12 +51,6 @@ export class ZLinkMeshCompletionTable {
         signal.reason ?? new DOMException('The operation was aborted.', 'AbortError')
       );
     }
-    if (this.pending.size >= this.maxPendingOperations) {
-      return Promise.reject(new ZLinkFrameworkException(
-        ZLinkFrameworkErrorKind.CapacityExceeded,
-        `Mesh completion capacity ${this.maxPendingOperations} is exhausted.`
-      ));
-    }
     const operationId = operation();
     // The backend submission callback can synchronously re-enter `dispose()`.
     // TypeScript's control-flow analysis cannot observe mutation through it.
@@ -117,7 +99,7 @@ export class ZLinkMeshCompletionTable {
     this.pending.delete(key);
     pending.removeAbort?.();
     try {
-      pending.resolve(copyCompletion(record));
+      pending.resolve(retainCompletion(record));
     } catch (error) {
       pending.reject(error);
     }
@@ -144,16 +126,23 @@ export class ZLinkMeshCompletionTable {
 
 }
 
-function copyCompletion(record: ReceiveRecord): ZLinkMeshCompletion {
+function retainCompletion(record: ReceiveRecord): ZLinkMeshCompletion {
   return {
     terminalResult: record.terminalResult,
     failureErrno: record.failureErrno,
     operationKind: record.operationKind,
     kindData: record.kindData,
-    parts: record.parts.map((part) => Message.fromOwned(Buffer.from(part.data())))
+    parts: record.parts.map(retainCompletionPart)
   };
 }
 
+function retainCompletionPart(part: ZLinkMessage): Message {
+  // A runtime message already owns a managed Buffer and close() is a no-op.
+  // Binding-native messages can expose native storage through data(), which
+  // becomes invalid when their owner closes; materialize that one boundary copy.
+  return part instanceof Message ? part : Message.fromOwned(Buffer.from(part.data()));
+}
+
 export function closeMeshCompletion(completion: ZLinkMeshCompletion): void {
   closeParts(completion.parts);
 }

package/src/runtime/backend/mesh-dispatch-pump.ts

@@ -1,8 +1,11 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
+import { availableParallelism } from 'node:os';
 import { ZLINK_BACKEND_RECV_DONT_WAIT } from './runtime-values';
 import {
   ReadyDomain,
+  type ReadyBatch,
   type ReadyRecord,
+  type ReceiveBatch,
   type ReceiveRecord
 } from '../foundation/service-runtime-contracts';
 import type { ZLinkBackendMeshNode } from './contracts';
@@ -13,9 +16,11 @@ import type {
 } from '../application-jobs/contracts';
 import { runWithApplicationJobPermit } from '../application-jobs/application-job-queue-scope';
 
-const MESH_DISPATCH_TIMER_YIELD_BATCHES = 16;
-const MESH_DISPATCH_TIMER_YIELD_INTERVAL_MS = 2;
+const MESH_DISPATCH_YIELD_RECORDS = 16;
+const MESH_DISPATCH_YIELD_INTERVAL_MS = 2;
 const MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET = 4;
+const MESH_DISPATCH_RECEIVE_CAPACITY = 64;
+const MESH_DISPATCH_MAX_APPLICATION_WORKERS = Math.max(2, availableParallelism());
 // Captured while the runtime module is loaded, before any application owner
 // exists. A ready callback may run inside a Spot turn; the shared Mesh pump
 // must enter like an independent receive-loop task, without inheriting that
@@ -52,13 +57,15 @@ class ZLinkMeshDispatchFailure extends Error {
 
 export class ZLinkMeshDispatchPump {
   private pendingDomains: number = ReadyDomain.None;
-  private scheduled = false;
   private infrastructureScheduled = false;
   private disposed = false;
-  private drainPromise?: Promise<void>;
   private infrastructureDrainPromise?: Promise<void>;
   private readonly activeDrains = new Set<Promise<void>>();
+  private readonly idleApplicationWorkers = new Set<() => void>();
+  private applicationWorkerCount = 0;
   private readonly capacityStop = new AbortController();
+  private recordsSinceYield = 0;
+  private yieldStartedAtMs = 0;
 
   constructor(
     private readonly node: ZLinkBackendMeshNode,
@@ -67,12 +74,12 @@ export class ZLinkMeshDispatchPump {
   }
 
   start(): void {
+    if (this.applicationWorkerCount === 0) this.startApplicationWorker();
     this.node.setReadyHandler((domains) => {
       if (this.disposed) {
         return ReadyDomain.None;
       }
-      this.pendingDomains |= domains;
-      this.schedule();
+      this.markReady(domains);
       return domains;
     });
   }
@@ -84,43 +91,102 @@ export class ZLinkMeshDispatchPump {
     this.disposed = true;
     this.capacityStop.abort();
     this.pendingDomains = ReadyDomain.None;
+    for (const wake of this.idleApplicationWorkers) wake();
+    this.idleApplicationWorkers.clear();
     while (this.activeDrains.size > 0) {
       await Promise.all([...this.activeDrains]);
     }
   }
 
-  private schedule(): void {
-    if ((this.pendingDomains & ReadyDomain.Infrastructure) !== 0) {
-      this.scheduleInfrastructure();
-    }
-    if ((this.pendingDomains & ReadyDomain.Application) === 0) {
+  private markReady(domains: number): void {
+    if (domains === ReadyDomain.None || this.disposed) return;
+    const previous = this.pendingDomains;
+    this.pendingDomains |= domains;
+    const startInfrastructure =
+      (domains & ReadyDomain.Infrastructure) !== 0
+      && (previous & ReadyDomain.Infrastructure) === 0;
+    const startApplication =
+      (domains & ReadyDomain.Application) !== 0
+      && (previous & ReadyDomain.Application) === 0;
+    if (startInfrastructure && startApplication) {
+      const startTurn = this.yieldIfNeeded() ?? Promise.resolve();
+      this.scheduleInfrastructure(startTurn);
       return;
     }
-    if (this.scheduled) {
+    if (startInfrastructure) this.scheduleInfrastructure();
+    if (startApplication) {
+      if ((domains & ReadyDomain.Infrastructure) !== 0) {
+        setImmediate(() => this.wakeApplicationWorker());
+      } else {
+        this.wakeApplicationWorker();
+      }
+    }
+  }
+
+  private wakeApplicationWorker(): void {
+    if (this.disposed || (this.pendingDomains & ReadyDomain.Application) === 0) return;
+    const idle = this.idleApplicationWorkers.values().next().value as (() => void) | undefined;
+    if (idle !== undefined) {
+      this.idleApplicationWorkers.delete(idle);
+      this.pendingDomains &= ~ReadyDomain.Application;
+      idle();
       return;
     }
-    this.scheduled = true;
-    const drain = yieldToEventLoop()
-      .then(() => detachedMeshDispatchScope(() => this.drain()))
-      .catch((error) => {
-        if (error instanceof ZLinkMeshDispatchFailure) {
-          this.options.reportError?.(error.dispatchCause, error.context);
-          return;
-        }
-        this.options.reportError?.(error);
+    if (this.applicationWorkerCount < MESH_DISPATCH_MAX_APPLICATION_WORKERS) {
+      this.startApplicationWorker();
+    }
+  }
+
+  private startApplicationWorker(): void {
+    this.applicationWorkerCount += 1;
+    let worker: Promise<void>;
+    worker = detachedMeshDispatchScope(() =>
+      runZLinkExecutionArea('application', () => this.runApplicationWorker()))
+      .finally(() => {
+        this.applicationWorkerCount -= 1;
+        this.activeDrains.delete(worker);
       });
-    this.activeDrains.add(drain);
-    this.drainPromise = drain;
-    void drain.finally(() => {
-      this.activeDrains.delete(drain);
-      if (this.drainPromise === drain) {
-        this.drainPromise = undefined;
-        this.scheduled = false;
-        if (!this.disposed && this.pendingDomains !== ReadyDomain.None) {
-          this.schedule();
+    this.activeDrains.add(worker);
+  }
+
+  private async runApplicationWorker(): Promise<void> {
+    // A worker claims one owner at a time so a suspended handler cannot hold
+    // unrelated owners. Each owner may supply up to 64 pre-admitted records.
+    const readyBatch = this.node.createReadyBatch(1);
+    const receiveBatch = this.node.createReceiveBatch(
+      MESH_DISPATCH_RECEIVE_CAPACITY, this.options.partCapacity ?? 256
+    );
+    try {
+      for (;;) {
+        await this.waitForApplicationReady();
+        if (this.disposed) return;
+        try {
+          await this.drainDomain(ReadyDomain.Application, readyBatch, receiveBatch);
+        } catch (error) {
+          this.reportDispatchError(error);
         }
       }
-    });
+    } finally {
+      receiveBatch.close();
+      readyBatch.close();
+    }
+  }
+
+  private waitForApplicationReady(): Promise<void> {
+    if (this.disposed) return Promise.resolve();
+    if ((this.pendingDomains & ReadyDomain.Application) !== 0) {
+      this.pendingDomains &= ~ReadyDomain.Application;
+      return Promise.resolve();
+    }
+    return new Promise(resolve => this.idleApplicationWorkers.add(resolve));
+  }
+
+  private reportDispatchError(error: unknown): void {
+    if (error instanceof ZLinkMeshDispatchFailure) {
+      this.options.reportError?.(error.dispatchCause, error.context);
+      return;
+    }
+    this.options.reportError?.(error);
   }
 
   /**
@@ -130,13 +196,14 @@ export class ZLinkMeshDispatchPump {
    * the infrastructure mailbox and prevent the relocation coordinator from
    * completing the drain that releases the application work.
    */
-  private scheduleInfrastructure(): void {
+  private scheduleInfrastructure(startTurn?: Promise<void>): void {
     if (this.infrastructureScheduled) {
       return;
     }
     this.infrastructureScheduled = true;
-    const drain = yieldToEventLoop()
-      .then(() => detachedMeshDispatchScope(() => this.drainInfrastructure()))
+    const drain = (startTurn ?? this.yieldIfNeeded() ?? Promise.resolve())
+      .then(() => detachedMeshDispatchScope(() =>
+        runZLinkExecutionArea('infrastructure', () => this.drainInfrastructure())))
       .catch((error) => {
         if (error instanceof ZLinkMeshDispatchFailure) {
           this.options.reportError?.(error.dispatchCause, error.context);
@@ -158,44 +225,45 @@ export class ZLinkMeshDispatchPump {
     });
   }
 
-  private async drain(): Promise<void> {
-    while (!this.disposed) {
-      if ((this.pendingDomains & ReadyDomain.Application) === 0) {
-        return;
-      }
-      this.pendingDomains &= ~ReadyDomain.Application;
-      await this.drainDomain(ReadyDomain.Application);
-    }
-  }
-
   private async drainInfrastructure(): Promise<void> {
-    while (!this.disposed) {
-      if ((this.pendingDomains & ReadyDomain.Infrastructure) === 0) {
-        return;
-      }
-      this.pendingDomains &= ~ReadyDomain.Infrastructure;
-      const lifecycleBudgetExhausted = await this.drainDomain(
-        ReadyDomain.Infrastructure,
-        MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET
-      );
-      if (lifecycleBudgetExhausted) {
-        this.pendingDomains |= ReadyDomain.Infrastructure;
+    const readyBatch = this.node.createReadyBatch(
+      Math.min(this.options.readyCapacity ?? 32, MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET)
+    );
+    const receiveBatch = this.node.createReceiveBatch(
+      MESH_DISPATCH_RECEIVE_CAPACITY, this.options.partCapacity ?? 256
+    );
+    try {
+      while (!this.disposed) {
+        if ((this.pendingDomains & ReadyDomain.Infrastructure) === 0) {
+          return;
+        }
+        this.pendingDomains &= ~ReadyDomain.Infrastructure;
+        if ((this.pendingDomains & ReadyDomain.Application) !== 0) {
+          setImmediate(() => this.wakeApplicationWorker());
+        }
+        const lifecycleBudgetExhausted = await this.drainDomain(
+          ReadyDomain.Infrastructure,
+          readyBatch,
+          receiveBatch,
+          MESH_DISPATCH_LIFECYCLE_CLAIM_BUDGET
+        );
+        if (lifecycleBudgetExhausted) {
+          this.pendingDomains |= ReadyDomain.Infrastructure;
+          await yieldToEventLoop();
+        }
       }
+    } finally {
+      receiveBatch.close();
+      readyBatch.close();
     }
   }
 
-  private async drainDomain(domain: number, claimBudget?: number): Promise<boolean> {
-    const readyCapacity = domain === ReadyDomain.Application
-      ? 1
-      : claimBudget === undefined
-        ? (this.options.readyCapacity ?? 32)
-        : Math.min(this.options.readyCapacity ?? 32, claimBudget);
-    const readyBatch = this.node.createReadyBatch(readyCapacity);
-    // One record per claim receive keeps one ordinary-ingress permit paired
-    // with exactly one dispatch turn. Terminal completion claims bypass it.
-    const receiveBatch = this.node.createReceiveBatch(1, this.options.partCapacity ?? 256);
-    let receiveBatchesSinceTimerYield = 0;
-    let timerYieldStartedAtMs = this.nowMs();
+  private async drainDomain(
+    domain: number,
+    readyBatch: ReadyBatch,
+    receiveBatch: ReceiveBatch,
+    claimBudget?: number
+  ): Promise<boolean> {
     let claimsDrained = 0;
     try {
       for (;;) {
@@ -210,59 +278,46 @@ export class ZLinkMeshDispatchPump {
           return false;
         }
         if (domain === ReadyDomain.Application && drained.hasResidue) {
-          this.pendingDomains |= ReadyDomain.Application;
+          this.markReady(ReadyDomain.Application);
         }
         for (let index = 0; index < drained.records.length; index += 1) {
           const claim = readyBatch.takeClaim(index);
           claimsDrained += 1;
+          const owner = drained.records[index];
+          // Raw ingress already attached one host permit to each record.
+          // A claim that reserves admission here may receive only that permit's record.
           try {
-            receiveBatch.reset();
+            const capacity = owner.ordinaryIngressPreAdmitted === true
+              ? MESH_DISPATCH_RECEIVE_CAPACITY : 1;
             for (;;) {
-              const owner = drained.records[index];
-              const claimPermit = owner.terminalCompletion === true
+              let claimPermit = owner.terminalCompletion === true
                 || owner.ordinaryIngressPreAdmitted === true
                 || domain === ReadyDomain.Infrastructure
                 ? undefined
                 : await this.acquirePermit();
-              if (claimPermit === undefined
-                  && this.disposed
-                  && owner.terminalCompletion !== true
-                  && owner.ordinaryIngressPreAdmitted !== true) return false;
-              const received = claim.recvBatch(receiveBatch, ZLINK_BACKEND_RECV_DONT_WAIT);
-              if (!received.ok) {
-                claimPermit?.releaseAfterInternalProcessing();
-                break;
-              }
-              if (received.records.length === 0) {
-                claimPermit?.releaseAfterInternalProcessing();
-              }
-              for (const record of received.records) {
-                const permit = record.applicationJobPermit ?? claimPermit;
-                if (owner.ordinaryIngressPreAdmitted === true && permit === undefined) {
-                  record.releaseRetainedIngress?.();
-                  throw new Error('Pre-admitted raw ingress record lost its Application Job Queue permit.');
+              try {
+                if (this.capacityStop.signal.aborted) return false;
+                receiveBatch.reset(capacity);
+                const received = claim.recvBatch(receiveBatch, ZLINK_BACKEND_RECV_DONT_WAIT);
+                if (!received.ok) break;
+                // This owner keeps its claim while it drains. Other owners and
+                // infrastructure may progress if one of its handlers suspends.
+                if (domain === ReadyDomain.Infrastructure) {
+                  this.infrastructureScheduled = false;
+                  this.infrastructureDrainPromise = undefined;
+                  if ((this.pendingDomains & ReadyDomain.Infrastructure) !== 0) {
+                    this.scheduleInfrastructure();
+                  }
                 }
                 try {
-                  // A handler may synchronously submit an operation whose
-                  // control/completion is owned by this same MeshNode (e.g. a
-                  // native Completion record fed back through this node's own
-                  // Infrastructure claim). The active lane's scheduling state
-                  // must be released here, or a nested re-entrant drain can
-                  // never start to deliver that completion, and the awaiting
-                  // handler deadlocks against its own claim (spec
-                  // 46-internal-dispatch-loop, receive/dispatch wake/ordering).
-                  this.scheduled = false;
-                  this.drainPromise = undefined;
-                  if (domain === ReadyDomain.Infrastructure) {
-                    this.infrastructureScheduled = false;
-                    this.infrastructureDrainPromise = undefined;
-                  }
-                  if (this.pendingDomains !== ReadyDomain.None) {
-                    this.schedule();
-                  }
-                  const dispatch = () => runZLinkExecutionArea(
-                    domain === ReadyDomain.Infrastructure ? 'infrastructure' : 'application',
-                    async () => {
+                  for (const record of received.records) {
+                    if (this.disposed) break;
+                    const permit = record.applicationJobPermit ?? claimPermit;
+                    if (owner.ordinaryIngressPreAdmitted === true && permit === undefined) {
+                      throw new Error('Pre-admitted raw ingress record lost its Application Job Queue permit.');
+                    }
+                    this.recordsSinceYield += 1;
+                    const dispatch = async () => {
                       try {
                         await this.options.dispatch(drained.records[index], record);
                       } catch (error) {
@@ -272,55 +327,67 @@ export class ZLinkMeshDispatchPump {
                         );
                       }
                       await record.onTerminalCompletion?.();
+                    };
+                    if (permit === undefined) {
+                      await dispatch();
+                    } else {
+                      if (
+                        domain === ReadyDomain.Application
+                        && record.applicationJobPermit === undefined
+                      ) permit.markApplicationQueued();
+                      // The scope now owns this reservation, including failure
+                      // and detached handler handoff. Only unused permits remain
+                      // owned by the receive attempt's finally block.
+                      if (permit === claimPermit) claimPermit = undefined;
+                      await runWithApplicationJobPermit(permit, dispatch);
                     }
-                  );
-                  if (permit === undefined) {
-                    await dispatch();
-                  } else {
-                    if (
-                      domain === ReadyDomain.Application
-                      && record.applicationJobPermit === undefined
-                    ) permit.markApplicationQueued();
-                    await runWithApplicationJobPermit(permit, dispatch);
+                    const yieldTurn = this.yieldIfNeeded();
+                    if (yieldTurn !== undefined) await yieldTurn;
                   }
                 } finally {
-                  for (const part of record.parts) {
-                    part.close();
+                  // Batch ownership includes records whose dispatch never began,
+                  // including on failure or shutdown in the middle of the batch.
+                  for (const record of received.records) {
+                    for (const part of record.parts) part.close();
+                    record.releaseRetainedIngress?.();
                   }
-                  record.releaseRetainedIngress?.();
                 }
+              } finally {
+                claimPermit?.releaseAfterInternalProcessing();
               }
-              // A continuously readable owner must not keep the timers phase
-              // from running, but a timer turn for every single record adds a
-              // Promise, closure, and timer allocation to the hot path.
-              receiveBatchesSinceTimerYield += 1;
-              if (
-                receiveBatchesSinceTimerYield >= MESH_DISPATCH_TIMER_YIELD_BATCHES
-                || this.nowMs() - timerYieldStartedAtMs >= MESH_DISPATCH_TIMER_YIELD_INTERVAL_MS
-              ) {
-                receiveBatchesSinceTimerYield = 0;
-                await yieldToTimers();
-                timerYieldStartedAtMs = this.nowMs();
-              }
-              receiveBatch.reset();
             }
           } finally {
             claim.release();
           }
         }
-        await yieldToTimers();
-        receiveBatchesSinceTimerYield = 0;
-        timerYieldStartedAtMs = this.nowMs();
+        if (claimBudget !== undefined && claimsDrained >= claimBudget) {
+          this.wakeApplicationWorker();
+          return true;
+        }
+        // Empty ready claims also count as work, so they cannot monopolize
+        // the microtask queue without giving I/O and deadlines a turn.
+        this.recordsSinceYield += 1;
+        const yieldTurn = this.yieldIfNeeded();
+        if (yieldTurn !== undefined) await yieldTurn;
         if (!drained.hasResidue) {
           return false;
         }
       }
     } finally {
-      receiveBatch.close();
-      readyBatch.close();
+      readyBatch.reset();
     }
   }
 
+  private yieldIfNeeded(): Promise<void> | undefined {
+    const nowMs = this.nowMs();
+    if (this.recordsSinceYield < MESH_DISPATCH_YIELD_RECORDS
+        && nowMs - this.yieldStartedAtMs < MESH_DISPATCH_YIELD_INTERVAL_MS) return undefined;
+    this.recordsSinceYield = 0;
+    return yieldToTimers().then(() => {
+      this.yieldStartedAtMs = this.nowMs();
+    });
+  }
+
   private nowMs(): number {
     return this.options.monotonicNowMs?.() ?? performance.now();
   }
@@ -358,6 +425,7 @@ function yieldToEventLoop(): Promise<void> {
   return new Promise((resolve) => setImmediate(resolve));
 }
 
+
 function yieldToTimers(): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, 0));
 }