@zlink-systems/framework 0.11.0 → 0.12.0

package/dist/runtime/spots/spot-node-runtime-manager.js

@@ -34,8 +34,6 @@ class ZLinkSpotNodeRuntimeManager {
     entryActivations = new Map();
     entryActivationStarts = new Map();
     publishers = new Map();
-    activePublishes = new Set();
-    publishSlotWaiters = new Map();
     disposed = false;
     autoConnectLoops = [];
     publishedMeshNodeDescriptors = new Map();
@@ -579,7 +577,6 @@ class ZLinkSpotNodeRuntimeManager {
         this.meshPumps.clear();
         const publishers = [...this.publishers.values()];
         this.publishers.clear();
-        this.rejectPublishSlotWaiters(runtimeShutdownError());
         const errors = [];
         const settle = async (operations) => {
             const results = await Promise.allSettled(operations);
@@ -802,35 +799,13 @@ class ZLinkSpotNodeRuntimeManager {
         if (publisher === undefined) {
             throw new configuration_1.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);
     }
-    async executePublish(publisher, meshName, channelName, topic, packetName, event, metadata) {
-        // 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 = (0, flow_context_1.runWithOutboundFlow)(this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true, () => (0, channel_envelope_1.encodeChannelPublishEnvelopeParts)(channelName, topic, packetName, event, undefined, 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: submission_result_1.ZLinkSubmitStatus.Submitted });
-        }
-        finally {
-            this.releasePublishSlot(meshName);
-        }
+    async executePublish(publisher, channelName, topic, packetName, event, metadata) {
+        const parts = (0, flow_context_1.runWithOutboundFlow)(this.options.dispatchErrors?.flow.flowCreationEnabled() ?? true, () => (0, channel_envelope_1.encodeChannelPublishEnvelopeParts)(channelName, topic, packetName, event, undefined, 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: submission_result_1.ZLinkSubmitStatus.Submitted });
     }
     tryPublish(meshName, channelName, topic, packetName, event, metadata = EMPTY_SPOT_METADATA) {
         return this.publishWithFlags(meshName, channelName, topic, packetName, event, ZLINK_SEND_DONT_WAIT, metadata);
@@ -855,141 +830,6 @@ class ZLinkSpotNodeRuntimeManager {
             throw error;
         }
     }
-    acquirePublishSlot(meshName, timeoutMs, signal) {
-        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((resolve, reject) => {
-            const waiter = {
-                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 ?? (0, abort_1.createAbortError)());
-                signal.addEventListener('abort', waiter.abortHandler, { once: true });
-            }
-        });
-    }
-    publishTimedOut() {
-        return { status: submission_result_1.ZLinkSubmitStatus.TimedOut };
-    }
-    releasePublishSlot(meshName) {
-        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);
-    }
-    settlePublishSlotWaiter(meshName, waiter, acquired) {
-        if (waiter.settled)
-            return;
-        waiter.settled = true;
-        this.removePublishSlotWaiter(meshName, waiter);
-        this.cleanupPublishSlotWaiter(waiter);
-        waiter.resolve(acquired);
-    }
-    rejectPublishSlotWaiter(meshName, waiter, error) {
-        if (waiter.settled)
-            return;
-        waiter.settled = true;
-        this.removePublishSlotWaiter(meshName, waiter);
-        this.cleanupPublishSlotWaiter(waiter);
-        waiter.reject(error);
-    }
-    removePublishSlotWaiter(meshName, waiter) {
-        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);
-    }
-    cleanupPublishSlotWaiter(waiter) {
-        if (waiter.timeout !== undefined)
-            clearTimeout(waiter.timeout);
-        if (waiter.abortHandler !== undefined) {
-            waiter.signal?.removeEventListener('abort', waiter.abortHandler);
-        }
-    }
-    rejectPublishSlotWaiters(error) {
-        for (const [meshName, queue] of this.publishSlotWaiters) {
-            let waiter;
-            while ((waiter = this.takePublishSlotWaiter(queue)) !== undefined) {
-                this.rejectPublishSlotWaiter(meshName, waiter, error);
-            }
-            this.publishSlotWaiters.delete(meshName);
-        }
-        this.activePublishes.clear();
-    }
-    takePublishSlotWaiter(queue) {
-        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;
-    }
-    compactPublishSlotWaiters(queue) {
-        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;
-        }
-    }
 }
 exports.ZLinkSpotNodeRuntimeManager = ZLinkSpotNodeRuntimeManager;
 function runtimeShutdownError() {

package/dist/runtime/spots/spot-serial-turn-executor.js

@@ -18,10 +18,7 @@ class ZLinkSpotSerialTurnExecutor {
     constructor(yieldAllowed = true, sourceSpotId, schedulerOptions) {
         this.yieldAllowed = yieldAllowed;
         this.sourceSpotId = sourceSpotId;
-        this.scheduler = new serial_execution_queue_1.ZLinkSerialExecutionQueue((record) => this.runQueuedRecord(record), {
-            ...schedulerOptions,
-            capacityError: schedulerOptions?.capacityError ?? (() => (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.WorkerQueueFull, 'Spot execution queue capacity was exceeded.'))
-        });
+        this.scheduler = new serial_execution_queue_1.ZLinkSerialExecutionQueue((record) => this.runQueuedRecord(record), schedulerOptions);
     }
     get isExecuting() {
         return this.depth > 0;

package/dist/runtime/spots/spot-timer.d.ts

@@ -74,6 +74,8 @@ export declare class ZLinkManagedTimer implements ZLinkTimer {
     private lastScheduledIndex;
     private timeout;
     private running;
+    private dispatchFailure;
+    private finalization;
     constructor(name: string, periodMs: number, options: Required<ZLinkTimerOptions>, onTick: (tick: ZLinkTimerTick) => Promise<void>, onFailure?: ZLinkTimerFailureReporter | undefined, shouldWaitForRunningOnCancel?: () => boolean, clock?: ZLinkTimerClock);
     get isDisposed(): boolean;
     cancel(_signal?: AbortSignal): Promise<void>;
@@ -83,6 +85,7 @@ export declare class ZLinkManagedTimer implements ZLinkTimer {
     private scheduleNext;
     private fire;
     private cancelCore;
+    private completeFinalization;
     private prepareCaptureCore;
     private prepareFireCore;
     private completeFireCore;

package/dist/runtime/spots/spot-timer.js

@@ -59,7 +59,9 @@ class ZLinkSpotTimerRegistry {
             : 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 = (0, flow_context_1.createInboundFlow)(undefined, 'Timer', this.flowCreationEnabled());
             const operation = () => {
                 const current = this.timers.get(name);
@@ -68,6 +70,7 @@ class ZLinkSpotTimerRegistry {
                 }
                 if (!this.executionAllowed())
                     return undefined;
+                callbackStarted = true;
                 return (0, flow_context_1.runWithFlow)(timerFlow, () => handler.handle(spot, tick));
             };
             if (this.executeTimer !== undefined) {
@@ -76,9 +79,7 @@ class ZLinkSpotTimerRegistry {
             else {
                 await executionSerial.execute(operation);
             }
-        }, reportFailure, () => this.executeTimer === undefined
-            ? !executionSerial.isExecuting
-            : this.isTimerExecuting?.(name) !== true, this.clock));
+        }, reportFailure, () => callbackStarted, this.clock));
         const registered = await this.lane.run(() => this.completeAddCore(name, prepared.generation, handlerType.name, timer));
         if (!registered)
             await timer.cancel(signal);
@@ -86,13 +87,18 @@ class ZLinkSpotTimerRegistry {
     }
     async dispose() {
         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() {
         const timers = await this.lane.run(() => [...this.timers.entries()].sort(([left], [right]) => left.localeCompare(right)));
@@ -155,6 +161,7 @@ class ZLinkRegisteredTimer {
     name;
     generation;
     timer;
+    finalization;
     constructor(registry, name, generation, timer) {
         this.registry = registry;
         this.name = name;
@@ -165,7 +172,16 @@ class ZLinkRegisteredTimer {
         return this.timer.isDisposed;
     }
     cancel(signal) {
-        return this.registry.cancel(this.name, this.generation, this.timer, signal);
+        if (this.finalization !== undefined)
+            return this.finalization;
+        try {
+            (0, abort_1.throwIfAborted)(signal);
+        }
+        catch (failure) {
+            return Promise.reject(failure);
+        }
+        this.finalization = this.registry.cancel(this.name, this.generation, this.timer);
+        return this.finalization;
     }
     dispose() {
         return this.cancel();
@@ -188,6 +204,8 @@ class ZLinkManagedTimer {
     lastScheduledIndex = 0n;
     timeout;
     running = Promise.resolve();
+    dispatchFailure;
+    finalization;
     constructor(name, periodMs, options, onTick, onFailure, shouldWaitForRunningOnCancel = () => true, clock = systemTimerClock) {
         this.name = name;
         this.periodMs = periodMs;
@@ -203,9 +221,27 @@ class ZLinkManagedTimer {
     get isDisposed() {
         return this.disposed;
     }
-    async cancel(_signal) {
-        const prepared = await this.lane.run(() => this.cancelCore());
-        await prepared.running;
+    cancel(_signal) {
+        if (this.finalization !== undefined)
+            return this.finalization.promise;
+        let resolve;
+        let reject;
+        const promise = new Promise((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() {
         return this.cancel();
@@ -264,7 +300,10 @@ class ZLinkManagedTimer {
             : 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);
     }
     async fire() {
@@ -284,14 +323,44 @@ class ZLinkManagedTimer {
         await this.lane.run(() => this.completeFireCore(prepared.scheduledIndex, shouldContinue));
     }
     cancelCore() {
-        if (this.disposed)
-            return { running: Promise.resolve() };
         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()
+        };
+    }
+    async completeFinalization(start, finalization) {
+        const failures = [];
+        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() };
     }
     prepareCaptureCore() {
         if (this.disposed)

package/dist/runtime/streams/session-serial-executor.js

@@ -5,9 +5,7 @@ const serial_execution_queue_1 = require("../execution/serial-execution-queue");
 const framework_errors_internal_1 = require("../framework-errors-internal");
 const application_job_queue_scope_1 = require("../application-jobs/application-job-queue-scope");
 class ZLinkSessionSerialExecutor {
-    scheduler = new serial_execution_queue_1.ZLinkSerialExecutionQueue(async (record) => this.execute(record), {
-        capacityError: (lane) => (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.WorkerQueueFull, `Stream Session ${lane} execution capacity is full.`, true)
-    });
+    scheduler = new serial_execution_queue_1.ZLinkSerialExecutionQueue(async (record) => this.execute(record), {});
     closed = false;
     executeApplication(work, options = {}, onRejected) {
         return this.submit(work, 'application', options, onRejected);

package/dist/runtime/streams/stream-session-runtime.d.ts

@@ -131,7 +131,7 @@ export declare class ZLinkStreamSessionNodeRuntime {
     private stopped;
     private readonly receiveAbortController;
     private receiveLoop;
-    private readonly receiveIdleWaiter;
+    private readonly receiveWake;
     private receiveWorkSinceYield;
     constructor(options: ZLinkStreamSessionNodeRuntimeOptions & ZLinkStreamLivenessOptions);
     start(): void;
@@ -159,7 +159,7 @@ export declare class ZLinkStreamSessionNodeRuntime {
     private removePendingConnectionMetadata;
     private resolveMonitorSession;
     private enqueueEndpointlessDisconnect;
-    private waitReceiveLoopIdle;
+    private waitReceiveLoopWake;
     private wakeReceiveLoop;
     private getOrCreateSession;
 }

package/dist/runtime/streams/stream-session-runtime.js

@@ -30,31 +30,21 @@ const systemLivenessClock = {
     setTimer: (callback, delayMs) => setTimeout(callback, delayMs),
     clearTimer: (timer) => clearTimeout(timer)
 };
-class ZLinkStreamIdleWaiter {
-    delayMs;
+class ZLinkStreamReceiveWake {
     pending;
     resolvePending;
-    timer;
     finish = () => {
-        if (this.timer !== undefined) {
-            clearTimeout(this.timer);
-            this.timer = undefined;
-        }
         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;
         });
-        this.timer = setTimeout(this.finish, this.delayMs);
         return this.pending;
     }
     wake() {
@@ -664,7 +654,7 @@ class ZLinkStreamSessionNodeRuntime {
     stopped = false;
     receiveAbortController = new AbortController();
     receiveLoop;
-    receiveIdleWaiter = new ZLinkStreamIdleWaiter(5);
+    receiveWake = new ZLinkStreamReceiveWake();
     receiveWorkSinceYield = 0;
     constructor(options) {
         this.options = options;
@@ -734,14 +724,15 @@ 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;
@@ -757,11 +748,11 @@ class ZLinkStreamSessionNodeRuntime {
                 if (!this.isReceiveStopped(signal) && !packetTransferred) {
                     this.options.onError?.(error);
                     this.receiveWorkSinceYield = 0;
-                    await this.waitReceiveLoopIdle();
+                    await new Promise((resolve) => setImmediate(resolve));
                 }
                 else if (!this.isReceiveStopped(signal)) {
                     this.receiveWorkSinceYield = 0;
-                    await this.waitReceiveLoopIdle();
+                    await new Promise((resolve) => setImmediate(resolve));
                 }
                 continue;
             }
@@ -1091,11 +1082,14 @@ class ZLinkStreamSessionNodeRuntime {
             pending.session.enqueueDisconnected(pending.error);
         });
     }
-    waitReceiveLoopIdle() {
-        return this.receiveIdleWaiter.wait();
+    async waitReceiveLoopWake(signal) {
+        await Promise.race([
+            this.options.readablePoller.waitForReadable(signal),
+            this.receiveWake.wait()
+        ]);
     }
     wakeReceiveLoop() {
-        this.receiveIdleWaiter.wake();
+        this.receiveWake.wake();
     }
     getOrCreateSession(routingId) {
         const sessionId = (0, managed_stream_1.streamSessionIdFromRoutingId)(routingId);

package/dist/runtime/workers/index.d.ts

@@ -6,7 +6,6 @@ export interface ZLinkWorkerRuntimeOptions {
     readonly minThreads: number;
     readonly maxThreads: number;
     readonly idleTimeoutMs: number;
-    readonly maxQueueLength: number;
 }
 export declare function resolveWorkerRuntimeOptions(options?: ZLinkWorkerOptions): ZLinkWorkerRuntimeOptions;
 export declare class ZLinkWorkerRuntime {

package/dist/runtime/workers/index.js

@@ -13,13 +13,11 @@ function resolveWorkerRuntimeOptions(options) {
     const resolved = {
         minThreads: options?.minThreads ?? InternalDefaults_1.DEFAULT_WORKER_MIN_THREADS,
         maxThreads: options?.maxThreads ?? (0, InternalDefaults_1.defaultWorkerMaxThreads)(),
-        idleTimeoutMs: options?.idleTimeoutMs ?? InternalDefaults_1.DEFAULT_WORKER_IDLE_TIMEOUT_MS,
-        maxQueueLength: options?.maxQueueLength ?? InternalDefaults_1.DEFAULT_WORKER_QUEUE_LENGTH
+        idleTimeoutMs: options?.idleTimeoutMs ?? InternalDefaults_1.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 configuration_1.ZLinkConfigurationException('Worker maxThreads must be greater than or equal to minThreads.');
     }
@@ -53,9 +51,6 @@ class ZLinkCpuWorkerPool {
         if (signal?.aborted === true) {
             return Promise.reject((0, abort_1.createAbortError)());
         }
-        if (this.queueCount >= this.options.maxQueueLength) {
-            return Promise.reject(workerQueueFull(this.options.maxQueueLength));
-        }
         return new Promise((resolve, reject) => {
             const job = {
                 source: work.toString(),
@@ -446,9 +441,6 @@ class ZLinkSerialDeliveredPromise {
         return this.then((value) => this.serial.execute(() => { onfinally?.(); return value; }), (reason) => this.serial.execute(() => { onfinally?.(); throw reason; }));
     }
 }
-function workerQueueFull(maxQueueLength) {
-    return (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.WorkerQueueFull, `CPU worker queue is full (maxQueueLength=${maxQueueLength}).`, true);
-}
 function workerTimedOut(timeoutMs) {
     return (0, framework_errors_internal_1.createInternalFrameworkException)(framework_errors_internal_1.ZLinkFrameworkInternalErrorKind.WorkerTimedOut, `Worker job timed out after ${timeoutMs}ms.`, true);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zlink-systems/framework",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
@@ -19,7 +19,7 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/api-logs": "^0.221.0",
-    "@zlink-systems/stream-wire": "0.11.0",
-    "@zlink-systems/zlink": "0.17.6"
+    "@zlink-systems/stream-wire": "0.12.0",
+    "@zlink-systems/zlink": "1.1.0"
   }
 }

package/src/contracts/Configuration/EndpointNotation.ts

@@ -1,6 +1,7 @@
 /**
- * Deterministic endpoint-notation normalization (endpoint 표기 정책,
- * doc/plan/endpoint-notation-policy.ko.md).
+ * Deterministic endpoint-notation normalization (endpoint 표기 정책),
+ * applied identically across all four language bindings so endpoint
+ * strings compare equal.
  *
  * `new URL()` cannot represent this domain: it throws on bracketed IPv6
  * literals that carry a zone id (`tcp://[fe80::1%eth0]:80`, even with the
@@ -16,7 +17,7 @@
  * public connect/disconnect APIs). Everything downstream compares the
  * resulting strings with plain `===`.
  *
- * Rules (policy 2.2), applied only to authority-bearing schemes
+ * Rules, applied only to authority-bearing schemes
  * (`tcp`, `tls`, `ws`, `wss` -- schemes whose grammar after `scheme://` is
  * `host:port`):
  *  - scheme: lowercased
@@ -39,7 +40,7 @@
  * `normalizeEndpoint(normalizeEndpoint(x)) === normalizeEndpoint(x)`.
  *
  * DNS names are never resolved. `localhost` and `127.0.0.1` remain distinct
- * endpoints (policy 2.1).
+ * endpoints.
  */
 
 const SCHEME_PATTERN = /^([A-Za-z][A-Za-z0-9+.-]*):\/\/(.*)$/s;

package/src/contracts/Configuration/InternalDefaults.ts

@@ -6,7 +6,6 @@ export const DEFAULT_STREAM_NODE_MAX_MESSAGE_SIZE = 64 * 1024;
 /** Defaults shared by registration normalization and the runtime worker pool. */
 export const DEFAULT_WORKER_MIN_THREADS = 0;
 export const DEFAULT_WORKER_IDLE_TIMEOUT_MS = 30_000;
-export const DEFAULT_WORKER_QUEUE_LENGTH = 1024;
 
 export function defaultWorkerMaxThreads(): number {
   return Math.max(2, os.availableParallelism());

package/src/contracts/Configuration/RegistrationNormalizers.ts

@@ -25,8 +25,7 @@ import {
   defaultWorkerMaxThreads,
   DEFAULT_STREAM_NODE_MAX_MESSAGE_SIZE,
   DEFAULT_WORKER_IDLE_TIMEOUT_MS,
-  DEFAULT_WORKER_MIN_THREADS,
-  DEFAULT_WORKER_QUEUE_LENGTH
+  DEFAULT_WORKER_MIN_THREADS
 } from './InternalDefaults';
 
 export function normalizeWorkerOptions(
@@ -37,8 +36,7 @@ export function normalizeWorkerOptions(
   return {
     minThreads: partial.minThreads ?? DEFAULT_WORKER_MIN_THREADS,
     maxThreads: partial.maxThreads ?? defaultWorkerMaxThreads(),
-    idleTimeoutMs: partial.idleTimeoutMs ?? DEFAULT_WORKER_IDLE_TIMEOUT_MS,
-    maxQueueLength: partial.maxQueueLength ?? DEFAULT_WORKER_QUEUE_LENGTH
+    idleTimeoutMs: partial.idleTimeoutMs ?? DEFAULT_WORKER_IDLE_TIMEOUT_MS
   };
 }