knitting 0.1.50 → 0.1.51

package/README.md

@@ -17,7 +17,8 @@ Thanks to its memory design, it can be 5x to 25x faster than using `postMessages
 
 Use it for parts of your program that should run in different environments, such as CPU-intensive tasks, small jobs, runtime-isolated tasks, custom isolation for workers in Docker or bwrap environments, long-running tools, or any processes that require speed and type flexibility.
 
-You define a task once, spin up a pool, and call it like a normal async function:
+You export a function or task, spin up a pool, and call it like a normal async
+function:
 
 ```ts
 
@@ -26,10 +27,10 @@ const result = await pool.call.resizeImage(file);
 ```
 
 So you only have to take care of 4 things:
- - Create a task
+ - Export a function or task
  - Create a pool
- - Call your task
- - Terminate the pool
+ - Call it
+ - Let `using` or `shutdown()` close the pool
 
 
 Under the hood, we take care of scheduling and orchestration across worker threads or separate processes, also handling signals, timeouts, life cycles, memory allocation, garbage collection, and cross-runtime memory over the processes.
@@ -60,35 +61,27 @@ npm install knitting
 For Deno projects:
 
 ```bash
-deno add --npm jsr:@vixeny/knitting
+deno add --npm knitting
 ```
 
 ## Quick Start
 
 ```ts
-import { createPool, isMain, task } from "knitting";
+import { createPool, isMain } from "knitting";
 
-export const square = task<number, number>({
-  f: (value) => value * value,
-});
+export const square = (value: number) => value * value;
 
-export const greet = task<string, string>({
-  f: (name) => `hello ${name}`,
-});
+export const greet = (name: string) => `hello ${name}`;
 
 if (isMain) {
-  const pool = createPool({ threads: 2 })({ square, greet });
+  using pool = createPool({ threads: 2 })({ square, greet });
 
-  try {
-    const [four, message] = await Promise.all([
-      pool.call.square(2),
-      pool.call.greet("knitting"),
-    ]);
+  const [four, message] = await Promise.all([
+    pool.call.square(2),
+    pool.call.greet("knitting"),
+  ]);
 
-    console.log({ four, message });
-  } finally {
-    await pool.shutdown();
-  }
+  console.log({ four, message });
 }
 ```
 
@@ -128,6 +121,39 @@ if (isMain) {
 }
 ```
 
+On TypeScript or runtimes that support explicit resource management, the pool is
+also a synchronous disposable:
+
+```ts
+if (isMain) {
+  using pool = createPool({ threads: 4 })({ add });
+
+  const value = await pool.call.add([1, 2]);
+  console.log(value);
+}
+```
+
+`using` starts pool shutdown when the scope exits and does not wait for it.
+TypeScript 5.2+ can compile this pattern for runtimes that do not parse `using`
+syntax directly. Use `await pool.shutdown()` when you need to wait for shutdown
+or pass a shutdown delay.
+
+For simple tasks that do not need timeout or abort metadata, exported functions
+can be used directly:
+
+```ts
+export const add = ([a, b]: [number, number]) => a + b;
+
+if (isMain) {
+  using pool = createPool({ threads: 1 })({ add });
+  console.log(await pool.call.add([1, 2]));
+}
+```
+
+Bare functions must be exported from the module that creates the pool. Inline
+anonymous functions cannot be imported by workers; use `task(...)` when you need
+metadata or a more explicit task definition.
+
 Once you have a pool, calls are just promises, so batching looks like normal
 JavaScript:
 
@@ -241,6 +267,14 @@ When workers import files, keep the pool's permission settings in mind. The
 default strict mode allows task imports, but custom permission policies can
 limit reads, writes, environment access, networking, and process execution.
 
+Imported tasks are never run on the host inline lane, even when the pool enables
+the `inliner`. Inlining would evaluate the imported module on the host and
+bypass the worker permissions that `importTask` exists to enforce, so Knitting
+always routes imported tasks to a worker. You can freely mix `importTask` and
+the `inliner` in one pool — regular tasks get inlined while imported ones stay
+on worker lanes — but the pool needs at least one worker thread for them to run,
+otherwise `createPool` throws.
+
 ### Single-task shorthand
 
 For quick scripts, a task can create its own pool:
@@ -422,7 +456,6 @@ the inherited fd:
 
 ```ts
 const pool = createPool({
-  threads: 2,
   worker: {
     runtime: "process",
     processRuntime: "bun",
@@ -502,7 +535,8 @@ If it isn't on that list, assume it isn't portable. Some things don't (or
 shouldn't) cross the boundary:
 
 - DOM objects and platform handles.
-- Functions, unless they are part of a `task` or `importTask` definition.
+- Functions, unless they are exported pool tasks or part of a `task` or
+  `importTask` definition.
 - Cyclic object graphs.
 - `Map`, `Set`, `WeakMap`, and non-global symbols.
 - Objects with behavior that depends on prototypes, getters, setters, or hidden

package/map.md

@@ -32,6 +32,10 @@ The core flow is:
 ## Build And Scripts
 
 - `build.ts`: Bundles `knitting.ts` to `out/` with Bun for a Node ESM target.
+- `tsconfig.npm.json`: TypeScript config for the npm release build. Emits
+  `.js` and `.d.ts` files beside the source tree.
+- `scripts/rewrite-declaration-imports.mjs`: Post-processes emitted `.d.ts`
+  files so declaration imports point at `.js` files for npm consumers.
 - `scripts/build-native-addons.ts`: Compiles the native Node addons into
   `build/Release/` on Linux, macOS, and Windows. It finds Node headers/libs,
   splits user flags, builds the shared-memory and futex addons, and emits the
@@ -39,6 +43,20 @@ The core flow is:
 - `run.sh`: Runs every top-level benchmark in `bench/` across Node, Deno, and
   Bun. `--json` writes JSON result files.
 
+## CI And Release
+
+- `.github/workflows/test.yml`: Push/PR test matrix for Deno, Node, and Bun
+  across Linux, macOS, and Windows.
+- `.github/workflows/coverage.yml`: Node coverage workflow with a 90% line
+  coverage gate.
+- `.github/workflows/build-and-test.yml`: Manual workflow that builds native
+  prebuild artifacts and runs runtime tests against them.
+- `.github/workflows/publish.yml`: Manual native-prebuild workflow. Verifies
+  Node and Windows FFI prebuilds, checks the JSR package contents, and commits
+  updated `prebuilds/` artifacts back to the branch.
+- `docs/windows-process-worker-hang-fix.md`: Investigation notes for the
+  Windows process-worker shared-memory and parked-worker hang fixes.
+
 ## Public API Layer
 
 - `src/api.ts`: Defines `task`, `importTask`, `createPool`, `isMain`, task id
@@ -85,12 +103,20 @@ The core flow is:
   first-idle, random, and first-idle-random.
 - `src/runtime/inline-executor.ts`: Optional in-process executor used by the
   inliner path to run tasks without crossing the worker boundary.
+- `src/runtime/process-worker.ts`: Process-worker spawning, command/runtime
+  selection, process shared-memory layout, inherited/named mapping metadata, and
+  child boot payload construction.
 
 ## Worker Side
 
+- `src/worker/bootstrap.ts`: Optional user bootstrap hook that runs before task
+  modules import and revives process-shared-buffer metadata in bootstrap data.
 - `src/worker/loop.ts`: Worker entrypoint and main loop. Boots worker contexts,
   installs safety guards, receives tasks, executes batches, writes completions,
   and supports process-worker bootstrapping.
+- `src/worker/process-worker-bootstrap.ts`: Child-side process-worker boot
+  payload validation, shared-memory remapping, runtime primitive setup, and
+  startup handoff into the worker loop.
 - `src/worker/task-loader.ts`: Imports task modules inside workers, finds
   exported task definitions, filters by id/caller position, and normalizes
   timeout metadata.
@@ -154,6 +180,8 @@ The core flow is:
   payload-codec registration.
 - `src/connections/file-descriptor.ts`: File descriptor wrapper, metadata
   parsing, mapping support, and descriptor lifecycle helpers.
+- `src/connections/node-addons.ts`: Native addon specifier resolution for
+  committed Node ABI prebuilds with `build/Release` fallback loading.
 - `src/connections/node.ts`: Loads POSIX Node native addons and exposes Node
   shared memory, mapping, unlink, and futex primitives.
 - `src/connections/bun.ts`: Bun FFI implementation for POSIX shared memory.
@@ -169,6 +197,10 @@ The core flow is:
 - `src/knitting_windows_shared_memory.cc`: Runtime-neutral Windows DLL exports
   for creating, opening, mapping, and closing named shared-memory objects from
   FFI runtimes.
+- `prebuilds/*/*.node`: Tracked Node native-addon prebuilds for supported
+  platform/Node ABI combinations.
+- `prebuilds/win32-x64/*.dll`: Tracked Windows FFI DLL prebuild used by Bun and
+  Deno shared-memory primitives on Windows.
 
 ## Permissions
 
@@ -190,6 +222,9 @@ The core flow is:
 - `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.
+- `bench/startup.ts`: Measures `createPool` to first-response startup latency
+  across thread and process workers, with optional cross-runtime and named
+  shared-memory candidates.
 - `bench/tokio-mpsc-knitting.ts`: Batch latency benchmark for string, number,
   and Uint8Array echo tasks.
 - `bench/payload-sweep.ts`: Uint8Array payload-size sweep promoted from the old
@@ -219,6 +254,7 @@ The core flow is:
 
 ## Tests
 
+- `test/_runner.ts`: Runtime-neutral test runner shim used by the test suite.
 - `test/abortSignal.test.ts`: Shared abort bitset behavior.
 - `test/api-cap.test.ts`: API limits such as maximum task id count.
 - `test/shared-buffer-io.test.ts`: Shared-buffer IO read/write behavior.
@@ -250,6 +286,8 @@ The core flow is:
 - `test/task-abort-context-api.test.ts`: Worker abort toolkit/context behavior.
 - `test/tx-queue.test.ts`: Host transmit queue behavior and late-result safety.
 - `test/type-inference.test.ts`: Public type inference guarantees.
+- `test/worker-bootstrap.test.ts`: Worker bootstrap hook behavior, shared-buffer
+  metadata revival, startup failure propagation, and inliner incompatibility.
 - `test/fixtures/*.ts`: Task modules used by tests.
 - `test/fixtures/probes/*.ts`: Probe programs for crash, permission, process,
   file-descriptor, and shared-memory-corruption safety cases.
@@ -259,12 +297,12 @@ The core flow is:
 - `build/Release/*.node`: Native addon output produced by
   `scripts/build-native-addons.ts`.
 - `out/`: Bundled output produced by `build.ts`.
+- `dest/`: Scratch output used by the `build:node` package script.
+- `knitting.js`, `knitting.d.ts`, `process-shared-buffer.js`,
+  `process-shared-buffer.d.ts`, and `src/**/*.js` / `src/**/*.d.ts`: npm
+  release build artifacts produced by `tsconfig.npm.json`.
 - `results/`: Benchmark output produced by `run.sh`.
+- `log/`, `logs`, and `*.log`: Local runtime/log output.
 - `node_modules/`: Installed dependencies. Not part of the source map.
 
-## Deleted Or Intentionally Absent
 
-- Browser-mode build/smoke files are no longer part of the project.
-- The old top-level scratch files `uwu.ts` and `examples.ts` are removed.
-- Python graph scripts under `graphs/` were removed; current benchmark output is
-  kept in the TypeScript benchmark suite.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "knitting",
-  "version": "0.1.50",
+  "version": "0.1.51",
   "description": "Shared-memory IPC runtime for Node.js, Deno, and Bun.",
   "license": "Apache-2.0",
   "repository": {
@@ -66,13 +66,13 @@
     "bun": ">=1.0.0"
   },
   "peerDependencies": {
-    "typescript": "^5.0.0"
+    "typescript": "^5.2.0"
   },
   "devDependencies": {
     "@types/bun": "latest",
     "@types/deno": "latest",
     "@types/node": "latest",
     "mitata": "^1.0.34",
-    "typescript": "^5.0.0"
+    "typescript": "^5.2.0"
   }
 }

package/src/api.d.ts

@@ -1,11 +1,12 @@
 import { endpointSymbol } from "./common/task-symbol.js";
-import type { Args, AbortSignalConfig, AbortSignalOption, AbortSignalToolkit, CreatePool, FixPoint, MaybePromise, Pool, TaskInput, ReturnFixed, ImportTaskOptions, TaskTimeout, tasks } from "./types.js";
+import type { Args, AbortSignalConfig, AbortSignalOption, AbortSignalToolkit, ComposedWithKey, CreatePool, FixPoint, MaybePromise, Pool, TaskInput, ReturnFixed, ImportTaskOptions, TaskTimeout, tasks } from "./types.js";
 type ToListAndIds = {
     list: string[];
     ids: number[];
+    names: string[];
     at: number[];
 };
-type ToListAndIdsFn = (args: tasks) => ToListAndIds;
+type ToListAndIdsFn = (args: ComposedWithKey[]) => ToListAndIds;
 type CreatePoolFactory = (options: CreatePool) => <T extends tasks>(tasks: T) => Pool<T>;
 type InferredTaskFunction = (...args: any[]) => MaybePromise<Args>;
 type InferredTaskInput<F extends InferredTaskFunction, AS extends AbortSignalOption> = Parameters<F> extends [] ? void : AS extends undefined ? Parameters<F> extends [infer A] ? A extends TaskInput ? A : never : never : Parameters<F> extends [infer A] ? A extends TaskInput ? A : never : Parameters<F> extends [infer A, AbortSignalToolkit<AS>] ? A extends TaskInput ? A : never : never;

package/src/api.js

@@ -30,19 +30,22 @@ export { endpointSymbol as endpointSymbol };
  *
  */
 export const toListAndIds = (args) => {
-    const result = Object.values(args)
+    const result = args
         .reduce((acc, v) => (acc[0].add(v.importedFrom),
         acc[1].add(v.id),
         acc[2].add(v.at),
+        acc[3].push(v.name),
         acc), [
         new Set(),
         new Set(),
-        new Set()
+        new Set(),
+        [],
     ]);
     return {
         list: [...result[0]],
         ids: [...result[1]],
         at: [...result[2]],
+        names: result[3],
     };
 };
 const resolveImportHref = (href, callerHref) => {
@@ -73,6 +76,28 @@ const resolveWorkerBootstrapSettings = (worker, callerHref) => {
         },
     };
 };
+const isTaskDefinition = (value) => value != null &&
+    typeof value === "object" &&
+    typeof value.f === "function";
+const toPoolTaskEntries = (input, callerHref) => Object.entries(input).map(([name, value]) => {
+    if (isTaskDefinition(value)) {
+        return {
+            ...value,
+            name,
+        };
+    }
+    if (typeof value === "function") {
+        return {
+            f: value,
+            id: -1,
+            importedFrom: new URL(callerHref).href,
+            at: -1,
+            name,
+            [endpointSymbol]: true,
+        };
+    }
+    throw new TypeError(`createPool task "${name}" must be a task definition or exported function`);
+});
 export const createPool = ({ threads, debug, inliner, balancer, payload, payloadInitialBytes, payloadMaxBytes, bufferMode, maxPayloadBytes, abortSignalCapacity, source, worker, workerExecArgv, permission, dispatcher, host, }) => (tasks) => {
     /**
      *  This functions is only available in the main thread.
@@ -97,14 +122,14 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, payload
         //@ts-ignore
         return {
             shutdown: mainThreadOnlyProxy,
+            [Symbol.dispose]: () => { },
             call: mainThreadOnlyProxy,
         };
     }
-    const { list, ids, at } = toListAndIds(tasks), listOfFunctions = Object.entries(tasks).map(([k, v]) => ({
-        ...v,
-        name: k,
-    }))
+    const callerHref = getCallerHref(3);
+    const listOfFunctions = toPoolTaskEntries(tasks, callerHref)
         .sort((a, b) => a.name.localeCompare(b.name));
+    const { list, ids, names, at } = toListAndIds(listOfFunctions);
     if (listOfFunctions.length > MAX_FUNCTION_COUNT) {
         throw new RangeError(`Too many tasks: received ${listOfFunctions.length}. ` +
             `Maximum is ${MAX_FUNCTION_COUNT} (Uint16 function IDs: 0..${MAX_FUNCTION_ID}).`);
@@ -177,7 +202,7 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, payload
     const execArgv = sanitizeExecArgv(combinedExecArgv.length > 0 ? combinedExecArgv : undefined);
     const hostDispatcher = host ?? dispatcher;
     const usesAbortSignal = listOfFunctions.some((fn) => fn.abortSignal !== undefined);
-    const resolvedWorker = resolveWorkerBootstrapSettings(worker, getCallerHref(3));
+    const resolvedWorker = resolveWorkerBootstrapSettings(worker, callerHref);
     if (usingInliner && resolvedWorker?.bootstrap !== undefined) {
         throw new Error("worker.bootstrap cannot be used with the inliner");
     }
@@ -189,6 +214,7 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, payload
     }).map((_, thread) => spawnWorkerContext({
         list,
         ids,
+        names,
         at,
         thread,
         debug,
@@ -208,7 +234,7 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, payload
     }));
     if (usingInliner) {
         const mainThread = createInlineExecutor({
-            tasks,
+            tasks: listOfFunctions,
             genTaskID,
             batchSize: inliner?.batchSize ?? 1,
         });
@@ -293,11 +319,15 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, payload
         })();
         return shutdownPromise;
     };
+    const disposePool = () => {
+        void shutdownWithDelay();
+    };
     const indexedFunctions = listOfFunctions.map((fn, index) => ({
         name: fn.name,
         index,
         timeout: fn.timeout,
         abortSignal: fn.abortSignal,
+        imported: fn.imported === true,
     }));
     const callHandlers = new Map();
     for (const { name } of indexedFunctions) {
@@ -316,22 +346,67 @@ export const createPool = ({ threads, debug, inliner, balancer, payload, payload
         }
     }
     const useDirectHandler = (threads ?? 1) === 1 && !usingInliner;
-    const buildInvoker = (handlers) => useDirectHandler
-        ? handlers[0]
-        : managerMethod({
-            contexts: workers,
+    // 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.
+    const buildImportedInvoker = (handlers) => {
+        const workerHandlers = [];
+        const workerContexts = [];
+        for (let lane = 0; lane < handlers.length; lane += 1) {
+            if (lane === inlinerIndex)
+                continue;
+            workerHandlers.push(handlers[lane]);
+            workerContexts.push(workers[lane]);
+        }
+        if (workerHandlers.length === 0) {
+            throw new Error("Imported task has no worker lane to run on: the pool only has the " +
+                "host inliner. Imported tasks are never inlined on the host; add at " +
+                "least one worker thread.");
+        }
+        if (workerHandlers.length === 1)
+            return workerHandlers[0];
+        return managerMethod({
+            contexts: workerContexts,
             balancer,
-            handlers,
-            inlinerGate: usingInliner
-                ? {
-                    index: inlinerIndex,
-                    threshold: inlinerDispatchThreshold,
-                }
-                : undefined,
+            handlers: workerHandlers,
+            // No inlinerGate: the inline lane is intentionally excluded here.
         });
-    const callEntries = Array.from(callHandlers.entries(), ([name, handlers]) => [name, buildInvoker(handlers)]);
+    };
+    const buildInvoker = (handlers, imported) => {
+        if (imported && usingInliner) {
+            return buildImportedInvoker(handlers);
+        }
+        return useDirectHandler
+            ? handlers[0]
+            : managerMethod({
+                contexts: workers,
+                balancer,
+                handlers,
+                inlinerGate: usingInliner
+                    ? {
+                        index: inlinerIndex,
+                        threshold: inlinerDispatchThreshold,
+                    }
+                    : undefined,
+            });
+    };
+    let callEntries;
+    try {
+        callEntries = indexedFunctions.map(({ name, imported }) => [name, buildInvoker(callHandlers.get(name), imported)]);
+    }
+    catch (error) {
+        // Building invokers can throw (e.g. an imported task with no worker lane,
+        // or a balancer that needs >=2 lanes). The inline executor and any spawned
+        // workers are already live here, so tear them down before propagating —
+        // otherwise their MessageChannel ports / worker handles keep the event
+        // loop alive and hang the process.
+        void closePoolNow();
+        throw error;
+    }
     return {
         shutdown: shutdownWithDelay,
+        [Symbol.dispose]: disposePool,
         call: Object.fromEntries(callEntries),
     };
 };
@@ -343,15 +418,17 @@ const createSingleTaskPool = (single, options) => {
     return {
         call: pool.call[SINGLE_TASK_KEY],
         shutdown: pool.shutdown,
+        [Symbol.dispose]: pool[Symbol.dispose],
     };
 };
-const buildTaskDefinitionFromCaller = (input, callerHref, at) => {
+const buildTaskDefinitionFromCaller = (input, callerHref, at, imported = false) => {
     const importedFrom = new URL(callerHref).href;
     const out = ({
         ...input,
         id: genTaskID(),
         importedFrom,
         at,
+        imported,
         [endpointSymbol]: true,
     });
     out.createPool = (options) => {
@@ -404,5 +481,5 @@ export function importTask(options) {
     return buildTaskDefinitionFromCaller({
         ...rest,
         f: createImportedTaskFn(resolvedHref, name),
-    }, callerHref, at);
+    }, callerHref, at, true);
 }

package/src/common/task-source.js

@@ -2,9 +2,13 @@ import { toModuleUrl } from "./module-url.js";
 export const genTaskID = ((counter) => () => counter++)(0);
 const INTERNAL_CALLER_HINTS = [
     "/src/common/task-source.ts",
+    "/src/common/task-source.js",
     "\\src\\common\\task-source.ts",
+    "\\src\\common\\task-source.js",
     "/src/api.ts",
+    "/src/api.js",
     "\\src\\api.ts",
+    "\\src\\api.js",
 ];
 const INTERNAL_CALLER_FUNCTIONS = new Set([
     "collectStackFrames",

package/src/connections/process-shared-buffer.js

@@ -150,6 +150,8 @@ export class ProcessSharedBuffer {
     static parse(serialized) {
         return ProcessSharedBuffer.fromMetadata(serialized);
     }
+    // Rebuilds from the 8 raw words (no name -> no JSON):
+    // fd, size, descByteLength, byteOffset, byteLength, runtime, kind, baseAddressMod64
     static [PROCESS_SHARED_BUFFER_NUMERIC_TRANSFER](metadata) {
         const [fd, size, descriptorByteLength, byteOffset, byteLength, runtime, kind, baseAddressMod64,] = metadata;
         return new ProcessSharedBuffer(new FileDescriptor({

package/src/knitting_shared_memory.cc

@@ -711,12 +711,19 @@ void UnlinkSharedMemory(const v8::FunctionCallbackInfo<v8::Value>& args) {
 #endif
 }
 
-void Initialize(v8::Local<v8::Object> exports) {
+void Initialize(
+  v8::Local<v8::Object> exports,
+  v8::Local<v8::Value> /*module*/,
+  v8::Local<v8::Context> /*context*/
+) {
   NODE_SET_METHOD(exports, "createSharedMemory", CreateSharedMemory);
   NODE_SET_METHOD(exports, "mapSharedMemory", MapSharedMemory);
   NODE_SET_METHOD(exports, "unlinkSharedMemory", UnlinkSharedMemory);
 }
 
-NODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)
+// This addon needs V8 APIs to expose mmap'd memory as a SharedArrayBuffer.
+// Context-aware registration lets Node initialize it inside worker threads
+// even after the main thread has already loaded the shared library.
+NODE_MODULE_CONTEXT_AWARE(NODE_GYP_MODULE_NAME, Initialize)
 
 }  // namespace knitting_shared_memory

package/src/memory/lock.js

@@ -564,171 +564,9 @@ export const lock2 = ({ headers, headerSlotStrideU32, LockBoundSector, payload,
                 return modified;
             };
         }
-        if (!shouldSettle) {
-            if (!onResolved) {
-                return () => {
-                    let diff = (a_load(hostBits, 0) ^ LastWorker) | 0;
-                    if (diff === 0)
-                        return 0;
-                    let modified = 0;
-                    let consumedBits = 0 | 0;
-                    let last = lastResolved;
-                    if (last === 32) {
-                        const idx = 31 - clz32(diff);
-                        const selectedBit = 1 << idx;
-                        const task = getTask(idx);
-                        decodeTask(task, idx);
-                        consumedBits = (consumedBits ^ selectedBit) | 0;
-                        settleTask(task);
-                        diff ^= selectedBit;
-                        modified++;
-                        if ((modified & 7) === 0 && consumedBits !== 0) {
-                            LastWorker = (LastWorker ^ consumedBits) | 0;
-                            a_store(workerBits, 0, LastWorker);
-                            consumedBits = 0 | 0;
-                        }
-                        last = idx;
-                    }
-                    while (diff !== 0) {
-                        const lowerMask = last === 31 ? 0x7fffffff : ((1 << last) - 1);
-                        let pick = diff & lowerMask;
-                        if (pick === 0)
-                            pick = diff;
-                        const idx = 31 - clz32(pick);
-                        const selectedBit = 1 << idx;
-                        const task = getTask(idx);
-                        decodeTask(task, idx);
-                        consumedBits = (consumedBits ^ selectedBit) | 0;
-                        settleTask(task);
-                        diff ^= selectedBit;
-                        modified++;
-                        if ((modified & 7) === 0 && consumedBits !== 0) {
-                            LastWorker = (LastWorker ^ consumedBits) | 0;
-                            a_store(workerBits, 0, LastWorker);
-                            consumedBits = 0 | 0;
-                        }
-                        last = idx;
-                    }
-                    if (consumedBits !== 0) {
-                        LastWorker = (LastWorker ^ consumedBits) | 0;
-                        a_store(workerBits, 0, LastWorker);
-                    }
-                    lastResolved = last;
-                    return modified;
-                };
-            }
-            const onResolvedTask = onResolved;
-            return () => {
-                let diff = (a_load(hostBits, 0) ^ LastWorker) | 0;
-                if (diff === 0)
-                    return 0;
-                let modified = 0;
-                let consumedBits = 0 | 0;
-                let last = lastResolved;
-                if (last === 32) {
-                    const idx = 31 - clz32(diff);
-                    const selectedBit = 1 << idx;
-                    const task = getTask(idx);
-                    decodeTask(task, idx);
-                    consumedBits = (consumedBits ^ selectedBit) | 0;
-                    settleTask(task);
-                    onResolvedTask(task);
-                    diff ^= selectedBit;
-                    modified++;
-                    if ((modified & 7) === 0 && consumedBits !== 0) {
-                        LastWorker = (LastWorker ^ consumedBits) | 0;
-                        a_store(workerBits, 0, LastWorker);
-                        consumedBits = 0 | 0;
-                    }
-                    last = idx;
-                }
-                while (diff !== 0) {
-                    const lowerMask = last === 31 ? 0x7fffffff : ((1 << last) - 1);
-                    let pick = diff & lowerMask;
-                    if (pick === 0)
-                        pick = diff;
-                    const idx = 31 - clz32(pick);
-                    const selectedBit = 1 << idx;
-                    const task = getTask(idx);
-                    decodeTask(task, idx);
-                    consumedBits = (consumedBits ^ selectedBit) | 0;
-                    settleTask(task);
-                    onResolvedTask(task);
-                    diff ^= selectedBit;
-                    modified++;
-                    if ((modified & 7) === 0 && consumedBits !== 0) {
-                        LastWorker = (LastWorker ^ consumedBits) | 0;
-                        a_store(workerBits, 0, LastWorker);
-                        consumedBits = 0 | 0;
-                    }
-                    last = idx;
-                }
-                if (consumedBits !== 0) {
-                    LastWorker = (LastWorker ^ consumedBits) | 0;
-                    a_store(workerBits, 0, LastWorker);
-                }
-                lastResolved = last;
-                return modified;
-            };
-        }
+        const hasOnResolved = onResolved !== undefined;
+        const onResolvedTask = onResolved ?? def;
         const shouldSettleTask = shouldSettle;
-        if (!onResolved) {
-            return () => {
-                let diff = (a_load(hostBits, 0) ^ LastWorker) | 0;
-                if (diff === 0)
-                    return 0;
-                let modified = 0;
-                let consumedBits = 0 | 0;
-                let last = lastResolved;
-                if (last === 32) {
-                    const idx = 31 - clz32(diff);
-                    const selectedBit = 1 << idx;
-                    const task = getTask(idx);
-                    decodeTask(task, idx);
-                    consumedBits = (consumedBits ^ selectedBit) | 0;
-                    if (shouldSettleTask(task)) {
-                        settleTask(task);
-                    }
-                    diff ^= selectedBit;
-                    modified++;
-                    if ((modified & 7) === 0 && consumedBits !== 0) {
-                        LastWorker = (LastWorker ^ consumedBits) | 0;
-                        a_store(workerBits, 0, LastWorker);
-                        consumedBits = 0 | 0;
-                    }
-                    last = idx;
-                }
-                while (diff !== 0) {
-                    const lowerMask = last === 31 ? 0x7fffffff : ((1 << last) - 1);
-                    let pick = diff & lowerMask;
-                    if (pick === 0)
-                        pick = diff;
-                    const idx = 31 - clz32(pick);
-                    const selectedBit = 1 << idx;
-                    const task = getTask(idx);
-                    decodeTask(task, idx);
-                    consumedBits = (consumedBits ^ selectedBit) | 0;
-                    if (shouldSettleTask(task)) {
-                        settleTask(task);
-                    }
-                    diff ^= selectedBit;
-                    modified++;
-                    if ((modified & 7) === 0 && consumedBits !== 0) {
-                        LastWorker = (LastWorker ^ consumedBits) | 0;
-                        a_store(workerBits, 0, LastWorker);
-                        consumedBits = 0 | 0;
-                    }
-                    last = idx;
-                }
-                if (consumedBits !== 0) {
-                    LastWorker = (LastWorker ^ consumedBits) | 0;
-                    a_store(workerBits, 0, LastWorker);
-                }
-                lastResolved = last;
-                return modified;
-            };
-        }
-        const onResolvedTask = onResolved;
         return () => {
             let diff = (a_load(hostBits, 0) ^ LastWorker) | 0;
             if (diff === 0)
@@ -742,9 +580,10 @@ export const lock2 = ({ headers, headerSlotStrideU32, LockBoundSector, payload,
                 const task = getTask(idx);
                 decodeTask(task, idx);
                 consumedBits = (consumedBits ^ selectedBit) | 0;
-                if (shouldSettleTask(task)) {
+                if (shouldSettleTask === undefined || shouldSettleTask(task)) {
                     settleTask(task);
-                    onResolvedTask(task);
+                    if (hasOnResolved)
+                        onResolvedTask(task);
                 }
                 diff ^= selectedBit;
                 modified++;
@@ -765,9 +604,10 @@ export const lock2 = ({ headers, headerSlotStrideU32, LockBoundSector, payload,
                 const task = getTask(idx);
                 decodeTask(task, idx);
                 consumedBits = (consumedBits ^ selectedBit) | 0;
-                if (shouldSettleTask(task)) {
+                if (shouldSettleTask === undefined || shouldSettleTask(task)) {
                     settleTask(task);
-                    onResolvedTask(task);
+                    if (hasOnResolved)
+                        onResolvedTask(task);
                 }
                 diff ^= selectedBit;
                 modified++;

package/src/memory/payloadCodec.js

@@ -92,22 +92,14 @@ const decodeExternalPayload = (raw) => {
         : { codec: codecId, metadata };
 };
 const PROCESS_SHARED_BUFFER_NUMERIC_WORDS = 8;
-const PROCESS_SHARED_BUFFER_NUMERIC_BYTES = PROCESS_SHARED_BUFFER_NUMERIC_WORDS * Uint32Array.BYTES_PER_ELEMENT;
 const NUMERIC_SENTINEL = 0xffffffff;
-const readProcessSharedBufferNumericPayload = (bytes) => {
-    const out = new Uint32Array(PROCESS_SHARED_BUFFER_NUMERIC_WORDS);
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    for (let i = 0; i < PROCESS_SHARED_BUFFER_NUMERIC_WORDS; i++) {
-        out[i] = view.getUint32(i * Uint32Array.BYTES_PER_ELEMENT, true);
-    }
-    return out;
-};
-const decodeProcessSharedBufferNumeric = (bytes) => {
-    const metadata = readProcessSharedBufferNumericPayload(bytes);
+const decodeProcessSharedBufferNumericWords = (words) => {
     const codec = externalPayloadGlobal.__KNITTING_PAYLOAD_CODECS__?.[PROCESS_SHARED_BUFFER_CODEC_ID];
-    return typeof codec?.decodeNumeric === "function"
-        ? codec.decodeNumeric(metadata)
-        : { codec: PROCESS_SHARED_BUFFER_CODEC_ID, metadata };
+    if (typeof codec?.decodeNumeric === "function")
+        return codec.decodeNumeric(words);
+    // `words` is a reusable scratch; copy it on the (unreachable in practice)
+    // codec-missing diagnostic path so the escaped value never aliases it.
+    return { codec: PROCESS_SHARED_BUFFER_CODEC_ID, metadata: Array.from(words) };
 };
 const tryEncodePrimitiveTask = (task) => {
     const value = task.value;
@@ -299,7 +291,7 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
         payloadConfig: resolvedPayloadConfig,
         textCompat: textCompat?.payload,
     });
-    const { maxBytes: staticMaxBytes, writeBinary: writeStaticBinary, writeBuffer: writeStaticBuffer, writeArrayBuffer: writeStaticArrayBuffer, writeExactUint8Array: writeStaticExactUint8Array, write8Binary: writeStatic8Binary, writeUtf8: writeStaticUtf8, } = requireStaticIO(headersBuffer, headerSlotStrideU32, textCompat?.headers);
+    const { maxBytes: staticMaxBytes, writeBinary: writeStaticBinary, writeBuffer: writeStaticBuffer, writeArrayBuffer: writeStaticArrayBuffer, writeExactUint8Array: writeStaticExactUint8Array, writeU32Words: writeStaticU32Words, write8Binary: writeStatic8Binary, writeUtf8: writeStaticUtf8, } = requireStaticIO(headersBuffer, headerSlotStrideU32, textCompat?.headers);
     const dynamicLimitError = (task, actualBytes, label) => encoderError({
         task,
         type: ErrorKnitting.Serializable,
@@ -523,11 +515,7 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
         task.value = null;
         return true;
     };
-    const processSharedBufferScratch = new Uint8Array(PROCESS_SHARED_BUFFER_NUMERIC_BYTES);
-    const processSharedBufferScratchView = new DataView(processSharedBufferScratch.buffer);
-    const writeProcessSharedBufferWord = (index, value) => {
-        processSharedBufferScratchView.setUint32(index * Uint32Array.BYTES_PER_ELEMENT, value, true);
-    };
+    const processSharedBufferWords = new Uint32Array(PROCESS_SHARED_BUFFER_NUMERIC_WORDS);
     const tryEncodeProcessSharedBufferNumeric = (task, slotIndex, value) => {
         const descriptor = value.descriptor;
         if (descriptor === undefined ||
@@ -544,19 +532,20 @@ export const encodePayload = ({ lockSector, payload, sab, payloadConfig, headers
             !isU32(baseAddressMod64)) {
             return false;
         }
-        writeProcessSharedBufferWord(0, descriptor.fd);
-        writeProcessSharedBufferWord(1, descriptor.size);
-        writeProcessSharedBufferWord(2, descriptor.byteLength);
-        writeProcessSharedBufferWord(3, value.byteOffset);
-        writeProcessSharedBufferWord(4, value.byteLength);
-        writeProcessSharedBufferWord(5, runtimeCode(descriptor.runtime));
-        writeProcessSharedBufferWord(6, kindCode(descriptor.kind));
-        writeProcessSharedBufferWord(7, baseAddressMod64 === undefined ? NUMERIC_SENTINEL : baseAddressMod64);
-        const written = writeStaticBinary(processSharedBufferScratch, slotIndex);
-        if (written !== PROCESS_SHARED_BUFFER_NUMERIC_BYTES)
-            return false;
+        processSharedBufferWords[0] = descriptor.fd;
+        processSharedBufferWords[1] = descriptor.size;
+        processSharedBufferWords[2] = descriptor.byteLength;
+        processSharedBufferWords[3] = value.byteOffset;
+        processSharedBufferWords[4] = value.byteLength;
+        processSharedBufferWords[5] = runtimeCode(descriptor.runtime);
+        processSharedBufferWords[6] = kindCode(descriptor.kind);
+        processSharedBufferWords[7] = baseAddressMod64 === undefined
+            ? NUMERIC_SENTINEL
+            : baseAddressMod64;
         task[TaskIndex.Type] = PayloadBuffer.ProcessSharedBuffer;
-        task[TaskIndex.PayloadLen] = written;
+        // Static region is a Uint32Array shared in-process; write the descriptor
+        // words straight in instead of staging bytes through a DataView + copy.
+        task[TaskIndex.PayloadLen] = writeStaticU32Words(processSharedBufferWords, PROCESS_SHARED_BUFFER_NUMERIC_WORDS, slotIndex);
         task.value = null;
         return true;
     };
@@ -969,7 +958,11 @@ export const decodePayload = ({ lockSector, payload, sab, payloadConfig, headers
         payloadConfig: resolvedPayloadConfig,
         textCompat: textCompat?.payload,
     });
-    const { readUtf8: readStaticUtf8, readBytesCopy: readStaticBytesCopy, readBytesBufferCopy: readStaticBufferCopy, readBufferCopy: readStaticBuffer, readUint8ArrayCopy: readStaticUint8ArrayCopy, readBytesArrayBufferCopy: readStaticArrayBufferCopy, readArrayBufferCopy: readStaticArrayBuffer, read8BytesFloatCopy: readStatic8BytesFloatCopy, } = requireStaticIO(headersBuffer, headerSlotStrideU32, textCompat?.headers);
+    const { readUtf8: readStaticUtf8, readBytesBufferCopy: readStaticBufferCopy, readBufferCopy: readStaticBuffer, readUint8ArrayCopy: readStaticUint8ArrayCopy, readBytesArrayBufferCopy: readStaticArrayBufferCopy, readArrayBufferCopy: readStaticArrayBuffer, read8BytesFloatCopy: readStatic8BytesFloatCopy, readU32Words: readStaticU32Words, } = requireStaticIO(headersBuffer, headerSlotStrideU32, textCompat?.headers);
+    // Reusable scratch for the ProcessSharedBuffer raw-word decode. Safe to share:
+    // decode is single-consumer and not re-entrant, and the words are consumed
+    // synchronously when building the ProcessSharedBuffer.
+    const processSharedBufferWords = new Uint32Array(PROCESS_SHARED_BUFFER_NUMERIC_WORDS);
     // TODO: remove slotIndex and make that all their callers
     // store the slot in their Task, to just get it when it comes
     // to the static versions of decoding
@@ -1118,7 +1111,7 @@ export const decodePayload = ({ lockSector, payload, sab, payloadConfig, headers
                 task.value = decodeExternalPayload(readStaticUtf8(0, task[TaskIndex.PayloadLen], slotIndex));
                 return;
             case PayloadBuffer.ProcessSharedBuffer:
-                task.value = decodeProcessSharedBufferNumeric(readStaticBytesCopy(0, task[TaskIndex.PayloadLen], slotIndex));
+                task.value = decodeProcessSharedBufferNumericWords(readStaticU32Words(processSharedBufferWords, PROCESS_SHARED_BUFFER_NUMERIC_WORDS, slotIndex));
                 return;
             case PayloadBuffer.Date:
                 Uint32View[0] = task[TaskIndex.Start];

package/src/memory/shared-buffer-io.d.ts

@@ -37,6 +37,8 @@ export declare const createSharedStaticBufferIO: ({ headersBuffer, slotStrideU32
     writeArrayBuffer: (src: ArrayBuffer, at: number, start?: number) => number;
     writeExactUint8Array: (src: Uint8Array, at: number, start?: number) => number;
     writeUint8Array: (src: Uint8Array, at: number, start?: number) => number;
+    writeU32Words: (words: ArrayLike<number>, count: number, at: number) => number;
+    readU32Words: (out: Uint32Array, count: number, at: number) => Uint32Array;
     write8Binary: (src: Float64Array, at: number, start?: number) => number;
     readBytesCopy: (start: number, end: number, at: number) => Uint8Array<ArrayBuffer>;
     readBytesView: (start: number, end: number, at: number) => Uint8Array<SharedArrayBuffer>;

package/src/memory/shared-buffer-io.js

@@ -269,6 +269,27 @@ export const createSharedStaticBufferIO = ({ headersBuffer, slotStrideU32, textC
     for (let i = 0; i < LockBound.slots; i++) {
         slotByteOffsets[i] = slotStartBytes(i) - baseByteOffset;
     }
+    // The static region is itself a Uint32Array, shared in-process with native
+    // endianness. Fixed-shape numeric payloads (e.g. ProcessSharedBuffer
+    // descriptors) can be written/read as raw words straight into the slot,
+    // skipping the byte scratch + DataView + copy that the generic paths require.
+    const baseU32 = new Uint32Array(buffer, baseByteOffset, (buffer.byteLength - baseByteOffset) >>> 2);
+    const slotU32Offsets = new Uint32Array(LockBound.slots);
+    for (let i = 0; i < LockBound.slots; i++) {
+        slotU32Offsets[i] = slotByteOffsets[i] >>> 2;
+    }
+    const writeU32Words = (words, count, at) => {
+        const base = slotU32Offsets[at];
+        for (let i = 0; i < count; i++)
+            baseU32[base + i] = words[i];
+        return count * u32Bytes;
+    };
+    const readU32Words = (out, count, at) => {
+        const base = slotU32Offsets[at];
+        for (let i = 0; i < count; i++)
+            out[i] = baseU32[base + i];
+        return out;
+    };
     const canWrite = (start, length) => (start | 0) >= 0 && (start + length) <= writableBytes;
     const writeUtf8 = (str, at) => {
         const start = slotByteOffsets[at];
@@ -364,6 +385,8 @@ export const createSharedStaticBufferIO = ({ headersBuffer, slotStrideU32, textC
         writeArrayBuffer,
         writeExactUint8Array,
         writeUint8Array,
+        writeU32Words,
+        readU32Words,
         write8Binary,
         readBytesCopy,
         readBytesView,

package/src/runtime/inline-executor.d.ts

@@ -1,6 +1,6 @@
-import type { WorkerCall, tasks } from "../types.js";
+import type { ComposedWithKey, tasks, WorkerCall } from "../types.js";
 export declare const createInlineExecutor: ({ tasks, genTaskID, batchSize, }: {
-    tasks: tasks;
+    tasks: tasks | ComposedWithKey[];
     genTaskID: () => number;
     batchSize?: number;
 }) => {

package/src/runtime/inline-executor.js

@@ -69,9 +69,21 @@ const composeInlineCallable = (fn, timeout, useAbortToolkit = false) => {
     };
 };
 export const createInlineExecutor = ({ tasks, genTaskID, batchSize, }) => {
-    const entries = Object.values(tasks)
-        .sort((a, b) => a.id - b.id);
-    const runners = entries.map((entry) => composeInlineCallable(entry.f, entry.timeout, entry.abortSignal !== undefined));
+    const entries = Array.isArray(tasks)
+        ? tasks
+        : Object.values(tasks).sort((a, b) => a.id - b.id);
+    const runners = entries.map((entry) => {
+        // Imported tasks must never execute on the host inline lane: their module
+        // import is meant to stay inside the worker so worker permission policies
+        // apply. The pool already routes them to worker lanes, but guard here as
+        // defense in depth so a dispatch regression can't silently import on host.
+        if (entry.imported === true) {
+            return () => {
+                throw new Error("Imported task cannot run on the host inline lane");
+            };
+        }
+        return composeInlineCallable(entry.f, entry.timeout, entry.abortSignal !== undefined);
+    });
     const initCap = 16;
     let fnByIndex = new Int32Array(initCap);
     let stateByIndex = new Int8Array(initCap).fill(-1 /* SlotStateMacro.Free */);

package/src/runtime/pool.d.ts

@@ -4,9 +4,10 @@ import { lock2 } from "../memory/lock.js";
 import type { DebugOptions, DispatcherSettings, WorkerContext, WorkerData, WorkerSettings } from "../types.js";
 import "../worker/loop.js";
 import { type PayloadBufferOptions } from "../memory/payload-config.js";
-export declare const spawnWorkerContext: ({ list, ids, sab, thread, debug, totalNumberOfThread, source, at, workerOptions, workerExecArgv, permission, host, payload, payloadInitialBytes, payloadMaxBytes, bufferMode, maxPayloadBytes, abortSignalCapacity, usesAbortSignal, }: {
+export declare const spawnWorkerContext: ({ list, ids, names, sab, thread, debug, totalNumberOfThread, source, at, workerOptions, workerExecArgv, permission, host, payload, payloadInitialBytes, payloadMaxBytes, bufferMode, maxPayloadBytes, abortSignalCapacity, usesAbortSignal, }: {
     list: string[];
     ids: number[];
+    names: string[];
     at: number[];
     sab?: Sab;
     thread: number;

package/src/runtime/pool.js

@@ -33,7 +33,7 @@ const withFixedPayloadConfig = (config) => ({
     mode: "fixed",
     payloadInitialBytes: config.payloadMaxByteLength,
 });
-export const spawnWorkerContext = ({ list, ids, sab, thread, debug, totalNumberOfThread, source, at, workerOptions, workerExecArgv, permission, host, payload, payloadInitialBytes, payloadMaxBytes, bufferMode, maxPayloadBytes, abortSignalCapacity, usesAbortSignal, }) => {
+export const spawnWorkerContext = ({ list, ids, names, sab, thread, debug, totalNumberOfThread, source, at, workerOptions, workerExecArgv, permission, host, payload, payloadInitialBytes, payloadMaxBytes, bufferMode, maxPayloadBytes, abortSignalCapacity, usesAbortSignal, }) => {
     const tsFileUrl = new URL(import.meta.url);
     const poliWorker = RUNTIME_WORKER;
     const resolvedWorkerOptions = serializeWorkerBootstrapData(withDefaultWorkerTimers(workerOptions));
@@ -217,6 +217,7 @@ export const spawnWorkerContext = ({ list, ids, sab, thread, debug, totalNumberO
             : undefined,
         list,
         ids,
+        names,
         at,
         thread,
         debug,

package/src/types.d.ts

@@ -22,6 +22,7 @@ type WorkerData = {
     abortSignalMax?: number;
     list: string[];
     ids: number[];
+    names: string[];
     thread: number;
     totalNumberOfThread: number;
     debug?: DebugOptions;
@@ -81,8 +82,9 @@ type TaskLike<AS extends AbortSignalOption = AbortSignalOption> = {
 } : {
     readonly abortSignal: AS;
 });
+type TaskFunctionLike = (...args: any[]) => any;
 type Composed<A extends TaskInput = Args, B extends Args = Args, AS extends AbortSignalOption = undefined> = FixPoint<A, B, AS> & SecondPart;
-type tasks = Record<string, Composed<any, any, AbortSignalOption>>;
+type tasks = Record<string, Composed<any, any, AbortSignalOption> | TaskFunctionLike>;
 type ComposedWithKey = Composed<any, any, AbortSignalOption> & {
     name: string;
 };
@@ -95,11 +97,12 @@ type NormalizeUndefinedSingleArg<T extends unknown[]> = T extends [undefined] ?
 type AbortAwareCallArgs<T extends unknown[]> = T extends [...infer Head, AbortSignalToolkit<any>] ? NormalizeUndefinedSingleArg<Head> : NormalizeUndefinedSingleArg<T>;
 type HostCallArgs<F extends (...args: any[]) => any, AS extends AbortSignalOption> = AS extends undefined ? Parameters<F> : AbortAwareCallArgs<Parameters<F>>;
 type PromisifyCallArgs<F extends (...args: any[]) => any, AS extends AbortSignalOption> = HostCallArgs<F, AS> extends infer T ? T extends unknown[] ? PromisifyArgs<T> : never : never;
-type AbortSignalOfTask<T extends TaskLike<any>> = T extends {
+type TaskCallable<T> = T extends TaskLike<any> ? T["f"] : T extends TaskFunctionLike ? T : never;
+type AbortSignalOfTask<T> = T extends {
     readonly abortSignal: infer AS;
 } ? Extract<AS, AbortSignalOption> : undefined;
-type FunctionMapType<T extends Record<string, TaskLike<any>>> = {
-    [K in keyof T]: PromiseWrapped<T[K]["f"], AbortSignalOfTask<T[K]>>;
+type FunctionMapType<T extends Record<string, TaskLike<any> | TaskFunctionLike>> = {
+    [K in keyof T]: PromiseWrapped<TaskCallable<T[K]>, AbortSignalOfTask<T[K]>>;
 };
 interface FixPointBase<A extends TaskInput, B extends Args, AS extends AbortSignalOption = undefined> {
     readonly f: TaskFn<A, B, AS>;
@@ -125,13 +128,23 @@ type SecondPart = {
      */
     readonly at: number;
     readonly importedFrom: string;
+    /**
+     * Marks a task whose worker-side function is imported dynamically (via
+     * `importTask`). Such tasks must never run on the host inliner lane: their
+     * module import is meant to happen inside the worker so worker permission
+     * policies apply. The pool routes them to worker lanes only, even when the
+     * inliner is enabled for other tasks.
+     */
+    readonly imported?: boolean;
 };
 type SingleTaskPool<A extends TaskInput = Args, B extends Args = Args, AS extends AbortSignalOption = undefined> = {
     call: PromiseWrapped<TaskFn<A, B, AS>, AS>;
     shutdown: (delayMs?: number) => Promise<void>;
+    [Symbol.dispose]: () => void;
 };
-type Pool<T extends Record<string, TaskLike<any>>> = {
+type Pool<T extends Record<string, TaskLike<any> | TaskFunctionLike>> = {
     shutdown: (delayMs?: number) => Promise<void>;
+    [Symbol.dispose]: () => void;
     call: FunctionMapType<T>;
 };
 type ReturnFixed<A extends TaskInput = undefined, B extends Args = undefined, AS extends AbortSignalOption = undefined> = FixPoint<A, B, AS> & SecondPart & {

package/src/worker/loop.js

@@ -53,7 +53,7 @@ export const workerMainLoop = async (startupData) => {
     installTerminationGuard();
     installUnhandledRejectionSilencer();
     installPerformanceNowGuard();
-    const { debug, sab, thread, startAt, workerOptions, lock, returnLock, abortSignalSAB, abortSignalMax, payloadConfig, permission, totalNumberOfThread, list, ids, at, } = startupData;
+    const { debug, sab, thread, startAt, workerOptions, lock, returnLock, abortSignalSAB, abortSignalMax, payloadConfig, permission, totalNumberOfThread, list, ids, names, at, } = startupData;
     scrubWorkerDataSensitiveBuffers(startupData);
     assertWorkerSharedMemoryBootData({ sab, lock, returnLock });
     let Comment;
@@ -111,10 +111,11 @@ export const workerMainLoop = async (startupData) => {
         list,
         isWorker: true,
         ids,
+        names,
         at,
         permission,
     });
-    assertWorkerImportsResolved({ debug, list, ids, listOfFunctions });
+    assertWorkerImportsResolved({ debug, list, ids, names, listOfFunctions });
     const abortSignals = abortSignalSAB
         ? signalAbortFactory({
             sab: abortSignalSAB,
@@ -260,6 +261,7 @@ const isWorkerBootPayload = (value) => {
     return isSharedBufferSource(candidate.sab) &&
         Array.isArray(candidate.list) &&
         Array.isArray(candidate.ids) &&
+        Array.isArray(candidate.names) &&
         Array.isArray(candidate.at) &&
         typeof candidate.thread === "number" &&
         typeof candidate.totalNumberOfThread === "number" &&

package/src/worker/process-worker-bootstrap.js

@@ -46,6 +46,7 @@ const isProcessWorkerBootPayload = (value) => {
         isProcessSharedBufferMetadata(workerData.sab) &&
         Array.isArray(workerData.list) &&
         Array.isArray(workerData.ids) &&
+        Array.isArray(workerData.names) &&
         Array.isArray(workerData.at) &&
         typeof workerData.thread === "number" &&
         typeof workerData.totalNumberOfThread === "number" &&

package/src/worker/safety/startup.d.ts

@@ -9,8 +9,9 @@ type ImportedFunctionsState = {
     debug: DebugOptions | undefined;
     list: string[];
     ids: number[];
+    names?: string[];
     listOfFunctions: readonly unknown[];
 };
 export declare const assertWorkerSharedMemoryBootData: ({ sab, lock, returnLock }: SharedMemoryBootData) => void;
-export declare const assertWorkerImportsResolved: ({ debug, list, ids, listOfFunctions }: ImportedFunctionsState) => void;
+export declare const assertWorkerImportsResolved: ({ debug, list, ids, names, listOfFunctions }: ImportedFunctionsState) => void;
 export {};

package/src/worker/safety/startup.js

@@ -17,14 +17,17 @@ export const assertWorkerSharedMemoryBootData = ({ sab, lock, returnLock }) => {
         throw new Error("worker missing return lock SABs");
     }
 };
-export const assertWorkerImportsResolved = ({ debug, list, ids, listOfFunctions }) => {
+export const assertWorkerImportsResolved = ({ debug, list, ids, names, listOfFunctions }) => {
     if (debug?.logImportedUrl === true) {
         console.log(list);
     }
-    if (listOfFunctions.length > 0)
+    if (listOfFunctions.length > 0 &&
+        (names === undefined || listOfFunctions.length === names.length))
         return;
     console.log(list);
     console.log(ids);
+    if (names !== undefined)
+        console.log(names);
     console.log(listOfFunctions);
     throw new Error("No imports were found.");
 };

package/src/worker/task-loader.d.ts

@@ -3,6 +3,7 @@ import type { ResolvedPermissionProtocol } from "../permission/protocol.js";
 type GetFunctionParams = {
     list: string[];
     ids: number[];
+    names: string[];
     at: number[];
     isWorker: boolean;
     permission?: ResolvedPermissionProtocol;
@@ -21,6 +22,6 @@ export type WorkerComposedWithKey = ComposedWithKey & {
     run: WorkerCallable;
     timeout?: TimeoutSpec;
 };
-export declare const getFunctions: ({ list, ids, at, permission }: GetFunctionParams) => Promise<WorkerComposedWithKey[]>;
+export declare const getFunctions: ({ list, ids, names, at, permission }: GetFunctionParams) => Promise<WorkerComposedWithKey[]>;
 export type GetFunctions = ReturnType<typeof getFunctions>;
 export {};

package/src/worker/task-loader.js

@@ -34,11 +34,12 @@ const normalizeTimeout = (timeout) => {
 const composeWorkerCallable = (fixed, _permission) => {
     return fixed.f;
 };
-export const getFunctions = async ({ list, ids, at, permission }) => {
+export const getFunctions = async ({ list, ids, names, at, permission }) => {
     const modules = list.map((specifier) => toModuleUrl(specifier));
+    const nameSet = new Set(names);
     const results = await Promise.all(modules.map(async (imports) => {
         const module = (await import(__rewriteRelativeImportExtension(imports)));
-        return Object.entries(module)
+        const fixedTasks = Object.entries(module)
             .filter(([_, value]) => value != null && typeof value === "object" &&
             //@ts-ignore Reason -> trust me
             value?.[endpointSymbol] === true)
@@ -47,6 +48,17 @@ export const getFunctions = async ({ list, ids, at, permission }) => {
             ...value,
             name,
         }));
+        const functionTasks = Object.entries(module)
+            .filter(([name, value]) => nameSet.has(name) && typeof value === "function")
+            .map(([name, value]) => ({
+            f: value,
+            id: -1,
+            importedFrom: imports,
+            at: -1,
+            name,
+            [endpointSymbol]: true,
+        }));
+        return [...fixedTasks, ...functionTasks];
     }));
     // Flatten the results, filter by IDs, and sort
     const flattened = results.flat();