knitting 0.1.63 → 0.1.73

package/src/worker/timers.js

@@ -2,10 +2,24 @@
 const Comment = {
     thisIsAHint: 0,
 };
+// A full collection costs milliseconds. Run on every idle entry, it made each
+// sequential call ~1000x slower under --expose-gc; once a second keeps the
+// idle collection without paying it per call.
+const IDLE_GC_INTERVAL_MS = 1000;
 const maybeGc = (() => {
     const host = globalThis;
-    const gc = typeof host.gc === "function"
-        ? (() => host.gc())
+    // Capture the function itself: the global is deleted below, so reading
+    // `host.gc` at call time would throw on the first idle pass.
+    const exposedGc = host.gc;
+    let lastGcAt = -Infinity;
+    const gc = typeof exposedGc === "function"
+        ? (() => {
+            const now = performance.now();
+            if (now - lastGcAt < IDLE_GC_INTERVAL_MS)
+                return;
+            lastGcAt = now;
+            exposedGc();
+        })
         : undefined;
     if (gc) {
         try {
@@ -30,8 +44,7 @@ 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);
-// `SharedArrayBuffer` is undeclared on pages that are not cross-origin
-// isolated, and this module has to load anyway so the pool can report why.
+// Some pages do not define SharedArrayBuffer; keep this module loadable there.
 const waitFallbackView = a_wait === undefined || typeof SharedArrayBuffer !== "function"
     ? undefined
     : new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
@@ -43,17 +56,16 @@ 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.
+// Bun on Windows requires special handling for short waits and process rings.
+export const IS_BUN_WINDOWS = runtimeGlobals.process?.platform === "win32" &&
+    typeof runtimeGlobals.process?.versions?.bun === "string";
+// Bun on Windows busy-spins for waits of 1ms or less; use a 2ms minimum.
+const BUN_WINDOWS_MIN_WAIT_MS = 2;
+const floorBunWindowsWait = (ms) => IS_BUN_WINDOWS && ms < BUN_WINDOWS_MIN_WAIT_MS ? BUN_WINDOWS_MIN_WAIT_MS : ms;
+// Windows process workers cannot be woken through the native address-based
+// wait, so cap their wait to 1ms and let polling rediscover work.
 const nativeWaitTimeoutMs = (parkMs) => isPlainNodeWindows ? 1 : Number.isFinite(parkMs) ? parkMs : Infinity;
-const pollingWaitTimeoutMs = (parkMs) => Number.isFinite(parkMs) ? Math.min(Math.max(parkMs, 0), 1) : 1;
+const pollingWaitTimeoutMs = (parkMs) => floorBunWindowsWait(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)
@@ -84,7 +96,6 @@ export const sleepUntilChanged = ({ at, opView, pauseInNanoseconds, rxStatus, tx
         };
     return (value, spinMicroseconds, parkMs) => {
         const until = p_now() + (spinMicroseconds / 1000);
-        maybeGc();
         let spinChecks = 0;
         while (true) {
             if (a_load(opView, at) !== value ||
@@ -96,24 +107,30 @@ export const sleepUntilChanged = ({ at, opView, pauseInNanoseconds, rxStatus, tx
             if ((spinChecks++ & 63) === 0 && p_now() >= until)
                 break;
         }
+        // Collect only once the spin found nothing, then re-check before parking.
+        maybeGc();
         if (tryProgress())
             return;
         a_store(rxStatus, 0, 0);
+        // The other half of the host's post-publish check: a publication that
+        // landed before rxStatus cleared is visible now, and one after it finds
+        // rxStatus clear and rings.
+        if (a_load(opView, at) !== value || tryProgress()) {
+            a_store(rxStatus, 0, 1);
+            return;
+        }
         if (nativeWaitU32 !== undefined) {
             nativeWaitU32(opView.buffer, opView.byteOffset + (at * Int32Array.BYTES_PER_ELEMENT), value >>> 0, nativeWaitTimeoutMs(parkMs));
         }
         else if (useSharedMemoryWait &&
             a_wait &&
             opView.buffer instanceof SharedArrayBuffer) {
-            // This is the notify-able path: a host Atomics.notify on opView wakes it.
-            // An infinite parkMs (debug) is intentional here — the worker blocks until
-            // a real signal instead of re-polling on a timeout.
-            a_wait(opView, at, value, parkMs ?? Infinity);
+            // This path can be woken with Atomics.notify; an infinite debug wait is
+            // intentional.
+            a_wait(opView, at, value, floorBunWindowsWait(parkMs ?? Infinity));
         }
         else if (a_wait && waitFallbackView) {
-            // waitFallbackView is never notified — this wait only ever times out and
-            // re-polls. Keep the slice short and finite so FFI-backed process workers
-            // stay responsive without a cross-process native wake primitive.
+            // This fallback is timeout-driven; keep the slice short for responsiveness.
             a_wait(waitFallbackView, 0, 0, pollingWaitTimeoutMs(parkMs));
         }
         a_store(rxStatus, 0, 1);

package/unsafe.d.ts

@@ -1 +1,2 @@
-export { BUFFER_REFERENCE_CODEC_ID, BUFFER_REFERENCE_KIND, BufferReference, type BufferReferenceMetadata, BufferReferenceReturn, type BufferReferenceRuntime, isBufferReferenceMetadata, } from "./src/connections/buffer-reference.js";
+export { BUFFER_REFERENCE_CODEC_ID, BUFFER_REFERENCE_KIND, BufferReference, type BufferReferenceMetadata, type BufferReferenceRuntime, isBufferReferenceMetadata, } from "./src/connections/buffer-reference.js";
+export { sharedBytes } from "./src/worker/shared-return.js";

package/unsafe.js

@@ -1 +1,2 @@
-export { BUFFER_REFERENCE_CODEC_ID, BUFFER_REFERENCE_KIND, BufferReference, BufferReferenceReturn, isBufferReferenceMetadata, } from "./src/connections/buffer-reference.js";
+export { BUFFER_REFERENCE_CODEC_ID, BUFFER_REFERENCE_KIND, BufferReference, isBufferReferenceMetadata, } from "./src/connections/buffer-reference.js";
+export { sharedBytes } from "./src/worker/shared-return.js";