knitting 0.1.56 → 0.1.61

package/src/worker/composable-runners.js

@@ -49,7 +49,7 @@ const readSignal = (slot) => {
     const signal = (encodedSignal - ABORT_SIGNAL_META_OFFSET) | 0;
     return signal >= 0 ? signal : NO_ABORT_SIGNAL;
 };
-const makeToolkitCache = (hasAborted) => {
+const makeToolkitCache = (hasAborted, now) => {
     const bySignal = [];
     return (signal) => {
         let toolkit = bySignal[signal];
@@ -58,6 +58,7 @@ const makeToolkitCache = (hasAborted) => {
         const hasAbortedMethod = () => hasAborted(signal);
         toolkit = {
             hasAborted: hasAbortedMethod,
+            now,
         };
         bySignal[signal] = toolkit;
         return toolkit;
@@ -76,7 +77,7 @@ export const composeWorkerRunner = ({ job, timeout, hasAborted, now, }) => {
             return applyTimeoutBudget(result, slot, timeout, nowTime);
         };
     }
-    const getToolkit = makeToolkitCache(hasAborted);
+    const getToolkit = makeToolkitCache(hasAborted, nowTime);
     if (!timeout) {
         return (slot) => {
             const signal = readSignal(slot);

package/src/worker/loop.d.ts

@@ -1,2 +1,3 @@
+import "../memory/payloadCodec.js";
 import type { WorkerData } from "../types.js";
 export declare const workerMainLoop: (startupData: WorkerData) => Promise<void>;

package/src/worker/loop.js

@@ -4,9 +4,12 @@ import { isLockBufferTextCompat } from "../common/shared-buffer-text.js";
 import { createWorkerRxQueue } from "./rx-queue.js";
 import { createSharedMemoryTransport } from "../ipc/transport/shared-memory.js";
 import { lock2 } from "../memory/lock.js";
+// Side-effect import: registers the payload codec (cycle break for Andromeda;
+// see lock.ts). Must run before any lock2() call.
+import "../memory/payloadCodec.js";
 import { getFunctions } from "./task-loader.js";
 import { pauseGeneric, sleepUntilChanged, whilePausing } from "./timers.js";
-import { RUNTIME, SET_IMMEDIATE } from "../common/runtime.js";
+import { IS_ANDROMEDA, RUNTIME, SET_IMMEDIATE } from "../common/runtime.js";
 import { getNodeProcess } from "../common/node-compat.js";
 import { assertWorkerImportsResolved, assertWorkerSharedMemoryBootData, installPerformanceNowGuard, installTerminationGuard, installUnhandledRejectionSilencer, scrubWorkerDataSensitiveBuffers, } from "./safety/index.js";
 import { signalAbortFactory } from "../shared/abortSignal.js";
@@ -70,7 +73,7 @@ export const workerMainLoop = async (startupData) => {
     installTerminationGuard();
     installUnhandledRejectionSilencer();
     installPerformanceNowGuard();
-    const { debug, sab, thread, startAt, workerOptions, lock, returnLock, abortSignalSAB, abortSignalMax, payloadConfig, bufferReferenceReturn, permission, totalNumberOfThread, list, ids, names, at, } = startupData;
+    const { debug, sab, thread, startAt, workerOptions, lock, returnLock, abortSignalSAB, abortSignalMax, payloadConfig, bufferReferenceReturn, permission, totalNumberOfThread, list, ids, names, at, steal, } = startupData;
     scrubWorkerDataSensitiveBuffers(startupData);
     assertWorkerSharedMemoryBootData({ sab, lock, returnLock });
     const debugNamespaces = resolveDebugNamespaces(debug);
@@ -81,10 +84,10 @@ export const workerMainLoop = async (startupData) => {
             namespaces: debugNamespaces,
         }))
         : undefined;
-    let Comment;
-    (function (Comment) {
-        Comment[Comment["thisIsAHint"] = 0] = "thisIsAHint";
-    })(Comment || (Comment = {}));
+    // const object, not `enum`: Andromeda's Nova engine can't parse `enum`.
+    const Comment = {
+        thisIsAHint: 0,
+    };
     const signals = createSharedMemoryTransport({
         sabObject: {
             sharedSab: sab,
@@ -101,6 +104,12 @@ export const workerMainLoop = async (startupData) => {
         payloadSector: lock.payloadSector,
         payloadConfig,
         textCompat: lock.textCompat,
+        processBoundary: RUNTIME_IS_PROCESS_WORKER,
+        // Under stealing the request region is shared, so decode() becomes a
+        // region-Dekker claim against the other endpoints.
+        consumers: steal?.consumers,
+        consumerId: steal?.consumerId,
+        regionLanes: steal?.regionLanes,
     });
     const returnLockState = lock2({
         headers: returnLock.headers,
@@ -110,6 +119,7 @@ export const workerMainLoop = async (startupData) => {
         payloadSector: returnLock.payloadSector,
         payloadConfig,
         textCompat: returnLock.textCompat,
+        processBoundary: RUNTIME_IS_PROCESS_WORKER,
     });
     const timers = workerOptions?.timers;
     const spinMicroseconds = timers?.spinMicroseconds ??
@@ -158,6 +168,7 @@ export const workerMainLoop = async (startupData) => {
         returnLock: returnLockState,
         borrowReturnedBufferReferences: bufferReferenceReturn === "borrow",
         hasAborted: abortSignals?.hasAborted,
+        stealing: steal !== undefined,
     });
     installBufferReferenceReleaseListener(releaseReturnedBufferReference);
     a_store(rxStatus, 0, 1);
@@ -170,6 +181,7 @@ export const workerMainLoop = async (startupData) => {
         pauseInNanoseconds: timers?.pauseNanoseconds,
         enqueueLock,
         write: () => hasCompleted() ? writeBatch(WRITE_MAX) : 0,
+        flushBeforeClaim: steal !== undefined,
         nativeWaitU32,
         useSharedMemoryWait: !(RUNTIME_IS_PROCESS_WORKER &&
             RUNTIME === "node" &&
@@ -245,15 +257,30 @@ export const workerMainLoop = async (startupData) => {
             pauseUntil(value, spinMicroseconds, parkMs);
         }
         : pauseUntil;
+    const flushBeforeClaim = steal !== undefined;
     const loop = () => {
         isInMacro = false;
         let progressed = true;
         let awaiting = 0;
         while (true) {
-            progressed = _enqueueLock();
-            if (_hasCompleted()) {
-                if (_writeBatch(WRITE_MAX) > 0)
-                    progressed = true;
+            if (flushBeforeClaim) {
+                // Stealing only. Flush finished work before taking more on: a computed
+                // response should not wait behind a claim, and that claim can block on
+                // a peer withdrawing its intent. Measured to hurt the per-lane path,
+                // where a claim is a cheap private decode and picking work up promptly
+                // matters more, so the classic order is kept below.
+                if (_hasCompleted()) {
+                    if (_writeBatch(WRITE_MAX) > 0)
+                        progressed = true;
+                }
+                progressed = _enqueueLock() || progressed;
+            }
+            else {
+                progressed = _enqueueLock();
+                if (_hasCompleted()) {
+                    if (_writeBatch(WRITE_MAX) > 0)
+                        progressed = true;
+                }
             }
             _drainReturnReleases();
             if (_hasPending()) {
@@ -295,15 +322,23 @@ export const workerMainLoop = async (startupData) => {
 };
 const isWorkerGlobalScope = () => {
     const scopeCtor = globalThis.WorkerGlobalScope;
-    if (typeof scopeCtor !== "function")
-        return false;
-    try {
-        return globalThis instanceof
-            scopeCtor;
+    if (typeof scopeCtor === "function") {
+        try {
+            if (globalThis instanceof scopeCtor) {
+                return true;
+            }
+        }
+        catch {
+            // fall through to runtime-specific checks
+        }
     }
-    catch {
-        return false;
+    // Andromeda has no `WorkerGlobalScope`; its worker scope carries a `self`
+    // global that the main thread lacks.
+    if (IS_ANDROMEDA &&
+        typeof globalThis.self !== "undefined") {
+        return true;
     }
+    return false;
 };
 const isLockBuffers = (value) => {
     if (!value || typeof value !== "object")

package/src/worker/rx-queue.d.ts

@@ -9,9 +9,19 @@ type ArgumentsForCreateWorkerQueue = {
     borrowReturnedBufferReferences?: boolean;
     hasAborted?: (signal: number) => boolean;
     now?: () => number;
+    /**
+     * Work-stealing discipline: only claim when this worker has nothing left to
+     * run. Without it a worker keeps claiming whole regions on top of a backlog
+     * it has not started, which is exactly the hoarding stealing exists to
+     * prevent — the queued tasks would be better taken by an idle peer.
+     *
+     * Off for the classic per-lane path, where the host has already assigned
+     * these tasks to this lane and batching them is a win.
+     */
+    stealing?: boolean;
 };
 export type CreateWorkerRxQueue = ReturnType<typeof createWorkerRxQueue>;
-export declare const createWorkerRxQueue: ({ listOfFunctions, workerOptions, lock, returnLock, borrowReturnedBufferReferences, hasAborted, now, }: ArgumentsForCreateWorkerQueue) => {
+export declare const createWorkerRxQueue: ({ listOfFunctions, workerOptions, lock, returnLock, borrowReturnedBufferReferences, hasAborted, now, stealing, }: ArgumentsForCreateWorkerQueue) => {
     hasCompleted: () => boolean;
     hasPending: () => boolean;
     writeBatch: (max: number) => number;

package/src/worker/rx-queue.js

@@ -2,7 +2,7 @@ import RingQueue from "../ipc/tools/ring-queue.js";
 import { attachPayloadTransportFinalizer, runTaskFinalizers, TaskFlag, TaskIndex, } from "../memory/lock.js";
 import { composeWorkerRunner } from "./composable-runners.js";
 import { BUFFER_REFERENCE_RETURN_RELEASE_TOKEN } from "../connections/buffer-reference.js";
-export const createWorkerRxQueue = ({ listOfFunctions, workerOptions, lock, returnLock, borrowReturnedBufferReferences, hasAborted, now, }) => {
+export const createWorkerRxQueue = ({ listOfFunctions, workerOptions, lock, returnLock, borrowReturnedBufferReferences, hasAborted, now, stealing, }) => {
     const PLACE_HOLDER = (_) => {
         throw ("UNREACHABLE FROM PLACE HOLDER (thread)");
     };
@@ -71,6 +71,9 @@ export const createWorkerRxQueue = ({ listOfFunctions, workerOptions, lock, retu
     const { decode, resolved } = lock;
     const resolvedShift = () => resolved.shiftNoClear();
     const enqueueLock = () => {
+        // Steal only when idle: leaving work unclaimed lets a free peer take it.
+        if (stealing && toWork.size !== 0)
+            return false;
         if (!decode())
             return false;
         let task = resolvedShift();

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

@@ -9,10 +9,11 @@ type GetFunctionParams = {
     permission?: ResolvedPermissionProtocol;
 };
 type WorkerCallable = (args: unknown, abortToolkit?: unknown) => unknown;
-export declare const enum TimeoutKind {
-    Reject = 0,
-    Resolve = 1
-}
+export declare const TimeoutKind: {
+    readonly Reject: 0;
+    readonly Resolve: 1;
+};
+export type TimeoutKind = typeof TimeoutKind[keyof typeof TimeoutKind];
 export type TimeoutSpec = {
     ms: number;
     kind: TimeoutKind;

package/src/worker/task-loader.js

@@ -1,27 +1,33 @@
 import { endpointSymbol } from "../common/task-symbol.js";
-import { toModuleUrl } from "../common/module-url.js";
+import { toImportSpecifier, toModuleUrl } from "../common/module-url.js";
+// const object, not `const enum`: Andromeda's Nova engine can't parse `enum`.
+// No longer inlined, but only read on cold paths.
+export const TimeoutKind = {
+    Reject: 0,
+    Resolve: 1,
+};
 const normalizeTimeout = (timeout) => {
     if (timeout == null)
         return undefined;
     if (typeof timeout === "number") {
         const ms = Math.floor(timeout);
         return ms >= 0
-            ? { ms, kind: 0 /* TimeoutKind.Reject */, value: new Error("Task timeout") }
+            ? { ms, kind: TimeoutKind.Reject, value: new Error("Task timeout") }
             : undefined;
     }
     const ms = Math.floor(timeout.time);
     if (!(ms >= 0))
         return undefined;
     if ("default" in timeout) {
-        return { ms, kind: 1 /* TimeoutKind.Resolve */, value: timeout.default };
+        return { ms, kind: TimeoutKind.Resolve, value: timeout.default };
     }
     if (timeout.maybe === true) {
-        return { ms, kind: 1 /* TimeoutKind.Resolve */, value: undefined };
+        return { ms, kind: TimeoutKind.Resolve, value: undefined };
     }
     if ("error" in timeout) {
-        return { ms, kind: 0 /* TimeoutKind.Reject */, value: timeout.error };
+        return { ms, kind: TimeoutKind.Reject, value: timeout.error };
     }
-    return { ms, kind: 0 /* TimeoutKind.Reject */, value: new Error("Task timeout") };
+    return { ms, kind: TimeoutKind.Reject, value: new Error("Task timeout") };
 };
 const composeWorkerCallable = (fixed, _permission) => {
     return fixed.f;
@@ -30,7 +36,7 @@ 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(imports));
+        const module = (await import(toImportSpecifier(imports)));
         const fixedTasks = Object.entries(module)
             .filter(([_, value]) => value != null && typeof value === "object" &&
             //@ts-ignore Reason -> trust me

package/src/worker/timers.d.ts

@@ -4,7 +4,7 @@ type PauseOptions = {
 export type NativeWaitU32 = (buffer: ArrayBuffer | SharedArrayBuffer, byteOffset: number, expected: number, timeoutMs?: number) => unknown;
 export declare const whilePausing: ({ pauseInNanoseconds }: PauseOptions) => () => void;
 export declare const pauseGeneric: () => void;
-export declare const sleepUntilChanged: ({ at, opView, pauseInNanoseconds, rxStatus, txStatus, enqueueLock, write, nativeWaitU32, useSharedMemoryWait, }: {
+export declare const sleepUntilChanged: ({ at, opView, pauseInNanoseconds, rxStatus, txStatus, enqueueLock, write, nativeWaitU32, useSharedMemoryWait, flushBeforeClaim, }: {
     opView: Int32Array;
     rxStatus: Int32Array;
     txStatus: Int32Array;
@@ -14,5 +14,12 @@ export declare const sleepUntilChanged: ({ at, opView, pauseInNanoseconds, rxSta
     write?: () => number | boolean;
     nativeWaitU32?: NativeWaitU32;
     useSharedMemoryWait?: boolean;
+    /**
+     * Stealing only: write results back before attempting to claim more work.
+     * A claim can spin waiting for a peer to withdraw its intent, so claiming
+     * first puts arbitration latency in front of a finished response. Measured
+     * to hurt the per-lane path, so it stays off by default.
+     */
+    flushBeforeClaim?: boolean;
 }) => (value: number, spinMicroseconds: number, parkMs?: number) => void;
 export {};

package/src/worker/timers.js

@@ -1,7 +1,7 @@
-var Comment;
-(function (Comment) {
-    Comment[Comment["thisIsAHint"] = 0] = "thisIsAHint";
-})(Comment || (Comment = {}));
+// const object, not `enum`: Andromeda's Nova engine can't parse `enum`.
+const Comment = {
+    thisIsAHint: 0,
+};
 const maybeGc = (() => {
     const host = globalThis;
     const gc = typeof host.gc === "function"
@@ -30,7 +30,9 @@ const a_load = Atomics.load;
 const a_store = Atomics.store;
 const a_wait = typeof Atomics.wait === "function" ? Atomics.wait : undefined;
 const p_now = performance.now.bind(performance);
-const waitFallbackView = a_wait === undefined
+// `SharedArrayBuffer` is undeclared on pages that are not cross-origin
+// isolated, and this module has to load anyway so the pool can report why.
+const waitFallbackView = a_wait === undefined || typeof SharedArrayBuffer !== "function"
     ? undefined
     : new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
 const a_pause = "pause" in Atomics
@@ -51,6 +53,7 @@ const isPlainNodeWindows = runtimeGlobals.process?.platform === "win32" &&
 // runners appear to hang. The native wait already polls internally, so this is
 // just bounding each poll slice.
 const nativeWaitTimeoutMs = (parkMs) => isPlainNodeWindows ? 1 : Number.isFinite(parkMs) ? parkMs : Infinity;
+const pollingWaitTimeoutMs = (parkMs) => Number.isFinite(parkMs) ? Math.min(Math.max(parkMs, 0), 1) : 1;
 export const whilePausing = ({ pauseInNanoseconds }) => {
     const forNanoseconds = pauseInNanoseconds ?? DEFAULT_PAUSE_TIME;
     if (!a_pause || forNanoseconds <= 0)
@@ -58,26 +61,27 @@ export const whilePausing = ({ pauseInNanoseconds }) => {
     return () => a_pause(forNanoseconds);
 };
 export const pauseGeneric = whilePausing({});
-export const sleepUntilChanged = ({ at, opView, pauseInNanoseconds, rxStatus, txStatus, enqueueLock, write, nativeWaitU32, useSharedMemoryWait = true, }) => {
+export const sleepUntilChanged = ({ at, opView, pauseInNanoseconds, rxStatus, txStatus, enqueueLock, write, nativeWaitU32, useSharedMemoryWait = true, flushBeforeClaim = false, }) => {
     const pause = pauseInNanoseconds === undefined
         ? pauseGeneric
         : whilePausing({ pauseInNanoseconds });
-    const tryProgress = () => {
-        let progressed = false;
-        if (enqueueLock())
-            progressed = true;
-        if (write) {
-            const wrote = write();
-            if (typeof wrote === "number") {
-                if (wrote > 0)
-                    progressed = true;
-            }
-            else if (wrote === true) {
-                progressed = true;
-            }
-        }
-        return progressed;
+    const flushWrite = () => {
+        if (!write)
+            return false;
+        const wrote = write();
+        if (typeof wrote === "number")
+            return wrote > 0;
+        return wrote === true;
     };
+    const tryProgress = flushBeforeClaim
+        ? () => {
+            const wrote = flushWrite();
+            return enqueueLock() || wrote;
+        }
+        : () => {
+            const claimed = enqueueLock();
+            return flushWrite() || claimed;
+        };
     return (value, spinMicroseconds, parkMs) => {
         const until = p_now() + (spinMicroseconds / 1000);
         maybeGc();
@@ -108,8 +112,9 @@ export const sleepUntilChanged = ({ at, opView, pauseInNanoseconds, rxStatus, tx
         }
         else if (a_wait && waitFallbackView) {
             // waitFallbackView is never notified — this wait only ever times out and
-            // re-polls, so it must stay finite or the worker would hang forever.
-            a_wait(waitFallbackView, 0, 0, Number.isFinite(parkMs) ? parkMs : Infinity);
+            // re-polls. Keep the slice short and finite so FFI-backed process workers
+            // stay responsive without a cross-process native wake primitive.
+            a_wait(waitFallbackView, 0, 0, pollingWaitTimeoutMs(parkMs));
         }
         a_store(rxStatus, 0, 1);
     };