@nxtedition/yield 1.0.18 → 1.0.20

package/README.md

@@ -34,16 +34,17 @@ for (const row of db.prepare('SELECT * FROM large_table').iterate()) {
 ### Callback-based
 
 ```js
-import { maybeYield } from '@nxtedition/yield'
+import { shouldYield, doYield } from '@nxtedition/yield'
 import fs from 'node:fs'
 
 function processFiles(files, i = 0) {
   for (; i < files.length; i++) {
+    if (shouldYield()) {
+      doYield((index) => processFiles(files, index), i)
+      return // resumes at index i after the event loop has had a turn
+    }
     const data = fs.readFileSync(files[i])
     transform(data)
-    if (maybeYield(processFiles, files, i + 1)) {
-      return // will resume via callback after yielding
-    }
   }
 }
 ```
@@ -65,14 +66,13 @@ doYield((opaque) => {
 ### Checking without yielding
 
 ```js
-import { shouldYield, doYield } from '@nxtedition/yield'
+import { shouldYield } from '@nxtedition/yield'
 
 while (hasWork()) {
-  doWork()
   if (shouldYield()) {
-    doMoreWork()
-    break
+    break // pick the remaining work back up on a later turn
   }
+  doWork()
 }
 ```
 
@@ -80,7 +80,9 @@ while (hasWork()) {
 
 ### `shouldYield(timeout?): boolean`
 
-Returns `true` when the current synchronous execution has exceeded the timeout threshold (default: 40ms). Does not yield — only checks whether yielding is recommended.
+Returns `true` when more than `timeout` milliseconds (default: 40) have elapsed since the last yield dispatch. Does not yield — only checks whether yielding is recommended.
+
+Once it returns `true` it latches and keeps returning `true` until the pending yield dispatch has run. When it latches, a dispatch is scheduled automatically, so the latch clears after the next event-loop turn even if the caller never enqueues a yield.
 
 ### `maybeYield(timeout?): Promise<void> | null`
 
@@ -90,6 +92,8 @@ If a yield is needed, queues a yield and returns a `Promise`. Otherwise returns
 
 If a yield is needed, defers `callback(opaque)` to after the yield. Otherwise calls `callback(opaque)` synchronously.
 
+Note: because the no-yield path invokes the callback synchronously, a recursive continuation-passing loop built on this overload grows the stack until the timeout elapses. For long loops prefer the `shouldYield()`/`doYield()` pattern shown above.
+
 ### `doYield(): Promise<void>`
 
 Unconditionally queues a yield and returns a `Promise` that resolves after the event loop has been given a turn.
@@ -100,15 +104,15 @@ Unconditionally defers `callback(opaque)` to after the next yield.
 
 ### `setYieldTimeout(timeout): void`
 
-Set the default yield timeout in milliseconds. Must be a non-negative number. Default: `40`.
+Set the default yield timeout in milliseconds. Must be a non-negative number (`NaN` is rejected; `Infinity` disables time-based yielding). Default: `40`.
 
 ### `setYieldDispatcher(dispatcher): void`
 
-Override the scheduling function used to defer work. The dispatcher receives a callback and should invoke it asynchronously (e.g. via `setTimeout` or `setImmediate`). Pass `null` to restore the default dispatcher.
+Override the scheduling function used to defer work. The dispatcher receives a callback and should invoke it asynchronously (e.g. via `setTimeout` or `setImmediate`) — asynchronous invocation is what actually gives the event loop a turn. A dispatcher that invokes the callback synchronously is tolerated and loses no queued items, but it defeats the purpose of yielding. Pass `null` (or `undefined`) to restore the default dispatcher. Throws a `TypeError` for any other non-function value. If the dispatcher itself throws, the error propagates to the caller and the library recovers on the next scheduling attempt.
 
 ## How it works
 
-The library tracks when the last yield occurred using `performance.now()`. When `shouldYield()` detects that more than `timeout` milliseconds have elapsed, it signals that a yield is due. `doYield` and `maybeYield` batch pending callbacks into a queue that is drained in a single microtask turn, yielding again if the timeout is exceeded during draining.
+The library tracks when the last yield occurred using `performance.now()`. When `shouldYield()` detects that more than `timeout` milliseconds have elapsed, it signals that a yield is due. `doYield` and `maybeYield` batch pending callbacks into a queue that is drained on the next event-loop turn (via `setImmediate` by default), yielding again if the timeout is exceeded during draining.
 
 ## License
 

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 type Dispatcher = (callback: () => void) => void;
-export declare function setYieldDispatcher(schedule: Dispatcher | null): void;
+export declare function setYieldDispatcher(schedule?: Dispatcher | null): void;
 export declare function setYieldTimeout(timeout: number): void;
 export declare function shouldYield(timeout?: number): boolean;
 export declare function maybeYield<T>(callback: (opaque: T | undefined) => void, opaque?: T, timeout?: number): void;
@@ -7,3 +7,4 @@ export declare function maybeYield(timeout?: number): Promise<void> | null;
 export declare function doYield<T>(callback: (opaque: T | undefined) => void, opaque?: T): void;
 export declare function doYield(): Promise<void>;
 export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,KAAK,UAAU,GAAG,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAA;AAahD,wBAAgB,kBAAkB,CAAC,QAAQ,CAAC,EAAE,UAAU,GAAG,IAAI,QAK9D;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,QAK9C;AAaD,wBAAgB,WAAW,CAAC,OAAO,CAAC,EAAE,MAAM,WAmB3C;AAED,wBAAgB,UAAU,CAAC,CAAC,EAC1B,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,GAAG,SAAS,KAAK,IAAI,EACzC,MAAM,CAAC,EAAE,CAAC,EACV,OAAO,CAAC,EAAE,MAAM,GACf,IAAI,CAAA;AACP,wBAAgB,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;AAmClE,wBAAgB,OAAO,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,GAAG,SAAS,KAAK,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,IAAI,CAAA;AACvF,wBAAgB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA"}

package/lib/index.js

@@ -1,146 +1,162 @@
-                                                
-
-const kDefaultSchedule             =
-  globalThis.setImmediate ?? ((fn            ) => setTimeout(fn, 0))
-let yieldSchedule = kDefaultSchedule
-const yieldQueue                 = []
-
-let yieldIndex = 0
-let yieldTimeout = 40
-let yieldActive = false
-let yieldScheduled = false
-let yieldTime = performance.now()
-
-export function setYieldDispatcher(schedule                   ) {
-  yieldSchedule = schedule ?? kDefaultSchedule
+const kDefaultSchedule = globalThis.setImmediate ?? ((fn) => setTimeout(fn, 0));
+let yieldSchedule = kDefaultSchedule;
+const yieldQueue = [];
+let yieldIndex = 0;
+let yieldTimeout = 40;
+let yieldActive = false;
+let yieldScheduled = false;
+let yieldTime = performance.now();
+export function setYieldDispatcher(schedule) {
+    if (schedule != null && typeof schedule !== 'function') {
+        throw new TypeError('dispatcher must be a function, null, or undefined');
+    }
+    yieldSchedule = schedule ?? kDefaultSchedule;
+}
+export function setYieldTimeout(timeout) {
+    if (typeof timeout !== 'number' || Number.isNaN(timeout) || timeout < 0) {
+        throw new TypeError('timeout must be a non-negative number');
+    }
+    yieldTimeout = timeout;
 }
-
-export function setYieldTimeout(timeout        ) {
-  if (typeof timeout !== 'number' || timeout < 0) {
-    throw new TypeError('timeout must be a positive number')
-  }
-  yieldTimeout = timeout
+function scheduleDispatch() {
+    yieldScheduled = true;
+    try {
+        yieldSchedule(dispatchYield);
+    }
+    catch (err) {
+        // Leave the queue recoverable: the next schedule attempt retries.
+        yieldScheduled = false;
+        throw err;
+    }
 }
-
-export function shouldYield(timeout         ) {
-  if (timeout === undefined) {
-    timeout = yieldTimeout
-  }
-
-  if (!yieldActive && performance.now() - yieldTime >= timeout) {
-    yieldActive = true
-  }
-
-  return yieldActive
+export function shouldYield(timeout) {
+    if (timeout === undefined) {
+        timeout = yieldTimeout;
+    }
+    if (!yieldActive && performance.now() - yieldTime >= timeout) {
+        yieldActive = true;
+        // Self-heal standalone usage: ensure a dispatch is pending so the latch
+        // and clock reset on the next event-loop turn even if the caller never
+        // enqueues a yield.
+        if (!yieldScheduled) {
+            scheduleDispatch();
+        }
+        // A synchronous dispatcher may already have run the reset dispatch,
+        // clearing yieldActive — still report that a yield was due at call time.
+        return true;
+    }
+    return yieldActive;
 }
-
-                              
-                                            
-             
-                   
-       
-                                                                  
-export function maybeYield   (
-  callbackOrTimeout                                             ,
-  opaque    ,
-  timeout         ,
-)                              {
-  if (
-    callbackOrTimeout != null &&
-    typeof callbackOrTimeout !== 'function' &&
-    typeof callbackOrTimeout !== 'number'
-  ) {
-    throw new TypeError('callback must be a function')
-  }
-
-  const callback = typeof callbackOrTimeout === 'function' ? callbackOrTimeout : undefined
-  if (timeout === undefined && typeof callbackOrTimeout === 'number') {
-    timeout = callbackOrTimeout
-  }
-
-  if (shouldYield(timeout)) {
+export function maybeYield(callbackOrTimeout, opaque, timeout) {
+    if (callbackOrTimeout != null &&
+        typeof callbackOrTimeout !== 'function' &&
+        typeof callbackOrTimeout !== 'number') {
+        throw new TypeError('callback must be a function');
+    }
+    const callback = typeof callbackOrTimeout === 'function' ? callbackOrTimeout : undefined;
+    if (timeout === undefined && typeof callbackOrTimeout === 'number') {
+        timeout = callbackOrTimeout;
+    }
+    if (shouldYield(timeout)) {
+        if (callback != null) {
+            doYield(callback, opaque);
+            return;
+        }
+        return doYield();
+    }
     if (callback != null) {
-      doYield(callback, opaque)
-      return
-    }
-    return doYield()
-  }
-
-  if (callback != null) {
-    callback(opaque)
-    return
-  }
-
-  return null
+        callback(opaque);
+        return;
+    }
+    return null;
 }
-
-                                                                                       
-                                        
-export function doYield   (
-  callback                                  ,
-  opaque    ,
-)                       {
-  if (callback != null && typeof callback !== 'function') {
-    throw new TypeError('callback must be a function')
-  }
-
-  if (!yieldScheduled) {
-    yieldScheduled = true
-    yieldSchedule(dispatchYield)
-  }
-
-  if (callback == null) {
-    return new Promise((resolve) => {
-      yieldQueue.push(resolve, null)
-    })
-  }
-
-  yieldQueue.push(callback, opaque)
+export function doYield(callback, opaque) {
+    if (callback != null && typeof callback !== 'function') {
+        throw new TypeError('callback must be a function');
+    }
+    // Enqueue before scheduling so a misbehaving synchronous dispatcher cannot
+    // drain past this item and strand it.
+    let promise;
+    if (callback == null) {
+        promise = new Promise((resolve) => {
+            yieldQueue.push(resolve, undefined);
+        });
+    }
+    else {
+        yieldQueue.push(callback, opaque);
+    }
+    if (!yieldScheduled) {
+        scheduleDispatch();
+    }
+    return promise;
 }
-
+let yieldDispatching = false;
+let yieldRedispatch = false;
 function dispatchYield() {
-  yieldTime = performance.now()
-  yieldActive = false
-
-  const maxIndex = yieldQueue.length
-
-  while (yieldIndex < maxIndex) {
-    const resolve = yieldQueue[yieldIndex]                             
-    yieldQueue[yieldIndex] = null
-    yieldIndex += 1
-
-    const opaque = yieldQueue[yieldIndex]
-    yieldQueue[yieldIndex] = null
-    yieldIndex += 1
-
+    // A synchronous dispatcher re-enters here from the tail reschedule in
+    // drainYieldQueue; flatten the recursion into the outer frame's loop so a
+    // deep backlog cannot overflow the stack.
+    if (yieldDispatching) {
+        yieldRedispatch = true;
+        return;
+    }
+    yieldDispatching = true;
     try {
-      resolve(opaque)
-    } catch (err) {
-      // Isolate the throw: rethrow asynchronously so dispatch continues.
-      // Otherwise yieldIndex stays mid-loop and the queue gets stuck.
-      // Materialize the stack now — queueMicrotask severs the sync frame.
-      if (err instanceof Error) {
-        void err.stack
-      }
-      queueMicrotask(() => {
-        throw err
-      })
-    }
-
-    if (shouldYield()) {
-      break
-    }
-  }
-
-  if (yieldIndex === yieldQueue.length) {
-    yieldScheduled = false
-    yieldQueue.length = 0
-    yieldIndex = 0
-  } else {
-    if (yieldIndex > 4 * 1024) {
-      yieldQueue.splice(0, yieldIndex)
-      yieldIndex = 0
-    }
-    yieldSchedule(dispatchYield)
-  }
+        do {
+            yieldRedispatch = false;
+            drainYieldQueue();
+        } while (yieldRedispatch);
+    }
+    finally {
+        yieldDispatching = false;
+    }
+}
+function drainYieldQueue() {
+    yieldTime = performance.now();
+    yieldActive = false;
+    const startIndex = yieldIndex;
+    const maxIndex = yieldQueue.length;
+    while (yieldIndex < maxIndex) {
+        const resolve = yieldQueue[yieldIndex];
+        const opaque = yieldQueue[yieldIndex + 1];
+        yieldIndex += 2;
+        try {
+            resolve(opaque);
+        }
+        catch (err) {
+            // Isolate the throw: rethrow asynchronously so dispatch continues.
+            // Otherwise yieldIndex stays mid-loop and the queue gets stuck.
+            // Materialize the stack now — queueMicrotask severs the sync frame.
+            if (err instanceof Error) {
+                void err.stack;
+            }
+            queueMicrotask(() => {
+                throw err;
+            });
+        }
+        if (shouldYield()) {
+            break;
+        }
+    }
+    if (yieldIndex === yieldQueue.length) {
+        yieldScheduled = false;
+        yieldQueue.length = 0;
+        yieldIndex = 0;
+    }
+    else {
+        if (yieldIndex > 4 * 1024 && 2 * yieldIndex >= yieldQueue.length) {
+            // Amortized O(1): only compact once the consumed prefix is at least
+            // half the array, so each splice shifts at most as many elements as
+            // were consumed since the previous compaction.
+            yieldQueue.splice(0, yieldIndex);
+            yieldIndex = 0;
+        }
+        else {
+            // Release references to consumed callbacks/opaques. Full drains skip
+            // this — truncating the queue above releases everything at once.
+            yieldQueue.fill(null, startIndex, yieldIndex);
+        }
+        scheduleDispatch();
+    }
 }
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/yield",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -14,7 +14,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "rimraf lib && tsc -p tsconfig.build.json && amaroc ./src/index.ts && mv src/index.js lib/",
+    "build": "rimraf lib && tsc -p tsconfig.build.json",
     "prepublishOnly": "yarn build",
     "typecheck": "tsc --noEmit",
     "test": "node --test",
@@ -23,11 +23,10 @@
   },
   "devDependencies": {
     "@types/node": "^25.5.0",
-    "amaroc": "^1.0.1",
     "oxlint-tsgolint": "^0.17.0",
     "rimraf": "^6.1.3",
     "tsd": "^0.33.0",
     "typescript": "^5.9.3"
   },
-  "gitHead": "7c9c7457c885c644c7a1e70ef894d4727ce240d6"
+  "gitHead": "c9f2526dc870597de119b8ec5083f97901d4a2e2"
 }