@zlink-systems/framework 0.11.0 → 0.12.0

package/src/runtime/spots/spot-node-runtime-manager.ts

@@ -142,22 +142,6 @@ export interface ZLinkSpotNodeRuntimeManagerOptions {
   };
 }
 
-interface ZLinkPublishSlotWaiter {
-  readonly resolve: (acquired: boolean) => void;
-  readonly reject: (error: unknown) => void;
-  readonly signal?: AbortSignal;
-  abortHandler?: () => void;
-  timeout?: ReturnType<typeof setTimeout>;
-  deadlineMs?: number;
-  settled: boolean;
-}
-
-interface ZLinkPublishSlotQueue {
-  readonly waiters: Array<ZLinkPublishSlotWaiter | undefined>;
-  head: number;
-  count: number;
-}
-
 export class ZLinkSpotNodeRuntimeManager {
   private readonly meshNodes = new Map<string, ZLinkBackendMeshNode>();
   private readonly meshPumps = new Map<string, ZLinkMeshDispatchPump>();
@@ -168,8 +152,6 @@ export class ZLinkSpotNodeRuntimeManager {
     string,
     ReturnType<ZLinkBackendMeshNode['createPublisher']>
   >();
-  private readonly activePublishes = new Set<string>();
-  private readonly publishSlotWaiters = new Map<string, ZLinkPublishSlotQueue>();
   private disposed = false;
   private readonly autoConnectLoops: ZLinkAutoConnectLoop[] = [];
   private readonly publishedMeshNodeDescriptors =
@@ -829,7 +811,6 @@ export class ZLinkSpotNodeRuntimeManager {
     this.meshPumps.clear();
     const publishers = [...this.publishers.values()];
     this.publishers.clear();
-    this.rejectPublishSlotWaiters(runtimeShutdownError());
     const errors: unknown[] = [];
     const settle = async (operations: readonly Promise<unknown>[]) => {
       const results = await Promise.allSettled(operations);
@@ -1120,76 +1101,32 @@ export class ZLinkSpotNodeRuntimeManager {
     if (publisher === undefined) {
       throw new ZLinkConfigurationException(`RouteMesh '${meshName}' publisher is not started.`);
     }
-    const sendTimeoutMs = this.options.registration.spotNodes
-      .get(meshName)?.publisherConfig?.sendTimeoutMs ?? 1000;
-    const slot = this.acquirePublishSlot(meshName, sendTimeoutMs, signal);
-    if (slot === false) {
-      // The bounded executor-admission tokens are exhausted. Do not retain the
-      // payload, cancellation state, or a timer for this hard-overload call.
-      return Promise.resolve(this.publishTimedOut());
-    }
-    if (slot === true) {
-      return this.executePublish(
-        publisher,
-        meshName,
-        channelName,
-        topic,
-        packetName,
-        event,
-        metadata
-      );
-    }
-    return slot.then((acquired) => acquired
-      ? this.executePublish(
-        publisher,
-        meshName,
-        channelName,
-        topic,
-        packetName,
-        event,
-        metadata
-      )
-      : this.publishTimedOut());
+    return this.executePublish(publisher, channelName, topic, packetName, event, metadata);
   }
 
   private async executePublish(
     publisher: ReturnType<ZLinkBackendMeshNode['createPublisher']>,
-    meshName: string,
     channelName: string,
     topic: string,
     packetName: string | undefined,
     event: Message,
     metadata: ReadonlyMap<string, string>
   ): Promise<ZLinkSubmitResult> {
-    // The slot is the source-local admission boundary. Once publishAsync takes
-    // the owned frames, target processing cannot change the caller terminal.
-    // Call-scoped flow (spec 27 §4): the fanout envelope flow pair does not
-    // outlive this publish call.
-    try {
-      const parts = runWithOutboundFlow(
-        this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true,
-        () => encodeChannelPublishEnvelopeParts(
-          channelName,
-          topic,
-          packetName,
-          event,
-          undefined,
-          this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true,
-          metadata
-        )
-      );
-      const processing = publisher.publishAsync(
+    const parts = runWithOutboundFlow(
+      this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true,
+      () => encodeChannelPublishEnvelopeParts(
         channelName,
         topic,
-        parts,
+        packetName,
+        event,
         undefined,
-        undefined
-      );
-      void Promise.resolve(processing).catch(() => undefined);
-      return Promise.resolve({ status: ZLinkSubmitStatus.Submitted });
-    } finally {
-      this.releasePublishSlot(meshName);
-    }
+        this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true,
+        metadata
+      )
+    );
+    const processing = publisher.publishAsync(channelName, topic, parts, undefined, undefined);
+    void Promise.resolve(processing).catch(() => undefined);
+    return Promise.resolve({ status: ZLinkSubmitStatus.Submitted });
   }
 
   tryPublish(
@@ -1242,163 +1179,6 @@ export class ZLinkSpotNodeRuntimeManager {
     }
   }
 
-  private acquirePublishSlot(
-    meshName: string,
-    timeoutMs: number,
-    signal?: AbortSignal
-  ): boolean | Promise<boolean> {
-    if (!this.activePublishes.has(meshName)) {
-      this.activePublishes.add(meshName);
-      return true;
-    }
-    const waiterCapacity = Math.max(
-      1,
-      this.options.registration.spotNodes
-        .get(meshName)?.publisherConfig?.sendHighWaterMark ?? 1
-    );
-    const queue = this.publishSlotWaiters.get(meshName) ?? {
-      waiters: [],
-      head: 0,
-      count: 0
-    };
-    if (queue.count >= waiterCapacity) {
-      // This call has no bounded executor-admission token. Fail without
-      // retaining its payload in a pending work queue.
-      return false;
-    }
-    return new Promise<boolean>((resolve, reject) => {
-      const waiter: ZLinkPublishSlotWaiter = {
-        resolve,
-        reject,
-        signal,
-        settled: false
-      };
-      if (timeoutMs !== -1) {
-        waiter.deadlineMs = performance.now() + Math.max(0, timeoutMs);
-      }
-      queue.waiters.push(waiter);
-      queue.count += 1;
-      this.publishSlotWaiters.set(meshName, queue);
-      if (timeoutMs !== -1) {
-        waiter.timeout = setTimeout(() => this.settlePublishSlotWaiter(
-          meshName,
-          waiter,
-          false
-        ), Math.max(0, timeoutMs));
-      }
-      if (signal !== undefined) {
-        waiter.abortHandler = () => this.rejectPublishSlotWaiter(
-          meshName,
-          waiter,
-          signal.reason ?? createAbortError()
-        );
-        signal.addEventListener('abort', waiter.abortHandler, { once: true });
-      }
-    });
-  }
-
-  private publishTimedOut(): ZLinkSubmitResult {
-    return { status: ZLinkSubmitStatus.TimedOut };
-  }
-
-  private releasePublishSlot(meshName: string): void {
-    const queue = this.publishSlotWaiters.get(meshName);
-    while (queue !== undefined && queue.count > 0) {
-      const waiter = this.takePublishSlotWaiter(queue);
-      if (waiter === undefined) continue;
-      if (waiter.settled) continue;
-      if (waiter.deadlineMs !== undefined && performance.now() >= waiter.deadlineMs) {
-        this.cleanupPublishSlotWaiter(waiter);
-        waiter.settled = true;
-        waiter.resolve(false);
-        continue;
-      }
-      this.cleanupPublishSlotWaiter(waiter);
-      waiter.settled = true;
-      waiter.resolve(true);
-      if (queue.count === 0) this.publishSlotWaiters.delete(meshName);
-      return;
-    }
-    this.publishSlotWaiters.delete(meshName);
-    this.activePublishes.delete(meshName);
-  }
-
-  private settlePublishSlotWaiter(
-    meshName: string,
-    waiter: ZLinkPublishSlotWaiter,
-    acquired: boolean
-  ): void {
-    if (waiter.settled) return;
-    waiter.settled = true;
-    this.removePublishSlotWaiter(meshName, waiter);
-    this.cleanupPublishSlotWaiter(waiter);
-    waiter.resolve(acquired);
-  }
-
-  private rejectPublishSlotWaiter(
-    meshName: string,
-    waiter: ZLinkPublishSlotWaiter,
-    error: unknown
-  ): void {
-    if (waiter.settled) return;
-    waiter.settled = true;
-    this.removePublishSlotWaiter(meshName, waiter);
-    this.cleanupPublishSlotWaiter(waiter);
-    waiter.reject(error);
-  }
-
-  private removePublishSlotWaiter(meshName: string, waiter: ZLinkPublishSlotWaiter): void {
-    const queue = this.publishSlotWaiters.get(meshName);
-    if (queue === undefined) return;
-    const index = queue.waiters.indexOf(waiter, queue.head);
-    if (index >= 0) {
-      queue.waiters[index] = undefined;
-      queue.count -= 1;
-      this.compactPublishSlotWaiters(queue);
-    }
-    if (queue.count === 0) this.publishSlotWaiters.delete(meshName);
-  }
-
-  private cleanupPublishSlotWaiter(waiter: ZLinkPublishSlotWaiter): void {
-    if (waiter.timeout !== undefined) clearTimeout(waiter.timeout);
-    if (waiter.abortHandler !== undefined) {
-      waiter.signal?.removeEventListener('abort', waiter.abortHandler);
-    }
-  }
-
-  private rejectPublishSlotWaiters(error: unknown): void {
-    for (const [meshName, queue] of this.publishSlotWaiters) {
-      let waiter: ZLinkPublishSlotWaiter | undefined;
-      while ((waiter = this.takePublishSlotWaiter(queue)) !== undefined) {
-        this.rejectPublishSlotWaiter(meshName, waiter, error);
-      }
-      this.publishSlotWaiters.delete(meshName);
-    }
-    this.activePublishes.clear();
-  }
-
-  private takePublishSlotWaiter(queue: ZLinkPublishSlotQueue): ZLinkPublishSlotWaiter | undefined {
-    while (queue.head < queue.waiters.length && queue.waiters[queue.head] === undefined) {
-      queue.head += 1;
-    }
-    const waiter = queue.waiters[queue.head];
-    if (waiter === undefined) return undefined;
-    queue.waiters[queue.head] = undefined;
-    queue.head += 1;
-    queue.count -= 1;
-    this.compactPublishSlotWaiters(queue);
-    return waiter;
-  }
-
-  private compactPublishSlotWaiters(queue: ZLinkPublishSlotQueue): void {
-    if (queue.count === 0) {
-      queue.waiters.length = 0;
-      queue.head = 0;
-    } else if (queue.head >= 1024 && queue.head * 2 >= queue.waiters.length) {
-      queue.waiters.splice(0, queue.head);
-      queue.head = 0;
-    }
-  }
 }
 
 function runtimeShutdownError(): ZLinkFrameworkException {

package/src/runtime/spots/spot-serial-turn-executor.ts

@@ -38,14 +38,7 @@ export class ZLinkSpotSerialTurnExecutor {
   ) {
     this.scheduler = new ZLinkSerialExecutionQueue(
       (record) => this.runQueuedRecord(record),
-      {
-        ...schedulerOptions,
-        capacityError: schedulerOptions?.capacityError ?? (() =>
-          createInternalFrameworkException(
-            ZLinkFrameworkInternalErrorKind.WorkerQueueFull,
-            'Spot execution queue capacity was exceeded.'
-          ))
-      }
+      schedulerOptions
     );
   }
 

package/src/runtime/spots/spot-timer.ts

@@ -41,6 +41,18 @@ const systemTimerClock: ZLinkTimerClock = {
 };
 
 type ZLinkTimerOwnerSpot = ZLinkSpot | ZLinkEntrySpot;
+
+interface ZLinkTimerFinalization {
+  readonly promise: Promise<void>;
+  readonly resolve: () => void;
+  readonly reject: (cause: unknown) => void;
+}
+
+interface ZLinkTimerFinalizationStart {
+  readonly timeout: unknown;
+  readonly running: Promise<void>;
+}
+
 type ZLinkTimerFailureReporter = (
   tick: ZLinkTimerTick,
   cause: unknown,
@@ -125,11 +137,13 @@ export class ZLinkSpotTimerRegistry {
       ? this.executionSerialForTimer?.(name, serial) ?? serial
       : undefined;
     if (this.executionBarrier !== undefined) executionSerial?.setExecutionBarrier(this.executionBarrier);
+    let callbackStarted = false;
     const timer = startOutsideStateLane(() => new ZLinkManagedTimer(
       name,
       periodMs,
       normalizeTimerOptions(options),
       async (tick) => {
+        callbackStarted = false;
         const timerFlow = createInboundFlow(undefined, 'Timer', this.flowCreationEnabled());
         const operation = () => {
           const current = this.timers.get(name);
@@ -137,6 +151,7 @@ export class ZLinkSpotTimerRegistry {
             return undefined;
           }
           if (!this.executionAllowed()) return undefined;
+          callbackStarted = true;
           return runWithFlow(timerFlow, () => handler.handle(spot, tick));
         };
         if (this.executeTimer !== undefined) {
@@ -146,9 +161,7 @@ export class ZLinkSpotTimerRegistry {
         }
       },
       reportFailure,
-      () => this.executeTimer === undefined
-        ? !executionSerial!.isExecuting
-        : this.isTimerExecuting?.(name) !== true,
+      () => callbackStarted,
       this.clock
     ));
     const registered = await this.lane.run(() => this.completeAddCore(
@@ -163,13 +176,18 @@ export class ZLinkSpotTimerRegistry {
 
   async dispose(): Promise<void> {
     const timers = await this.lane.run(() => {
-      const active = [...this.timers.values()].map((entry) => entry.timer);
+      const active = [...this.timers.entries()].map(([name, entry]) => ({
+        name,
+        timer: entry.timer,
+        wait: this.executeTimer === undefined
+          ? true
+          : this.isTimerExecuting?.(name) !== true
+      }));
       this.timers.clear();
       return active;
     });
-    for (const timer of timers) {
-      await timer.dispose();
-    }
+    const finalizations = timers.map(({ timer }) => timer.dispose());
+    await Promise.all(finalizations.filter((_, index) => timers[index]!.wait));
   }
 
   async captureRelocation(): Promise<readonly ZLinkTimerRelocationState[]> {
@@ -248,6 +266,8 @@ export class ZLinkSpotTimerRegistry {
 }
 
 class ZLinkRegisteredTimer implements ZLinkTimer {
+  private finalization: Promise<void> | undefined;
+
   constructor(
     private readonly registry: ZLinkSpotTimerRegistry,
     private readonly name: string,
@@ -260,7 +280,18 @@ class ZLinkRegisteredTimer implements ZLinkTimer {
   }
 
   cancel(signal?: AbortSignal): Promise<void> {
-    return this.registry.cancel(this.name, this.generation, this.timer, signal);
+    if (this.finalization !== undefined) return this.finalization;
+    try {
+      throwIfAborted(signal);
+    } catch (failure) {
+      return Promise.reject(failure);
+    }
+    this.finalization = this.registry.cancel(
+      this.name,
+      this.generation,
+      this.timer
+    );
+    return this.finalization;
   }
 
   dispose(): Promise<void> {
@@ -278,6 +309,8 @@ export class ZLinkManagedTimer implements ZLinkTimer {
   private lastScheduledIndex = 0n;
   private timeout: unknown;
   private running: Promise<void> = Promise.resolve();
+  private dispatchFailure: { readonly cause: unknown } | undefined;
+  private finalization: ZLinkTimerFinalization | undefined;
 
   constructor(
     private readonly name: string,
@@ -297,9 +330,30 @@ export class ZLinkManagedTimer implements ZLinkTimer {
     return this.disposed;
   }
 
-  async cancel(_signal?: AbortSignal): Promise<void> {
-    const prepared = await this.lane.run(() => this.cancelCore());
-    await prepared.running;
+  cancel(_signal?: AbortSignal): Promise<void> {
+    if (this.finalization !== undefined) return this.finalization.promise;
+
+    let resolve!: () => void;
+    let reject!: (cause: unknown) => void;
+    const promise = new Promise<void>((complete, fail) => {
+      resolve = complete;
+      reject = fail;
+    });
+    const finalization = { promise, resolve, reject };
+    this.finalization = finalization;
+
+    try {
+      const preparation = this.lane.run(() => this.cancelCore());
+      void preparation.then(
+        start => {
+          void this.completeFinalization(start, finalization).then(undefined, reject);
+        },
+        reject
+      );
+    } catch (failure) {
+      reject(failure);
+    }
+    return promise;
   }
 
   dispose(): Promise<void> {
@@ -363,7 +417,13 @@ export class ZLinkManagedTimer implements ZLinkTimer {
       : Math.max(0, Number(this.lastScheduledIndex + 1n) * this.periodMs - this.elapsedMs());
     this.timeout = this.clock.setTimeout(() => {
       this.timeout = undefined;
-      this.running = startOutsideStateLane(() => this.fire()).catch(() => undefined);
+      const execution = startOutsideStateLane(() => this.fire());
+      this.running = execution.then(
+        () => undefined,
+        cause => this.lane.run(() => {
+          this.dispatchFailure ??= { cause };
+        })
+      );
     }, delayMs);
   }
 
@@ -388,14 +448,45 @@ export class ZLinkManagedTimer implements ZLinkTimer {
     await this.lane.run(() => this.completeFireCore(prepared.scheduledIndex, shouldContinue));
   }
 
-  private cancelCore(): { readonly running: Promise<void> } {
-    if (this.disposed) return { running: Promise.resolve() };
+  private cancelCore(): ZLinkTimerFinalizationStart {
     this.disposed = true;
-    if (this.timeout !== undefined) {
-      this.clock.clearTimeout(this.timeout);
-      this.timeout = undefined;
+    const timeout = this.timeout;
+    this.timeout = undefined;
+    return {
+      timeout,
+      running: this.shouldWaitForRunningOnCancel()
+        ? this.running
+        : Promise.resolve()
+    };
+  }
+
+  private async completeFinalization(
+    start: ZLinkTimerFinalizationStart,
+    finalization: ZLinkTimerFinalization
+  ): Promise<void> {
+    const failures: unknown[] = [];
+    if (start.timeout !== undefined) {
+      try {
+        this.clock.clearTimeout(start.timeout);
+      } catch (failure) {
+        failures.push(failure);
+      }
+    }
+    try {
+      await start.running;
+    } catch (failure) {
+      failures.push(failure);
+    }
+    const dispatchFailure = await this.lane.run(() => this.dispatchFailure);
+    if (dispatchFailure !== undefined) failures.push(dispatchFailure.cause);
+
+    if (failures.length === 0) {
+      finalization.resolve();
+    } else if (failures.length === 1) {
+      finalization.reject(failures[0]);
+    } else {
+      finalization.reject(new AggregateError(failures, `Timer '${this.name}' cleanup failed.`));
     }
-    return { running: this.shouldWaitForRunningOnCancel() ? this.running : Promise.resolve() };
   }
 
   private prepareCaptureCore(): { readonly running: Promise<void> } {

package/src/runtime/streams/session-serial-executor.ts

@@ -16,13 +16,7 @@ import {
 export class ZLinkSessionSerialExecutor {
   private readonly scheduler = new ZLinkSerialExecutionQueue(
     async (record) => this.execute(record),
-    {
-      capacityError: (lane) => createInternalFrameworkException(
-        ZLinkFrameworkInternalErrorKind.WorkerQueueFull,
-        `Stream Session ${lane} execution capacity is full.`,
-        true
-      )
-    }
+    {}
   );
   private closed = false;
 

package/src/runtime/streams/stream-session-runtime.ts

@@ -92,29 +92,21 @@ const systemLivenessClock: ZLinkStreamLivenessClock = {
   clearTimer: (timer) => clearTimeout(timer as ReturnType<typeof setTimeout>)
 };
 
-class ZLinkStreamIdleWaiter {
+class ZLinkStreamReceiveWake {
   private pending?: Promise<void>;
   private resolvePending?: () => void;
-  private timer?: ReturnType<typeof setTimeout>;
   private readonly finish = (): void => {
-    if (this.timer !== undefined) {
-      clearTimeout(this.timer);
-      this.timer = undefined;
-    }
     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;
     });
-    this.timer = setTimeout(this.finish, this.delayMs);
     return this.pending;
   }
 
@@ -892,7 +884,7 @@ export class ZLinkStreamSessionNodeRuntime {
   private stopped = false;
   private readonly receiveAbortController = new AbortController();
   private receiveLoop: Promise<void> | undefined;
-  private readonly receiveIdleWaiter = new ZLinkStreamIdleWaiter(5);
+  private readonly receiveWake = new ZLinkStreamReceiveWake();
   private receiveWorkSinceYield = 0;
   constructor(
     private readonly options: ZLinkStreamSessionNodeRuntimeOptions & ZLinkStreamLivenessOptions
@@ -967,14 +959,15 @@ export class ZLinkStreamSessionNodeRuntime {
         }
         if (!this.options.readablePoller.wait(0)) {
           permit.releaseAfterInternalProcessing();
-          await this.waitReceiveLoopIdle();
+          await this.waitReceiveLoopWake(signal);
           continue;
         }
         packet = this.takePacket();
         if (!this.options.socket.recvPacket(packet, ZLINK_RECV_DONT_WAIT)) {
+          this.options.readablePoller.markDrained();
           permit.releaseAfterInternalProcessing();
           this.recyclePacket(packet);
-          await this.waitReceiveLoopIdle();
+          await this.waitReceiveLoopWake(signal);
           continue;
         }
         packetTransferred = true;
@@ -987,10 +980,10 @@ export class ZLinkStreamSessionNodeRuntime {
         if (!this.isReceiveStopped(signal) && !packetTransferred) {
           this.options.onError?.(error);
           this.receiveWorkSinceYield = 0;
-          await this.waitReceiveLoopIdle();
+          await new Promise<void>((resolve) => setImmediate(resolve));
         } else if (!this.isReceiveStopped(signal)) {
           this.receiveWorkSinceYield = 0;
-          await this.waitReceiveLoopIdle();
+          await new Promise<void>((resolve) => setImmediate(resolve));
         }
         continue;
       }
@@ -1350,12 +1343,15 @@ export class ZLinkStreamSessionNodeRuntime {
     });
   }
 
-  private waitReceiveLoopIdle(): Promise<void> {
-    return this.receiveIdleWaiter.wait();
+  private async waitReceiveLoopWake(signal: AbortSignal): Promise<void> {
+    await Promise.race([
+      this.options.readablePoller.waitForReadable(signal),
+      this.receiveWake.wait()
+    ]);
   }
 
   private wakeReceiveLoop(): void {
-    this.receiveIdleWaiter.wake();
+    this.receiveWake.wake();
   }
 
   private getOrCreateSession(routingId: unknown): ZLinkStreamSessionRuntime | undefined {

package/src/runtime/workers/index.ts

@@ -7,8 +7,7 @@ import { ZLinkConfigurationException } from '../configuration';
 import {
   defaultWorkerMaxThreads,
   DEFAULT_WORKER_IDLE_TIMEOUT_MS,
-  DEFAULT_WORKER_MIN_THREADS,
-  DEFAULT_WORKER_QUEUE_LENGTH
+  DEFAULT_WORKER_MIN_THREADS
 } from '../../contracts/Configuration/InternalDefaults';
 import { createAbortError } from '../abort';
 import {
@@ -24,20 +23,17 @@ export interface ZLinkWorkerRuntimeOptions {
   readonly minThreads: number;
   readonly maxThreads: number;
   readonly idleTimeoutMs: number;
-  readonly maxQueueLength: number;
 }
 
 export function resolveWorkerRuntimeOptions(options?: ZLinkWorkerOptions): ZLinkWorkerRuntimeOptions {
   const resolved = {
     minThreads: options?.minThreads ?? DEFAULT_WORKER_MIN_THREADS,
     maxThreads: options?.maxThreads ?? defaultWorkerMaxThreads(),
-    idleTimeoutMs: options?.idleTimeoutMs ?? DEFAULT_WORKER_IDLE_TIMEOUT_MS,
-    maxQueueLength: options?.maxQueueLength ?? DEFAULT_WORKER_QUEUE_LENGTH
+    idleTimeoutMs: options?.idleTimeoutMs ?? DEFAULT_WORKER_IDLE_TIMEOUT_MS
   };
   requireNonNegativeInteger('Worker minThreads', resolved.minThreads);
   requirePositiveInteger('Worker maxThreads', resolved.maxThreads);
   requireNonNegativeInteger('Worker idleTimeoutMs', resolved.idleTimeoutMs);
-  requirePositiveInteger('Worker maxQueueLength', resolved.maxQueueLength);
   if (resolved.maxThreads < resolved.minThreads) {
     throw new ZLinkConfigurationException('Worker maxThreads must be greater than or equal to minThreads.');
   }
@@ -98,9 +94,6 @@ class ZLinkCpuWorkerPool {
     if (signal?.aborted === true) {
       return Promise.reject(createAbortError());
     }
-    if (this.queueCount >= this.options.maxQueueLength) {
-      return Promise.reject(workerQueueFull(this.options.maxQueueLength));
-    }
     return new Promise<T>((resolve, reject) => {
       const job = {
         source: work.toString(),
@@ -535,14 +528,6 @@ class ZLinkSerialDeliveredPromise<T> implements Promise<T> {
   }
 }
 
-function workerQueueFull(maxQueueLength: number): ZLinkFrameworkException {
-  return createInternalFrameworkException(
-    ZLinkFrameworkInternalErrorKind.WorkerQueueFull,
-    `CPU worker queue is full (maxQueueLength=${maxQueueLength}).`,
-    true
-  );
-}
-
 function workerTimedOut(timeoutMs: number): ZLinkFrameworkException {
   return createInternalFrameworkException(
     ZLinkFrameworkInternalErrorKind.WorkerTimedOut,