@omnicross/core 0.1.10 → 0.2.1

package/dist/search/http.cjs

@@ -0,0 +1,37 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkHL2YSPL7cjs = require('../chunk-HL2YSPL7.cjs');
+require('../chunk-7RJI3NDI.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_MAX_RESULTS = _chunkHL2YSPL7cjs.DEFAULT_MAX_RESULTS; exports.DEFAULT_SEARCH_TIMEOUT_MS = _chunkHL2YSPL7cjs.DEFAULT_SEARCH_TIMEOUT_MS; exports.HTTP_BING_PROVIDER_ID = _chunkHL2YSPL7cjs.HTTP_BING_PROVIDER_ID; exports.HTTP_DUCKDUCKGO_PROVIDER_ID = _chunkHL2YSPL7cjs.HTTP_DUCKDUCKGO_PROVIDER_ID; exports.HTTP_SEARCH_CAPABILITIES = _chunkHL2YSPL7cjs.HTTP_SEARCH_CAPABILITIES; exports.HttpBingProvider = _chunkHL2YSPL7cjs.HttpBingProvider; exports.HttpDuckDuckGoProvider = _chunkHL2YSPL7cjs.HttpDuckDuckGoProvider; exports.MAX_REDIRECTS = _chunkHL2YSPL7cjs.MAX_REDIRECTS; exports.MAX_RESULTS = _chunkHL2YSPL7cjs.MAX_RESULTS; exports.SEARCH_BROWSER_HEADERS = _chunkHL2YSPL7cjs.SEARCH_BROWSER_HEADERS; exports.SEARCH_HTTP_TRANSPORT_ID = _chunkHL2YSPL7cjs.SEARCH_HTTP_TRANSPORT_ID; exports.SEARCH_RESPONSE_BYTES = _chunkHL2YSPL7cjs.SEARCH_RESPONSE_BYTES; exports.builtinHttpSearchContributions = _chunkHL2YSPL7cjs.builtinHttpSearchContributions; exports.clampMaxResults = _chunkHL2YSPL7cjs.clampMaxResults; exports.createSearchHttpTransport = _chunkHL2YSPL7cjs.createSearchHttpTransport; exports.defaultSearchHttpTransport = _chunkHL2YSPL7cjs.defaultSearchHttpTransport;

package/dist/search/http.d.cts

@@ -0,0 +1,269 @@
+import { SearchProviderId, SearchResult, SearchProviderCapabilities, SearchProviderContribution, SearchProvider, SearchOptions } from '@omnicross/contracts/search-types';
+import { S as SearchEgressPolicy } from '../egress-I46O_p5L.cjs';
+import { P as ProxyEnvironment } from '../proxy-UZTtjPZx.cjs';
+import 'node:dns';
+import 'undici';
+
+/**
+ * Shared vocabulary for the keyless HTTP search slice (plan 阶段2).
+ *
+ * Everything here is transport- and parser-neutral so the providers, the
+ * shared transport, and the doctor can agree on one set of names without
+ * importing each other.
+ *
+ * @module search/http/types
+ */
+
+/**
+ * The transport identity stamped on every failure this slice throws.
+ *
+ * Phase 1 ships exactly one transport. `impit` (Elftia's browser-fingerprint
+ * client) is deliberately NOT introduced here — the injection seam below is the
+ * whole extent of future-proofing, so an alternative transport can never become
+ * an implicit behavior change.
+ */
+declare const SEARCH_HTTP_TRANSPORT_ID = "undici";
+/**
+ * Which phase of a search failed (plan §11.4 — transport identity and failure
+ * stage must be observable).
+ *
+ * - `connect` — the request never produced a response (DNS, TCP, TLS).
+ * - `fetch` — a response arrived but is unusable (refused status, deadline).
+ * - `redirect` — the redirect chain exceeded its cap.
+ * - `body-cap` — the response body outgrew its byte cap mid-stream.
+ * - `challenge` — the engine served a bot challenge instead of a SERP.
+ * - `trust` — the page parsed, but the anti-decoy check refused it.
+ * - `parse` — the page is not recognizable as this engine's SERP.
+ */
+type SearchHttpStage = 'connect' | 'fetch' | 'redirect' | 'body-cap' | 'challenge' | 'trust' | 'parse';
+/** One fetched search page. */
+interface SearchHttpResource {
+    /** The URL the response was finally served from (after redirects). */
+    finalUrl: string;
+    /** HTTP status of the final response. */
+    status: number;
+    /** `content-type` header value, or `''`. */
+    contentType: string;
+    /** Decoded response body. */
+    rawText: string;
+}
+/** What the transport needs to execute one attempt. */
+interface SearchHttpRequest {
+    /** Hard budget for this single attempt, in milliseconds. */
+    timeoutMs: number;
+    /** Byte cap enforced while the body streams in. */
+    maxResponseBytes: number;
+    /** Caller cancellation. Aborting surfaces as code `cancelled`, never `timeout`. */
+    signal?: AbortSignal;
+    /** Stamped onto thrown errors so a failure names its provider. */
+    providerId?: SearchProviderId;
+}
+/**
+ * The seam both providers accept in their constructor.
+ *
+ * This is the test seam (fixtures are served through it) and the seam a future
+ * alternative transport would occupy.
+ */
+type SearchHttpTransport = (url: string, request: SearchHttpRequest) => Promise<SearchHttpResource>;
+/**
+ * The low-level fetch primitive the shared transport drives — undici's `fetch`
+ * by default. Separate from {@link SearchHttpTransport} so redirect, body-cap
+ * and header behavior can be unit-tested without a network.
+ */
+type SearchHttpFetch = (url: string, init: RequestInit) => Promise<Response>;
+/** The outcome of running one engine's parser over one page. */
+interface ParsedSerp {
+    /**
+     * Whether the page is structurally recognizable as this engine's SERP.
+     *
+     * This is what separates "the engine found nothing" (recognized, zero
+     * results → `[]`) from "the engine's markup changed under us" (unrecognized
+     * → `parse_failed`).
+     */
+    recognized: boolean;
+    /** Usable organic results, already clamped to the caller's `maxResults`. */
+    results: SearchResult[];
+}
+
+/**
+ * The builtin HTTP search contributions.
+ *
+ * Everything the registry must not infer is declared here: `source` and `kind`
+ * are stated, never derived from the id's spelling, and the capability set is
+ * explicit down to the options these engines do NOT honor.
+ *
+ * `priorityHint` is deliberately absent. Provider ordering is the orchestrator's
+ * decision (阶段3); encoding a preference here would recreate exactly the
+ * scattered-fallback-order problem the extraction exists to remove.
+ *
+ * @module search/http/contributions
+ */
+
+/**
+ * What both keyless HTTP engines can do.
+ *
+ * `supportsRegion` / `supportsLanguage` / `supportsTimeRange` are false because
+ * the scraped endpoints never honored those options; per the contract, a
+ * provider ignores an option it does not declare rather than failing.
+ */
+declare const HTTP_SEARCH_CAPABILITIES: Readonly<SearchProviderCapabilities>;
+/**
+ * Both builtin HTTP providers, ready to hand to a registry.
+ *
+ * @param transport - optional shared transport for both providers (tests, or a
+ *   future alternative client). Omit for the production undici transport.
+ */
+declare function builtinHttpSearchContributions(transport?: SearchHttpTransport): SearchProviderContribution[];
+
+/**
+ * The candidate-URL walk both HTTP providers share.
+ *
+ * Mirrors the baselined `searchWebViaFetch` loop (one shared deadline, split
+ * evenly across the remaining candidates, last error retained) with one
+ * plan-mandated behavior change: the three-way outcome distinction.
+ *
+ * Elftia collapses "the engine found nothing" and "the engine's markup changed"
+ * into a single `response contained no result entries` error. Here they are
+ * different answers:
+ *
+ * - a recognized SERP with zero organic results → `[]` (a legitimate answer);
+ * - an unrecognizable page → `parse_failed` (the parser-drift alarm);
+ * - a challenge or decoy page → a `challenge`/`trust` staged failure, checked
+ *   before either of the above.
+ *
+ * The divergence is deliberate (plan §11.4) and is recorded for 阶段5's
+ * behavior-comparison report as an allowed difference.
+ *
+ * @module search/http/engine
+ */
+
+/** Response byte cap at the search call sites (the fetch layer allows 5 MiB). */
+declare const SEARCH_RESPONSE_BYTES: number;
+/** Default budget for one whole search, across all its candidate URLs. */
+declare const DEFAULT_SEARCH_TIMEOUT_MS = 15000;
+/** `maxResults` clamp: [1, 10], defaulting to 5. */
+declare const DEFAULT_MAX_RESULTS = 5;
+declare const MAX_RESULTS = 10;
+/**
+ * Clamp a caller's `maxResults` into the engine-supported range.
+ *
+ * `NaN` passes through to `slice(0, NaN)` and yields `[]`, exactly as the
+ * baseline does. Left at parity deliberately: normalizing pathological option
+ * values belongs to the runtime that owns option handling (阶段3), not to two
+ * providers that would then disagree with every other one.
+ */
+declare function clampMaxResults(maxResults: number | undefined): number;
+
+/**
+ * The browser navigation header profile the search transport sends.
+ *
+ * This is the profile `packages/core/test-fixtures/http-search/` was captured
+ * with, so changing it invalidates the fixtures as live-behavior evidence.
+ *
+ * Ported from Elftia's `webFetchHttp.browserHeaders()` with ONE deliberate
+ * difference: the Chrome version is PINNED here instead of read from
+ * `process.versions.chrome`. Elftia runs inside Electron and inherits a real
+ * Chromium version; `@omnicross/core` runs in plain Node, where that field is
+ * absent — pinning keeps the sent profile identical across every host and
+ * matches the spec's "pinned Chrome desktop User-Agent".
+ *
+ * @module search/http/headers
+ */
+/** The exact header set sent with every search request. */
+declare const SEARCH_BROWSER_HEADERS: Readonly<Record<string, string>>;
+
+/**
+ * `http-bing` — keyless Bing search over the shared HTTP transport.
+ *
+ * Standalone by construction: `new HttpBingProvider()` works with no config, no
+ * registry and no host. Nothing in Phase 1 阶段2 registers or calls it — that is
+ * 阶段3's job.
+ *
+ * @module search/http/HttpBingProvider
+ */
+
+/** The id this provider registers under. */
+declare const HTTP_BING_PROVIDER_ID = "http-bing";
+declare class HttpBingProvider implements SearchProvider {
+    readonly id: SearchProviderId;
+    private readonly transport;
+    constructor(transport?: SearchHttpTransport);
+    search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+}
+
+/**
+ * `http-duckduckgo` — keyless DuckDuckGo search over the shared HTTP transport.
+ *
+ * Two candidate endpoints, tried in order under one shared deadline: the html
+ * endpoint first, then the lite endpoint. The lite endpoint is reached only when
+ * the html one produced no usable results (or failed outright) — the baselined
+ * behavior.
+ *
+ * @module search/http/HttpDuckDuckGoProvider
+ */
+
+/** The id this provider registers under. */
+declare const HTTP_DUCKDUCKGO_PROVIDER_ID = "http-duckduckgo";
+declare class HttpDuckDuckGoProvider implements SearchProvider {
+    readonly id: SearchProviderId;
+    private readonly transport;
+    constructor(transport?: SearchHttpTransport);
+    search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+}
+
+/**
+ * The shared HTTP transport both keyless search providers run on.
+ *
+ * Ported from Elftia's `webFetchHttp.fetchWebResource` + `nodeWebFetchTransport`
+ * (baselined in `docs/design/search-baseline/elftia-search-baseline.md` §3.3),
+ * with the failure channel replaced: instead of bare `Error` strings, every
+ * failure is a `SearchProviderError` carrying `details.transport` and
+ * `details.stage`.
+ *
+ * Fixed semantics:
+ * - undici `fetch`, with an `EnvHttpProxyAgent` dispatcher when the environment
+ *   configures a proxy (cached per proxy signature).
+ * - The pinned browser navigation header profile (see `./headers`).
+ * - `redirect: 'manual'`, at most {@link MAX_REDIRECTS} hops, with the initial
+ *   URL and every hop target checked against the search egress policy
+ *   (`../egress`). These two engines are fixed-host and keyless, so nothing an
+ *   attacker controls picks the URL — but a redirect target is upstream input,
+ *   and this is the seam 阶段2 identified and 阶段4 fills. The default policy
+ *   permits every public host, so the fixed engines and the live `cn.bing.com`
+ *   geo-redirect are unaffected.
+ * - A byte cap enforced WHILE the body streams — an oversized page fails, it is
+ *   never silently truncated (this diverges from Elftia, which truncates and
+ *   parses the fragment; the spec requires a `body-cap` failure).
+ * - One deadline per attempt; caller aborts surface as `cancelled`, the deadline
+ *   as `timeout`, never conflated.
+ * - Compression is undici's business: it negotiates `Accept-Encoding` and
+ *   decodes the response.
+ *
+ * `impit` is NOT used. undici is the sole Phase-1 transport; the injection seam
+ * below is the only future-proofing.
+ *
+ * @module search/http/transport
+ */
+
+/** Redirect hop cap. */
+declare const MAX_REDIRECTS = 5;
+/** Knobs for {@link createSearchHttpTransport}. */
+interface SearchHttpTransportOptions {
+    /** The fetch primitive to drive. Defaults to undici's `fetch`. */
+    fetch?: SearchHttpFetch;
+    /** Environment to read proxy variables from. Defaults to `process.env`. */
+    env?: ProxyEnvironment;
+    /** Redirect hop cap. Defaults to {@link MAX_REDIRECTS}. */
+    maxRedirects?: number;
+    /**
+     * Egress policy for the initial URL and every redirect hop. Defaults to
+     * public-only, which is all these fixed-host engines ever need.
+     */
+    egressPolicy?: SearchEgressPolicy;
+}
+/** Build a transport. Tests inject `fetch`; production takes the default. */
+declare function createSearchHttpTransport(options?: SearchHttpTransportOptions): SearchHttpTransport;
+/** The production transport: undici, reading proxy settings from `process.env`. */
+declare const defaultSearchHttpTransport: SearchHttpTransport;
+
+export { DEFAULT_MAX_RESULTS, DEFAULT_SEARCH_TIMEOUT_MS, HTTP_BING_PROVIDER_ID, HTTP_DUCKDUCKGO_PROVIDER_ID, HTTP_SEARCH_CAPABILITIES, HttpBingProvider, HttpDuckDuckGoProvider, MAX_REDIRECTS, MAX_RESULTS, type ParsedSerp, SEARCH_BROWSER_HEADERS, SEARCH_HTTP_TRANSPORT_ID, SEARCH_RESPONSE_BYTES, type SearchHttpFetch, type SearchHttpRequest, type SearchHttpResource, type SearchHttpStage, type SearchHttpTransport, type SearchHttpTransportOptions, builtinHttpSearchContributions, clampMaxResults, createSearchHttpTransport, defaultSearchHttpTransport };

package/dist/search/http.d.ts

@@ -0,0 +1,269 @@
+import { SearchProviderId, SearchResult, SearchProviderCapabilities, SearchProviderContribution, SearchProvider, SearchOptions } from '@omnicross/contracts/search-types';
+import { S as SearchEgressPolicy } from '../egress-I46O_p5L.js';
+import { P as ProxyEnvironment } from '../proxy-UZTtjPZx.js';
+import 'node:dns';
+import 'undici';
+
+/**
+ * Shared vocabulary for the keyless HTTP search slice (plan 阶段2).
+ *
+ * Everything here is transport- and parser-neutral so the providers, the
+ * shared transport, and the doctor can agree on one set of names without
+ * importing each other.
+ *
+ * @module search/http/types
+ */
+
+/**
+ * The transport identity stamped on every failure this slice throws.
+ *
+ * Phase 1 ships exactly one transport. `impit` (Elftia's browser-fingerprint
+ * client) is deliberately NOT introduced here — the injection seam below is the
+ * whole extent of future-proofing, so an alternative transport can never become
+ * an implicit behavior change.
+ */
+declare const SEARCH_HTTP_TRANSPORT_ID = "undici";
+/**
+ * Which phase of a search failed (plan §11.4 — transport identity and failure
+ * stage must be observable).
+ *
+ * - `connect` — the request never produced a response (DNS, TCP, TLS).
+ * - `fetch` — a response arrived but is unusable (refused status, deadline).
+ * - `redirect` — the redirect chain exceeded its cap.
+ * - `body-cap` — the response body outgrew its byte cap mid-stream.
+ * - `challenge` — the engine served a bot challenge instead of a SERP.
+ * - `trust` — the page parsed, but the anti-decoy check refused it.
+ * - `parse` — the page is not recognizable as this engine's SERP.
+ */
+type SearchHttpStage = 'connect' | 'fetch' | 'redirect' | 'body-cap' | 'challenge' | 'trust' | 'parse';
+/** One fetched search page. */
+interface SearchHttpResource {
+    /** The URL the response was finally served from (after redirects). */
+    finalUrl: string;
+    /** HTTP status of the final response. */
+    status: number;
+    /** `content-type` header value, or `''`. */
+    contentType: string;
+    /** Decoded response body. */
+    rawText: string;
+}
+/** What the transport needs to execute one attempt. */
+interface SearchHttpRequest {
+    /** Hard budget for this single attempt, in milliseconds. */
+    timeoutMs: number;
+    /** Byte cap enforced while the body streams in. */
+    maxResponseBytes: number;
+    /** Caller cancellation. Aborting surfaces as code `cancelled`, never `timeout`. */
+    signal?: AbortSignal;
+    /** Stamped onto thrown errors so a failure names its provider. */
+    providerId?: SearchProviderId;
+}
+/**
+ * The seam both providers accept in their constructor.
+ *
+ * This is the test seam (fixtures are served through it) and the seam a future
+ * alternative transport would occupy.
+ */
+type SearchHttpTransport = (url: string, request: SearchHttpRequest) => Promise<SearchHttpResource>;
+/**
+ * The low-level fetch primitive the shared transport drives — undici's `fetch`
+ * by default. Separate from {@link SearchHttpTransport} so redirect, body-cap
+ * and header behavior can be unit-tested without a network.
+ */
+type SearchHttpFetch = (url: string, init: RequestInit) => Promise<Response>;
+/** The outcome of running one engine's parser over one page. */
+interface ParsedSerp {
+    /**
+     * Whether the page is structurally recognizable as this engine's SERP.
+     *
+     * This is what separates "the engine found nothing" (recognized, zero
+     * results → `[]`) from "the engine's markup changed under us" (unrecognized
+     * → `parse_failed`).
+     */
+    recognized: boolean;
+    /** Usable organic results, already clamped to the caller's `maxResults`. */
+    results: SearchResult[];
+}
+
+/**
+ * The builtin HTTP search contributions.
+ *
+ * Everything the registry must not infer is declared here: `source` and `kind`
+ * are stated, never derived from the id's spelling, and the capability set is
+ * explicit down to the options these engines do NOT honor.
+ *
+ * `priorityHint` is deliberately absent. Provider ordering is the orchestrator's
+ * decision (阶段3); encoding a preference here would recreate exactly the
+ * scattered-fallback-order problem the extraction exists to remove.
+ *
+ * @module search/http/contributions
+ */
+
+/**
+ * What both keyless HTTP engines can do.
+ *
+ * `supportsRegion` / `supportsLanguage` / `supportsTimeRange` are false because
+ * the scraped endpoints never honored those options; per the contract, a
+ * provider ignores an option it does not declare rather than failing.
+ */
+declare const HTTP_SEARCH_CAPABILITIES: Readonly<SearchProviderCapabilities>;
+/**
+ * Both builtin HTTP providers, ready to hand to a registry.
+ *
+ * @param transport - optional shared transport for both providers (tests, or a
+ *   future alternative client). Omit for the production undici transport.
+ */
+declare function builtinHttpSearchContributions(transport?: SearchHttpTransport): SearchProviderContribution[];
+
+/**
+ * The candidate-URL walk both HTTP providers share.
+ *
+ * Mirrors the baselined `searchWebViaFetch` loop (one shared deadline, split
+ * evenly across the remaining candidates, last error retained) with one
+ * plan-mandated behavior change: the three-way outcome distinction.
+ *
+ * Elftia collapses "the engine found nothing" and "the engine's markup changed"
+ * into a single `response contained no result entries` error. Here they are
+ * different answers:
+ *
+ * - a recognized SERP with zero organic results → `[]` (a legitimate answer);
+ * - an unrecognizable page → `parse_failed` (the parser-drift alarm);
+ * - a challenge or decoy page → a `challenge`/`trust` staged failure, checked
+ *   before either of the above.
+ *
+ * The divergence is deliberate (plan §11.4) and is recorded for 阶段5's
+ * behavior-comparison report as an allowed difference.
+ *
+ * @module search/http/engine
+ */
+
+/** Response byte cap at the search call sites (the fetch layer allows 5 MiB). */
+declare const SEARCH_RESPONSE_BYTES: number;
+/** Default budget for one whole search, across all its candidate URLs. */
+declare const DEFAULT_SEARCH_TIMEOUT_MS = 15000;
+/** `maxResults` clamp: [1, 10], defaulting to 5. */
+declare const DEFAULT_MAX_RESULTS = 5;
+declare const MAX_RESULTS = 10;
+/**
+ * Clamp a caller's `maxResults` into the engine-supported range.
+ *
+ * `NaN` passes through to `slice(0, NaN)` and yields `[]`, exactly as the
+ * baseline does. Left at parity deliberately: normalizing pathological option
+ * values belongs to the runtime that owns option handling (阶段3), not to two
+ * providers that would then disagree with every other one.
+ */
+declare function clampMaxResults(maxResults: number | undefined): number;
+
+/**
+ * The browser navigation header profile the search transport sends.
+ *
+ * This is the profile `packages/core/test-fixtures/http-search/` was captured
+ * with, so changing it invalidates the fixtures as live-behavior evidence.
+ *
+ * Ported from Elftia's `webFetchHttp.browserHeaders()` with ONE deliberate
+ * difference: the Chrome version is PINNED here instead of read from
+ * `process.versions.chrome`. Elftia runs inside Electron and inherits a real
+ * Chromium version; `@omnicross/core` runs in plain Node, where that field is
+ * absent — pinning keeps the sent profile identical across every host and
+ * matches the spec's "pinned Chrome desktop User-Agent".
+ *
+ * @module search/http/headers
+ */
+/** The exact header set sent with every search request. */
+declare const SEARCH_BROWSER_HEADERS: Readonly<Record<string, string>>;
+
+/**
+ * `http-bing` — keyless Bing search over the shared HTTP transport.
+ *
+ * Standalone by construction: `new HttpBingProvider()` works with no config, no
+ * registry and no host. Nothing in Phase 1 阶段2 registers or calls it — that is
+ * 阶段3's job.
+ *
+ * @module search/http/HttpBingProvider
+ */
+
+/** The id this provider registers under. */
+declare const HTTP_BING_PROVIDER_ID = "http-bing";
+declare class HttpBingProvider implements SearchProvider {
+    readonly id: SearchProviderId;
+    private readonly transport;
+    constructor(transport?: SearchHttpTransport);
+    search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+}
+
+/**
+ * `http-duckduckgo` — keyless DuckDuckGo search over the shared HTTP transport.
+ *
+ * Two candidate endpoints, tried in order under one shared deadline: the html
+ * endpoint first, then the lite endpoint. The lite endpoint is reached only when
+ * the html one produced no usable results (or failed outright) — the baselined
+ * behavior.
+ *
+ * @module search/http/HttpDuckDuckGoProvider
+ */
+
+/** The id this provider registers under. */
+declare const HTTP_DUCKDUCKGO_PROVIDER_ID = "http-duckduckgo";
+declare class HttpDuckDuckGoProvider implements SearchProvider {
+    readonly id: SearchProviderId;
+    private readonly transport;
+    constructor(transport?: SearchHttpTransport);
+    search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+}
+
+/**
+ * The shared HTTP transport both keyless search providers run on.
+ *
+ * Ported from Elftia's `webFetchHttp.fetchWebResource` + `nodeWebFetchTransport`
+ * (baselined in `docs/design/search-baseline/elftia-search-baseline.md` §3.3),
+ * with the failure channel replaced: instead of bare `Error` strings, every
+ * failure is a `SearchProviderError` carrying `details.transport` and
+ * `details.stage`.
+ *
+ * Fixed semantics:
+ * - undici `fetch`, with an `EnvHttpProxyAgent` dispatcher when the environment
+ *   configures a proxy (cached per proxy signature).
+ * - The pinned browser navigation header profile (see `./headers`).
+ * - `redirect: 'manual'`, at most {@link MAX_REDIRECTS} hops, with the initial
+ *   URL and every hop target checked against the search egress policy
+ *   (`../egress`). These two engines are fixed-host and keyless, so nothing an
+ *   attacker controls picks the URL — but a redirect target is upstream input,
+ *   and this is the seam 阶段2 identified and 阶段4 fills. The default policy
+ *   permits every public host, so the fixed engines and the live `cn.bing.com`
+ *   geo-redirect are unaffected.
+ * - A byte cap enforced WHILE the body streams — an oversized page fails, it is
+ *   never silently truncated (this diverges from Elftia, which truncates and
+ *   parses the fragment; the spec requires a `body-cap` failure).
+ * - One deadline per attempt; caller aborts surface as `cancelled`, the deadline
+ *   as `timeout`, never conflated.
+ * - Compression is undici's business: it negotiates `Accept-Encoding` and
+ *   decodes the response.
+ *
+ * `impit` is NOT used. undici is the sole Phase-1 transport; the injection seam
+ * below is the only future-proofing.
+ *
+ * @module search/http/transport
+ */
+
+/** Redirect hop cap. */
+declare const MAX_REDIRECTS = 5;
+/** Knobs for {@link createSearchHttpTransport}. */
+interface SearchHttpTransportOptions {
+    /** The fetch primitive to drive. Defaults to undici's `fetch`. */
+    fetch?: SearchHttpFetch;
+    /** Environment to read proxy variables from. Defaults to `process.env`. */
+    env?: ProxyEnvironment;
+    /** Redirect hop cap. Defaults to {@link MAX_REDIRECTS}. */
+    maxRedirects?: number;
+    /**
+     * Egress policy for the initial URL and every redirect hop. Defaults to
+     * public-only, which is all these fixed-host engines ever need.
+     */
+    egressPolicy?: SearchEgressPolicy;
+}
+/** Build a transport. Tests inject `fetch`; production takes the default. */
+declare function createSearchHttpTransport(options?: SearchHttpTransportOptions): SearchHttpTransport;
+/** The production transport: undici, reading proxy settings from `process.env`. */
+declare const defaultSearchHttpTransport: SearchHttpTransport;
+
+export { DEFAULT_MAX_RESULTS, DEFAULT_SEARCH_TIMEOUT_MS, HTTP_BING_PROVIDER_ID, HTTP_DUCKDUCKGO_PROVIDER_ID, HTTP_SEARCH_CAPABILITIES, HttpBingProvider, HttpDuckDuckGoProvider, MAX_REDIRECTS, MAX_RESULTS, type ParsedSerp, SEARCH_BROWSER_HEADERS, SEARCH_HTTP_TRANSPORT_ID, SEARCH_RESPONSE_BYTES, type SearchHttpFetch, type SearchHttpRequest, type SearchHttpResource, type SearchHttpStage, type SearchHttpTransport, type SearchHttpTransportOptions, builtinHttpSearchContributions, clampMaxResults, createSearchHttpTransport, defaultSearchHttpTransport };

package/dist/search/http.js

@@ -0,0 +1,37 @@
+import {
+  DEFAULT_MAX_RESULTS,
+  DEFAULT_SEARCH_TIMEOUT_MS,
+  HTTP_BING_PROVIDER_ID,
+  HTTP_DUCKDUCKGO_PROVIDER_ID,
+  HTTP_SEARCH_CAPABILITIES,
+  HttpBingProvider,
+  HttpDuckDuckGoProvider,
+  MAX_REDIRECTS,
+  MAX_RESULTS,
+  SEARCH_BROWSER_HEADERS,
+  SEARCH_HTTP_TRANSPORT_ID,
+  SEARCH_RESPONSE_BYTES,
+  builtinHttpSearchContributions,
+  clampMaxResults,
+  createSearchHttpTransport,
+  defaultSearchHttpTransport
+} from "../chunk-NLUOTJWB.js";
+import "../chunk-DBBR6RHF.js";
+export {
+  DEFAULT_MAX_RESULTS,
+  DEFAULT_SEARCH_TIMEOUT_MS,
+  HTTP_BING_PROVIDER_ID,
+  HTTP_DUCKDUCKGO_PROVIDER_ID,
+  HTTP_SEARCH_CAPABILITIES,
+  HttpBingProvider,
+  HttpDuckDuckGoProvider,
+  MAX_REDIRECTS,
+  MAX_RESULTS,
+  SEARCH_BROWSER_HEADERS,
+  SEARCH_HTTP_TRANSPORT_ID,
+  SEARCH_RESPONSE_BYTES,
+  builtinHttpSearchContributions,
+  clampMaxResults,
+  createSearchHttpTransport,
+  defaultSearchHttpTransport
+};

package/dist/search.cjs

@@ -0,0 +1,57 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+var _chunkD4WNI6BRcjs = require('./chunk-D4WNI6BR.cjs');
+require('./chunk-HL2YSPL7.cjs');
+
+
+
+
+
+
+
+var _chunk7RJI3NDIcjs = require('./chunk-7RJI3NDI.cjs');
+
+
+
+
+
+
+
+
+
+
+var _chunkE4QHVXV5cjs = require('./chunk-E4QHVXV5.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_NORMALIZED_MAX_RESULTS = _chunkD4WNI6BRcjs.DEFAULT_NORMALIZED_MAX_RESULTS; exports.DEFAULT_SEARCH_EGRESS_POLICY = _chunk7RJI3NDIcjs.DEFAULT_SEARCH_EGRESS_POLICY; exports.DEFAULT_SEARCH_FRONTEND_MODES = _chunkE4QHVXV5cjs.DEFAULT_SEARCH_FRONTEND_MODES; exports.SEARCH_FRONTEND_MODES = _chunkE4QHVXV5cjs.SEARCH_FRONTEND_MODES; exports.SEARCH_FRONTEND_NAMES = _chunkE4QHVXV5cjs.SEARCH_FRONTEND_NAMES; exports.SEARCH_UNSUPPORTED_CAPABILITY_CODE = _chunkE4QHVXV5cjs.SEARCH_UNSUPPORTED_CAPABILITY_CODE; exports.SearchOrchestrator = _chunkD4WNI6BRcjs.SearchOrchestrator; exports.SearchProviderRegistry = _chunkD4WNI6BRcjs.SearchProviderRegistry; exports.SearchRegistryError = _chunkD4WNI6BRcjs.SearchRegistryError; exports.assertEgressAddressAllowed = _chunk7RJI3NDIcjs.assertEgressAddressAllowed; exports.createEgressGuardedDispatcher = _chunk7RJI3NDIcjs.createEgressGuardedDispatcher; exports.createEgressGuardedLookup = _chunk7RJI3NDIcjs.createEgressGuardedLookup; exports.createSearchRuntime = _chunkD4WNI6BRcjs.createSearchRuntime; exports.findEgressDenial = _chunk7RJI3NDIcjs.findEgressDenial; exports.hashSearchQuery = _chunkD4WNI6BRcjs.hashSearchQuery; exports.isDirectResultUrl = _chunkD4WNI6BRcjs.isDirectResultUrl; exports.isSearchFrontendMode = _chunkE4QHVXV5cjs.isSearchFrontendMode; exports.normalizeSearchFrontendModes = _chunkE4QHVXV5cjs.normalizeSearchFrontendModes; exports.normalizeSearchResults = _chunkD4WNI6BRcjs.normalizeSearchResults; exports.normalizedResultLimit = _chunkD4WNI6BRcjs.normalizedResultLimit; exports.searchErrorHttpStatus = _chunkE4QHVXV5cjs.searchErrorHttpStatus; exports.searchRuntimeAsWebSearchBackend = _chunkE4QHVXV5cjs.searchRuntimeAsWebSearchBackend; exports.validateEgressUrl = _chunk7RJI3NDIcjs.validateEgressUrl; exports.validateSearchFrontendModes = _chunkE4QHVXV5cjs.validateSearchFrontendModes;