knitting 0.1.63 → 0.1.73

package/knitting.js

@@ -2,5 +2,6 @@
 import { workerMainLoop } from "./src/worker/loop.js";
 import { checkCompiledWorker, createPool, importTask, isMain, setModuleUrl, task, } from "./src/api.js";
 import { Envelope } from "./src/common/envelope.js";
+import { KnittingError } from "./src/error.js";
 import { isNumericArray, NumericArray, } from "./src/connections/numeric-array.js";
-export { checkCompiledWorker as checkCompiledWorker, createPool as createPool, Envelope as Envelope, importTask as importTask, isMain as isMain, isNumericArray as isNumericArray, NumericArray as NumericArray, setModuleUrl as setModuleUrl, task as task, workerMainLoop as workerMainLoop, };
+export { checkCompiledWorker as checkCompiledWorker, createPool as createPool, Envelope as Envelope, importTask as importTask, isMain as isMain, isNumericArray as isNumericArray, KnittingError as KnittingError, NumericArray as NumericArray, setModuleUrl as setModuleUrl, task as task, workerMainLoop as workerMainLoop, };

package/map.md

@@ -237,12 +237,8 @@ The core flow is:
 
 - `bench/latency.ts`: Compares basic task-call latency against a direct worker
   postMessage baseline.
-- `bench/types.ts`: Compares payload-type behavior between knitting and worker
-  messaging.
 - `bench/types_knitting.ts`: Knitting-only payload-type benchmark with broader
   type coverage.
-- `bench/ipc.ts`: Larger IPC comparison benchmark covering local calls,
-  postMessage, HTTP, WebSocket, and knitting.
 - `bench/withload.ts`: Measures behavior under main-thread load.
 - `bench/call-growth.ts`: Measures call cost as payload size grows.
 - `bench/call-growth-batch.ts`: Batch-focused version of call-growth tests.
@@ -254,8 +250,6 @@ The core flow is:
 - `bench/payload-sweep.ts`: Uint8Array payload-size sweep promoted from the old
   scratch file. Supports table output and `--json`.
 - `bench/postmessage/single.ts`: Worker-thread postMessage baseline helper.
-- `bench/postmessage/test.go`: Go comparison/experiment for postMessage-style
-  IPC.
 - `bench/util/json-parse.ts`: Mitata JSON output reducer used by benchmark
   scripts.
 - `bench/util/type-payloads.ts`: Shared payload cases and size estimation for

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knitting",
-  "version": "0.1.63",
+  "version": "0.1.73",
   "description": "Shared-memory IPC runtime for Node.js, Deno, and Bun.",
   "license": "Apache-2.0",
   "repository": {
@@ -83,11 +83,12 @@
     "release:npm": "npm run test:all && npm publish",
     "release:npm:dry-run": "npm publish --dry-run",
     "test": "npm run test:deno",
-    "test:deno": "deno test -A --ignore=test/runtime.node.test.ts --ignore=test/runtime.process.test.ts",
+    "test:deno": "deno test -A --ignore=test/runtime.node.test.ts --ignore=test/runtime.process.test.ts test",
     "test:node": "node --no-warnings --experimental-transform-types --test \"./test/*.test.ts\"",
     "test:node:26": "node --no-warnings --experimental-ffi test/node26-ffi.integration.mjs",
-    "test:bun": "bun test ./test/*.test.ts --path-ignore-patterns=**/tx-queue.test.ts",
+    "test:bun": "bun test",
     "test:browser": "bun run scripts/test-browser.ts",
+    "check:windows-park": "bun run scripts/check-windows-park.ts",
     "test:runtimes": "npm run test:node && npm run test:bun",
     "test:all": "npm run test:deno && npm run test:runtimes && npm run test:browser",
     "coverage:node": "node --no-warnings --experimental-transform-types --experimental-test-coverage --test \"./test/*.test.ts\"",
@@ -101,13 +102,17 @@
     "bun": ">=1.0.0"
   },
   "peerDependencies": {
-    "typescript": "^5.2.0"
+    "typescript": ">=5.2.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@types/bun": "latest",
     "@types/deno": "latest",
     "@types/node": "latest",
-    "dts-bundle-generator": "^9.5.1",
     "mitata": "^1.0.34",
     "typescript": "^5.2.0"
   }

package/scripts/build-native-addons.ts

@@ -237,6 +237,11 @@ const addons = [
     source: "src/knitting_buffer_pointer.cc",
     output: "build/Release/knitting_buffer_pointer.node",
   },
+  {
+    name: "knitting_doorbell",
+    source: "src/knitting_doorbell.cc",
+    output: "build/Release/knitting_doorbell.node",
+  },
 ];
 const ffiLibraries = isWindows
   ? [

package/shared-memory.d.ts

@@ -1 +1,4 @@
 export { getDefaultProcessSharedBufferPrimitives, parseProcessSharedBufferMetadata, PROCESS_SHARED_BUFFER_BRAND, ProcessSharedBuffer, setDefaultProcessSharedBufferPrimitives, type ProcessSharedBufferCreator, type ProcessSharedBufferMapper, type ProcessSharedBufferMetadata, type ProcessSharedBufferPrimitives, type ProcessSharedBufferRange, type ProcessSharedBufferView, type ProcessSharedBufferViewConstructor, } from "./src/connections/process-shared-buffer.js";
+export { attachKnittingAllocator, createKnittingAllocator, DEFAULT_ARENA_BYTE_LENGTH, detectRegion, type KnittingAllocator, type KnittingAllocatorOptions, type KnittingBufferDescriptor, KnittingSharedBuffer, } from "./src/memory/knitting-buffer.js";
+export { createBodyReader, type KnittingBody, type KnittingBodyWire, type KnittingTransport, } from "./src/memory/knitting-body.js";
+export { HTTP_BODY_STREAM_THRESHOLD_BYTES, HTTP_BODY_REFERENCE_THRESHOLD_BYTES, type ReadBodyIntoBytesOptions, type ReadBodyOptions, type ReadBodyOrReferOptions, type ReadBodyPayload, readBodyIntoBytes, readBodyIntoRegion, readBodyOrRefer, type RegionAllocator, } from "./src/memory/knitting-buffer-http.js";

package/shared-memory.js

@@ -1 +1,4 @@
 export { getDefaultProcessSharedBufferPrimitives, parseProcessSharedBufferMetadata, PROCESS_SHARED_BUFFER_BRAND, ProcessSharedBuffer, setDefaultProcessSharedBufferPrimitives, } from "./src/connections/process-shared-buffer.js";
+export { attachKnittingAllocator, createKnittingAllocator, DEFAULT_ARENA_BYTE_LENGTH, detectRegion, KnittingSharedBuffer, } from "./src/memory/knitting-buffer.js";
+export { createBodyReader, } from "./src/memory/knitting-body.js";
+export { HTTP_BODY_STREAM_THRESHOLD_BYTES, HTTP_BODY_REFERENCE_THRESHOLD_BYTES, readBodyIntoBytes, readBodyIntoRegion, readBodyOrRefer, } from "./src/memory/knitting-buffer-http.js";

package/src/api.js

@@ -4,22 +4,28 @@ import { genTaskID, stableTaskID } from "./common/task-source.js";
 import { toModuleUrl } from "./common/module-url.js";
 import { endpointSymbol } from "./common/task-symbol.js";
 import { createStealPoolBuffers, MAX_STEAL_CONSUMERS, spawnWorkerContext, } from "./runtime/pool.js";
+import { isNodePermissionExecFlag } from "./runtime/worker-common.js";
 import { ChannelHandler, hostDispatcherLoop } from "./runtime/dispatcher.js";
+import { createDenoCompletionDoorbell } from "./runtime/deno-doorbell.js";
 import { createSharedArrayBuffer, RUNTIME } from "./common/runtime.js";
 import { RUNTIME_IS_MAIN_THREAD, RUNTIME_POOL_DEPTH, RUNTIME_WORKER_DATA, } from "./common/worker-runtime.js";
 import { classifyProcessPermissionCompatibility, enforceProcessPermissionCompatibility, resolvePermissionProtocol, toRuntimePermissionFlags, } from "./permission/index.js";
 import { getNodeProcess } from "./common/node-compat.js";
 import { readProcessSharedMemorySettings, readProcessWorkerNodeMajor, readProcessWorkerRuntime, } from "./runtime/process-worker.js";
+import { assertStealClaim, DEFAULT_STEAL_CLAIM, } from "./memory/lock.js";
 import { TRANSPORT_SIGNAL_BYTES } from "./ipc/transport/shared-memory.js";
 import { inspectCompiledWorkerArtifact } from "./runtime/compiled-artifact.js";
 import { managerMethod } from "./runtime/balancer.js";
 import { createInlineExecutor } from "./runtime/inline-executor.js";
+import { createHostArgAllocator } from "./runtime/host-arg-arena.js";
 const hasDebugNamespace = (namespaces, namespace) => namespaces.has("*") || namespaces.has(namespace);
-const createHostDebug = (namespaces) => {
+const createHostDebug = (namespaces, epoch) => {
     const enabled = (namespace) => hasDebugNamespace(namespaces, namespace);
     if (!enabled("host"))
         return undefined;
-    const base = performance.now();
+    // Same rebase the workers do (see debug/handle.ts), so host and worker lines
+    // share one zero.
+    const base = epoch - performance.timeOrigin;
     const tag = `host·${RUNTIME}`;
     const log = (message) => {
         const elapsed = (performance.now() - base).toFixed(1);
@@ -242,13 +248,20 @@ const toPoolTaskEntries = (input, callerHref) => Object.entries(input).map(([nam
  * argument; use an object or tuple for multiple values.
  */
 export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe, abortSignalCapacity, source, worker, workerExecArgv, permission, host, }) => (tasks) => {
-    const bufferReferenceReturn = unsafe?.BufferReferenceReturn;
+    const sharedBytesEnabled = unsafe?.SharedBytes === true;
+    const sharedArgsEnabled = unsafe?.SharedArgs === true;
     const debugRequested = DEBUG_ENABLED ||
         (debug !== undefined && debug !== false);
     let debugNamespaces;
     const getDebugNamespaces = () => debugNamespaces ??= resolveDebugNamespaces(debug);
-    const hostDebug = debugRequested
-        ? createHostDebug(getDebugNamespaces())
+    // Absolute (Unix-epoch ms) zero for every debug clock in this pool. Raw
+    // `performance.now()` is relative to each thread/process's own time origin;
+    // `timeOrigin + now()` is not, so workers can rebase onto this value.
+    const debugEpoch = debugRequested
+        ? performance.timeOrigin + performance.now()
+        : undefined;
+    const hostDebug = debugEpoch !== undefined
+        ? createHostDebug(getDebugNamespaces(), debugEpoch)
         : undefined;
     const debugEnabled = (namespace) => debugRequested && hasDebugNamespace(getDebugNamespaces(), namespace);
     /**
@@ -275,6 +288,7 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         return {
             shutdown: mainThreadOnlyProxy,
             [Symbol.dispose]: () => { },
+            [Symbol.asyncDispose]: async () => { },
             call: mainThreadOnlyProxy,
         };
     }
@@ -303,20 +317,7 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
     const permissionExecArgv = toRuntimePermissionFlags(permissionProtocol);
     const nodeProcess = getNodeProcess();
     const allowedFlags = nodeProcess?.allowedNodeEnvironmentFlags ?? null;
-    const isNodePermissionFlag = (flag) => {
-        const key = flag.split("=", 1)[0];
-        return key === "--permission" ||
-            key === "--experimental-permission" ||
-            key === "--allow-fs-read" ||
-            key === "--allow-fs-write" ||
-            key === "--allow-worker" ||
-            key === "--allow-child-process" ||
-            key === "--allow-net" ||
-            key === "--allow-addons" ||
-            key === "--allow-ffi" ||
-            key === "--allow-wasi";
-    };
-    const stripNodePermissionFlags = (flags) => flags?.filter((flag) => !isNodePermissionFlag(flag));
+    const stripNodePermissionFlags = (flags) => flags?.filter((flag) => !isNodePermissionExecFlag(flag));
     const dedupeFlags = (flags) => {
         const out = [];
         const seen = new Set();
@@ -343,16 +344,11 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         ? nodeProcess.execArgv
         : undefined;
     const defaultExecArgvCandidate = workerExecArgv ??
-        (inheritedExecArgv
-            ? (allowedFlags?.has("--expose-gc") === true
-                ? (inheritedExecArgv.includes("--expose-gc")
-                    ? inheritedExecArgv
-                    : [...inheritedExecArgv, "--expose-gc"])
-                : inheritedExecArgv)
-            : undefined);
-    const defaultExecArgv = permissionProtocol?.unsafe === true
-        ? stripNodePermissionFlags(defaultExecArgvCandidate)
-        : defaultExecArgvCandidate;
+        inheritedExecArgv;
+    // Knitting resolves the worker's permission policy itself. Do not inherit
+    // the host's Node grants (or caller-supplied permission flags), which could
+    // broaden that policy when Node combines repeated --allow-* options.
+    const defaultExecArgv = stripNodePermissionFlags(defaultExecArgvCandidate);
     const combinedExecArgv = dedupeFlags([
         ...permissionExecArgv,
         ...(defaultExecArgv ?? []),
@@ -364,6 +360,16 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
     hostDebug?.log(`permission=${permissionProtocol?.mode ?? "off"} execArgv=${formatDebugList(execArgv)}`);
     const usesAbortSignal = listOfFunctions.some((fn) => fn.abortSignal !== undefined);
     const resolvedWorker = resolveWorkerSettings(worker, callerHref);
+    if (RUNTIME === "node" &&
+        resolvedWorker?.runtime !== "process" &&
+        resolvedWorker?.runtime !== "compiled") {
+        const missingPermissionFlags = permissionExecArgv.filter((flag) => isNodePermissionExecFlag(flag) && !execArgv?.includes(flag));
+        if (missingPermissionFlags.length > 0) {
+            throw new Error("Node cannot apply the resolved permission policy to this thread " +
+                `worker (unsupported flags: ${missingPermissionFlags.join(", ")}). ` +
+                "Refusing to start the worker without those permissions.");
+        }
+    }
     const dispatcherEnv = nodeProcess?.env?.KNITTING_DISPATCHER;
     const stealEnvRaw = nodeProcess?.env?.KNITTING_STEAL?.trim().toLowerCase();
     const stealEnv = stealEnvRaw === "1" || stealEnvRaw === "true"
@@ -371,14 +377,24 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         : stealEnvRaw === "0" || stealEnvRaw === "false"
             ? false
             : undefined;
-    // Shared-submit stealing is the default for compatible multi-worker pools.
-    // An explicit option wins over the environment; compiled and inline
-    // transports retain their existing topology.
+    // Shared-submit stealing is the default for compatible multi-worker pools;
+    // explicit options take precedence over the environment.
     const dispatcherExplicitlySelected = host?.dispatcher !== undefined ||
         dispatcherEnv === "serial-channel" || dispatcherEnv === "per-thread";
     const stealDefaultCompatible = balancer === undefined &&
         !dispatcherExplicitlySelected && (threads ?? 1) <= MAX_STEAL_CONSUMERS;
     const stealRequested = host?.steal ?? stealEnv ?? stealDefaultCompatible;
+    const stealClaimEnvRaw = nodeProcess?.env?.KNITTING_STEAL_CLAIM?.trim()
+        .toLowerCase();
+    // An unrecognised discipline is an error, not a fallback: `cas-mask` and
+    // typos used to select Dekker silently and run under the wrong name.
+    const stealClaimEnv = stealClaimEnvRaw === undefined || stealClaimEnvRaw === ""
+        ? undefined
+        : assertStealClaim(stealClaimEnvRaw, "KNITTING_STEAL_CLAIM");
+    // Select the stealing claim discipline, preferring the explicit option.
+    const stealClaim = host?.stealClaim === undefined
+        ? stealClaimEnv ?? DEFAULT_STEAL_CLAIM
+        : assertStealClaim(host.stealClaim, "host.stealClaim");
     const usingCompiledWorker = resolvedWorker?.runtime === "compiled";
     if (resolvedWorker?.compiled !== undefined && !usingCompiledWorker) {
         throw new Error("worker.compiled requires worker.runtime to be compiled");
@@ -463,9 +479,8 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
             ? dispatcherEnv
             : undefined);
     const autoDispatcher = (() => {
-        // Experimental default for HTTP-style bursts: Bun still favors direct
-        // per-thread channels, while Node/Deno multi-worker pools favor one shared
-        // macro channel over the per-lane dispatcher checks.
+        // Bun and single-worker pools use per-thread dispatch; other pools share a
+        // channel across their private lanes.
         if (RUNTIME === "bun")
             return "per-thread";
         if ((threads ?? 1) <= 1)
@@ -473,10 +488,8 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         return "serial-channel";
     })();
     const dispatcher = explicitDispatcher ?? autoDispatcher;
-    // Work stealing: one shared submit region, private return lanes, one
-    // pool-global pending registry. It is the compatible multi-worker default;
-    // an explicit balancer/dispatcher keeps the private-lane topology unless
-    // stealing itself was explicitly requested.
+    // Stealing uses one submit region and private return lanes. Explicit balancer
+    // or dispatcher settings retain private lanes unless stealing is requested.
     const useSteal = stealRequested &&
         !usingCompiledWorker &&
         (threads ?? 1) > 1 &&
@@ -485,7 +498,9 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         ? createStealPoolBuffers({
             threads: threads ?? 1,
             payload,
+            sharedArgs: sharedArgsEnabled,
             regionLanes: host?.stealRegionLanes,
+            stealClaim,
             abortSignalCapacity,
             usesAbortSignal,
             processWorker: resolvedWorker?.runtime === "process"
@@ -498,13 +513,16 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         : undefined;
     const serialChannel = !usingCompiledWorker && !useSteal &&
         dispatcher === "serial-channel";
-    // One serial-channel hop drives every lane check in turn, and it depends on
-    // the channel's delivery to do that: swapping in the cheaper `setImmediate`
-    // pump cost 25% throughput and tripled p99 here, where every other topology
-    // gained. See ChannelHandler's note.
+    // The serial topology relies on channel delivery to run each lane check.
     const serialDispatcherChannel = serialChannel
         ? new ChannelHandler("channel")
         : undefined;
+    // Deno uses a threadSafe FFI callback because waitAsync does not wake an idle
+    // event loop; process workers cannot use the process-local pointer.
+    const denoCompletionDoorbell = !usingCompiledWorker &&
+        resolvedWorker?.runtime !== "process" && host?.doorbell !== false
+        ? createDenoCompletionDoorbell()
+        : undefined;
     let workers = Array.from({
         length: threads ?? 1,
     }).map((_, thread) => spawnWorkerContext({
@@ -514,6 +532,7 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         at,
         thread,
         debug,
+        debugEpoch,
         hostDebug: hostDebug?.log,
         totalNumberOfThread,
         // Worker count without the inline lane. The inliner runs on the host
@@ -522,13 +541,15 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         source,
         workerOptions: resolvedWorker,
         workerExecArgv: execArgv,
+        requestedExecArgv: workerExecArgv,
         host,
         payload,
-        bufferReferenceReturn,
+        sharedBytesEnabled,
         abortSignalCapacity,
         usesAbortSignal,
         permission: permissionProtocol,
         sharedChannelHandler: serialDispatcherChannel,
+        denoCompletionDoorbell,
         stealPool: stealBuffers === undefined ? undefined : {
             submitBuffers: stealBuffers.submitBuffers,
             returnBuffers: stealBuffers.returnBuffers[thread],
@@ -538,6 +559,7 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
             consumers: threads ?? 1,
             consumerId: thread,
             regionLanes: stealBuffers.regionLanes,
+            stealClaim: stealBuffers.stealClaim,
             abortSignalSAB: stealBuffers.abortSignalSAB,
             abortSignalMax: stealBuffers.abortSignalMax,
             processMemory: stealBuffers.processMemory,
@@ -547,23 +569,34 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
     if (useSteal) {
         const channel = stealChannel;
         const queue = stealBuffers.sharedQueue;
-        // Wake exactly one worker per drain, round-robin. Stealing decouples the
-        // wake target from the assignment: if the woken worker is busy, any other
-        // idle endpoint claims the region instead. So this costs one notify per
-        // publish regardless of pool size, rather than one per lane.
+        // Round-robin wake keeps stealing at one notify per publish; any idle worker
+        // can claim the region.
         let wakeCursor = 0;
+        let lastWoken = 0;
         const wakeOne = () => {
             const lanes = workers.length;
             if (lanes === 0)
                 return;
-            const lane = wakeCursor;
+            const lane = lastWoken = wakeCursor;
             wakeCursor = wakeCursor + 1 < lanes ? wakeCursor + 1 : 0;
             workers[lane].laneWake?.();
         };
+        // Any awake worker will claim what was just published, so a lost wake
+        // only strands work when every worker is parked. Ring the lane this pass
+        // already rang: one still waking up absorbs it, and a second lane would
+        // be one more thread woken per call.
+        const wakeIfAllParked = () => {
+            for (let lane = 0; lane < workers.length; lane++) {
+                const context = workers[lane];
+                if (context.laneAwake?.() !== false)
+                    return;
+            }
+            workers[lastWoken]?.laneWake?.();
+        };
         // The shared dispatcher drives one queue, so it needs signal words of its
         // own rather than any single lane's; waking is delegated to `wakeOne`.
         const signalWords = new Int32Array(createSharedArrayBuffer(3 * Int32Array.BYTES_PER_ELEMENT));
-        const { check } = hostDispatcherLoop({
+        const { check, wakeCompletion } = hostDispatcherLoop({
             signalBox: {
                 opView: signalWords.subarray(0, 1),
                 txStatus: signalWords.subarray(1, 2),
@@ -573,19 +606,32 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
             channelHandler: channel,
             dispatcherOptions: host,
             notifySignal: wakeOne,
+            wakeAfterPass: wakeIfAllParked,
             crossProcess: resolvedWorker?.runtime === "process",
+            nativeCompletionDoorbell: denoCompletionDoorbell !== undefined ||
+                workers.some((context) => context
+                    .nodeCompletionDoorbell === true),
+            processCompletionDoorbell: workers.some((context) => context.processCompletionDoorbell === true),
         });
         channel.open(check);
+        if (denoCompletionDoorbell !== undefined) {
+            workers.forEach((_, thread) => {
+                denoCompletionDoorbell.listen(thread, wakeCompletion);
+            });
+        }
+        workers.forEach((context) => {
+            context.bindCompletionWake?.(wakeCompletion);
+        });
         workers.forEach((context) => {
             context.bindSend(() => {
                 if (check.isRunning !== true) {
                     check.isRunning = true;
-                    Promise.resolve().then(check);
+                    queueMicrotask(check);
                 }
                 wakeOne();
             });
         });
-        hostDebug?.log(`dispatcher=steal lanes=${workers.length} g=${stealBuffers.regionLanes}`);
+        hostDebug?.log(`dispatcher=steal lanes=${workers.length} g=${stealBuffers.regionLanes} claim=${stealClaim}`);
     }
     const sharedDispatcherChannel = serialDispatcherChannel;
     if (serialChannel) {
@@ -595,11 +641,7 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         let serialScheduled = false;
         let serialInFlight = false;
         let serialRerun = false;
-        // Busy-lane set: a tick walks only the lanes that have work, not all of
-        // them. `active` is a dense list of lane indices; `isActive` keeps the
-        // membership test O(1). A lane joins on send() and leaves once its queue
-        // reports idle, so an N-worker pool with one busy lane costs one check per
-        // tick instead of N.
+        // Visit only active private lanes; inactive lanes stay out of the tick.
         const active = [];
         const isActive = new Uint8Array(checks.length);
         const markActive = (lane) => {
@@ -642,7 +684,7 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
             if (serialScheduled)
                 return;
             serialScheduled = true;
-            Promise.resolve().then(runSerialChecks);
+            queueMicrotask(runSerialChecks);
         };
         channel.open(runSerialChecks);
         workers.forEach((context, lane) => {
@@ -690,11 +732,29 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         if (closePromise)
             return closePromise;
         closing = true;
+        let canCloseNativeDoorbells = denoCompletionDoorbell === undefined;
         closePromise = Promise.allSettled(workers.map((context) => context.requestStop?.()))
-            .then(() => Promise.allSettled(workers.map((context) => context.kills())))
+            .then((stops) => {
+            if (denoCompletionDoorbell !== undefined) {
+                canCloseNativeDoorbells = stops.every((result, index) => {
+                    if (workers[index].requestStop === undefined)
+                        return true;
+                    return result.status === "fulfilled" && result.value === true;
+                });
+            }
+            return Promise.allSettled(workers.map((context) => context.kills()));
+        })
             .then(() => {
             sharedDispatcherChannel?.close();
             stealChannel?.close();
+        })
+            .finally(() => {
+            if (canCloseNativeDoorbells) {
+                denoCompletionDoorbell?.close();
+                return;
+            }
+            // Keep the callback alive if a worker failed to acknowledge shutdown.
+            denoCompletionDoorbell?.unref();
         });
         return closePromise;
     };
@@ -763,23 +823,41 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
     for (const { name } of indexedFunctions) {
         callHandlers.set(name, []);
     }
-    for (const worker of workers) {
+    if (useSteal) {
+        // Every worker context points at the same pool-global submit queue in the
+        // stealing topology. There is therefore no worker to assign here: the
+        // claimant is selected later by decodeSteal(). Keep one call closure per
+        // task and avoid paying N equivalent wrapper allocations at pool setup.
+        const sharedWorker = workers[0];
         for (const { name, index, timeout, abortSignal } of indexedFunctions) {
-            callHandlers.get(name).push(wrapGuardedInvoke({
-                taskName: name,
-                invoke: worker.call({
-                    fnNumber: index,
-                    timeout,
-                    abortSignal,
+            callHandlers.set(name, [
+                wrapGuardedInvoke({
+                    taskName: name,
+                    invoke: sharedWorker.call({
+                        fnNumber: index,
+                        timeout,
+                        abortSignal,
+                    }),
                 }),
-            }));
+            ]);
+        }
+    }
+    else {
+        for (const worker of workers) {
+            for (const { name, index, timeout, abortSignal } of indexedFunctions) {
+                callHandlers.get(name).push(wrapGuardedInvoke({
+                    taskName: name,
+                    invoke: worker.call({
+                        fnNumber: index,
+                        timeout,
+                        abortSignal,
+                    }),
+                }));
+            }
         }
     }
     const useDirectHandler = (threads ?? 1) === 1 && !usingInliner;
-    // Imported tasks must never execute on the host inliner lane: their module
-    // import is meant to happen inside the worker so worker permission policies
-    // apply. When the inliner is active we strip the inline lane from their
-    // handler set so they only ever reach real worker lanes.
+    // Imported tasks must run on a worker so worker-side permission policies apply.
     const buildImportedInvoker = (handlers) => {
         const workerHandlers = [];
         const workerContexts = [];
@@ -804,6 +882,11 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
         });
     };
     const buildInvoker = (handlers, imported) => {
+        // Stealing owns one shared submit queue. The worker that runs a call is
+        // deliberately chosen by the worker-side claim protocol, not by the host
+        // balancer, so round-robin/first-idle selection would only add overhead.
+        if (useSteal)
+            return handlers[0];
         if (imported && usingInliner) {
             return buildImportedInvoker(handlers);
         }
@@ -835,7 +918,10 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, unsafe,
     return {
         shutdown: shutdownWithDelay,
         [Symbol.dispose]: disposePool,
+        [Symbol.asyncDispose]: () => shutdownWithDelay(),
         call: Object.fromEntries(callEntries),
+        // Only the shared submit queue has a single arena to build arguments in.
+        sharedArgBytes: createHostArgAllocator(sharedArgsEnabled ? stealBuffers?.submitBuffers.payload : undefined),
     };
 };
 const SINGLE_TASK_KEY = "__task__";
@@ -847,6 +933,7 @@ const createSingleTaskPool = (single, options) => {
         call: pool.call[SINGLE_TASK_KEY],
         shutdown: pool.shutdown,
         [Symbol.dispose]: pool[Symbol.dispose],
+        [Symbol.asyncDispose]: pool[Symbol.asyncDispose],
     };
 };
 const buildTaskDefinitionFromCaller = (input, callerHref, at, imported = false) => {

package/src/common/with-resolvers.js

@@ -7,11 +7,8 @@ export const withResolvers = () => {
     const native = Promise.withResolvers;
     if (typeof native === "function") {
         const deferred = native.call(Promise);
-        return {
-            promise: attachReject(deferred.promise, deferred.reject),
-            resolve: deferred.resolve,
-            reject: deferred.reject,
-        };
+        attachReject(deferred.promise, deferred.reject);
+        return deferred;
     }
     let resolve;
     let reject;

package/src/common/worker-runtime.d.ts

@@ -29,6 +29,13 @@ export declare const RUNTIME_PROCESS_WORKER_ENV = "KNITTING_PROCESS_WORKER";
 export declare const RUNTIME_PROCESS_WORKER_BOOT_ENV = "KNITTING_PROCESS_WORKER_BOOT";
 export declare const RUNTIME_PROCESS_WORKER_BOOT_VERSION = 1;
 export declare const RUNTIME_POOL_DEPTH_ENV = "KNITTING_POOL_DEPTH";
+/**
+ * A coalesced completion wake sent over a process worker's existing IPC
+ * channel. The result itself remains in shared memory; this is only the
+ * doorbell byte.
+ */
+export declare const PROCESS_COMPLETION_DOORBELL = "__knittingCompletionDoorbell";
+export declare const isProcessCompletionDoorbell: (value: unknown) => boolean;
 export declare const RUNTIME_IS_PROCESS_WORKER: boolean;
 export declare const RUNTIME_POOL_DEPTH: number;
 export declare const RUNTIME_WORKER: new (specifier: string | URL, options?: Record<string, unknown>) => RuntimeWorkerLike;