@bluefields/fetcher 0.2.0

package/dist/fetcher-escalating.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Escalating fetcher — smart fetcher-tier escalation.
+ *
+ * Wraps the three fetcher tiers and tries them cheapest-first, escalating only
+ * when a result looks like a JS shell or an anti-bot block. Easy pages stay on
+ * the cheap/fast HTTP tier (1 credit); only hard pages pay for the browser
+ * (3 credits) or unlocker (8 credits) tiers. This lifts coverage on JS-render /
+ * anti-bot pages while keeping blended cost low — and is actually CHEAPER than
+ * the previous default (which went straight to the browser tier whenever
+ * IPROYAL was configured).
+ *
+ * Four-layer rule: this is a Fetcher-layer concern — it only
+ * selects which fetcher to use and returns the winning tier's raw FetchResult
+ * unchanged (its real `fetcherId`), so downstream credit billing charges for
+ * the tier actually used. It does not extract, diff, or notify.
+ *
+ * Tiers are env-gated: the browser (Patchright/IPROYAL) and unlocker (Bright
+ * Data) tiers are built only when their credentials are present, so escalation
+ * is implicitly enabled by configuring those creds. In an env with neither,
+ * this behaves exactly like the plain HTTP fetcher.
+ *
+ * Browser-only requests (page actions or a screenshot) bypass escalation and go
+ * straight to the browser tier — HTTP rejects actions and can't screenshot, and
+ * the unlocker can't run actions.
+ *
+ * NOTE: this classifier is deliberately mirrored by the benchmark suite's
+ * coverage block-detector (same anti-bot fingerprints + thin-body threshold +
+ * empty-SPA-root detection), since the benchmark suite cannot be a dependency
+ * of the fetcher. Keep them in sync. A future refactor could hoist the shared
+ * heuristic into one module both import.
+ */
+import type { FetchResult, FetcherAdapter, WarmableFetcherAdapter } from './types.js';
+/** Live fetch outcome — the live subset of block-detector's FetchOutcome. */
+export type FetchOutcome = 'success' | 'empty_shell' | 'challenge' | 'blocked' | 'login_wall' | 'error';
+/**
+ * Crude visible-text length: strip script/style/comment bodies and tags,
+ * collapse whitespace. An order-of-magnitude "is there a page here?" signal,
+ * not a parse. No deps.
+ */
+export declare function visibleTextLength(html: string): number;
+/**
+ * True when the HTML carries a known SPA mount point (SPA_ROOT_IDS) that is
+ * (near-)empty — a framework shell that rendered no content server-side. This
+ * catches "padded" shells that clear MIN_CONTENT_CHARS on boilerplate alone, so
+ * the escalating fetcher hands them to a browser tier that can hydrate the app.
+ * Cheap string/regex scan, no deps. A false positive only costs one escalation
+ * (the higher tier returns equal-or-better content); a false negative leaves
+ * coverage on the floor — so this errs toward catching shells.
+ */
+export declare function hasEmptySpaRoot(html: string): boolean;
+/**
+ * Classify a fetch result the same way the coverage benchmark does. 404s and
+ * 5xx are `error` (a real response — escalation won't help); 403/429/503 are a
+ * challenge (anti-bot markers) or a hard block; a thin 2xx body is a JS shell;
+ * a padded body whose SPA mount point is empty is also a shell.
+ */
+export declare function classifyFetchResult(r: FetchResult): FetchOutcome;
+/** Outcomes a higher tier might fix. 404s, login walls, and success do NOT escalate. */
+export declare function needsEscalation(o: FetchOutcome): boolean;
+export interface EscalatingFetcherOptions {
+    /** Tier-0 HTTP adapter. Default: createHttpFetcherAdapter(). */
+    tier0?: FetcherAdapter;
+    /** Tier-1 browser adapter (Patchright). Default: tryCreatePatchrightAdapter(env) — may be null. */
+    tier1?: FetcherAdapter | null;
+    /** Tier-2 unlocker adapter (Bright Data). Default: tryCreateBrightDataAdapter(env) — may be null. */
+    tier2?: FetcherAdapter | null;
+    /** Env used to build the default tiers. Default: process.env. */
+    env?: NodeJS.ProcessEnv;
+    /** Tier-0 fast-fail budget (ms). Default: TIER0_FAST_FAIL_MS. */
+    tier0TimeoutMs?: number;
+    /**
+     * P2 hedged escalation (opt-in). When > 0, after a slow tier-0 has run this
+     * long without a good-enough result, tier-1 (browser) is launched IN PARALLEL
+     * rather than waiting the full tier-0 fast-fail — cutting the tail on
+     * slow-shell pages. Default: `HEDGE_TIER1_DELAY_MS` (0 = OFF → pure sequential
+     * escalation, the shipped behavior). Also settable via the
+     * `HEDGE_TIER1_DELAY_MS` env. Coverage-safe by construction (best result kept).
+     */
+    hedgeDelayMs?: number;
+    /** Test seam: clock for the shared deadline. Default: Date.now. */
+    nowMsFn?: () => number;
+}
+/**
+ * Race a tier fetch against a hard wall-clock budget. Some fetch paths (notably
+ * `ssrfSafeFetch`'s undici wrapper) don't honor the AbortSignal during the
+ * connect/headers phase, so an adapter's own timeout can be silently ignored —
+ * the perf benchmark caught a tier-0 fetch running 90s past its 8s budget while
+ * the target slow-rolled its response headers. This guarantees the escalating
+ * fetcher honors the deadline regardless: on expiry it fires `onTimeout` (used to
+ * abort the abandoned tier so it releases resources — e.g. closes a browser) and
+ * rejects so the loop escalates (or breaks). `setTimer` is a test seam.
+ */
+export declare function raceTierBudget<T>(p: Promise<T>, budgetMs: number, onTimeout?: () => void, setTimer?: typeof setTimeout): Promise<T>;
+/**
+ * Build an escalating fetcher. Tries tier-0 (HTTP) first and escalates to the
+ * browser then unlocker tiers only when the result is a shell/challenge/block.
+ * Returns the winning tier's FetchResult unchanged (real `fetcherId`, so the
+ * route bills for the tier actually used).
+ */
+export declare function createEscalatingFetcherAdapter(opts?: EscalatingFetcherOptions): WarmableFetcherAdapter;

package/dist/fetcher-escalating.js

@@ -0,0 +1,489 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+/**
+ * Escalating fetcher — smart fetcher-tier escalation.
+ *
+ * Wraps the three fetcher tiers and tries them cheapest-first, escalating only
+ * when a result looks like a JS shell or an anti-bot block. Easy pages stay on
+ * the cheap/fast HTTP tier (1 credit); only hard pages pay for the browser
+ * (3 credits) or unlocker (8 credits) tiers. This lifts coverage on JS-render /
+ * anti-bot pages while keeping blended cost low — and is actually CHEAPER than
+ * the previous default (which went straight to the browser tier whenever
+ * IPROYAL was configured).
+ *
+ * Four-layer rule: this is a Fetcher-layer concern — it only
+ * selects which fetcher to use and returns the winning tier's raw FetchResult
+ * unchanged (its real `fetcherId`), so downstream credit billing charges for
+ * the tier actually used. It does not extract, diff, or notify.
+ *
+ * Tiers are env-gated: the browser (Patchright/IPROYAL) and unlocker (Bright
+ * Data) tiers are built only when their credentials are present, so escalation
+ * is implicitly enabled by configuring those creds. In an env with neither,
+ * this behaves exactly like the plain HTTP fetcher.
+ *
+ * Browser-only requests (page actions or a screenshot) bypass escalation and go
+ * straight to the browser tier — HTTP rejects actions and can't screenshot, and
+ * the unlocker can't run actions.
+ *
+ * NOTE: this classifier is deliberately mirrored by the benchmark suite's
+ * coverage block-detector (same anti-bot fingerprints + thin-body threshold +
+ * empty-SPA-root detection), since the benchmark suite cannot be a dependency
+ * of the fetcher. Keep them in sync. A future refactor could hoist the shared
+ * heuristic into one module both import.
+ */
+import { createLayerLogger, envInt } from '@bluefields/primitives';
+import { tryCreateBrightDataAdapter } from './fetcher-brightdata.js';
+import { createHttpFetcherAdapter } from './fetcher-http.js';
+import { tryCreatePatchrightAdapter } from './fetcher-patchright.js';
+const log = createLayerLogger('fetcher');
+/** Below this many chars of *visible* text, a 2xx body is a JS shell, not content. */
+const MIN_CONTENT_CHARS = 500;
+/**
+ * Canonical SPA mount-point ids. When one of these containers is present but
+ * (near-)empty, the 2xx body is a framework shell whose real content renders
+ * client-side — even when the page is padded with enough boilerplate (nav,
+ * footer, <noscript>, cookie banner) to clear MIN_CONTENT_CHARS. The list is
+ * deliberately tight (well-known mount points only) so static pages that merely
+ * happen to use one of these ids with real content are not flagged.
+ */
+const SPA_ROOT_IDS = [
+    'root',
+    '__next',
+    '__nuxt',
+    'app',
+    'application',
+    'gatsby-focus-wrapper',
+];
+/** A known SPA root with fewer than this many chars of *visible* inner text is "empty". */
+const ROOT_EMPTY_CHARS = 64;
+/**
+ * Cap the inner-HTML scan for a root container. If the matching close tag isn't
+ * found within this many chars, the container is large (so it has content and is
+ * not a shell) — and the cap keeps a pathological page from stalling the
+ * classifier.
+ */
+const ROOT_SCAN_WINDOW = 20_000;
+/** Anti-bot interstitial fingerprints (lowercased substring match). */
+const CHALLENGE_MARKERS = [
+    'just a moment',
+    'checking your browser',
+    'cf-browser-verification',
+    'cf_chl_opt',
+    'attention required! | cloudflare',
+    'enable javascript and cookies to continue',
+    'datadome',
+    'px-captcha',
+    'captcha-delivery.com',
+    '_imperva_',
+    'are you a robot',
+    'verify you are human',
+];
+/** Login / auth-wall fingerprints (decisive only when the page is also thin). */
+const LOGIN_MARKERS = [
+    'sign in to continue',
+    'please log in',
+    'log in to continue',
+    'you must be logged in',
+    'join linkedin',
+    'log in to linkedin',
+    'sign in to linkedin',
+    'log into facebook',
+    'log in to instagram',
+];
+/** Outcome rank — higher = closer to a real page; used to keep the best result. */
+const OUTCOME_RANK = {
+    success: 7,
+    empty_shell: 5,
+    login_wall: 4,
+    challenge: 3,
+    blocked: 2,
+    error: 0,
+};
+/**
+ * Crude visible-text length: strip script/style/comment bodies and tags,
+ * collapse whitespace. An order-of-magnitude "is there a page here?" signal,
+ * not a parse. No deps.
+ */
+export function visibleTextLength(html) {
+    return html
+        .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, ' ')
+        .replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, ' ')
+        .replace(/<!--[\s\S]*?-->/g, ' ')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/&nbsp;/gi, ' ')
+        .replace(/\s+/g, ' ')
+        .trim().length;
+}
+/**
+ * Inner HTML of an element of `tag` whose content starts at `innerStart`, found
+ * by depth-matching open/close tags of the same name. Returns null when the
+ * matching close isn't reached within ROOT_SCAN_WINDOW chars — i.e. the
+ * container is large, so it has content (not a shell). Script/style/comment
+ * bodies are stripped first so `<div>`-like strings inside them don't skew the
+ * depth count. No DOM parser (stdlib only); self-closing roots (not
+ * valid HTML for div/main/section) are not handled — they read as "has content".
+ */
+function extractRootInnerHtml(html, tag, innerStart) {
+    const slice = html
+        .slice(innerStart, innerStart + ROOT_SCAN_WINDOW)
+        .replace(/<script\b[^>]*>[\s\S]*?<\/script>/gi, ' ')
+        .replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, ' ')
+        .replace(/<!--[\s\S]*?-->/g, ' ');
+    // tag comes from a [a-z][a-z0-9]* capture, so it carries no regex metachars.
+    const tagRe = new RegExp(`<(/?)${tag}\\b`, 'gi');
+    let depth = 1;
+    let m = tagRe.exec(slice);
+    while (m !== null) {
+        if (m[1] === '/') {
+            depth -= 1;
+            if (depth === 0)
+                return slice.slice(0, m.index);
+        }
+        else {
+            depth += 1;
+        }
+        m = tagRe.exec(slice);
+    }
+    return null;
+}
+/**
+ * True when the HTML carries a known SPA mount point (SPA_ROOT_IDS) that is
+ * (near-)empty — a framework shell that rendered no content server-side. This
+ * catches "padded" shells that clear MIN_CONTENT_CHARS on boilerplate alone, so
+ * the escalating fetcher hands them to a browser tier that can hydrate the app.
+ * Cheap string/regex scan, no deps. A false positive only costs one escalation
+ * (the higher tier returns equal-or-better content); a false negative leaves
+ * coverage on the floor — so this errs toward catching shells.
+ */
+export function hasEmptySpaRoot(html) {
+    const idAlternation = SPA_ROOT_IDS.join('|');
+    const openRe = new RegExp(`<([a-z][a-z0-9]*)\\b[^>]*\\bid\\s*=\\s*["'](?:${idAlternation})["'][^>]*>`, 'gi');
+    let m = openRe.exec(html);
+    while (m !== null) {
+        const tag = m[1]?.toLowerCase();
+        if (tag) {
+            const inner = extractRootInnerHtml(html, tag, m.index + m[0].length);
+            // inner === null → container too large to be a shell (has content).
+            if (inner !== null && visibleTextLength(inner) < ROOT_EMPTY_CHARS)
+                return true;
+        }
+        m = openRe.exec(html);
+    }
+    return false;
+}
+/**
+ * Classify a fetch result the same way the coverage benchmark does. 404s and
+ * 5xx are `error` (a real response — escalation won't help); 403/429/503 are a
+ * challenge (anti-bot markers) or a hard block; a thin 2xx body is a JS shell;
+ * a padded body whose SPA mount point is empty is also a shell.
+ */
+export function classifyFetchResult(r) {
+    const status = r.responseStatus;
+    const bodyLower = r.html.toLowerCase();
+    const isChallenge = CHALLENGE_MARKERS.some((m) => bodyLower.includes(m));
+    if (status === 401)
+        return 'login_wall';
+    if (status === 403 || status === 429 || status === 503) {
+        return isChallenge ? 'challenge' : 'blocked';
+    }
+    if (status >= 400)
+        return 'error'; // 404 / 5xx — a real response, not escalation-worthy
+    const textLen = visibleTextLength(r.html);
+    if (isChallenge && textLen < MIN_CONTENT_CHARS)
+        return 'challenge';
+    const looksLikeLogin = LOGIN_MARKERS.some((m) => bodyLower.includes(m));
+    if (looksLikeLogin && textLen < MIN_CONTENT_CHARS)
+        return 'login_wall';
+    if (textLen < MIN_CONTENT_CHARS)
+        return 'empty_shell';
+    // Padded shell: boilerplate clears the thin-body threshold, but the SPA mount
+    // point is empty — real content never rendered server-side. Escalate so a
+    // browser tier can hydrate it.
+    if (hasEmptySpaRoot(r.html))
+        return 'empty_shell';
+    return 'success';
+}
+/** Outcomes a higher tier might fix. 404s, login walls, and success do NOT escalate. */
+export function needsEscalation(o) {
+    return o === 'empty_shell' || o === 'challenge' || o === 'blocked';
+}
+/**
+ * Tier-0 (HTTP) fast-fail budget. A slow/dead static fetch escalates to the
+ * browser tier after this long instead of burning the whole request budget
+ * before tier-1 even starts — the #1 tail-latency cause (FETCH_PERF_PROPOSAL P0).
+ * Healthy HTTP returns well under this, so easy pages are unaffected.
+ *
+ * Perf round (L2): lowered 8s → 5s and made it env-overridable via
+ * `BLUEFIELDS_TIER0_FAST_FAIL_MS` (or per-call `opts.tier0TimeoutMs`). Coverage-safe:
+ * abandoning a slow tier-0 only ESCALATES it to the browser (which returns
+ * equal-or-better content), never drops coverage — so the only cost is one extra
+ * escalation for a page that genuinely takes 5–8s on tier-0. With L1 now escalating
+ * detectable blocks at time-to-headers, the 5–8s band is dominated by slow-doomed
+ * fetches, not valid slow-static pages. The fixture harness shows p95 11000→9300ms
+ * with coverage held at the floor; confirm on real-traffic tier-0 latencies before
+ * relying on 5s in prod (set the env back to 8000 to revert instantly).
+ */
+const TIER0_FAST_FAIL_MS = 5_000;
+/** Overall request budget assumed when the caller passes no `timeoutMs`. */
+const DEFAULT_REQUEST_TIMEOUT_MS = 60_000;
+/**
+ * Race a tier fetch against a hard wall-clock budget. Some fetch paths (notably
+ * `ssrfSafeFetch`'s undici wrapper) don't honor the AbortSignal during the
+ * connect/headers phase, so an adapter's own timeout can be silently ignored —
+ * the perf benchmark caught a tier-0 fetch running 90s past its 8s budget while
+ * the target slow-rolled its response headers. This guarantees the escalating
+ * fetcher honors the deadline regardless: on expiry it fires `onTimeout` (used to
+ * abort the abandoned tier so it releases resources — e.g. closes a browser) and
+ * rejects so the loop escalates (or breaks). `setTimer` is a test seam.
+ */
+export function raceTierBudget(p, budgetMs, onTimeout, setTimer = setTimeout) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimer(() => {
+            onTimeout?.();
+            reject(new Error(`tier fetch exceeded ${budgetMs}ms budget`));
+        }, budgetMs);
+        p.then((v) => {
+            clearTimeout(timer);
+            resolve(v);
+        }, (e) => {
+            clearTimeout(timer);
+            reject(e);
+        });
+    });
+}
+/**
+ * Default hedge delay (ms) for P2 hedged escalation. 0 = OFF — pure sequential
+ * escalation, the shipped behavior. Overridden per-call by `hedgeDelayMs` or
+ * process-wide by the `HEDGE_TIER1_DELAY_MS` env.
+ */
+const HEDGE_TIER1_DELAY_MS = 0;
+/** Promise-based delay — the hedge timer. */
+function delayMs(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** A stage produced a good-enough result (a real page, not a shell/challenge/block). */
+function isGoodEnough(o) {
+    return o !== null && 'outcome' in o && !needsEscalation(o.outcome);
+}
+/**
+ * Resolve as soon as one stage returns a good-enough result (not a
+ * shell/challenge/block), aborting the losers; otherwise wait for all stages and
+ * return the best by `OUTCOME_RANK`. This mirrors the sequential loop's "stop
+ * when the best is good enough" rule, so a hedged race never yields lower
+ * coverage than the sequential ladder. Stages are pre-wrapped to never reject
+ * (`{error}`), but a rejection is tolerated defensively.
+ */
+function firstSuccessOrBest(stages) {
+    return new Promise((resolve) => {
+        if (stages.length === 0) {
+            resolve({ best: null, lastError: undefined });
+            return;
+        }
+        let remaining = stages.length;
+        let best = null;
+        let lastError;
+        let done = false;
+        const settle = () => {
+            if (!done) {
+                done = true;
+                resolve({ best, lastError });
+            }
+        };
+        for (const s of stages) {
+            s.p.then((res) => {
+                if (done)
+                    return;
+                remaining -= 1;
+                if ('error' in res) {
+                    lastError = res.error;
+                }
+                else if (!('skipped' in res)) {
+                    if (!best || OUTCOME_RANK[res.outcome] > OUTCOME_RANK[best.outcome])
+                        best = res;
+                    if (!needsEscalation(res.outcome)) {
+                        // Good enough — take it and abandon the losers.
+                        for (const other of stages)
+                            if (other !== s)
+                                other.abort.abort();
+                        settle();
+                        return;
+                    }
+                }
+                if (remaining === 0)
+                    settle();
+            }, (err) => {
+                if (done)
+                    return;
+                remaining -= 1;
+                lastError = err;
+                if (remaining === 0)
+                    settle();
+            });
+        }
+    });
+}
+/**
+ * Build an escalating fetcher. Tries tier-0 (HTTP) first and escalates to the
+ * browser then unlocker tiers only when the result is a shell/challenge/block.
+ * Returns the winning tier's FetchResult unchanged (real `fetcherId`, so the
+ * route bills for the tier actually used).
+ */
+export function createEscalatingFetcherAdapter(opts = {}) {
+    const env = opts.env ?? process.env;
+    const tier0 = opts.tier0 ?? createHttpFetcherAdapter();
+    const tier1 = opts.tier1 !== undefined ? opts.tier1 : tryCreatePatchrightAdapter(env);
+    const tier2 = opts.tier2 !== undefined ? opts.tier2 : tryCreateBrightDataAdapter(env);
+    const tier0FastFailMs = opts.tier0TimeoutMs ?? envInt('BLUEFIELDS_TIER0_FAST_FAIL_MS', TIER0_FAST_FAIL_MS);
+    const now = opts.nowMsFn ?? Date.now;
+    // P2 hedged escalation delay: option wins, else env, else OFF. NaN/≤0 → OFF.
+    const hedgeDelayMs = (() => {
+        const v = opts.hedgeDelayMs ?? Number(env.HEDGE_TIER1_DELAY_MS ?? HEDGE_TIER1_DELAY_MS);
+        return Number.isFinite(v) && v > 0 ? v : 0;
+    })();
+    const ladder = [{ adapter: tier0, tier: 0 }];
+    if (tier1)
+        ladder.push({ adapter: tier1, tier: 1 });
+    if (tier2)
+        ladder.push({ adapter: tier2, tier: 2 });
+    return {
+        /**
+         * L4: pre-warm the browser tier's pool at boot so the first escalating fetch that
+         * hits tier-1 doesn't pay the cold Chromium launch. Best-effort; no-op when tier-1
+         * has no pool (PATCHRIGHT_POOL unset) or no browser tier is configured. Call once at
+         * app boot, fire-and-forget (`void fetcher.warmUp?.()` after construction).
+         */
+        async warmUp() {
+            await tier1?.warmUp?.();
+        },
+        async fetch(url, options) {
+            // Page actions + screenshots require the browser tier; HTTP rejects
+            // actions and can't screenshot, and the unlocker can't run actions.
+            // Falling back to tier-0 preserves today's behavior when no browser tier
+            // is configured (HTTP throws on actions / returns a null screenshot).
+            const needsBrowser = (options?.actions?.length ?? 0) > 0 || options?.captureScreenshot === true;
+            if (needsBrowser) {
+                return (tier1 ?? tier0).fetch(url, options);
+            }
+            let best = null;
+            let lastError = null;
+            // Shared, decrementing deadline across the ladder so worst-case wall-clock
+            // ≈ the request budget, NOT the sum of per-tier timeouts (FETCH_PERF_PROPOSAL
+            // P0). Tier-0 additionally fast-fails so a dead static fetch escalates
+            // quickly; later tiers get whatever budget remains.
+            const deadlineMs = now() + (options?.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS);
+            // Run one tier with its budget under a hard wall-clock bound (independent of
+            // the abort signal, which some fetch paths ignore) so one slow tier can't
+            // eat the whole budget. On expiry / abandonment we abort the tier so it
+            // frees resources (the browser tier closes its context; HTTP/unlocker
+            // ignore it). The __fullRender hint renders SPA shells in browser tiers
+            // when the customer gave no waitFor. These internal fields are NOT part of
+            // the public FetchOptions contract.
+            const runStage = async (adapter, tier, budgetMs, abort) => {
+                const tierOptions = {
+                    ...(options ?? {}),
+                    timeoutMs: budgetMs,
+                    __abortSignal: abort.signal,
+                    // L1: only tier-0 opts into early-block escalation (skip draining a doomed
+                    // 403/429/503 body). Tiers 1/2 ignore the flag; a standalone HTTP caller
+                    // never sets it. Coverage-safe — see internal-options.ts / classifyFetchResult.
+                    ...(tier === 0 ? { __earlyClassify: true } : {}),
+                    ...(tier > 0 && !options?.waitFor ? { __fullRender: true } : {}),
+                };
+                const result = await raceTierBudget(adapter.fetch(url, tierOptions), budgetMs, () => abort.abort());
+                return { result, outcome: classifyFetchResult(result), tier };
+            };
+            if (hedgeDelayMs > 0 && tier1) {
+                // ── P2 hedged escalation ──────────────────────────────────────────────
+                // Launch tier-1 in parallel with a slow tier-0 instead of waiting the
+                // full tier-0 fast-fail. Eligible only when both tiers exist (browser-only
+                // requests already returned above). Coverage-safe: firstSuccessOrBest
+                // keeps the best result and mirrors the sequential "stop when good enough"
+                // rule, so coverage ≥ the sequential ladder.
+                const t0Budget = Math.min(deadlineMs - now(), tier0FastFailMs);
+                const t0Abort = new AbortController();
+                let t0Settled = null;
+                const p0 = runStage(tier0, 0, t0Budget, t0Abort).then((s) => {
+                    t0Settled = s;
+                    return s;
+                }, (e) => {
+                    const r = { error: e };
+                    t0Settled = r;
+                    return r;
+                });
+                const t1Abort = new AbortController();
+                const p1 = (async () => {
+                    // Start tier-1 on the earlier of: tier-0 settling, or the hedge delay.
+                    await Promise.race([p0, delayMs(hedgeDelayMs)]);
+                    // If tier-0 already produced a good-enough result, don't spend tier-1.
+                    if (isGoodEnough(t0Settled)) {
+                        return { skipped: true };
+                    }
+                    const rem = deadlineMs - now();
+                    if (rem <= 0)
+                        return { skipped: true };
+                    return runStage(tier1, 1, rem, t1Abort).catch((e) => ({ error: e }));
+                })();
+                const picked = await firstSuccessOrBest([
+                    { p: p0, abort: t0Abort },
+                    { p: p1, abort: t1Abort },
+                ]);
+                best = picked.best;
+                if (picked.lastError !== undefined)
+                    lastError = picked.lastError;
+                // Tier-2 sequentially if tier-0/tier-1 didn't satisfy and budget remains.
+                if ((!best || needsEscalation(best.outcome)) && tier2) {
+                    const rem = deadlineMs - now();
+                    if (rem > 0) {
+                        try {
+                            const staged = await runStage(tier2, 2, rem, new AbortController());
+                            if (!best || OUTCOME_RANK[staged.outcome] > OUTCOME_RANK[best.outcome])
+                                best = staged;
+                        }
+                        catch (err) {
+                            lastError = err;
+                        }
+                    }
+                }
+            }
+            else {
+                // ── Sequential ladder (shipped default) ───────────────────────────────
+                for (const { adapter, tier } of ladder) {
+                    // Stop once the best result so far is good enough (not a shell/block).
+                    if (best && !needsEscalation(best.outcome))
+                        break;
+                    const remainingMs = deadlineMs - now();
+                    if (remainingMs <= 0)
+                        break; // shared budget exhausted — honor the deadline
+                    // Tier-0 fast-fails ONLY when there's a higher tier to escalate to. If tier-0 is
+                    // the only tier (HTTP-only deployment — no browser/unlocker configured), capping it
+                    // would needlessly abandon a slow-but-valid static page with nowhere to go and then
+                    // throw. Give it the full remaining deadline instead. (Adversarial-review fix: this
+                    // closes the HTTP-only 5–8s cliff that lowering the fast-fail to 5s would widen.)
+                    const hasHigherTier = ladder.length > 1;
+                    const tierTimeoutMs = tier === 0 && hasHigherTier ? Math.min(remainingMs, tier0FastFailMs) : remainingMs;
+                    try {
+                        const staged = await runStage(adapter, tier, tierTimeoutMs, new AbortController());
+                        if (!best || OUTCOME_RANK[staged.outcome] > OUTCOME_RANK[best.outcome])
+                            best = staged;
+                    }
+                    catch (err) {
+                        // Transport throw (DNS/TLS/socket/timeout): try the next tier (a
+                        // different network path may succeed). Keep it in case all fail.
+                        lastError = err;
+                    }
+                }
+            }
+            if (best) {
+                if (best.tier > 0) {
+                    log.debug({
+                        winning_tier: best.tier,
+                        outcome: best.outcome,
+                        fetcher_id: best.result.fetcherId,
+                    }, 'fetch escalated to a higher tier');
+                }
+                return best.result;
+            }
+            throw lastError ?? new Error('escalating fetcher: no tier produced a result');
+        },
+    };
+}
+//# sourceMappingURL=fetcher-escalating.js.map

package/dist/fetcher-escalating.js.map

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