@gajae-code/utils 0.12.11 → 0.12.13

package/dist/types/broken-pipe.d.ts

@@ -10,9 +10,10 @@ export declare function isKnownSinkPeerClosedError(error: unknown): boolean;
  */
 export declare function isBrokenPipeError(error: unknown): boolean;
 /**
- * A classifier for process-level stdout `EPIPE` errors. Its direct-write
- * evidence is private to each factory instance, so only the owner that
- * intercepted `process.stdout.write` can mark an error for this classifier.
+ * A classifier for process-level stdout peer-closed errors (`EPIPE`, `EIO`,
+ * `EBADF`). Its direct-write evidence is private to each factory instance, so
+ * only the owner that intercepted `process.stdout.write` can mark an error
+ * for this classifier.
  */
 export interface ProcessStdoutEpipeClassifier {
     markDirectProcessStdoutWriteError(error: unknown): void;

package/dist/types/fetch-retry.d.ts

@@ -22,13 +22,16 @@ export interface FetchWithRetryOptions extends RequestInit {
     /**
      * Per-delay cap. Server-provided `Retry-After` hints exceeding this return
      * the current response immediately — caller deals with the `!response.ok`.
-     * Default `60_000`.
+     * Scheduled values are also capped at the platform timer ceiling. Default
+     * `60_000`.
      */
     maxDelayMs?: number;
     /**
      * Fallback delay schedule when no server hint is present. Number, array
      * (indexed by attempt, clamped to last), or function. Default exponential
-     * `500ms * 2 ** attempt` capped at `maxDelayMs`.
+     * `500ms * 2 ** attempt` capped at `maxDelayMs` and the platform timer
+     * ceiling. Values that remain negative or non-finite after capping retry
+     * immediately.
      */
     defaultDelayMs?: number | readonly number[] | ((attempt: number) => number);
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/utils",
-	"version": "0.12.11",
+	"version": "0.12.13",
 	"description": "Shared utilities for pi packages",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo",
@@ -31,7 +31,7 @@
 		"fmt": "biome format --write ."
 	},
 	"dependencies": {
-		"@gajae-code/natives": "0.12.11",
+		"@gajae-code/natives": "0.12.13",
 		"beautiful-mermaid": "^1.1.3",
 		"handlebars": "^4.7.9",
 		"winston": "^3.19.0",

package/src/broken-pipe.ts

@@ -9,6 +9,16 @@
 import * as fs from "node:fs";
 
 const KNOWN_SINK_PEER_CLOSED_CODES = new Set(["EPIPE", "ERR_STREAM_DESTROYED"]);
+/**
+ * Errno codes that mean the process's own stdout sink has gone away because
+ * the peer (terminal emulator, pager, pipe reader, or pty) was torn down. On
+ * macOS a torn-down pty slave produces `EIO`; a closed fd produces `EBADF`;
+ * a closed pipe produces `EPIPE`. All three are the same benign condition:
+ * the terminal disconnected.
+ *
+ * Mirrors `CLOSED_STDERR_ERROR_CODES` in `safe-stderr.ts`; keep in sync.
+ */
+const PROCESS_STDOUT_PEER_CLOSED_CODES = new Set(["EIO", "EPIPE", "EBADF"]);
 
 type ErrorProperty = "code" | "fd" | "syscall";
 
@@ -70,9 +80,10 @@ export function isBrokenPipeError(error: unknown): boolean {
 }
 
 /**
- * A classifier for process-level stdout `EPIPE` errors. Its direct-write
- * evidence is private to each factory instance, so only the owner that
- * intercepted `process.stdout.write` can mark an error for this classifier.
+ * A classifier for process-level stdout peer-closed errors (`EPIPE`, `EIO`,
+ * `EBADF`). Its direct-write evidence is private to each factory instance, so
+ * only the owner that intercepted `process.stdout.write` can mark an error
+ * for this classifier.
  */
 export interface ProcessStdoutEpipeClassifier {
 	markDirectProcessStdoutWriteError(error: unknown): void;
@@ -109,7 +120,8 @@ export function createProcessStdoutEpipeClassifier(): ProcessStdoutEpipeClassifi
 			if (!isObjectLike(error)) return false;
 
 			const code = readErrorProperty(error, "code");
-			if (!code.available || code.value !== "EPIPE") return false;
+			if (!code.available || typeof code.value !== "string" || !PROCESS_STDOUT_PEER_CLOSED_CODES.has(code.value))
+				return false;
 
 			if (directProcessStdoutWriteErrors.has(error)) return true;
 

package/src/fetch-retry.ts

@@ -81,13 +81,16 @@ export interface FetchWithRetryOptions extends RequestInit {
 	/**
 	 * Per-delay cap. Server-provided `Retry-After` hints exceeding this return
 	 * the current response immediately — caller deals with the `!response.ok`.
-	 * Default `60_000`.
+	 * Scheduled values are also capped at the platform timer ceiling. Default
+	 * `60_000`.
 	 */
 	maxDelayMs?: number;
 	/**
 	 * Fallback delay schedule when no server hint is present. Number, array
 	 * (indexed by attempt, clamped to last), or function. Default exponential
-	 * `500ms * 2 ** attempt` capped at `maxDelayMs`.
+	 * `500ms * 2 ** attempt` capped at `maxDelayMs` and the platform timer
+	 * ceiling. Values that remain negative or non-finite after capping retry
+	 * immediately.
 	 */
 	defaultDelayMs?: number | readonly number[] | ((attempt: number) => number);
 	/**
@@ -106,6 +109,9 @@ export interface FetchWithRetryOptions extends RequestInit {
 
 const DEFAULT_MAX_DELAY_MS = 60_000;
 const DEFAULT_MAX_ATTEMPTS = 5;
+// Node-compatible timers coerce larger delays to 1 ms. Bun follows the same
+// signed 32-bit boundary, so every scheduler input must stay at or below it.
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
 
 /**
  * Fetch with bounded retries and sensible defaults. Retries on any
@@ -142,7 +148,8 @@ export async function fetchWithRetry(
 			if (signal?.aborted) throw new Error("Request was aborted");
 			const wrapped = wrapNetworkError(error);
 			if (attempt + 1 >= maxAttempts) throw wrapped;
-			await scheduler.wait(resolveDefaultDelay(defaultDelayMs, attempt, maxDelayMs), { signal });
+			const delayMs = normalizeRetryDelay(resolveDefaultDelay(defaultDelayMs, attempt), maxDelayMs);
+			await scheduler.wait(delayMs, { signal });
 			continue;
 		}
 
@@ -152,7 +159,7 @@ export async function fetchWithRetry(
 		const hint = extractRetryHint(response, await response.clone().text());
 		if (hint !== undefined && hint > maxDelayMs) return response;
 
-		const delayMs = Math.min(hint ?? resolveDefaultDelay(defaultDelayMs, attempt, maxDelayMs), maxDelayMs);
+		const delayMs = normalizeRetryDelay(hint ?? resolveDefaultDelay(defaultDelayMs, attempt), maxDelayMs);
 		void response.body?.cancel().catch(() => undefined);
 		await scheduler.wait(delayMs, { signal });
 	}
@@ -184,15 +191,16 @@ function wrapNetworkError(error: unknown): Error {
 	return new Error(String(error));
 }
 
-function resolveDefaultDelay(
-	option: FetchWithRetryOptions["defaultDelayMs"],
-	attempt: number,
-	maxDelayMs: number,
-): number {
-	if (option === undefined) return Math.min(500 * 2 ** attempt, maxDelayMs);
-	if (typeof option === "number") return Math.min(option, maxDelayMs);
-	if (typeof option === "function") return Math.min(option(attempt), maxDelayMs);
-	return Math.min(option[Math.min(attempt, option.length - 1)] ?? 0, maxDelayMs);
+function resolveDefaultDelay(option: FetchWithRetryOptions["defaultDelayMs"], attempt: number): number {
+	if (option === undefined) return 500 * 2 ** attempt;
+	if (typeof option === "number") return option;
+	if (typeof option === "function") return option(attempt);
+	return option[Math.min(attempt, option.length - 1)] ?? 0;
+}
+
+function normalizeRetryDelay(delayMs: number, maxDelayMs: number): number {
+	const cappedDelayMs = Math.min(delayMs, maxDelayMs, MAX_TIMER_DELAY_MS);
+	return Number.isFinite(cappedDelayMs) && cappedDelayMs >= 0 ? cappedDelayMs : 0;
 }
 
 /**