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

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

@@ -0,0 +1,3 @@
+import type { ResolverContext } from "../types.js";
+export declare const RESOLVER_INSTRUMENTATION_METADATA: unique symbol;
+export declare function createUnsupportedResolverClient(reason?: string): ResolverContext;

package/dist/runtime/resolver-shared.js

@@ -0,0 +1,12 @@
+import { ProviderError } from "../errors.js";
+export const RESOLVER_INSTRUMENTATION_METADATA = Symbol.for("@apifuse/provider-sdk/runtime/resolver-instrumentation-metadata");
+export function createUnsupportedResolverClient(reason) {
+    return {
+        async solve() {
+            throw new ProviderError(reason ?? "Resolver runtime is not configured", {
+                code: "RESOLVER_UNAVAILABLE",
+                fix: "Declare resolver on the provider definition and configure vendor credentials.",
+            });
+        },
+    };
+}

package/dist/runtime/resolver-vendors/browser.js

@@ -204,8 +204,9 @@ export function createBrowserResolverVendorAdapter(options) {
             });
         },
         async solve(challenge, identity, callerSignal, traceRecorder) {
-            void identity;
-            if (!options.cdpUrl?.trim()) {
+            const cdpUrl = options.cdpUrl?.trim();
+            const proxyUrl = identity?.proxyUrl;
+            if (!cdpUrl && proxyUrl === undefined) {
                 throw new ResolverVendorUnavailableError(BROWSER_VENDOR_ID, "missing_credentials");
             }
             if (!isSupportedKind(challenge.kind)) {
@@ -214,6 +215,14 @@ export function createBrowserResolverVendorAdapter(options) {
             assertResolverHostAllowed(challenge.pageUrl, options.allowedHosts);
             const challengeKind = challenge.kind;
             callerSignal.throwIfAborted();
+            if (proxyUrl !== undefined && proxyUrl.length === 0) {
+                throw new ResolverVendorUnavailableError(BROWSER_VENDOR_ID, "missing_proxy_identity");
+            }
+            if (cdpUrl && proxyUrl !== undefined) {
+                // The current pool acquire protocol cannot bind a proxy to its browser context.
+                // Refuse so the chain can choose a vendor that can honor the resolved identity.
+                throw new ResolverVendorUnavailableError(BROWSER_VENDOR_ID, "not_implemented");
+            }
             const solveController = new AbortController();
             const onCallerAbort = () => solveController.abort(abortReason(callerSignal));
             callerSignal.addEventListener("abort", onCallerAbort, { once: true });
@@ -223,8 +232,9 @@ export function createBrowserResolverVendorAdapter(options) {
             try {
                 client = createClient({
                     allowedHosts: [...options.allowedHosts],
-                    cdpUrl: options.cdpUrl.trim(),
-                    requireCdpPool: true,
+                    cdpUrl: cdpUrl ?? "",
+                    ...(proxyUrl === undefined ? {} : { proxy: proxyUrl }),
+                    requireCdpPool: cdpUrl !== undefined,
                 });
                 const contextOperation = client.withIsolatedContext(async (page) => {
                     handlerEntered = true;

package/dist/runtime/resolver-vendors/twocaptcha.d.ts

@@ -1,4 +1,5 @@
 import type { ChallengeSolution, ProviderChallenge } from "../../types.js";
+import type { TraceRecorder } from "../trace.js";
 import { type ResolverIdentity, type ResolverVendorAdapter } from "./types.js";
 type Delay = (ms: number, signal: AbortSignal) => Promise<void>;
 export interface TwoCaptchaResolverVendorOptions {
@@ -15,7 +16,7 @@ export interface TwoCaptchaResolverVendorOptions {
 }
 export interface TwoCaptchaResolverVendorAdapter extends ResolverVendorAdapter {
     readonly id: "2captcha";
-    solve(challenge: ProviderChallenge, identity: ResolverIdentity | undefined, signal: AbortSignal): Promise<Extract<ChallengeSolution, {
+    solve(challenge: ProviderChallenge, identity: ResolverIdentity | undefined, signal: AbortSignal, traceRecorder?: TraceRecorder): Promise<Extract<ChallengeSolution, {
         readonly form: "token";
     }>>;
 }

package/dist/runtime/resolver-vendors/twocaptcha.js

@@ -1,5 +1,5 @@
 import { assertResolverHostAllowed } from "./hosts.js";
-import { ResolverVendorUnavailableError, resolverVendorSupports, } from "./types.js";
+import { ResolverChallengeVerdictError, ResolverVendorUnavailableError, resolverVendorSupports, } from "./types.js";
 const TWOCAPTCHA_VENDOR_ID = "2captcha";
 const DEFAULT_TWOCAPTCHA_BASE_URL = "https://api.2captcha.com";
 const DEFAULT_POLL_INTERVAL_MS = 3_000;
@@ -16,7 +16,46 @@ function isJsonRecord(value) {
 function abortReason(signal) {
     return signal.reason ?? new DOMException("The operation was aborted", "AbortError");
 }
-function raceWithAbort(operation, signal, phase) {
+function containsSensitiveValue(value, sensitiveValues) {
+    const secrets = sensitiveValues.filter((secret) => secret.length > 0);
+    if (secrets.length === 0)
+        return false;
+    const seen = new Set();
+    const inspect = (candidate) => {
+        if (typeof candidate === "string") {
+            return secrets.some((secret) => candidate.includes(secret));
+        }
+        if (candidate === null ||
+            (typeof candidate !== "object" && typeof candidate !== "function")) {
+            return false;
+        }
+        if (seen.has(candidate))
+            return false;
+        seen.add(candidate);
+        try {
+            for (const property of Reflect.ownKeys(candidate)) {
+                if (typeof property === "string" && inspect(property))
+                    return true;
+                const descriptor = Object.getOwnPropertyDescriptor(candidate, property);
+                if (!descriptor)
+                    return true;
+                if ("value" in descriptor && inspect(descriptor.value))
+                    return true;
+                if (descriptor.get !== undefined || descriptor.set !== undefined)
+                    return true;
+            }
+        }
+        catch {
+            return true;
+        }
+        return false;
+    };
+    return inspect(value);
+}
+function safeCauseOptions(error, sensitiveValues) {
+    return containsSensitiveValue(error, sensitiveValues) ? {} : { cause: error };
+}
+function raceWithAbort(operation, signal, phase, sensitiveValues = []) {
     if (signal.aborted)
         return Promise.reject(abortReason(signal));
     return new Promise((resolve, reject) => {
@@ -36,7 +75,7 @@ function raceWithAbort(operation, signal, phase) {
                 return;
             }
             reject(new ResolverVendorUnavailableError(TWOCAPTCHA_VENDOR_ID, "transport_failure", {
-                cause: error,
+                ...safeCauseOptions(error, sensitiveValues),
                 phase,
             }));
         });
@@ -92,17 +131,23 @@ function isAllocationExhausted(payload) {
     return (code === "error_zero_balance" ||
         /(?:insufficient|zero|no|not enough)\s+(?:balance|funds|credit)/u.test(`${code} ${description}`));
 }
+function isNegativeVerdict(payload) {
+    return errorText(payload, "errorCode").toLowerCase() === "error_captcha_unsolvable";
+}
 function unavailableForPayload(payload, phase) {
+    if (isNegativeVerdict(payload)) {
+        return new ResolverChallengeVerdictError(TWOCAPTCHA_VENDOR_ID, "solve_failed");
+    }
     return new ResolverVendorUnavailableError(TWOCAPTCHA_VENDOR_ID, isAllocationExhausted(payload) ? "allocation_exhausted" : "transport_failure", { phase });
 }
-async function postJson(fetchImpl, url, body, signal, phase) {
+async function postJson(fetchImpl, url, body, signal, phase, sensitiveValues) {
     const response = await raceWithAbort(() => fetchImpl(url, {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: JSON.stringify(body),
         signal,
         redirect: "error",
-    }), signal, phase);
+    }), signal, phase, sensitiveValues);
     let responseText;
     try {
         responseText = await raceWithAbort(() => response.text(), signal, phase);
@@ -136,10 +181,13 @@ function taskIdFrom(payload) {
     const taskId = payload.taskId;
     return typeof taskId === "string" || typeof taskId === "number" ? taskId : undefined;
 }
-function tokenFrom(payload) {
+function tokenFrom(payload, challenge) {
     const solution = payload.solution;
     if (!isJsonRecord(solution))
         return undefined;
+    if (challenge.kind === "aws_waf") {
+        return typeof solution.existing_token === "string" ? solution.existing_token : undefined;
+    }
     if (typeof solution.gRecaptchaResponse === "string")
         return solution.gRecaptchaResponse;
     return typeof solution.token === "string" ? solution.token : undefined;
@@ -147,6 +195,24 @@ function tokenFrom(payload) {
 function endpoint(baseUrl, path) {
     return `${baseUrl.replace(/\/+$/u, "")}/${path}`;
 }
+function spanErrorAttributes(error, phase) {
+    if (error instanceof ResolverVendorUnavailableError) {
+        return {
+            unavailability_reason: error.reason,
+            transport_phase: error.phase,
+        };
+    }
+    // The solve budget raises TwoCaptchaSolveTimeoutError inside the spanned closure and
+    // the outer catch converts it only after the span has been finalized, so the span has
+    // to recognize it here or slow solves lose exactly the attribution these spans add.
+    if (error instanceof TwoCaptchaSolveTimeoutError) {
+        return {
+            unavailability_reason: "timeout",
+            transport_phase: phase,
+        };
+    }
+    return undefined;
+}
 export function createTwoCaptchaResolverVendorAdapter(options) {
     const fetchImpl = options.fetchImpl ?? globalThis.fetch;
     const baseUrl = options.baseUrl ?? DEFAULT_TWOCAPTCHA_BASE_URL;
@@ -159,7 +225,7 @@ export function createTwoCaptchaResolverVendorAdapter(options) {
         supports(kind) {
             return resolverVendorSupports(TWOCAPTCHA_VENDOR_ID, kind);
         },
-        async solve(challenge, identity, callerSignal) {
+        async solve(challenge, identity, callerSignal, traceRecorder) {
             const apiKey = options.apiKey?.trim();
             if (!apiKey) {
                 throw new ResolverVendorUnavailableError(TWOCAPTCHA_VENDOR_ID, "missing_credentials", {
@@ -169,8 +235,16 @@ export function createTwoCaptchaResolverVendorAdapter(options) {
             if (!resolverVendorSupports(TWOCAPTCHA_VENDOR_ID, challenge.kind)) {
                 throw new TypeError(`2captcha resolver does not support ${challenge.kind}`);
             }
-            if (challenge.kind !== "recaptcha_v2") {
-                // AWS WAF remains deferred because its challenge variant has no required site key.
+            if (challenge.kind !== "recaptcha_v2" && challenge.kind !== "aws_waf") {
+                throw new ResolverVendorUnavailableError(TWOCAPTCHA_VENDOR_ID, "not_implemented", {
+                    phase: "create_task",
+                });
+            }
+            if (challenge.kind === "aws_waf" &&
+                (!challenge.siteKey?.trim() ||
+                    !challenge.captchaScript?.trim() ||
+                    !challenge.context?.trim() ||
+                    !challenge.iv?.trim())) {
                 throw new ResolverVendorUnavailableError(TWOCAPTCHA_VENDOR_ID, "not_implemented", {
                     phase: "create_task",
                 });
@@ -192,50 +266,78 @@ export function createTwoCaptchaResolverVendorAdapter(options) {
             const startedAt = now();
             let phase = "create_task";
             try {
-                const createResult = await postJson(fetchImpl, endpoint(baseUrl, "createTask"), {
-                    clientKey: apiKey,
-                    task: {
-                        type: proxy ? "RecaptchaV2Task" : "RecaptchaV2TaskProxyless",
-                        websiteURL: challenge.pageUrl,
-                        websiteKey: challenge.siteKey,
-                        isInvisible: false,
-                        ...(identity ? { userAgent: identity.userAgent } : {}),
-                        ...(proxy ?? {}),
-                    },
-                }, solveController.signal, phase);
-                const taskId = taskIdFrom(createResult.payload);
-                if (!createResult.ok || createResult.payload.errorId !== 0 || taskId === undefined) {
-                    throw unavailableForPayload(createResult.payload, phase);
-                }
-                phase = "poll_result";
-                while (true) {
-                    callerSignal.throwIfAborted();
-                    const remainingMs = timeoutMs - (now() - startedAt);
-                    if (remainingMs <= 0)
-                        throw new TwoCaptchaSolveTimeoutError();
-                    await delay(Math.min(pollIntervalMs, remainingMs), solveController.signal);
-                    callerSignal.throwIfAborted();
-                    if (now() - startedAt >= timeoutMs)
-                        throw new TwoCaptchaSolveTimeoutError();
-                    const pollResult = await postJson(fetchImpl, endpoint(baseUrl, "getTaskResult"), { clientKey: apiKey, taskId }, solveController.signal, phase);
-                    if (!pollResult.ok || pollResult.payload.errorId !== 0) {
-                        throw unavailableForPayload(pollResult.payload, phase);
-                    }
-                    if (pollResult.payload.status === "processing")
-                        continue;
-                    if (pollResult.payload.status !== "ready") {
-                        throw new ResolverVendorUnavailableError(TWOCAPTCHA_VENDOR_ID, "transport_failure", {
-                            phase,
-                        });
+                const createTask = async () => {
+                    const task = challenge.kind === "aws_waf"
+                        ? {
+                            type: proxy ? "AmazonTask" : "AmazonTaskProxyless",
+                            websiteURL: challenge.pageUrl,
+                            websiteKey: challenge.siteKey,
+                            captchaScript: challenge.captchaScript,
+                            context: challenge.context,
+                            iv: challenge.iv,
+                            ...(identity ? { userAgent: identity.userAgent } : {}),
+                            ...(proxy ?? {}),
+                        }
+                        : {
+                            type: proxy ? "RecaptchaV2Task" : "RecaptchaV2TaskProxyless",
+                            websiteURL: challenge.pageUrl,
+                            websiteKey: challenge.siteKey,
+                            isInvisible: false,
+                            ...(identity ? { userAgent: identity.userAgent } : {}),
+                            ...(proxy ?? {}),
+                        };
+                    const createResult = await postJson(fetchImpl, endpoint(baseUrl, "createTask"), { clientKey: apiKey, task }, solveController.signal, phase, [apiKey]);
+                    const taskId = taskIdFrom(createResult.payload);
+                    if (!createResult.ok || createResult.payload.errorId !== 0 || taskId === undefined) {
+                        throw unavailableForPayload(createResult.payload, phase);
                     }
-                    const token = tokenFrom(pollResult.payload);
-                    if (!token?.trim()) {
-                        throw new ResolverVendorUnavailableError(TWOCAPTCHA_VENDOR_ID, "transport_failure", {
-                            phase,
-                        });
+                    return taskId;
+                };
+                const taskId = traceRecorder
+                    ? await traceRecorder.runSpan("resolver.vendor.create_task", createTask, {
+                        attributes: {
+                            vendor: TWOCAPTCHA_VENDOR_ID,
+                            challenge_kind: challenge.kind,
+                        },
+                        onError: (error) => spanErrorAttributes(error, "create_task"),
+                    })
+                    : await createTask();
+                phase = "poll_result";
+                const pollResult = async () => {
+                    while (true) {
+                        callerSignal.throwIfAborted();
+                        const remainingMs = timeoutMs - (now() - startedAt);
+                        if (remainingMs <= 0)
+                            throw new TwoCaptchaSolveTimeoutError();
+                        await delay(Math.min(pollIntervalMs, remainingMs), solveController.signal);
+                        callerSignal.throwIfAborted();
+                        if (now() - startedAt >= timeoutMs)
+                            throw new TwoCaptchaSolveTimeoutError();
+                        const pollResult = await postJson(fetchImpl, endpoint(baseUrl, "getTaskResult"), { clientKey: apiKey, taskId }, solveController.signal, phase, [apiKey]);
+                        if (!pollResult.ok || pollResult.payload.errorId !== 0) {
+                            throw unavailableForPayload(pollResult.payload, phase);
+                        }
+                        if (pollResult.payload.status === "processing")
+                            continue;
+                        if (pollResult.payload.status !== "ready") {
+                            throw new ResolverVendorUnavailableError(TWOCAPTCHA_VENDOR_ID, "transport_failure", { phase });
+                        }
+                        const token = tokenFrom(pollResult.payload, challenge);
+                        if (!token?.trim()) {
+                            throw new ResolverVendorUnavailableError(TWOCAPTCHA_VENDOR_ID, "transport_failure", { phase });
+                        }
+                        return { form: "token", token };
                     }
-                    return { form: "token", token };
-                }
+                };
+                return traceRecorder
+                    ? await traceRecorder.runSpan("resolver.vendor.poll_result", pollResult, {
+                        attributes: {
+                            vendor: TWOCAPTCHA_VENDOR_ID,
+                            challenge_kind: challenge.kind,
+                        },
+                        onError: (error) => spanErrorAttributes(error, "poll_result"),
+                    })
+                    : await pollResult();
             }
             catch (error) {
                 if (callerSignal.aborted)
@@ -247,10 +349,12 @@ export function createTwoCaptchaResolverVendorAdapter(options) {
                         phase,
                     });
                 }
-                if (error instanceof ResolverVendorUnavailableError)
+                if (error instanceof ResolverVendorUnavailableError ||
+                    error instanceof ResolverChallengeVerdictError) {
                     throw error;
+                }
                 throw new ResolverVendorUnavailableError(TWOCAPTCHA_VENDOR_ID, "transport_failure", {
-                    cause: error,
+                    ...safeCauseOptions(error, [apiKey]),
                     phase,
                 });
             }

package/dist/runtime/resolver-vendors/types.d.ts

@@ -55,8 +55,8 @@ export interface ResolverVendorAdapter {
     getIssuingIdentity?(solution: ChallengeSolution, requestedIdentity: ResolverIdentity | undefined, challenge: ProviderChallenge): ResolverIssuingIdentity | undefined;
     solve(challenge: ProviderChallenge, identity: ResolverIdentity | undefined, signal: AbortSignal, traceRecorder?: TraceRecorder, transport?: ResolverVendorTransport): Promise<ChallengeSolution>;
 }
-export type ResolverVendorUnavailableReason = "missing_credentials" | "missing_transport" | "allocation_exhausted" | "transport_failure" | "timeout" | "not_implemented";
-export type ResolverChallengeVerdictReason = "human_puzzle";
+export type ResolverVendorUnavailableReason = "missing_credentials" | "missing_proxy_identity" | "missing_client_profile" | "missing_transport" | "allocation_exhausted" | "transport_failure" | "timeout" | "not_implemented";
+export type ResolverChallengeVerdictReason = "human_puzzle" | "solve_failed";
 type ResolverErrorOptions = {
     /** Raw cause; adapters must not place bodies, cookies, headers, credentials, or proxy URLs here. */
     readonly cause?: unknown;

package/dist/runtime/resolver-vendors/types.js

@@ -56,7 +56,9 @@ export class ResolverChallengeVerdictError extends Error {
     vendor;
     reason;
     constructor(vendor, reason, options = {}) {
-        super(`Resolver vendor ${vendor} returned a challenge verdict: ${reason}`);
+        super(reason === "solve_failed"
+            ? `Resolver vendor ${vendor} attempted the challenge but did not solve it`
+            : `Resolver vendor ${vendor} returned a challenge verdict: ${reason}`);
         this.vendor = vendor;
         this.reason = reason;
         this.name = "ResolverChallengeVerdictError";

package/dist/runtime/resolver.d.ts

@@ -1,12 +1,9 @@
-import type { ChallengeSolution, ProviderCache, ProviderChallenge, ProviderChallengeKind, ProviderResolverConfig, ProviderResolverVendor, ResolverContext } from "../types.js";
+import { type ProxyResolutionOptions } from "../config/loader.js";
+import type { ChallengeSolution, ProviderCache, ProviderChallenge, ProviderChallengeKind, ProviderProxyMode, ProviderResolverConfig, ProviderResolverVendor, ResolverContext } from "../types.js";
 import { type ResolverIdentity, type ResolverVendorAdapter, type ResolverVendorTransport } from "./resolver-vendors/types.js";
 import type { TraceRecorder } from "./trace.js";
-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;
+export { createUnsupportedResolverClient, RESOLVER_INSTRUMENTATION_METADATA, } from "./resolver-shared.js";
+export { APIFUSE__CDP_POOL__URL, APIFUSE__RESOLVER__2CAPTCHA__API_KEY, APIFUSE__RESOLVER__CAPMONSTER__API_KEY, APIFUSE__RESOLVER__CAPSOLVER__API_KEY, APIFUSE__RESOLVER__TIMEOUT_MS, DEFAULT_RESOLVER_TIMEOUT_MS, } from "./resolver-config.js";
 type EnvLike = Record<string, string | undefined>;
 type ResolverChainClient = ResolverContext & {
     solve(challenge: ProviderChallenge, signal?: AbortSignal, traceRecorder?: TraceRecorder): Promise<ChallengeSolution>;
@@ -14,6 +11,14 @@ type ResolverChainClient = ResolverContext & {
 export interface ResolverRuntimeOptions {
     readonly allowedHosts?: readonly string[];
     readonly cache?: ProviderCache;
+    /** Inputs for SDK-owned lazy proxy resolution. The SDK never accepts a caller-built identity. */
+    readonly proxyIntent?: {
+        readonly mode: ProviderProxyMode;
+        readonly upstream: NonNullable<ProxyResolutionOptions["upstream"]>;
+        readonly affinityKey?: ProxyResolutionOptions["affinityKey"];
+        readonly telemetry?: ProxyResolutionOptions["telemetry"];
+        readonly userAgent?: string;
+    };
     /** Server-owned context/proxy scope used only for identity-bound cache entries. */
     readonly identityScope?: string;
     /** SDK-owned transport already bound to the resolved proxy lease and client profile. */
@@ -25,7 +30,6 @@ export interface ResolverRuntimeOptions {
         readonly identityScope?: string;
     }) => ResolverVendorTransport;
 }
-export declare const RESOLVER_INSTRUMENTATION_METADATA: unique symbol;
 export type ResolverInstrumentationMetadata = {
     readonly target: ResolverContext;
     readonly traceRecorder: TraceRecorder;
@@ -33,6 +37,8 @@ export type ResolverInstrumentationMetadata = {
 export type ResolverAdapterFactory = (configuration: string, timeoutMs: number, allowedHosts: readonly string[]) => ResolverVendorAdapter;
 export declare const RESOLVER_ADAPTER_REGISTRY: Partial<Readonly<Record<ProviderResolverVendor, ResolverAdapterFactory>>>;
 export declare function swapResolverAdapterFactoryForTests(vendor: ProviderResolverVendor, factory: ResolverAdapterFactory | undefined): () => void;
+/** Internal test seam; deliberately not re-exported from the package root. */
+export declare function swapResolverDefaultUserAgentForTests(resolver: (() => string | undefined) | undefined): () => void;
 /** Remove the cached entry for the exact solution object returned by this resolver. */
 export declare function invalidateResolverSolution(resolver: ResolverContext, challenge: ProviderChallenge, solution: ChallengeSolution): Promise<void>;
 export declare function createResolverClient(options: {
@@ -41,14 +47,13 @@ export declare function createResolverClient(options: {
     readonly unavailableReason?: string;
     readonly cache?: ProviderCache;
     readonly identity?: ResolverIdentity;
+    readonly proxyIntent?: ResolverRuntimeOptions["proxyIntent"];
     readonly transport?: ResolverVendorTransport;
     readonly createTransport?: ResolverRuntimeOptions["createTransport"];
     readonly clientProfile?: string;
     readonly allowedHosts?: readonly string[];
 }): ResolverChainClient;
-export declare function createUnsupportedResolverClient(reason?: string): ResolverContext;
 export declare function bindResolverSignal(resolver: ResolverContext, defaultSignal: AbortSignal | undefined): ResolverContext;
 export declare function createResolverClientFromEnv(config: ProviderResolverConfig | undefined, env?: EnvLike, options?: ResolverRuntimeOptions): ResolverContext;
 /** Internal test seam; deliberately not re-exported from the package root. */
 export declare function createResolverClientFromEnvForTests(config: ProviderResolverConfig | undefined, env: EnvLike, options: ResolverRuntimeOptions, adapterFactories: Partial<Readonly<Record<ProviderResolverVendor, ResolverAdapterFactory>>>): ResolverContext;
-export {};