knitting 0.1.46 → 0.1.51

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

@@ -0,0 +1,160 @@
+import { RUNTIME } from "../common/runtime.js";
+import { RUNTIME_IS_PROCESS_WORKER, RUNTIME_PARENT_PORT, RUNTIME_PROCESS_WORKER_BOOT_ENV, RUNTIME_PROCESS_WORKER_BOOT_VERSION, } from "../common/worker-runtime.js";
+import { getNodeProcess } from "../common/node-compat.js";
+import { isLockBufferTextCompat } from "../common/shared-buffer-text.js";
+import { getDefaultProcessSharedBufferPrimitives, ProcessSharedBuffer, setDefaultProcessSharedBufferPrimitives, } from "../connections/process-shared-buffer.js";
+import { createBunConnectionPrimitives } from "../connections/bun.js";
+import { createDenoConnectionPrimitives } from "../connections/deno.js";
+import { loadNodeFutexAddon } from "../connections/node.js";
+export const getProcessWorkerNativeWaitU32 = () => {
+    if (!RUNTIME_IS_PROCESS_WORKER || RUNTIME !== "node")
+        return undefined;
+    try {
+        return loadNodeFutexAddon().waitU32;
+    }
+    catch {
+        return undefined;
+    }
+};
+const isProcessSharedBufferMetadata = (value) => {
+    try {
+        ProcessSharedBuffer.fromMetadata(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const isProcessWorkerWireLockBuffers = (value) => {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return isProcessSharedBufferMetadata(candidate.headers) &&
+        isProcessSharedBufferMetadata(candidate.lockSector) &&
+        isProcessSharedBufferMetadata(candidate.payload) &&
+        isProcessSharedBufferMetadata(candidate.payloadSector) &&
+        (candidate.textCompat === undefined ||
+            isLockBufferTextCompat(candidate.textCompat));
+};
+const isProcessWorkerBootPayload = (value) => {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    const workerData = candidate.workerData;
+    return candidate.version === RUNTIME_PROCESS_WORKER_BOOT_VERSION &&
+        !!workerData &&
+        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" &&
+        typeof workerData.startAt === "number" &&
+        (workerData.abortSignalSAB === undefined ||
+            isProcessSharedBufferMetadata(workerData.abortSignalSAB)) &&
+        isProcessWorkerWireLockBuffers(workerData.lock) &&
+        isProcessWorkerWireLockBuffers(workerData.returnLock);
+};
+const getProcessWorkerPrimitives = () => {
+    const primitives = RUNTIME === "bun"
+        ? createBunConnectionPrimitives()
+        : RUNTIME === "deno"
+            ? createDenoConnectionPrimitives()
+            : getDefaultProcessSharedBufferPrimitives();
+    setDefaultProcessSharedBufferPrimitives(primitives);
+    return primitives;
+};
+const reviveProcessWorkerData = (wire) => {
+    const primitives = getProcessWorkerPrimitives();
+    const mappings = new Map();
+    const mappingKey = (descriptor) => descriptor.name === undefined
+        ? `fd:${descriptor.fd}:${descriptor.size}:${descriptor.runtime ?? ""}`
+        : `name:${descriptor.name}:${descriptor.size}:${descriptor.runtime ?? ""}`;
+    const reviveRegion = (metadata) => {
+        const processBuffer = ProcessSharedBuffer.fromMetadata(metadata);
+        const descriptor = processBuffer.descriptor;
+        const key = mappingKey(descriptor);
+        let mapping = mappings.get(key);
+        if (mapping === undefined) {
+            mapping = descriptor.map(primitives);
+            mappings.set(key, mapping);
+        }
+        else {
+            descriptor.attach(mapping);
+        }
+        return {
+            sab: mapping.buffer,
+            byteOffset: processBuffer.byteOffset,
+            byteLength: processBuffer.byteLength,
+        };
+    };
+    const reviveLockBuffers = (lock) => ({
+        ...lock,
+        headers: reviveRegion(lock.headers),
+        lockSector: reviveRegion(lock.lockSector),
+        payload: reviveRegion(lock.payload),
+        payloadSector: reviveRegion(lock.payloadSector),
+    });
+    return {
+        ...wire,
+        sab: reviveRegion(wire.sab),
+        abortSignalSAB: wire.abortSignalSAB === undefined
+            ? undefined
+            : reviveRegion(wire.abortSignalSAB),
+        lock: reviveLockBuffers(wire.lock),
+        returnLock: reviveLockBuffers(wire.returnLock),
+    };
+};
+export const installProcessWorkerBootstrap = ({ isWorkerBootPayload, reportWorkerStartupFatal, startWorker, }) => {
+    const processLike = getNodeProcess();
+    const start = (payload) => {
+        const data = reviveProcessWorkerData(payload.workerData);
+        if (!isWorkerBootPayload(data)) {
+            throw new TypeError("invalid process worker boot payload");
+        }
+        startWorker(data);
+    };
+    const envBoot = processLike?.env?.[RUNTIME_PROCESS_WORKER_BOOT_ENV];
+    if (typeof envBoot === "string" && envBoot.length > 0) {
+        try {
+            const payload = JSON.parse(envBoot);
+            if (!isProcessWorkerBootPayload(payload)) {
+                throw new TypeError("invalid process worker boot payload");
+            }
+            try {
+                delete processLike?.env?.[RUNTIME_PROCESS_WORKER_BOOT_ENV];
+            }
+            catch {
+            }
+            start(payload);
+        }
+        catch (error) {
+            reportWorkerStartupFatal(error);
+        }
+        return;
+    }
+    if (RUNTIME_PARENT_PORT === undefined) {
+        reportWorkerStartupFatal(new TypeError("missing process worker boot payload"));
+        return;
+    }
+    if (typeof processLike?.on !== "function")
+        return;
+    const onMessage = (message) => {
+        if (!isProcessWorkerBootPayload(message))
+            return;
+        try {
+            processLike.off?.("message", onMessage);
+            processLike.removeListener?.("message", onMessage);
+        }
+        catch {
+        }
+        try {
+            start(message);
+        }
+        catch (error) {
+            reportWorkerStartupFatal(error);
+        }
+    };
+    processLike.on("message", onMessage);
+};

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();

package/src/worker/timers.js

@@ -36,6 +36,21 @@ const waitFallbackView = a_wait === undefined
 const a_pause = "pause" in Atomics
     ? Atomics.pause
     : undefined;
+const runtimeGlobals = globalThis;
+const isPlainNodeWindows = runtimeGlobals.process?.platform === "win32" &&
+    typeof runtimeGlobals.process?.versions?.node === "string" &&
+    runtimeGlobals.process?.versions?.bun === undefined &&
+    runtimeGlobals.Deno === undefined;
+// Windows has no working cross-process wake. The native wake (WakeByAddress)
+// is keyed to a virtual address, so a host cannot wake a process worker parked
+// on the same physical page mapped at a different address in the child — the
+// addon's FutexWake is a no-op there. A parked Windows Node process worker can
+// therefore never be signalled and must rediscover work by polling. Cap the
+// native wait at 1ms so it re-checks every millisecond instead of sleeping the
+// full parkMs (up to seconds); the long park with no wake is what made CI
+// runners appear to hang. The native wait already polls internally, so this is
+// just bounding each poll slice.
+const nativeWaitTimeoutMs = (parkMs) => isPlainNodeWindows ? 1 : parkMs ?? 60;
 export const whilePausing = ({ pauseInNanoseconds }) => {
     const forNanoseconds = pauseInNanoseconds ?? DEFAULT_PAUSE_TIME;
     if (!a_pause || forNanoseconds <= 0)
@@ -44,10 +59,9 @@ export const whilePausing = ({ pauseInNanoseconds }) => {
 };
 export const pauseGeneric = whilePausing({});
 export const sleepUntilChanged = ({ at, opView, pauseInNanoseconds, rxStatus, txStatus, enqueueLock, write, nativeWaitU32, useSharedMemoryWait = true, }) => {
-    const pause = pauseInNanoseconds
-        !== undefined
-        ? whilePausing({ pauseInNanoseconds })
-        : pauseGeneric;
+    const pause = pauseInNanoseconds === undefined
+        ? pauseGeneric
+        : whilePausing({ pauseInNanoseconds });
     const tryProgress = () => {
         let progressed = false;
         if (enqueueLock())
@@ -82,7 +96,7 @@ export const sleepUntilChanged = ({ at, opView, pauseInNanoseconds, rxStatus, tx
             return;
         a_store(rxStatus, 0, 0);
         if (nativeWaitU32 !== undefined) {
-            nativeWaitU32(opView.buffer, opView.byteOffset + (at * Int32Array.BYTES_PER_ELEMENT), value >>> 0, parkMs ?? 60);
+            nativeWaitU32(opView.buffer, opView.byteOffset + (at * Int32Array.BYTES_PER_ELEMENT), value >>> 0, nativeWaitTimeoutMs(parkMs));
         }
         else if (useSharedMemoryWait &&
             a_wait &&