@apifuse/provider-sdk 2.2.0-beta.27 → 2.2.0-beta.29

package/dist/runtime/browser.js

@@ -141,7 +141,13 @@ function formatExpression(fn) {
 }
 function toLaunchOptions(options) {
     return {
-        args: options.extraArgs,
+        // `extraArgs` is optional, but playwright-extra's stealth evasions mutate
+        // `options.args` unguarded (navigator.webdriver does
+        // `options.args.findIndex(...)` in beforeLaunch). Forwarding `undefined`
+        // therefore crashes every stealth launch that omits extraArgs with
+        // "TypeError: undefined is not an object (evaluating 'options.args.findIndex')".
+        // Always hand the launcher a concrete array.
+        args: options.extraArgs ?? [],
         executablePath: options.executablePath,
         headless: options.headless ?? true,
         proxy: options.proxy ? { server: options.proxy } : undefined,
@@ -684,6 +690,17 @@ function getCdpExecutionContext(params) {
         id: typeof contextId === "number" ? contextId : undefined,
     };
 }
+function getCdpDestroyedExecutionContextId(params) {
+    if (!isRecord(params)) {
+        return undefined;
+    }
+    return typeof params.executionContextId === "number"
+        ? params.executionContextId
+        : undefined;
+}
+function isMissingExecutionContextError(error) {
+    return error instanceof Error && /\b(?:cannot|failed to) find context\b/i.test(error.message);
+}
 class CdpBrowserLocator {
     frame;
     selector;
@@ -809,7 +826,19 @@ class CdpPoolBrowserPage {
     async evaluateInFrame(frameId, fn) {
         await this.initialize();
         const contextId = await this.getFrameExecutionContextId(frameId);
-        return await this.evaluateWithContext(fn, contextId);
+        try {
+            return await this.evaluateWithContext(fn, contextId);
+        }
+        catch (error) {
+            if (!isMissingExecutionContextError(error)) {
+                throw error;
+            }
+            if (this.frameExecutionContexts.get(frameId) === contextId) {
+                this.frameExecutionContexts.delete(frameId);
+            }
+            const refreshedContextId = await this.getFrameExecutionContextId(frameId);
+            return await this.evaluateWithContext(fn, refreshedContextId);
+        }
     }
     async waitForSelectorInFrame(frameId, selector, options) {
         const timeout = options?.timeout ?? DEFAULT_WAIT_TIMEOUT_MS;
@@ -1010,6 +1039,20 @@ class CdpPoolBrowserPage {
                 this.frameExecutionContexts.set(context.frameId, context.id);
             }
         });
+        this.pageClient.on("Runtime.executionContextDestroyed", (params) => {
+            const destroyedContextId = getCdpDestroyedExecutionContextId(params);
+            if (destroyedContextId === undefined) {
+                return;
+            }
+            for (const [frameId, contextId] of this.frameExecutionContexts) {
+                if (contextId === destroyedContextId) {
+                    this.frameExecutionContexts.delete(frameId);
+                }
+            }
+        });
+        this.pageClient.on("Runtime.executionContextsCleared", () => {
+            this.frameExecutionContexts.clear();
+        });
         await this.pageClient.send("Page.enable");
         await this.pageClient.send("Runtime.enable");
         this.initialized = true;

package/dist/runtime/http.d.ts

@@ -4,5 +4,6 @@ export type HttpClientOptions = ProxyResolutionOptions & {
     warn?: (message: string) => void;
     userAgent?: string;
     onRetrySummary?: (summary: HttpRetrySummary) => void;
+    signal?: AbortSignal;
 };
 export declare function createHttpClient(baseUrl?: string, clientOptions?: HttpClientOptions): HttpClient;

package/dist/runtime/http.js

@@ -11,10 +11,42 @@ function isHttpStatusOutcome(outcome) {
 function isDedupeSkipOutcome(outcome) {
     return "kind" in outcome && outcome.kind === "dedupe-skip";
 }
-async function sleep(ms) {
+function toAmbientCancellationError(signal, error = signal.reason) {
+    if (error instanceof TransportError && error.code === "transport_cancelled") {
+        return error;
+    }
+    return new TransportError("Request cancelled", {
+        code: "transport_cancelled",
+        status: 0,
+        retryable: false,
+        ...(error !== undefined
+            ? { cause: error instanceof Error ? error : new Error(String(error)) }
+            : {}),
+    });
+}
+function throwIfAmbientAborted(signal) {
+    if (signal?.aborted)
+        throw toAmbientCancellationError(signal);
+}
+async function sleep(ms, signal) {
+    throwIfAmbientAborted(signal);
     if (ms <= 0)
         return;
-    await new Promise((resolve) => setTimeout(resolve, ms));
+    if (!signal) {
+        await new Promise((resolve) => setTimeout(resolve, ms));
+        return;
+    }
+    await new Promise((resolve, reject) => {
+        const onAbort = () => {
+            clearTimeout(timer);
+            reject(toAmbientCancellationError(signal));
+        };
+        const timer = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
 }
 function toUpstreamHttpError(status) {
     return new TransportError(`Upstream request failed with status ${status}`, {
@@ -53,7 +85,17 @@ function parseJson(body) {
 function isTimeoutMessage(message) {
     return /\b(timed out|timeout|deadline exceeded)\b/i.test(message);
 }
-function toHttpTransportError(error) {
+function toHttpTransportError(error, ambientSignal, timeoutSignal) {
+    if (ambientSignal?.aborted) {
+        return toAmbientCancellationError(ambientSignal, error);
+    }
+    if (timeoutSignal?.aborted) {
+        return new TransportError("Request timed out", {
+            code: "transport_timeout",
+            status: 0,
+            ...(error instanceof Error ? { cause: error } : {}),
+        });
+    }
     if (error instanceof TransportError) {
         if (error.code) {
             return error;
@@ -125,6 +167,76 @@ function requireNativeResponseBody(response) {
     }
     return response.body;
 }
+function mergeAbortSignals(...signals) {
+    const activeSignals = signals.filter((signal) => signal != null);
+    if (activeSignals.length === 0)
+        return undefined;
+    if (activeSignals.length === 1)
+        return activeSignals[0];
+    return AbortSignal.any(activeSignals);
+}
+function cancelStreamOnAbort(body, signal) {
+    if (!signal)
+        return body;
+    let reader;
+    let finished = false;
+    let streamController;
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    const onAbort = () => {
+        if (finished)
+            return;
+        finished = true;
+        cleanup();
+        const reason = toAmbientCancellationError(signal);
+        streamController?.error(reason);
+        const cancellation = reader ? reader.cancel(reason) : body.cancel(reason);
+        void cancellation.catch(() => undefined).finally(() => reader?.releaseLock());
+    };
+    return new ReadableStream({
+        start(controller) {
+            streamController = controller;
+            signal.addEventListener("abort", onAbort, { once: true });
+            if (signal.aborted)
+                onAbort();
+        },
+        async pull(controller) {
+            try {
+                reader ??= body.getReader();
+                const chunk = await reader.read();
+                if (finished)
+                    return;
+                if (chunk.done) {
+                    finished = true;
+                    cleanup();
+                    controller.close();
+                    reader.releaseLock();
+                    return;
+                }
+                controller.enqueue(chunk.value);
+            }
+            catch (error) {
+                if (finished)
+                    return;
+                finished = true;
+                cleanup();
+                controller.error(error);
+                reader?.releaseLock();
+            }
+        },
+        async cancel(reason) {
+            if (finished)
+                return;
+            finished = true;
+            cleanup();
+            try {
+                await (reader ? reader.cancel(reason) : body.cancel(reason));
+            }
+            finally {
+                reader?.releaseLock();
+            }
+        },
+    }, { highWaterMark: 0 });
+}
 function sanitizeStreamErrors(body, serializedUrl) {
     if (serializedUrl.sensitiveValues.length === 0)
         return body;
@@ -154,9 +266,9 @@ function sanitizeStreamErrors(body, serializedUrl) {
         },
     }, { highWaterMark: 0 });
 }
-function toNativeHttpStreamResponse(response, serializedUrl) {
+function toNativeHttpStreamResponse(response, serializedUrl, signal) {
     const headers = Object.fromEntries(response.headers.entries());
-    const body = sanitizeStreamErrors(requireNativeResponseBody(response), serializedUrl);
+    const body = sanitizeStreamErrors(cancelStreamOnAbort(requireNativeResponseBody(response), signal), serializedUrl);
     return {
         body,
         headers,
@@ -418,15 +530,18 @@ async function fetchNativeHttp(baseUrl, url, method, options, clientOptions, war
     const serializedUrl = serializeHttpRequestUrl(baseUrl, url, options);
     const { requestUrl } = serializedUrl;
     const controller = options.timeout ? new AbortController() : undefined;
+    const signal = mergeAbortSignals(clientOptions.signal, controller?.signal);
     const timeoutHandle = options.timeout
         ? setTimeout(() => controller?.abort(), options.timeout)
         : undefined;
     let proxy;
     try {
+        throwIfAmbientAborted(clientOptions.signal);
         // Resolve inside the try (and after the timeout is armed) so allocator
         // failures are branded as TransportErrors and count against the request
         // deadline, exactly as an inline resolve would.
         proxy = await resolveNativeProxy(options, clientOptions, warn, proxyAttemptOffset);
+        throwIfAmbientAborted(clientOptions.signal);
         // For a registry allocator chain, skip an endpoint a prior attempt already
         // tried rather than re-issuing the same request. Returning the sentinel
         // (instead of breaking) lets the loop keep advancing the flat offset until
@@ -441,7 +556,7 @@ async function fetchNativeHttp(baseUrl, url, method, options, clientOptions, war
             headers: options.headers,
             method,
             ...(proxy ? { proxy } : {}),
-            signal: controller?.signal,
+            ...(signal ? { signal } : {}),
         };
         if (options.body !== undefined) {
             requestInit.body = normalizeNativeFetchBody(options.body);
@@ -471,7 +586,7 @@ async function fetchNativeHttp(baseUrl, url, method, options, clientOptions, war
         if (error instanceof SyntaxError) {
             throw redactSensitiveError(error, serializedUrl.sensitiveValues, serializedUrl.requestUrl, serializedUrl.redactedUrl);
         }
-        const transportError = redactSensitiveError(toHttpTransportError(error), serializedUrl.sensitiveValues, serializedUrl.requestUrl, serializedUrl.redactedUrl);
+        const transportError = redactSensitiveError(toHttpTransportError(error, clientOptions.signal, controller?.signal), serializedUrl.sensitiveValues, serializedUrl.requestUrl, serializedUrl.redactedUrl);
         transportError.proxyUsed = Boolean(proxy);
         throw transportError;
     }
@@ -484,16 +599,19 @@ async function fetchNativeHttpStream(baseUrl, url, method, options, clientOption
     const serializedUrl = serializeHttpRequestUrl(baseUrl, url, options);
     const { requestUrl } = serializedUrl;
     const controller = options.timeout ? new AbortController() : undefined;
+    const signal = mergeAbortSignals(clientOptions.signal, controller?.signal);
     const timeoutHandle = options.timeout
         ? setTimeout(() => controller?.abort(), options.timeout)
         : undefined;
     try {
+        throwIfAmbientAborted(clientOptions.signal);
         const proxy = await resolveNativeProxy(options, clientOptions, warn);
+        throwIfAmbientAborted(clientOptions.signal);
         const requestInit = {
             headers: options.headers,
             method,
             ...(proxy ? { proxy } : {}),
-            signal: controller?.signal,
+            ...(signal ? { signal } : {}),
         };
         if (options.body !== undefined) {
             requestInit.body = normalizeNativeFetchBody(options.body);
@@ -506,13 +624,15 @@ async function fetchNativeHttpStream(baseUrl, url, method, options, clientOption
                 status: response.status,
             });
         }
-        return toNativeHttpStreamResponse(response, serializedUrl);
+        // Per-call timeout remains header-scoped, while the ambient request signal
+        // stays attached to the response body for its full consumption lifetime.
+        return toNativeHttpStreamResponse(response, serializedUrl, clientOptions.signal);
     }
     catch (error) {
         if (error instanceof SyntaxError) {
             throw redactSensitiveError(error, serializedUrl.sensitiveValues, serializedUrl.requestUrl, serializedUrl.redactedUrl);
         }
-        throw redactSensitiveError(toHttpTransportError(error), serializedUrl.sensitiveValues, serializedUrl.requestUrl, serializedUrl.redactedUrl);
+        throw redactSensitiveError(toHttpTransportError(error, clientOptions.signal, controller?.signal), serializedUrl.sensitiveValues, serializedUrl.requestUrl, serializedUrl.redactedUrl);
     }
     finally {
         if (timeoutHandle)
@@ -616,6 +736,7 @@ export function createHttpClient(baseUrl, clientOptions = {}) {
         const dedupeContext = dedupeAllocatorEndpoints ? { attempted: new Set() } : undefined;
         const executeOnce = (proxyAttemptOffset = 0) => fetchNativeHttp(baseUrl, url, methodName, attemptOptions, clientOptions, warnOnce, statusRetryEnabled ? retryOptions?.statusCodes : undefined, proxyAttemptOffset, dedupeContext);
         if (!retryEnabled || !retryOptions) {
+            throwIfAmbientAborted(clientOptions.signal);
             const outcome = await executeOnce();
             if (isDedupeSkipOutcome(outcome)) {
                 // Single-shot path never de-duplicates (dedupeContext is undefined),
@@ -639,6 +760,7 @@ export function createHttpClient(baseUrl, clientOptions = {}) {
         // allocations skip offsets.
         let issued = 0;
         for (let attempt = 1; attempt <= transportAttemptCap; attempt += 1) {
+            throwIfAmbientAborted(clientOptions.signal);
             // Whether this offset actually issued a request (vs. a skipped duplicate),
             // so the catch counts a thrown *transport* failure once without
             // double-counting a status outcome that already incremented before it
@@ -657,7 +779,7 @@ export function createHttpClient(baseUrl, clientOptions = {}) {
                 if (isHttpStatusOutcome(outcome)) {
                     lastStatus = outcome.status;
                     if (outcome.retryable && issued < retryOptions.attempts) {
-                        await sleep(computeProxyTransportRetryDelayMs(retryOptions, attempt, outcome.headers));
+                        await sleep(computeProxyTransportRetryDelayMs(retryOptions, attempt, outcome.headers), clientOptions.signal);
                         continue;
                     }
                     throw toUpstreamHttpError(outcome.status);
@@ -680,6 +802,7 @@ export function createHttpClient(baseUrl, clientOptions = {}) {
                 return response;
             }
             catch (error) {
+                throwIfAmbientAborted(clientOptions.signal);
                 if (!issuedThisAttempt)
                     issued += 1;
                 lastError = error;
@@ -694,7 +817,7 @@ export function createHttpClient(baseUrl, clientOptions = {}) {
                         options: retryOptions,
                         proxyUsed,
                     })) {
-                    await sleep(computeProxyTransportRetryDelayMs(retryOptions, attempt));
+                    await sleep(computeProxyTransportRetryDelayMs(retryOptions, attempt), clientOptions.signal);
                     continue;
                 }
                 throw error;

package/dist/runtime/instrumentation.js

@@ -1,7 +1,7 @@
 import { readableBytes, readableLines, readableTextChunks } from "../stream.js";
 import { parseHttpRequestInvocation, isSensitiveKey, redactSensitiveError, redactSensitiveText, redactUrlQueryParams, requestOptionsFromHttpInvocation, serializeRequestUrl, } from "./request-options.js";
 import { createTraceContext, getTraceRecorder, } from "./trace.js";
-import { RESOLVER_INSTRUMENTATION_METADATA } from "./resolver.js";
+import { RESOLVER_INSTRUMENTATION_METADATA } from "./resolver-shared.js";
 const BROWSER_PAGE_METHODS = new Set(["goto", "fill", "click", "type", "waitForSelector"]);
 const DIAGNOSTIC_BASE_URL = "http://apifuse-instrumentation.invalid";
 function isThenable(value) {

package/dist/runtime/native-network-errors.d.ts

@@ -0,0 +1,33 @@
+import { TransportError } from "../errors.js";
+export type NativeNetworkErrorCode = "native_connection_aborted" | "native_connection_closed" | "native_connection_failed" | "native_connection_idle_timeout" | "native_connection_timeout" | "native_egress_authorization_failed" | "native_egress_grant_expired" | "native_egress_grant_invalid" | "native_egress_grant_limit_exceeded" | "native_egress_input_invalid" | "native_egress_not_declared" | "native_egress_policy_invalid" | "native_dynamic_egress_unsupported" | "native_proxy_expired" | "native_proxy_invalid";
+export declare class NativeNetworkError extends TransportError {
+    constructor(message: string, code: NativeNetworkErrorCode, cause?: Error);
+    get code(): NativeNetworkErrorCode;
+}
+export declare function safeDiagnosticEgressHost(value: unknown): string;
+export declare class NativeProxyExpiredError extends NativeNetworkError {
+    readonly expiresAt: string;
+    constructor(expiresAt: string);
+}
+/** Raised before transport setup when a native destination is not authorized. */
+export declare class NativeEgressNotDeclaredError extends NativeNetworkError {
+    readonly port: number;
+    readonly tls: "required" | "disabled";
+    readonly host: string;
+    constructor(host: string, port: number, tls: "required" | "disabled");
+}
+/**
+ * Raised when the destination was authorized by a grant whose TTL elapsed and
+ * its expiry remains in the client's bounded recent-expiry evidence window.
+ */
+export declare class NativeEgressGrantExpiredError extends NativeNetworkError {
+    readonly port: number;
+    readonly tls: "required" | "disabled";
+    readonly expiresAt: string;
+    readonly host: string;
+    constructor(host: string, port: number, tls: "required" | "disabled", expiresAt: string);
+}
+/** Raised when an established connection exceeds its opt-in read-idle window. */
+export declare class NativeIdleTimeoutError extends NativeNetworkError {
+    constructor();
+}

package/dist/runtime/native-network-errors.js

@@ -0,0 +1,69 @@
+import { TransportError } from "../errors.js";
+import { canonicalizeEgressHost } from "../native-address.js";
+export class NativeNetworkError extends TransportError {
+    constructor(message, code, cause) {
+        const isEgressPolicyFailure = code.startsWith("native_egress_") || code === "native_dynamic_egress_unsupported";
+        super(message, {
+            code,
+            status: 0,
+            ...(cause ? { cause } : {}),
+            ...(isEgressPolicyFailure ? { category: "provider_error", retryable: false } : {}),
+        });
+        this.name = "NativeNetworkError";
+    }
+    get code() {
+        return super.code;
+    }
+}
+export function safeDiagnosticEgressHost(value) {
+    const canonical = canonicalizeEgressHost(value);
+    return canonical.ok ? canonical.host : `<invalid-host:${canonical.reason}>`;
+}
+export class NativeProxyExpiredError extends NativeNetworkError {
+    expiresAt;
+    constructor(expiresAt) {
+        super("Native connection closed at sticky proxy expiry", "native_proxy_expired");
+        this.expiresAt = expiresAt;
+        this.name = "NativeProxyExpiredError";
+    }
+}
+/** Raised before transport setup when a native destination is not authorized. */
+export class NativeEgressNotDeclaredError extends NativeNetworkError {
+    port;
+    tls;
+    host;
+    constructor(host, port, tls) {
+        const diagnosticHost = safeDiagnosticEgressHost(host);
+        super(`Native ${tls === "required" ? "TLS" : "TCP"} egress is not declared for ${diagnosticHost}:${port}`, "native_egress_not_declared");
+        this.port = port;
+        this.tls = tls;
+        this.host = diagnosticHost;
+        this.name = "NativeEgressNotDeclaredError";
+    }
+}
+/**
+ * Raised when the destination was authorized by a grant whose TTL elapsed and
+ * its expiry remains in the client's bounded recent-expiry evidence window.
+ */
+export class NativeEgressGrantExpiredError extends NativeNetworkError {
+    port;
+    tls;
+    expiresAt;
+    host;
+    constructor(host, port, tls, expiresAt) {
+        const diagnosticHost = safeDiagnosticEgressHost(host);
+        super(`Native ${tls === "required" ? "TLS" : "TCP"} egress grant expired for ${diagnosticHost}:${port}`, "native_egress_grant_expired");
+        this.port = port;
+        this.tls = tls;
+        this.expiresAt = expiresAt;
+        this.host = diagnosticHost;
+        this.name = "NativeEgressGrantExpiredError";
+    }
+}
+/** Raised when an established connection exceeds its opt-in read-idle window. */
+export class NativeIdleTimeoutError extends NativeNetworkError {
+    constructor() {
+        super("Native network socket timed out while reading.", "native_connection_idle_timeout");
+        this.name = "NativeIdleTimeoutError";
+    }
+}

package/dist/runtime/native-network.d.ts

@@ -1,40 +1,10 @@
 import { Socket } from "node:net";
 import { type TLSSocket } from "node:tls";
 import { type ProxyProtocol } from "../config/loader.js";
-import { TransportError } from "../errors.js";
 import { type DynamicEgressRuleSnapshot } from "../native-egress-policy.js";
 import type { NativeNetworkClient, NativeNetworkConnectInput, NativeNetworkConnection, NativeNetworkDynamicGrantOptions, NativeNetworkEgressGrant, NativeProviderConfig, NativeProxyEgressInfo, ProviderProxyPolicy, ProviderProxyProvider, EnvContext } from "../types.js";
-export type NativeNetworkErrorCode = "native_connection_aborted" | "native_connection_closed" | "native_connection_failed" | "native_connection_idle_timeout" | "native_connection_timeout" | "native_egress_authorization_failed" | "native_egress_grant_expired" | "native_egress_grant_invalid" | "native_egress_grant_limit_exceeded" | "native_egress_input_invalid" | "native_egress_not_declared" | "native_egress_policy_invalid" | "native_dynamic_egress_unsupported" | "native_proxy_expired" | "native_proxy_invalid";
-export declare class NativeNetworkError extends TransportError {
-    constructor(message: string, code: NativeNetworkErrorCode, cause?: Error);
-    get code(): NativeNetworkErrorCode;
-}
-export declare class NativeProxyExpiredError extends NativeNetworkError {
-    readonly expiresAt: string;
-    constructor(expiresAt: string);
-}
-/** Raised before transport setup when a native destination is not authorized. */
-export declare class NativeEgressNotDeclaredError extends NativeNetworkError {
-    readonly port: number;
-    readonly tls: "required" | "disabled";
-    readonly host: string;
-    constructor(host: string, port: number, tls: "required" | "disabled");
-}
-/**
- * Raised when the destination was authorized by a grant whose TTL elapsed and
- * its expiry remains in the client's bounded recent-expiry evidence window.
- */
-export declare class NativeEgressGrantExpiredError extends NativeNetworkError {
-    readonly port: number;
-    readonly tls: "required" | "disabled";
-    readonly expiresAt: string;
-    readonly host: string;
-    constructor(host: string, port: number, tls: "required" | "disabled", expiresAt: string);
-}
-/** Raised when an established connection exceeds its opt-in read-idle window. */
-export declare class NativeIdleTimeoutError extends NativeNetworkError {
-    constructor();
-}
+export { NativeEgressGrantExpiredError, NativeEgressNotDeclaredError, NativeIdleTimeoutError, NativeNetworkError, NativeProxyExpiredError, } from "./native-network-errors.js";
+export type { NativeNetworkErrorCode } from "./native-network-errors.js";
 export type NativeGatewayProxy = NativeProxyEgressInfo & {
     readonly url: string;
 };
@@ -124,4 +94,3 @@ export declare function createNativeEgressAuthorization(options: NativeNetworkCl
 };
 /** Create the SDK byte-stream runtime with provider-declared egress enforcement. */
 export declare function createNativeNetworkClient(options?: NativeNetworkClientOptions): NativeNetworkClient;
-export {};

package/dist/runtime/native-network.js

@@ -3,79 +3,13 @@ import { Socket } from "node:net";
 import { connect as connectTlsSocket } from "node:tls";
 import { SocksClient } from "socks";
 import { assertTunnelingScheme, ProxyResolutionError, SMARTPROXY_APP_KEY_ENV, VENDOR_DEFAULT_PROTOCOL, resolveWithVendor, } from "../config/loader.js";
-import { TransportError } from "../errors.js";
 import { NativeEgressPolicyValidationError, parseNativeEgressPolicy, } from "../native-egress-policy.js";
 import { canonicalizeEgressHost, classifyEgressHost, embeddedIpv4FromIpv6, ipv4InCidr, ipv6InCidr, parseIpv6, parseStrictIpv4, } from "../native-address.js";
 import { createEnvContext } from "./env.js";
+import { NativeEgressGrantExpiredError, NativeEgressNotDeclaredError, NativeIdleTimeoutError, NativeNetworkError, NativeProxyExpiredError, safeDiagnosticEgressHost, } from "./native-network-errors.js";
 import { NODEMAVEN_FILTER_ENV, NODEMAVEN_PASSWORD_ENV, NODEMAVEN_USERNAME_ENV, nodemavenSessionWindow, synthesizeNodemavenProxy, } from "./proxy-nodemaven.js";
 import { redactSensitiveError } from "./request-options.js";
-export class NativeNetworkError extends TransportError {
-    constructor(message, code, cause) {
-        const isEgressPolicyFailure = code.startsWith("native_egress_") || code === "native_dynamic_egress_unsupported";
-        super(message, {
-            code,
-            status: 0,
-            ...(cause ? { cause } : {}),
-            ...(isEgressPolicyFailure ? { category: "provider_error", retryable: false } : {}),
-        });
-        this.name = "NativeNetworkError";
-    }
-    get code() {
-        return super.code;
-    }
-}
-function safeDiagnosticEgressHost(value) {
-    const canonical = canonicalizeEgressHost(value);
-    return canonical.ok ? canonical.host : `<invalid-host:${canonical.reason}>`;
-}
-export class NativeProxyExpiredError extends NativeNetworkError {
-    expiresAt;
-    constructor(expiresAt) {
-        super("Native connection closed at sticky proxy expiry", "native_proxy_expired");
-        this.expiresAt = expiresAt;
-        this.name = "NativeProxyExpiredError";
-    }
-}
-/** Raised before transport setup when a native destination is not authorized. */
-export class NativeEgressNotDeclaredError extends NativeNetworkError {
-    port;
-    tls;
-    host;
-    constructor(host, port, tls) {
-        const diagnosticHost = safeDiagnosticEgressHost(host);
-        super(`Native ${tls === "required" ? "TLS" : "TCP"} egress is not declared for ${diagnosticHost}:${port}`, "native_egress_not_declared");
-        this.port = port;
-        this.tls = tls;
-        this.host = diagnosticHost;
-        this.name = "NativeEgressNotDeclaredError";
-    }
-}
-/**
- * Raised when the destination was authorized by a grant whose TTL elapsed and
- * its expiry remains in the client's bounded recent-expiry evidence window.
- */
-export class NativeEgressGrantExpiredError extends NativeNetworkError {
-    port;
-    tls;
-    expiresAt;
-    host;
-    constructor(host, port, tls, expiresAt) {
-        const diagnosticHost = safeDiagnosticEgressHost(host);
-        super(`Native ${tls === "required" ? "TLS" : "TCP"} egress grant expired for ${diagnosticHost}:${port}`, "native_egress_grant_expired");
-        this.port = port;
-        this.tls = tls;
-        this.expiresAt = expiresAt;
-        this.host = diagnosticHost;
-        this.name = "NativeEgressGrantExpiredError";
-    }
-}
-/** Raised when an established connection exceeds its opt-in read-idle window. */
-export class NativeIdleTimeoutError extends NativeNetworkError {
-    constructor() {
-        super("Native network socket timed out while reading.", "native_connection_idle_timeout");
-        this.name = "NativeIdleTimeoutError";
-    }
-}
+export { NativeEgressGrantExpiredError, NativeEgressNotDeclaredError, NativeIdleTimeoutError, NativeNetworkError, NativeProxyExpiredError, } from "./native-network-errors.js";
 const VENDOR_CREDENTIAL_NAMES = {
     smartproxy: [SMARTPROXY_APP_KEY_ENV],
     nodemaven: [NODEMAVEN_USERNAME_ENV, NODEMAVEN_PASSWORD_ENV],

package/dist/runtime/proxy-telemetry.js

@@ -33,6 +33,7 @@ export class ProxyTelemetryCollector {
     recordProxyResolution(event) {
         this.#events.push({
             provider: event.provider,
+            ...(event.userAgentSource ? { userAgentSource: event.userAgentSource } : {}),
             ...(event.protocol ? { protocol: event.protocol } : {}),
             cacheStatus: event.cacheStatus,
             cacheHit: event.cacheHit,
@@ -99,6 +100,7 @@ export class ProxyTelemetryCollector {
         }
         const aggregate = rest.reduce((acc, event) => ({
             provider: event.provider,
+            userAgentSource: event.userAgentSource ?? acc.userAgentSource,
             cacheStatus: worseStatus(acc.cacheStatus, event.cacheStatus),
             cacheHit: acc.cacheHit && event.cacheHit,
             resolutionMs: acc.resolutionMs + event.resolutionMs,
@@ -118,6 +120,7 @@ export class ProxyTelemetryCollector {
             v: 1,
             proxy: {
                 provider: serving.provider,
+                ...(aggregate.userAgentSource ? { userAgentSource: aggregate.userAgentSource } : {}),
                 ...(serving.protocol ? { protocol: serving.protocol } : {}),
                 cacheStatus: aggregate.cacheStatus,
                 cacheHit: aggregate.cacheHit,

package/dist/runtime/redis.d.ts

@@ -1,4 +1,4 @@
-import { Redis } from "ioredis";
+import type { Redis } from "ioredis";
 export type ProviderRedisClient = Redis;
 export type ProviderRedisClientOptions = {
     readonly redisUrl: string;

package/dist/runtime/redis.js

@@ -1,6 +1,8 @@
-import { Redis } from "ioredis";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
 export function createProviderRedisClient(options) {
-    const redis = new Redis(options.redisUrl, {
+    const { Redis: RedisClient } = require("ioredis");
+    const redis = new RedisClient(options.redisUrl, {
         connectTimeout: options.timeoutMs,
         enableOfflineQueue: false,
         lazyConnect: true,

package/dist/runtime/resolver-config.d.ts

@@ -0,0 +1,6 @@
+export declare const APIFUSE__RESOLVER__2CAPTCHA__API_KEY = "APIFUSE__RESOLVER__2CAPTCHA__API_KEY";
+export declare const APIFUSE__RESOLVER__CAPSOLVER__API_KEY = "APIFUSE__RESOLVER__CAPSOLVER__API_KEY";
+export declare const APIFUSE__RESOLVER__CAPMONSTER__API_KEY = "APIFUSE__RESOLVER__CAPMONSTER__API_KEY";
+export declare const APIFUSE__RESOLVER__TIMEOUT_MS = "APIFUSE__RESOLVER__TIMEOUT_MS";
+export declare const APIFUSE__CDP_POOL__URL = "APIFUSE__CDP_POOL__URL";
+export declare const DEFAULT_RESOLVER_TIMEOUT_MS = 180000;

package/dist/runtime/resolver-config.js

@@ -0,0 +1,6 @@
+export const APIFUSE__RESOLVER__2CAPTCHA__API_KEY = "APIFUSE__RESOLVER__2CAPTCHA__API_KEY";
+export const APIFUSE__RESOLVER__CAPSOLVER__API_KEY = "APIFUSE__RESOLVER__CAPSOLVER__API_KEY";
+export const APIFUSE__RESOLVER__CAPMONSTER__API_KEY = "APIFUSE__RESOLVER__CAPMONSTER__API_KEY";
+export const APIFUSE__RESOLVER__TIMEOUT_MS = "APIFUSE__RESOLVER__TIMEOUT_MS";
+export const APIFUSE__CDP_POOL__URL = "APIFUSE__CDP_POOL__URL";
+export const DEFAULT_RESOLVER_TIMEOUT_MS = 180_000;

package/dist/runtime/resolver-public.d.ts

@@ -0,0 +1 @@
+export { APIFUSE__CDP_POOL__URL, APIFUSE__RESOLVER__2CAPTCHA__API_KEY, APIFUSE__RESOLVER__CAPMONSTER__API_KEY, APIFUSE__RESOLVER__CAPSOLVER__API_KEY, APIFUSE__RESOLVER__TIMEOUT_MS, bindResolverSignal, createResolverClient, createResolverClientFromEnv, createUnsupportedResolverClient, DEFAULT_RESOLVER_TIMEOUT_MS, invalidateResolverSolution, RESOLVER_ADAPTER_REGISTRY, RESOLVER_INSTRUMENTATION_METADATA, type ResolverAdapterFactory, type ResolverInstrumentationMetadata, type ResolverRuntimeOptions, } from "./resolver.js";

package/dist/runtime/resolver-public.js

@@ -0,0 +1 @@
+export { APIFUSE__CDP_POOL__URL, APIFUSE__RESOLVER__2CAPTCHA__API_KEY, APIFUSE__RESOLVER__CAPMONSTER__API_KEY, APIFUSE__RESOLVER__CAPSOLVER__API_KEY, APIFUSE__RESOLVER__TIMEOUT_MS, bindResolverSignal, createResolverClient, createResolverClientFromEnv, createUnsupportedResolverClient, DEFAULT_RESOLVER_TIMEOUT_MS, invalidateResolverSolution, RESOLVER_ADAPTER_REGISTRY, RESOLVER_INSTRUMENTATION_METADATA, } from "./resolver.js";