knitting 0.1.46 → 0.1.51

package/src/knitting_windows_shared_memory.cc

@@ -0,0 +1,156 @@
+#if !defined(_WIN32)
+#error "knitting_windows_shared_memory.cc only supports Windows."
+#endif
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+#include <cstdint>
+
+namespace {
+
+constexpr uint32_t MODE_CREATE = 1;
+constexpr uint32_t MODE_OPEN = 2;
+constexpr size_t CACHE_LINE_SIZE = 64;
+
+struct KnittingWindowsSharedMemory {
+  void* address;
+  uintptr_t handle;
+  uint64_t size;
+  uint32_t base_address_mod64;
+  uint32_t reserved;
+};
+
+static_assert(sizeof(KnittingWindowsSharedMemory) == 32);
+
+bool HasName(const wchar_t* name) {
+  return name != nullptr && name[0] != L'\0';
+}
+
+uint32_t LastErrorOrInvalidParameter() {
+  DWORD error = GetLastError();
+  return error == ERROR_SUCCESS ? ERROR_INVALID_PARAMETER : error;
+}
+
+uint32_t FillMapping(
+  HANDLE handle,
+  uint64_t size,
+  KnittingWindowsSharedMemory* out
+) {
+  if (handle == nullptr || out == nullptr || size == 0) {
+    if (handle != nullptr) CloseHandle(handle);
+    return ERROR_INVALID_PARAMETER;
+  }
+
+  void* address = MapViewOfFile(
+    handle,
+    FILE_MAP_ALL_ACCESS,
+    0,
+    0,
+    static_cast<SIZE_T>(size)
+  );
+  if (address == nullptr) {
+    DWORD error = GetLastError();
+    CloseHandle(handle);
+    return error == ERROR_SUCCESS ? ERROR_INVALID_PARAMETER : error;
+  }
+
+  out->address = address;
+  out->handle = reinterpret_cast<uintptr_t>(handle);
+  out->size = size;
+  out->base_address_mod64 =
+    static_cast<uint32_t>(reinterpret_cast<uintptr_t>(address) % CACHE_LINE_SIZE);
+  out->reserved = 0;
+  return ERROR_SUCCESS;
+}
+
+}  // namespace
+
+extern "C" __declspec(dllexport) uint32_t
+knitting_windows_create_shared_memory(
+  uint64_t size,
+  const wchar_t* name,
+  uint32_t mode,
+  KnittingWindowsSharedMemory* out
+) {
+  if (!HasName(name) || size == 0 || out == nullptr) {
+    return ERROR_INVALID_PARAMETER;
+  }
+
+  HANDLE handle = nullptr;
+  if (mode == MODE_OPEN) {
+    handle = OpenFileMappingW(FILE_MAP_ALL_ACCESS, FALSE, name);
+    if (handle == nullptr) return LastErrorOrInvalidParameter();
+  } else if (mode == MODE_CREATE) {
+    handle = CreateFileMappingW(
+      INVALID_HANDLE_VALUE,
+      nullptr,
+      PAGE_READWRITE,
+      static_cast<DWORD>(size >> 32),
+      static_cast<DWORD>(size & 0xffffffffULL),
+      name
+    );
+    if (handle == nullptr) return LastErrorOrInvalidParameter();
+    if (GetLastError() == ERROR_ALREADY_EXISTS) {
+      CloseHandle(handle);
+      return ERROR_ALREADY_EXISTS;
+    }
+  } else {
+    return ERROR_INVALID_PARAMETER;
+  }
+
+  return FillMapping(handle, size, out);
+}
+
+extern "C" __declspec(dllexport) uint32_t
+knitting_windows_map_shared_memory(
+  uintptr_t handle_value,
+  uint64_t size,
+  const wchar_t* name,
+  KnittingWindowsSharedMemory* out
+) {
+  HANDLE handle = nullptr;
+  if (HasName(name)) {
+    handle = OpenFileMappingW(FILE_MAP_ALL_ACCESS, FALSE, name);
+    if (handle == nullptr) return LastErrorOrInvalidParameter();
+  } else if (handle_value != 0) {
+    BOOL ok = DuplicateHandle(
+      GetCurrentProcess(),
+      reinterpret_cast<HANDLE>(handle_value),
+      GetCurrentProcess(),
+      &handle,
+      0,
+      FALSE,
+      DUPLICATE_SAME_ACCESS
+    );
+    if (!ok) return LastErrorOrInvalidParameter();
+  } else {
+    return ERROR_INVALID_PARAMETER;
+  }
+
+  return FillMapping(handle, size, out);
+}
+
+extern "C" __declspec(dllexport) uint32_t
+knitting_windows_close_shared_memory(KnittingWindowsSharedMemory* mapping) {
+  if (mapping == nullptr) return ERROR_INVALID_PARAMETER;
+
+  uint32_t result = ERROR_SUCCESS;
+  if (mapping->address != nullptr && !UnmapViewOfFile(mapping->address)) {
+    result = LastErrorOrInvalidParameter();
+  }
+
+  if (mapping->handle != 0) {
+    HANDLE handle = reinterpret_cast<HANDLE>(mapping->handle);
+    if (!CloseHandle(handle) && result == ERROR_SUCCESS) {
+      result = LastErrorOrInvalidParameter();
+    }
+  }
+
+  mapping->address = nullptr;
+  mapping->handle = 0;
+  mapping->size = 0;
+  mapping->base_address_mod64 = 0;
+  mapping->reserved = 0;
+  return result;
+}

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,14 +515,11 @@ 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 ||
+            descriptor.name !== undefined ||
             !isU32(descriptor.fd) ||
             !isU32(descriptor.size) ||
             !isU32(descriptor.byteLength) ||
@@ -543,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;
     };
@@ -968,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
@@ -1117,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

@@ -1,23 +1,13 @@
+import { type ProcessSharedMemoryBacking } from "./process-worker.js";
 import { type Sab } from "../ipc/transport/shared-memory.js";
 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";
-type ProcessSharedMemoryNativeMapping = {
-    sab: SharedArrayBuffer;
-    fd: number;
-    size: number;
-    baseAddressMod64?: number;
-};
-type ProcessSharedMemoryBacking = ProcessSharedMemoryNativeMapping & {
-    runtime: "node";
-    buffer: SharedArrayBuffer;
-    kind: "shared-array-buffer";
-    byteLength: number;
-};
-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;
@@ -40,4 +30,3 @@ export declare const spawnWorkerContext: ({ list, ids, sab, thread, debug, total
     processSharedMemoryBackings?: readonly ProcessSharedMemoryBacking[];
 };
 export type CreateContext = WorkerContext;
-export {};