@promptbook/node 0.113.0-10 → 0.113.0-11

package/esm/index.es.js

@@ -36,7 +36,7 @@ const BOOK_LANGUAGE_VERSION = '2.0.0';
  * @generated
  * @see https://github.com/webgptorg/promptbook
  */
-const PROMPTBOOK_ENGINE_VERSION = '0.113.0-10';
+const PROMPTBOOK_ENGINE_VERSION = '0.113.0-11';
 /**
  * TODO: string_promptbook_version should be constrained to the all versions of Promptbook engine
  * Note: [💞] Ignore a discrepancy between file name and entity name
@@ -3061,6 +3061,47 @@ async function $runGoScriptWithOutput(options) {
     });
 }
 
+/**
+ * Minimum timer duration used to avoid a zero-millisecond polling loop.
+ */
+const MINIMUM_WORLD_TIME_WAIT_POLL_INTERVAL_MS = 1;
+/**
+ * Waits until one wall-clock deadline has passed.
+ *
+ * The remaining time is recalculated from `Date.now()` after every poll and after every tick callback.
+ * This makes waits elapse while the process is paused at a checkpoint or the computer is asleep.
+ *
+ * @private internal utility of `ptbk coder` wait handling
+ */
+async function waitUntilWorldTimeDeadline(options) {
+    const { deadlineTimeMs, pollIntervalMs, onTick } = options;
+    const normalizedPollIntervalMs = Math.max(MINIMUM_WORLD_TIME_WAIT_POLL_INTERVAL_MS, pollIntervalMs);
+    while (true) {
+        const remainingDurationMs = getRemainingDurationMs(deadlineTimeMs);
+        if (remainingDurationMs <= 0) {
+            return;
+        }
+        await (onTick === null || onTick === void 0 ? void 0 : onTick(remainingDurationMs));
+        const remainingDurationAfterTickMs = getRemainingDurationMs(deadlineTimeMs);
+        if (remainingDurationAfterTickMs <= 0) {
+            return;
+        }
+        await waitForMilliseconds(Math.min(normalizedPollIntervalMs, remainingDurationAfterTickMs));
+    }
+}
+/**
+ * Returns the remaining wall-clock duration until a timestamp.
+ */
+function getRemainingDurationMs(deadlineTimeMs) {
+    return Math.max(0, deadlineTimeMs - Date.now());
+}
+/**
+ * Waits for one short polling interval.
+ */
+async function waitForMilliseconds(durationMs) {
+    await new Promise((resolve) => setTimeout(resolve, durationMs));
+}
+
 /**
  * Base delimiter used for passing large prompts through stdin.
  */
@@ -3470,36 +3511,32 @@ class ClaudeCodeRunner {
  * Waits until the Claude Code session can be resumed, keeping terminal status clear.
  */
 async function waitForClaudeCodeSessionLimitReset(sessionLimit, resurrectionCount, options) {
-    var _a, _b, _c;
+    var _a, _b;
     const delayMs = getClaudeCodeSessionLimitDelayMs(sessionLimit);
+    const resetDeadlineTimeMs = Date.now() + delayMs;
     const sessionLabel = formatClaudeCodeSessionIdForDisplay(sessionLimit.sessionId);
     const resetSummary = formatClaudeCodeSessionLimitForDisplay(sessionLimit);
     if ((_a = options.shouldPrintLiveOutput) !== null && _a !== void 0 ? _a : true) {
         console.warn(colors.yellow(`[claude-code] Session limit detected for ${sessionLimit.sessionId}. Resurrection #${resurrectionCount} will resume with --resume after ${formatDurationMs(delayMs)}. ${resetSummary}`));
     }
-    let remainingDelayMs = delayMs;
-    while (remainingDelayMs > 0) {
-        await ((_b = options.waitForPauseCheckpoint) === null || _b === void 0 ? void 0 : _b.call(options, {
-            checkpointLabel: 'the Claude Code session limit reset',
-            phase: 'waiting',
-            statusMessage: `Claude Code session ${sessionLabel} hit its limit; resurrection #${resurrectionCount} resumes in ${formatDurationMs(remainingDelayMs)}`,
-        }));
-        const currentDelayMs = Math.min(CLAUDE_CODE_SESSION_RESURRECTION_POLL_MS, remainingDelayMs);
-        await waitFor$1(currentDelayMs);
-        remainingDelayMs -= currentDelayMs;
-    }
-    await ((_c = options.waitForPauseCheckpoint) === null || _c === void 0 ? void 0 : _c.call(options, {
+    await waitUntilWorldTimeDeadline({
+        deadlineTimeMs: resetDeadlineTimeMs,
+        pollIntervalMs: CLAUDE_CODE_SESSION_RESURRECTION_POLL_MS,
+        onTick: async (remainingDelayMs) => {
+            var _a;
+            await ((_a = options.waitForPauseCheckpoint) === null || _a === void 0 ? void 0 : _a.call(options, {
+                checkpointLabel: 'the Claude Code session limit reset',
+                phase: 'waiting',
+                statusMessage: `Claude Code session ${sessionLabel} hit its limit; resurrection #${resurrectionCount} resumes in ${formatDurationMs(Math.min(remainingDelayMs, delayMs))}`,
+            }));
+        },
+    });
+    await ((_b = options.waitForPauseCheckpoint) === null || _b === void 0 ? void 0 : _b.call(options, {
         checkpointLabel: 'resurrecting the Claude Code session with --resume',
         phase: 'running',
         statusMessage: `Resurrecting Claude Code session ${sessionLabel} with --resume`,
     }));
 }
-/**
- * Waits for a fixed amount of milliseconds.
- */
-async function waitFor$1(delayMs) {
-    await new Promise((resolve) => setTimeout(resolve, delayMs));
-}
 /**
  * Formats a Claude Code session id for compact terminal status lines.
  */
@@ -4460,12 +4497,6 @@ const RATE_LIMIT_BACKOFF_MAX_MS = 30 * 60 * 1000;
  * Randomized delay proportion added/subtracted for retry jitter.
  */
 const RATE_LIMIT_BACKOFF_JITTER_RATIO = 0.15;
-/**
- * Waits for one given amount of milliseconds.
- */
-async function waitFor(delayMs) {
-    await new Promise((resolve) => setTimeout(resolve, delayMs));
-}
 /**
  * Formats a delay value into a concise `xh ym zs` style label.
  */
@@ -4555,13 +4586,18 @@ class OpenAiCodexRunner {
                     throw error;
                 }
                 const delayMs = this.rateLimitBackoff.nextDelayMs();
-                const retryAt = new Date(Date.now() + delayMs).toISOString();
+                const retryDeadlineTimeMs = Date.now() + delayMs;
+                const retryAt = new Date(retryDeadlineTimeMs).toISOString();
                 const retryIndex = this.rateLimitBackoff.retryCount;
                 const summary = extractFailureSummary(details);
                 if ((_b = options.shouldPrintLiveOutput) !== null && _b !== void 0 ? _b : true) {
                     console.warn(colors.yellow(`[codex] Rate limit/quota detected (${summary}). Retry #${retryIndex} in ${formatDelay(delayMs)} at ${retryAt}.`));
                 }
-                await waitForRetryDelay(delayMs, options);
+                await waitForRetryDelay({
+                    delayMs,
+                    retryDeadlineTimeMs,
+                    promptRunOptions: options,
+                });
             }
         }
     }
@@ -4569,20 +4605,21 @@ class OpenAiCodexRunner {
 /**
  * Waits for the next Codex retry while polling for requested pause checkpoints.
  */
-async function waitForRetryDelay(delayMs, options) {
-    var _a;
-    let remainingDelayMs = delayMs;
-    while (remainingDelayMs > 0) {
-        const remainingDelayLabel = formatDelay(remainingDelayMs);
-        await ((_a = options.waitForPauseCheckpoint) === null || _a === void 0 ? void 0 : _a.call(options, {
-            checkpointLabel: 'the next OpenAI Codex retry after rate limit',
-            phase: 'running',
-            statusMessage: `Waiting ${remainingDelayLabel} before retrying OpenAI Codex`,
-        }));
-        const currentDelayMs = Math.min(RATE_LIMIT_BACKOFF_POLL_MS, remainingDelayMs);
-        await waitFor(currentDelayMs);
-        remainingDelayMs -= currentDelayMs;
-    }
+async function waitForRetryDelay(options) {
+    const { delayMs, retryDeadlineTimeMs, promptRunOptions } = options;
+    await waitUntilWorldTimeDeadline({
+        deadlineTimeMs: retryDeadlineTimeMs,
+        pollIntervalMs: RATE_LIMIT_BACKOFF_POLL_MS,
+        onTick: async (remainingDelayMs) => {
+            var _a;
+            const remainingDelayLabel = formatDelay(Math.min(remainingDelayMs, delayMs));
+            await ((_a = promptRunOptions.waitForPauseCheckpoint) === null || _a === void 0 ? void 0 : _a.call(promptRunOptions, {
+                checkpointLabel: 'the next OpenAI Codex retry after rate limit',
+                phase: 'running',
+                statusMessage: `Waiting ${remainingDelayLabel} before retrying OpenAI Codex`,
+            }));
+        },
+    });
 }
 
 /**