@fgv/ts-extras 5.1.0-5 → 5.1.0-50

package/lib/packlets/safer-fetch/deadline.d.ts

@@ -0,0 +1,138 @@
+import type { FetchFailureReason, FetchTimeoutPhase } from './failureReason';
+/**
+ * Why a {@link DeadlineWatch} stopped waiting.
+ * @internal
+ */
+export type DeadlineStopCause = 'caller-aborted' | FetchTimeoutPhase;
+/**
+ * The outcome of racing a promise against the deadlines.
+ * @internal
+ */
+export type DeadlineRace<T> = {
+    readonly stopped: false;
+    readonly value: T;
+} | {
+    readonly stopped: true;
+    readonly cause: DeadlineStopCause;
+};
+/**
+ * Composes the caller's cancellation signal with an overall deadline and a headers deadline
+ * into one `AbortSignal`, and remembers which of the three stopped the call.
+ *
+ * @remarks
+ * The composition is done with a plain `AbortController` and listeners rather than
+ * `AbortSignal.any`, so there is no runtime-version floor to state and no feature-detection
+ * branch that only one of the two runtimes would ever execute.
+ *
+ * The overall deadline covers the connect, the headers, and the body read, and it is what
+ * stops a response that dribbles one byte every 25 seconds — such a response passes every
+ * per-read check and never trips a connect timeout.
+ * @internal
+ */
+export declare class DeadlineWatch {
+    private _controller;
+    private readonly _startedAt;
+    private readonly _timeoutMs;
+    private readonly _headersTimeoutMs;
+    private readonly _callerSignal;
+    private readonly _onCallerAbort;
+    private _overallTimer;
+    private _headersTimer;
+    private _cause;
+    /**
+     * Whether the current stop ends the whole call rather than just this attempt. The overall
+     * deadline and the caller's signal are terminal; the per-attempt headers deadline is not.
+     */
+    private _terminal;
+    private _inBodyPhase;
+    private readonly _waiters;
+    constructor(timeoutMs: number, headersTimeoutMs: number, callerSignal?: AbortSignal);
+    /** The composed signal to hand to the transport. */
+    get signal(): AbortSignal;
+    /** Why the call was stopped, or `undefined` while it is still running. */
+    get cause(): DeadlineStopCause | undefined;
+    /**
+     * Records that a new attempt is starting: the headers deadline is (re)armed from now.
+     *
+     * @remarks
+     * The headers deadline is **per attempt**, and a redirect walk makes more than one. Without a
+     * re-arm, {@link DeadlineWatch.headersReceived} on the first hop would retire the headers
+     * deadline for the whole call, leaving every later hop bounded only by the overall deadline —
+     * so a chain whose second host simply never answers would hang for the overall budget instead
+     * of failing as `timeout.phase === 'headers'`.
+     *
+     * Called before the address guard rather than before the connect, because guard evaluation
+     * (a DNS resolution, in the shipped guard) is part of the time a caller waits for a usable
+     * response and is deliberately inside this budget.
+     *
+     * The overall deadline is untouched: it spans the whole call, redirects included.
+     */
+    attemptStarted(): void;
+    /**
+     * Records that response headers have arrived: the headers deadline no longer applies to this
+     * attempt, and a subsequent overall-deadline expiry is a body-phase timeout rather than an
+     * overall one.
+     */
+    headersReceived(): void;
+    /**
+     * Races a promise against the deadlines. A stopped race reports the cause; the underlying
+     * promise is abandoned, not cancelled — the caller is responsible for releasing whatever
+     * resource it represents (a response body reader, in practice).
+     *
+     * @remarks
+     * The waiter is removed once the race settles. A body read calls this once per chunk, so a
+     * waiter set that only grew would be a leak proportional to the number of chunks — in the
+     * exact code path whose job is to bound what a hostile response can cost the process.
+     */
+    race<T>(promise: Promise<T>): Promise<DeadlineRace<T>>;
+    /**
+     * Records that an attempt has ended and another may follow: the headers deadline is disarmed,
+     * and a stop that ended only *that attempt* is cleared.
+     *
+     * @remarks
+     * **The headers deadline is attempt-scoped and the overall deadline is not.** A retry attempt
+     * that timed out waiting for headers must not leave the whole call stopped — without this,
+     * retry could never answer a `timeout.phase === 'headers'` failure, which is precisely the
+     * failure retry exists for. The composed signal is replaced rather than reset, because an
+     * aborted `AbortSignal` cannot be un-aborted.
+     *
+     * The overall deadline and the caller's signal are **terminal** by contrast: neither is about
+     * one attempt, and clearing either would let a retry loop outlive the budget the caller set or
+     * ignore the cancellation the caller requested. A terminal stop survives this call, so the
+     * backoff that follows is answered immediately and the call ends.
+     *
+     * Called between attempts rather than at the start of one, so the interval spent in a backoff
+     * is bounded by the overall deadline alone — arming a headers deadline over a sleep during
+     * which no request is outstanding would stop the call for a response nobody is waiting for.
+     */
+    attemptEnded(): void;
+    /**
+     * How much of the overall deadline is left, in milliseconds, never below zero.
+     *
+     * @remarks
+     * Read by the retry scheduler, which must not sleep past a deadline it is already inside:
+     * "the overall budget is the ceiling" is only enforceable if the remaining budget is
+     * observable.
+     */
+    get remainingMs(): number;
+    /**
+     * Waits for the given number of milliseconds, or until the call is stopped — whichever comes
+     * first.
+     *
+     * @remarks
+     * Backing the retry delay with the same watch the request races against is what keeps a
+     * caller's `abort()` responsive *between* attempts. A bare `setTimeout` would leave a caller
+     * who cancelled during a five-second backoff waiting out the full delay before being told the
+     * call was aborted.
+     *
+     * The timer is cleared however the wait ends, so a stopped delay leaves nothing pending —
+     * which matters in a test runner, where a stray timer keeps the process alive.
+     */
+    delay(ms: number): Promise<DeadlineRace<true>>;
+    /** Builds the failure reason corresponding to why the call was stopped. */
+    toFailureReason(cause: DeadlineStopCause): FetchFailureReason;
+    /** Clears timers and listeners. Safe to call more than once. */
+    dispose(): void;
+    private _stop;
+}
+//# sourceMappingURL=deadline.d.ts.map

package/lib/packlets/safer-fetch/deadline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deadline.d.ts","sourceRoot":"","sources":["../../../src/packlets/safer-fetch/deadline.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAE7E;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,GAAG,iBAAiB,CAAC;AAErE;;;GAGG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IACtB;IAAE,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAC9C;IAAE,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAA;CAAE,CAAC;AAElE;;;;;;;;;;;;;GAaG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAS;IAC3C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA0B;IACxD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAa;IAE5C,OAAO,CAAC,aAAa,CAA4C;IACjE,OAAO,CAAC,aAAa,CAA4C;IACjE,OAAO,CAAC,MAAM,CAAgC;IAC9C;;;OAGG;IACH,OAAO,CAAC,SAAS,CAAU;IAC3B,OAAO,CAAC,YAAY,CAAU;IAC9B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0C;gBAEhD,SAAS,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,WAAW;IAuB1F,oDAAoD;IACpD,IAAW,MAAM,IAAI,WAAW,CAE/B;IAED,0EAA0E;IAC1E,IAAW,KAAK,IAAI,iBAAiB,GAAG,SAAS,CAEhD;IAED;;;;;;;;;;;;;;;OAeG;IACI,cAAc,IAAI,IAAI;IAW7B;;;;OAIG;IACI,eAAe,IAAI,IAAI;IAQ9B;;;;;;;;;OASG;IACU,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IAoBnE;;;;;;;;;;;;;;;;;;;OAmBG;IACI,YAAY,IAAI,IAAI;IAoB3B;;;;;;;OAOG;IACH,IAAW,WAAW,IAAI,MAAM,CAE/B;IAED;;;;;;;;;;;;OAYG;IACU,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAe3D,2EAA2E;IACpE,eAAe,CAAC,KAAK,EAAE,iBAAiB,GAAG,kBAAkB;IAYpE,gEAAgE;IACzD,OAAO,IAAI,IAAI;IAetB,OAAO,CAAC,KAAK;CAkBd"}

package/lib/packlets/safer-fetch/deadline.js

@@ -0,0 +1,258 @@
+"use strict";
+// Copyright (c) 2026 Erik Fortune
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeadlineWatch = void 0;
+/**
+ * Composes the caller's cancellation signal with an overall deadline and a headers deadline
+ * into one `AbortSignal`, and remembers which of the three stopped the call.
+ *
+ * @remarks
+ * The composition is done with a plain `AbortController` and listeners rather than
+ * `AbortSignal.any`, so there is no runtime-version floor to state and no feature-detection
+ * branch that only one of the two runtimes would ever execute.
+ *
+ * The overall deadline covers the connect, the headers, and the body read, and it is what
+ * stops a response that dribbles one byte every 25 seconds — such a response passes every
+ * per-read check and never trips a connect timeout.
+ * @internal
+ */
+class DeadlineWatch {
+    constructor(timeoutMs, headersTimeoutMs, callerSignal) {
+        this._controller = new AbortController();
+        this._startedAt = Date.now();
+        this._timeoutMs = timeoutMs;
+        this._headersTimeoutMs = headersTimeoutMs;
+        this._callerSignal = callerSignal;
+        this._terminal = false;
+        this._inBodyPhase = false;
+        this._waiters = new Set();
+        this._onCallerAbort = () => this._stop('caller-aborted');
+        this._overallTimer = setTimeout(() => this._stop(this._inBodyPhase ? 'body' : 'overall'), timeoutMs);
+        this._headersTimer = setTimeout(() => this._stop('headers'), headersTimeoutMs);
+        if (callerSignal !== undefined) {
+            if (callerSignal.aborted) {
+                this._stop('caller-aborted');
+            }
+            else {
+                callerSignal.addEventListener('abort', this._onCallerAbort);
+            }
+        }
+    }
+    /** The composed signal to hand to the transport. */
+    get signal() {
+        return this._controller.signal;
+    }
+    /** Why the call was stopped, or `undefined` while it is still running. */
+    get cause() {
+        return this._cause;
+    }
+    /**
+     * Records that a new attempt is starting: the headers deadline is (re)armed from now.
+     *
+     * @remarks
+     * The headers deadline is **per attempt**, and a redirect walk makes more than one. Without a
+     * re-arm, {@link DeadlineWatch.headersReceived} on the first hop would retire the headers
+     * deadline for the whole call, leaving every later hop bounded only by the overall deadline —
+     * so a chain whose second host simply never answers would hang for the overall budget instead
+     * of failing as `timeout.phase === 'headers'`.
+     *
+     * Called before the address guard rather than before the connect, because guard evaluation
+     * (a DNS resolution, in the shipped guard) is part of the time a caller waits for a usable
+     * response and is deliberately inside this budget.
+     *
+     * The overall deadline is untouched: it spans the whole call, redirects included.
+     */
+    attemptStarted() {
+        if (this._cause !== undefined) {
+            return;
+        }
+        if (this._headersTimer !== undefined) {
+            clearTimeout(this._headersTimer);
+        }
+        this._headersTimer = setTimeout(() => this._stop('headers'), this._headersTimeoutMs);
+        this._inBodyPhase = false;
+    }
+    /**
+     * Records that response headers have arrived: the headers deadline no longer applies to this
+     * attempt, and a subsequent overall-deadline expiry is a body-phase timeout rather than an
+     * overall one.
+     */
+    headersReceived() {
+        if (this._headersTimer !== undefined) {
+            clearTimeout(this._headersTimer);
+            this._headersTimer = undefined;
+        }
+        this._inBodyPhase = true;
+    }
+    /**
+     * Races a promise against the deadlines. A stopped race reports the cause; the underlying
+     * promise is abandoned, not cancelled — the caller is responsible for releasing whatever
+     * resource it represents (a response body reader, in practice).
+     *
+     * @remarks
+     * The waiter is removed once the race settles. A body read calls this once per chunk, so a
+     * waiter set that only grew would be a leak proportional to the number of chunks — in the
+     * exact code path whose job is to bound what a hostile response can cost the process.
+     */
+    async race(promise) {
+        if (this._cause !== undefined) {
+            return { stopped: true, cause: this._cause };
+        }
+        // Definitely assigned: a Promise executor runs synchronously.
+        let waiter;
+        const stop = new Promise((resolve) => {
+            waiter = (cause) => resolve({ stopped: true, cause });
+        });
+        this._waiters.add(waiter);
+        try {
+            return await Promise.race([
+                promise.then((value) => ({ stopped: false, value })),
+                stop
+            ]);
+        }
+        finally {
+            this._waiters.delete(waiter);
+        }
+    }
+    /**
+     * Records that an attempt has ended and another may follow: the headers deadline is disarmed,
+     * and a stop that ended only *that attempt* is cleared.
+     *
+     * @remarks
+     * **The headers deadline is attempt-scoped and the overall deadline is not.** A retry attempt
+     * that timed out waiting for headers must not leave the whole call stopped — without this,
+     * retry could never answer a `timeout.phase === 'headers'` failure, which is precisely the
+     * failure retry exists for. The composed signal is replaced rather than reset, because an
+     * aborted `AbortSignal` cannot be un-aborted.
+     *
+     * The overall deadline and the caller's signal are **terminal** by contrast: neither is about
+     * one attempt, and clearing either would let a retry loop outlive the budget the caller set or
+     * ignore the cancellation the caller requested. A terminal stop survives this call, so the
+     * backoff that follows is answered immediately and the call ends.
+     *
+     * Called between attempts rather than at the start of one, so the interval spent in a backoff
+     * is bounded by the overall deadline alone — arming a headers deadline over a sleep during
+     * which no request is outstanding would stop the call for a response nobody is waiting for.
+     */
+    attemptEnded() {
+        if (this._headersTimer !== undefined) {
+            clearTimeout(this._headersTimer);
+            this._headersTimer = undefined;
+        }
+        // No attempt is in flight between attempts, so the call is not in its body phase — whatever
+        // the previous attempt reached. Without this, an attempt that failed *after* headers arrived
+        // (a body-read network error, a non-2xx) would leave the flag set through the backoff, and
+        // an overall-deadline expiry during that sleep would be reported as `timeout.phase: 'body'`
+        // while no bytes were being transferred at all. `phase` is part of the taxonomy's contract,
+        // and a phase that names the wrong thing is exactly the kind of small lie this primitive is
+        // built not to tell.
+        this._inBodyPhase = false;
+        if (this._terminal || this._cause === undefined) {
+            return;
+        }
+        this._cause = undefined;
+        this._controller = new AbortController();
+    }
+    /**
+     * How much of the overall deadline is left, in milliseconds, never below zero.
+     *
+     * @remarks
+     * Read by the retry scheduler, which must not sleep past a deadline it is already inside:
+     * "the overall budget is the ceiling" is only enforceable if the remaining budget is
+     * observable.
+     */
+    get remainingMs() {
+        return Math.max(0, this._timeoutMs - (Date.now() - this._startedAt));
+    }
+    /**
+     * Waits for the given number of milliseconds, or until the call is stopped — whichever comes
+     * first.
+     *
+     * @remarks
+     * Backing the retry delay with the same watch the request races against is what keeps a
+     * caller's `abort()` responsive *between* attempts. A bare `setTimeout` would leave a caller
+     * who cancelled during a five-second backoff waiting out the full delay before being told the
+     * call was aborted.
+     *
+     * The timer is cleared however the wait ends, so a stopped delay leaves nothing pending —
+     * which matters in a test runner, where a stray timer keeps the process alive.
+     */
+    async delay(ms) {
+        let timer;
+        try {
+            return await this.race(new Promise((resolve) => {
+                timer = setTimeout(() => resolve(true), ms);
+            }));
+        }
+        finally {
+            if (timer !== undefined) {
+                clearTimeout(timer);
+            }
+        }
+    }
+    /** Builds the failure reason corresponding to why the call was stopped. */
+    toFailureReason(cause) {
+        if (cause === 'caller-aborted') {
+            return { kind: 'aborted' };
+        }
+        return {
+            kind: 'timeout',
+            phase: cause,
+            elapsedMs: Date.now() - this._startedAt,
+            limitMs: cause === 'headers' ? this._headersTimeoutMs : this._timeoutMs
+        };
+    }
+    /** Clears timers and listeners. Safe to call more than once. */
+    dispose() {
+        if (this._overallTimer !== undefined) {
+            clearTimeout(this._overallTimer);
+            this._overallTimer = undefined;
+        }
+        if (this._headersTimer !== undefined) {
+            clearTimeout(this._headersTimer);
+            this._headersTimer = undefined;
+        }
+        if (this._callerSignal !== undefined) {
+            this._callerSignal.removeEventListener('abort', this._onCallerAbort);
+        }
+        this._waiters.clear();
+    }
+    _stop(cause) {
+        // First cause wins. The overall and headers deadlines can be scheduled for the same instant,
+        // and a caller can abort while one of them is already firing; reporting the second would
+        // rewrite a phase the caller has arguably already been told about.
+        if (this._cause !== undefined) {
+            return;
+        }
+        this._cause = cause;
+        // Every cause but the per-attempt headers deadline ends the call: the overall deadline is
+        // the whole budget, and the caller's signal is the caller's decision.
+        this._terminal = cause !== 'headers';
+        const waiters = Array.from(this._waiters);
+        this._waiters.clear();
+        this._controller.abort();
+        for (const waiter of waiters) {
+            waiter(cause);
+        }
+    }
+}
+exports.DeadlineWatch = DeadlineWatch;
+//# sourceMappingURL=deadline.js.map

package/lib/packlets/safer-fetch/deadline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deadline.js","sourceRoot":"","sources":["../../../src/packlets/safer-fetch/deadline.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) 2026 Erik Fortune\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\nimport type { FetchFailureReason, FetchTimeoutPhase } from './failureReason';\n\n/**\n * Why a {@link DeadlineWatch} stopped waiting.\n * @internal\n */\nexport type DeadlineStopCause = 'caller-aborted' | FetchTimeoutPhase;\n\n/**\n * The outcome of racing a promise against the deadlines.\n * @internal\n */\nexport type DeadlineRace<T> =\n  | { readonly stopped: false; readonly value: T }\n  | { readonly stopped: true; readonly cause: DeadlineStopCause };\n\n/**\n * Composes the caller's cancellation signal with an overall deadline and a headers deadline\n * into one `AbortSignal`, and remembers which of the three stopped the call.\n *\n * @remarks\n * The composition is done with a plain `AbortController` and listeners rather than\n * `AbortSignal.any`, so there is no runtime-version floor to state and no feature-detection\n * branch that only one of the two runtimes would ever execute.\n *\n * The overall deadline covers the connect, the headers, and the body read, and it is what\n * stops a response that dribbles one byte every 25 seconds — such a response passes every\n * per-read check and never trips a connect timeout.\n * @internal\n */\nexport class DeadlineWatch {\n  private _controller: AbortController;\n  private readonly _startedAt: number;\n  private readonly _timeoutMs: number;\n  private readonly _headersTimeoutMs: number;\n  private readonly _callerSignal: AbortSignal | undefined;\n  private readonly _onCallerAbort: () => void;\n\n  private _overallTimer: ReturnType<typeof setTimeout> | undefined;\n  private _headersTimer: ReturnType<typeof setTimeout> | undefined;\n  private _cause: DeadlineStopCause | undefined;\n  /**\n   * Whether the current stop ends the whole call rather than just this attempt. The overall\n   * deadline and the caller's signal are terminal; the per-attempt headers deadline is not.\n   */\n  private _terminal: boolean;\n  private _inBodyPhase: boolean;\n  private readonly _waiters: Set<(cause: DeadlineStopCause) => void>;\n\n  public constructor(timeoutMs: number, headersTimeoutMs: number, callerSignal?: AbortSignal) {\n    this._controller = new AbortController();\n    this._startedAt = Date.now();\n    this._timeoutMs = timeoutMs;\n    this._headersTimeoutMs = headersTimeoutMs;\n    this._callerSignal = callerSignal;\n    this._terminal = false;\n    this._inBodyPhase = false;\n    this._waiters = new Set();\n\n    this._onCallerAbort = (): void => this._stop('caller-aborted');\n    this._overallTimer = setTimeout(() => this._stop(this._inBodyPhase ? 'body' : 'overall'), timeoutMs);\n    this._headersTimer = setTimeout(() => this._stop('headers'), headersTimeoutMs);\n\n    if (callerSignal !== undefined) {\n      if (callerSignal.aborted) {\n        this._stop('caller-aborted');\n      } else {\n        callerSignal.addEventListener('abort', this._onCallerAbort);\n      }\n    }\n  }\n\n  /** The composed signal to hand to the transport. */\n  public get signal(): AbortSignal {\n    return this._controller.signal;\n  }\n\n  /** Why the call was stopped, or `undefined` while it is still running. */\n  public get cause(): DeadlineStopCause | undefined {\n    return this._cause;\n  }\n\n  /**\n   * Records that a new attempt is starting: the headers deadline is (re)armed from now.\n   *\n   * @remarks\n   * The headers deadline is **per attempt**, and a redirect walk makes more than one. Without a\n   * re-arm, {@link DeadlineWatch.headersReceived} on the first hop would retire the headers\n   * deadline for the whole call, leaving every later hop bounded only by the overall deadline —\n   * so a chain whose second host simply never answers would hang for the overall budget instead\n   * of failing as `timeout.phase === 'headers'`.\n   *\n   * Called before the address guard rather than before the connect, because guard evaluation\n   * (a DNS resolution, in the shipped guard) is part of the time a caller waits for a usable\n   * response and is deliberately inside this budget.\n   *\n   * The overall deadline is untouched: it spans the whole call, redirects included.\n   */\n  public attemptStarted(): void {\n    if (this._cause !== undefined) {\n      return;\n    }\n    if (this._headersTimer !== undefined) {\n      clearTimeout(this._headersTimer);\n    }\n    this._headersTimer = setTimeout(() => this._stop('headers'), this._headersTimeoutMs);\n    this._inBodyPhase = false;\n  }\n\n  /**\n   * Records that response headers have arrived: the headers deadline no longer applies to this\n   * attempt, and a subsequent overall-deadline expiry is a body-phase timeout rather than an\n   * overall one.\n   */\n  public headersReceived(): void {\n    if (this._headersTimer !== undefined) {\n      clearTimeout(this._headersTimer);\n      this._headersTimer = undefined;\n    }\n    this._inBodyPhase = true;\n  }\n\n  /**\n   * Races a promise against the deadlines. A stopped race reports the cause; the underlying\n   * promise is abandoned, not cancelled — the caller is responsible for releasing whatever\n   * resource it represents (a response body reader, in practice).\n   *\n   * @remarks\n   * The waiter is removed once the race settles. A body read calls this once per chunk, so a\n   * waiter set that only grew would be a leak proportional to the number of chunks — in the\n   * exact code path whose job is to bound what a hostile response can cost the process.\n   */\n  public async race<T>(promise: Promise<T>): Promise<DeadlineRace<T>> {\n    if (this._cause !== undefined) {\n      return { stopped: true, cause: this._cause };\n    }\n    // Definitely assigned: a Promise executor runs synchronously.\n    let waiter!: (cause: DeadlineStopCause) => void;\n    const stop: Promise<DeadlineRace<T>> = new Promise((resolve) => {\n      waiter = (cause: DeadlineStopCause): void => resolve({ stopped: true, cause });\n    });\n    this._waiters.add(waiter);\n    try {\n      return await Promise.race([\n        promise.then((value): DeadlineRace<T> => ({ stopped: false, value })),\n        stop\n      ]);\n    } finally {\n      this._waiters.delete(waiter);\n    }\n  }\n\n  /**\n   * Records that an attempt has ended and another may follow: the headers deadline is disarmed,\n   * and a stop that ended only *that attempt* is cleared.\n   *\n   * @remarks\n   * **The headers deadline is attempt-scoped and the overall deadline is not.** A retry attempt\n   * that timed out waiting for headers must not leave the whole call stopped — without this,\n   * retry could never answer a `timeout.phase === 'headers'` failure, which is precisely the\n   * failure retry exists for. The composed signal is replaced rather than reset, because an\n   * aborted `AbortSignal` cannot be un-aborted.\n   *\n   * The overall deadline and the caller's signal are **terminal** by contrast: neither is about\n   * one attempt, and clearing either would let a retry loop outlive the budget the caller set or\n   * ignore the cancellation the caller requested. A terminal stop survives this call, so the\n   * backoff that follows is answered immediately and the call ends.\n   *\n   * Called between attempts rather than at the start of one, so the interval spent in a backoff\n   * is bounded by the overall deadline alone — arming a headers deadline over a sleep during\n   * which no request is outstanding would stop the call for a response nobody is waiting for.\n   */\n  public attemptEnded(): void {\n    if (this._headersTimer !== undefined) {\n      clearTimeout(this._headersTimer);\n      this._headersTimer = undefined;\n    }\n    // No attempt is in flight between attempts, so the call is not in its body phase — whatever\n    // the previous attempt reached. Without this, an attempt that failed *after* headers arrived\n    // (a body-read network error, a non-2xx) would leave the flag set through the backoff, and\n    // an overall-deadline expiry during that sleep would be reported as `timeout.phase: 'body'`\n    // while no bytes were being transferred at all. `phase` is part of the taxonomy's contract,\n    // and a phase that names the wrong thing is exactly the kind of small lie this primitive is\n    // built not to tell.\n    this._inBodyPhase = false;\n    if (this._terminal || this._cause === undefined) {\n      return;\n    }\n    this._cause = undefined;\n    this._controller = new AbortController();\n  }\n\n  /**\n   * How much of the overall deadline is left, in milliseconds, never below zero.\n   *\n   * @remarks\n   * Read by the retry scheduler, which must not sleep past a deadline it is already inside:\n   * \"the overall budget is the ceiling\" is only enforceable if the remaining budget is\n   * observable.\n   */\n  public get remainingMs(): number {\n    return Math.max(0, this._timeoutMs - (Date.now() - this._startedAt));\n  }\n\n  /**\n   * Waits for the given number of milliseconds, or until the call is stopped — whichever comes\n   * first.\n   *\n   * @remarks\n   * Backing the retry delay with the same watch the request races against is what keeps a\n   * caller's `abort()` responsive *between* attempts. A bare `setTimeout` would leave a caller\n   * who cancelled during a five-second backoff waiting out the full delay before being told the\n   * call was aborted.\n   *\n   * The timer is cleared however the wait ends, so a stopped delay leaves nothing pending —\n   * which matters in a test runner, where a stray timer keeps the process alive.\n   */\n  public async delay(ms: number): Promise<DeadlineRace<true>> {\n    let timer: ReturnType<typeof setTimeout> | undefined;\n    try {\n      return await this.race(\n        new Promise<true>((resolve) => {\n          timer = setTimeout(() => resolve(true), ms);\n        })\n      );\n    } finally {\n      if (timer !== undefined) {\n        clearTimeout(timer);\n      }\n    }\n  }\n\n  /** Builds the failure reason corresponding to why the call was stopped. */\n  public toFailureReason(cause: DeadlineStopCause): FetchFailureReason {\n    if (cause === 'caller-aborted') {\n      return { kind: 'aborted' };\n    }\n    return {\n      kind: 'timeout',\n      phase: cause,\n      elapsedMs: Date.now() - this._startedAt,\n      limitMs: cause === 'headers' ? this._headersTimeoutMs : this._timeoutMs\n    };\n  }\n\n  /** Clears timers and listeners. Safe to call more than once. */\n  public dispose(): void {\n    if (this._overallTimer !== undefined) {\n      clearTimeout(this._overallTimer);\n      this._overallTimer = undefined;\n    }\n    if (this._headersTimer !== undefined) {\n      clearTimeout(this._headersTimer);\n      this._headersTimer = undefined;\n    }\n    if (this._callerSignal !== undefined) {\n      this._callerSignal.removeEventListener('abort', this._onCallerAbort);\n    }\n    this._waiters.clear();\n  }\n\n  private _stop(cause: DeadlineStopCause): void {\n    // First cause wins. The overall and headers deadlines can be scheduled for the same instant,\n    // and a caller can abort while one of them is already firing; reporting the second would\n    // rewrite a phase the caller has arguably already been told about.\n    if (this._cause !== undefined) {\n      return;\n    }\n    this._cause = cause;\n    // Every cause but the per-attempt headers deadline ends the call: the overall deadline is\n    // the whole budget, and the caller's signal is the caller's decision.\n    this._terminal = cause !== 'headers';\n    const waiters = Array.from(this._waiters);\n    this._waiters.clear();\n    this._controller.abort();\n    for (const waiter of waiters) {\n      waiter(cause);\n    }\n  }\n}\n"]}

package/lib/packlets/safer-fetch/defaults.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Default overall deadline, in milliseconds — comfortably above a slow-but-real API and far
+ * below "a hung request pins a socket for minutes". Streaming LLM calls should not use this
+ * primitive at all; that is what `AiAssist` is for.
+ * @public
+ */
+export declare const DEFAULT_TIMEOUT_MS: number;
+/**
+ * Default deadline to first response headers, in milliseconds. A host that has not sent
+ * headers in ten seconds is not answering.
+ * @public
+ */
+export declare const DEFAULT_HEADERS_TIMEOUT_MS: number;
+/**
+ * Default cap on decoded response bytes (5 MiB) — roughly an order of magnitude above a
+ * realistic JSON API response and well below a size that threatens a Node heap.
+ *
+ * @remarks
+ * Raising it is a per-call option, not a construction-time setting, precisely because real
+ * documents clear this. See `ISaferFetchOptions.maxResponseBytes`.
+ * @public
+ */
+export declare const DEFAULT_MAX_RESPONSE_BYTES: number;
+/**
+ * Redirect statuses this primitive recognizes as redirects. Other 3xx statuses (`300`, `304`,
+ * …) do not direct the client at a new URL and are reported as ordinary non-2xx responses.
+ * @public
+ */
+export declare const REDIRECT_STATUSES: ReadonlyArray<number>;
+/**
+ * Default cap on redirect hops followed under `'validate-each-hop'`.
+ *
+ * @remarks
+ * Five is enough for the ordinary shortener-then-canonicalize-then-CDN chains real services
+ * produce and small enough that a chain designed to burn budget is refused quickly. Every hop
+ * costs a full guard evaluation — including a DNS resolution — against the same overall
+ * deadline, so the cap bounds work, not just politeness.
+ * @public
+ */
+export declare const DEFAULT_MAX_REDIRECTS: number;
+/**
+ * Header names dropped on every cross-origin redirect hop, whatever the caller configured.
+ *
+ * @remarks
+ * Turning on manual redirects makes this primitive responsible for a rule the platform was
+ * applying for free: browsers and `curl` both strip credential headers when a redirect leaves
+ * the origin, and a hand-rolled loop that replays them hands `Authorization: Bearer …` to
+ * whatever host the redirect names. Callers add their own names with
+ * `ISaferFetchOptions.sensitiveHeaders`; these three are not removable.
+ * @public
+ */
+export declare const ALWAYS_STRIPPED_HEADERS: ReadonlyArray<string>;
+/**
+ * URL schemes this primitive will ever request.
+ *
+ * @remarks
+ * Core rejects everything else — `file:`, `data:`, `blob:`, `ftp:`, `gopher:`, `ws:` — outright
+ * and at every hop, because none of them is a legitimate network fetch and each is a standard
+ * SSRF payload. Deciding between `http:` and `https:`, and which ports are acceptable, belongs
+ * to the address guard, which is why core does not narrow this further.
+ * @public
+ */
+export declare const SUPPORTED_SCHEMES: ReadonlyArray<string>;
+/**
+ * Default base delay for {@link SaferFetch.IRetryPolicy | retry} backoff, in milliseconds.
+ * @public
+ */
+export declare const DEFAULT_RETRY_BASE_DELAY_MS: number;
+/**
+ * Default ceiling on a single {@link SaferFetch.IRetryPolicy | retry} delay, in milliseconds.
+ *
+ * @remarks
+ * It bounds the computed backoff **and** a server-supplied `Retry-After`. That second role is
+ * the security-relevant one: `Retry-After` is a header an attacker-controlled server chooses
+ * freely, so an unclamped `Retry-After: 86400` is a denial of service on the caller.
+ * @public
+ */
+export declare const DEFAULT_RETRY_MAX_DELAY_MS: number;
+/**
+ * HTTP statuses a {@link SaferFetch.IRetryPolicy | retry policy} will retry.
+ *
+ * @remarks
+ * Every other status — including every other 4xx — is terminal. A `401`, a `403` and a `404`
+ * mean the same thing on the second attempt as on the first, and retrying them turns a client
+ * bug into load against a service that already said no.
+ * @public
+ */
+export declare const RETRYABLE_HTTP_STATUSES: ReadonlyArray<number>;
+/**
+ * Statuses whose `Retry-After` header is honored.
+ *
+ * @remarks
+ * `429` and `503` are the two the header is specified for and the two where it carries real
+ * scheduling information. Honoring it on a `500` would let any failing endpoint dictate the
+ * caller's schedule for no benefit.
+ * @public
+ */
+export declare const RETRY_AFTER_STATUSES: ReadonlyArray<number>;
+/**
+ * Methods retried without an explicit opt-in.
+ *
+ * @remarks
+ * A timeout does not tell you whether the server processed the request, so a retried `POST`
+ * can double-charge. `retryNonIdempotent` opts out, per call, visibly.
+ * @public
+ */
+export declare const IDEMPOTENT_METHODS: ReadonlyArray<string>;
+//# sourceMappingURL=defaults.d.ts.map

package/lib/packlets/safer-fetch/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../../../src/packlets/safer-fetch/defaults.ts"],"names":[],"mappings":"AAoBA;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAe,CAAC;AAEjD;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,EAAE,MAAe,CAAC;AAEzD;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,EAAE,MAAwB,CAAC;AAElE;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,MAAM,CAA6B,CAAC;AAElF;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,EAAE,MAAU,CAAC;AAE/C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB,EAAE,aAAa,CAAC,MAAM,CAIzD,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,EAAE,aAAa,CAAC,MAAM,CAAuB,CAAC;AAE5E;;;GAGG;AACH,eAAO,MAAM,2BAA2B,EAAE,MAAY,CAAC;AAEvD;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,EAAE,MAAc,CAAC;AAExD;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,EAAE,aAAa,CAAC,MAAM,CAAkC,CAAC;AAE7F;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,EAAE,aAAa,CAAC,MAAM,CAAc,CAAC;AAEtE;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,EAAE,aAAa,CAAC,MAAM,CAAmB,CAAC"}