@apifuse/provider-sdk 2.2.0-beta.22 → 2.2.0-beta.24

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @apifuse/provider-sdk Changelog
 
+## 2.2.0-beta.24
+
+- Release candidate for main commit 0f21a2959dcbb9b96fe426259259d0870cfc537f.
+
+## 2.2.0-beta.23
+
+- Release candidate for main commit 36b3bedc9c14913c4152c4631cc87de71062f21f.
+
 ## 2.2.0-beta.22
 
 - Release candidate for main commit b8bf920b5ca053d1bf43018167fd4eedff01700d.

package/bin/apifuse-dev.ts

@@ -8,8 +8,10 @@ import {
 	createCredentialContext,
 	createEnvContext,
 	createHttpClient,
+	createOcrClientFromEnv,
 	createProviderCache,
 	createProviderChoiceContext,
+	createUnsupportedResolverClient,
 	createStealthClient,
 	createSttClientFromEnv,
 	PROVIDER_RUNTIME_CHOICE_TOKEN_MASTER_SECRET_ENV,
@@ -96,7 +98,9 @@ export function createProviderContext(provider: ProviderDefinition): {
 		state,
 		trace: createTraceContext(),
 		stealth: createStealthClient("http://localhost"),
+		ocr: createOcrClientFromEnv(provider.ocr),
 		stt: createSttClientFromEnv(provider.stt),
+		resolver: createUnsupportedResolverClient("Resolver is not available in apifuse dev"),
 		choice: createProviderChoiceContext({
 			providerId: provider.id,
 			env,

package/bin/apifuse-pack-types.ts

@@ -18,7 +18,7 @@
 //   3. A Node (not bun) ESM runtime import — node does not tolerate
 //      extensionless relative specifiers, bun does.
 //
-// A deliberate negative control proves the fixture compiler actually fails on
+// Deliberate negative controls prove the fixture compiler actually fails on
 // type errors, so this check cannot rot into a false-positive green.
 
 import { execFileSync, spawnSync } from "node:child_process";
@@ -36,6 +36,182 @@ const PACK_RESULT_SCHEMA = z.array(
 const KEEP_TEMP = process.env.APIFUSE__PACK_TYPES__KEEP_TEMP === "1";
 const sdkRoot = process.cwd();
 
+const NEGATIVE_CONTROLS = [
+	{
+		filename: "negative-control-provider-error-name.ts",
+		expectedCode: "TS2322",
+		description: "ProviderError.name remains a string",
+		source: [
+			'import { ProviderError } from "@apifuse/provider-sdk";',
+			"",
+			"// Intentionally wrong: name is a string. If this file compiles, the",
+			"// fixture consumer is not actually type-checking and the guard is void.",
+			'export const mustNotCompile: number = new ProviderError("boom").name;',
+			"",
+		].join("\n"),
+	},
+	{
+		filename: "negative-control-unknown-resolver-vendor.ts",
+		expectedCode: "TS2322",
+		description: "ProviderResolverConfig rejects an unknown vendor",
+		source: [
+			'import type { ProviderResolverConfig } from "@apifuse/provider-sdk";',
+			"",
+			"export const mustNotCompile: ProviderResolverConfig = {",
+			'\tvendors: ["unknown-vendor"],',
+			'\tkinds: ["turnstile"],',
+			"};",
+			"",
+		].join("\n"),
+	},
+	{
+		filename: "negative-control-define-provider-resolver-vendor.ts",
+		expectedCode: "TS2322",
+		description: "defineProvider rejects an unknown resolver vendor",
+		source: [
+			'import { defineProvider, z } from "@apifuse/provider-sdk";',
+			"",
+			"export const mustNotCompile = defineProvider({",
+			'\tid: "invalid-resolver-vendor",',
+			'\tversion: "1.0.0",',
+			'\truntime: "standard",',
+			'\tresolver: { vendors: ["unknown-vendor"], kinds: ["turnstile"] },',
+			'\tmeta: { displayName: "Invalid Resolver Vendor", descriptionKey: "meta.description", category: "test" },',
+			"\toperations: {",
+			"\t\tprobe: {",
+			"\t\t\tinput: z.object({}),",
+			"\t\t\toutput: z.object({ ok: z.boolean() }),",
+			"\t\t\thandler: async () => ({ ok: true }),",
+			'\t\t\thealthCheckUnsupported: { reason: "type fixture" },',
+			"\t\t},",
+			"\t},",
+			"});",
+			"",
+		].join("\n"),
+	},
+	{
+		filename: "negative-control-unknown-challenge-kind.ts",
+		expectedCode: "TS2820",
+		description: "ProviderChallenge rejects an unknown challenge kind",
+		source: [
+			'import type { ProviderChallenge } from "@apifuse/provider-sdk";',
+			"",
+			"export const mustNotCompile: ProviderChallenge = {",
+			'\tkind: "funcaptcha",',
+			'\tsiteKey: "key",',
+			'\tpageUrl: "https://example.com",',
+			"};",
+			"",
+		].join("\n"),
+	},
+	{
+		filename: "negative-control-provider-challenge-kind.ts",
+		expectedCode: "TS2820",
+		description: "ProviderChallengeKind rejects an unknown challenge kind",
+		source: [
+			'import type { ProviderChallengeKind } from "@apifuse/provider-sdk";',
+			"",
+			'export const mustNotCompile: ProviderChallengeKind = "funcaptcha";',
+			"",
+		].join("\n"),
+	},
+	{
+		filename: "negative-control-cookie-solution-token-read.ts",
+		expectedCode: "TS2339",
+		description: "ChallengeSolution requires narrowing before reading token",
+		source: [
+			'import type { ChallengeSolution } from "@apifuse/provider-sdk";',
+			"",
+			"export function mustNotCompile(solution: ChallengeSolution): string {",
+			"\treturn solution.token;",
+			"}",
+			"",
+		].join("\n"),
+	},
+	{
+		filename: "negative-control-cookie-challenge-site-key.ts",
+		expectedCode: "TS2353",
+		description: "cookie-family challenges reject token-family fields",
+		source: [
+			'import type { ProviderChallenge } from "@apifuse/provider-sdk";',
+			"",
+			"export const mustNotCompile: ProviderChallenge = {",
+			'\tkind: "cloudflare_interstitial",',
+			'\tpageUrl: "https://example.com",',
+			'\tsiteKey: "not-allowed",',
+			"};",
+			"",
+		].join("\n"),
+	},
+	{
+		filename: "negative-control-recaptcha-v3-action.ts",
+		expectedCode: "TS2322",
+		description: "recaptcha_v3 challenges require action",
+		source: [
+			'import type { ProviderChallenge } from "@apifuse/provider-sdk";',
+			"",
+			"export const mustNotCompile: ProviderChallenge = {",
+			'\tkind: "recaptcha_v3",',
+			'\tsiteKey: "key",',
+			'\tpageUrl: "https://example.com",',
+			"};",
+			"",
+		].join("\n"),
+	},
+	{
+		filename: "negative-control-browser-cookie-expires.ts",
+		expectedCode: "TS2322",
+		description: "BrowserCookie.expires remains optional for session cookies",
+		source: [
+			'import type { BrowserCookie } from "@apifuse/provider-sdk";',
+			"",
+			"export function mustNotCompile(cookie: BrowserCookie): number {",
+			"\treturn cookie.expires;",
+			"}",
+			"",
+		].join("\n"),
+	},
+	{
+		filename: "negative-control-resolver-runtime-identity.ts",
+		expectedCode: "TS2353",
+		description: "ResolverRuntimeOptions does not accept caller-synthesized identity",
+		source: [
+			'import type { ResolverRuntimeOptions } from "@apifuse/provider-sdk";',
+			"",
+			"export const mustNotCompile: ResolverRuntimeOptions = {",
+			'\tidentity: "caller-controlled",',
+			"};",
+			"",
+		].join("\n"),
+	},
+	{
+		filename: "negative-control-resolver-runtime-allowed-hosts.ts",
+		expectedCode: "TS2322",
+		description: "ResolverRuntimeOptions.allowedHosts accepts only host strings",
+		source: [
+			'import type { ResolverRuntimeOptions } from "@apifuse/provider-sdk";',
+			"",
+			"export const mustNotCompile: ResolverRuntimeOptions = {",
+			'\tallowedHosts: ["example.com", 42],',
+			"};",
+			"",
+		].join("\n"),
+	},
+	{
+		filename: "negative-control-resolver-signal.ts",
+		expectedCode: "TS2345",
+		description: "ResolverContext.solve accepts only AbortSignal as its optional signal",
+		source: [
+			'import type { ProviderChallenge, ResolverContext } from "@apifuse/provider-sdk";',
+			"",
+			"declare const resolver: ResolverContext;",
+			"declare const challenge: ProviderChallenge;",
+			"resolver.solve(challenge, { aborted: false });",
+			"",
+		].join("\n"),
+	},
+] as const;
+
 const tempRoot = mkdtempSync(join(tmpdir(), "apifuse-provider-sdk-pack-types-"));
 const packDir = join(tempRoot, "pack");
 const consumerDir = join(tempRoot, "consumer");
@@ -123,8 +299,8 @@ function setUpFixtureConsumer(consumerDir: string, tarballPath: string): void {
 	writeFileSync(
 		join(consumerDir, "consumer.ts"),
 		[
-			'import { ProviderError, resolveProxy, SessionExpiredError, z } from "@apifuse/provider-sdk";',
-			'import type { NativeNetworkClient, NativeNetworkConnection, NativeProviderConfig, NativeProviderContext, NativeTcpEgressGrant, ProviderContext, ProviderFileRef, ProviderFilesContext, ProviderResolvedFile } from "@apifuse/provider-sdk";',
+			'import { defineProvider, invalidateResolverSolution, ProviderError, resolveProxy, SessionExpiredError, z } from "@apifuse/provider-sdk";',
+			'import type { BrowserCookie, ChallengeSolution, NativeNetworkClient, NativeNetworkConnection, NativeProviderConfig, NativeProviderContext, NativeTcpEgressGrant, ProviderChallenge, ProviderContext, ProviderFileRef, ProviderFilesContext, ProviderResolvedFile, ProviderResolverConfig, ResolverContext, ResolverRuntimeOptions } from "@apifuse/provider-sdk";',
 			'import type { ProxyProtocol, ProxyResolutionOptions, ProxyResolutionSource, ProxyVendorName, RequestOptions, ResolvedProxyConfig } from "@apifuse/provider-sdk";',
 			'import { defineCredentialsAuth } from "@apifuse/provider-sdk/provider";',
 			'import type { NativeNetworkClient as ProviderEntryNativeNetworkClient, ProviderFilesContext as ProviderEntryFilesContext } from "@apifuse/provider-sdk/provider";',
@@ -164,6 +340,25 @@ function setUpFixtureConsumer(consumerDir: string, tarballPath: string): void {
 			"const providerContext = undefined as unknown as ProviderContext;",
 			"const optionalFiles: ProviderFilesContext | undefined = providerContext.files;",
 			"const optionalNative: NativeProviderContext | undefined = providerContext.native;",
+			"export const providerResolver: ResolverContext = providerContext.resolver;",
+			'export const resolverRuntimeOptions: ResolverRuntimeOptions = { allowedHosts: ["example.com"], cache: providerContext.cache };',
+			"",
+			'export const turnstileChallenge: ProviderChallenge = { kind: "turnstile", siteKey: "key", pageUrl: "https://example.com" };',
+			"export const abortableResolverSolve = providerResolver.solve(turnstileChallenge, new AbortController().signal);",
+			'export const recaptchaV2Challenge: ProviderChallenge = { kind: "recaptcha_v2", siteKey: "key", pageUrl: "https://example.com" };',
+			'export const recaptchaV3Challenge: ProviderChallenge = { kind: "recaptcha_v3", siteKey: "key", pageUrl: "https://example.com", action: "login" };',
+			'export const hcaptchaChallenge: ProviderChallenge = { kind: "hcaptcha", siteKey: "key", pageUrl: "https://example.com" };',
+			'export const cloudflareInterstitialChallenge: ProviderChallenge = { kind: "cloudflare_interstitial", pageUrl: "https://example.com", blockedHtml: "<html></html>" };',
+			'export const awsWafChallenge: ProviderChallenge = { kind: "aws_waf", pageUrl: "https://example.com", captchaScript: "script" };',
+			'export const tokenSolution: ChallengeSolution = { form: "token", token: "solved-token" };',
+			'export const cookieSolution: ChallengeSolution = { form: "cookies", cookies: { cf_clearance: "clearance" }, userAgent: "fixture-agent" };',
+			"export const invalidation = invalidateResolverSolution(providerContext.resolver, awsWafChallenge, cookieSolution);",
+			'export const resolverConfig: ProviderResolverConfig = { vendors: ["browser", "capsolver"], kinds: ["cloudflare_interstitial", "turnstile"] };',
+			'export const resolverProvider = defineProvider({ id: "pack-types-resolver", version: "1.0.0", runtime: "standard", resolver: resolverConfig, meta: { displayName: "Pack Types Resolver", descriptionKey: "meta.description", category: "test" }, operations: { probe: { input: z.object({}), output: z.object({ ok: z.boolean() }), handler: async () => ({ ok: true }), healthCheckUnsupported: { reason: "type fixture" } } } });',
+			"export const resolverContext: ResolverContext = { solve: async () => tokenSolution };",
+			'export const browserCookie: BrowserCookie = { name: "persistent-id", value: "persistent-token", domain: "example.com", path: "/", expires: 1786698176, httpOnly: true, secure: true };',
+			'const browserPage = undefined as unknown as Awaited<ReturnType<ProviderContext["browser"]["newPage"]>>;',
+			"export const browserCookies: Promise<readonly BrowserCookie[]> = browserPage.cookies();",
 			'const queryCredentialOptions: RequestOptions = { sensitiveParams: { serviceKey: "type-test-key" } };',
 			"",
 			"export const witnesses = {",
@@ -190,6 +385,8 @@ function setUpFixtureConsumer(consumerDir: string, tarballPath: string): void {
 			"	nativeConfig,",
 			"	optionalFiles,",
 			"	optionalNative,",
+			"	browserCookie,",
+			"	browserCookies,",
 			"	queryCredentialOptions,",
 			"	defineCredentialsAuth,",
 			"	extractProviderContract,",
@@ -201,17 +398,9 @@ function setUpFixtureConsumer(consumerDir: string, tarballPath: string): void {
 		].join("\n"),
 	);
 
-	writeFileSync(
-		join(consumerDir, "negative-control.ts"),
-		[
-			'import { ProviderError } from "@apifuse/provider-sdk";',
-			"",
-			"// Intentionally wrong: name is a string. If this file compiles, the",
-			"// fixture consumer is not actually type-checking and the guard is void.",
-			'export const mustNotCompile: number = new ProviderError("boom").name;',
-			"",
-		].join("\n"),
-	);
+	for (const negativeControl of NEGATIVE_CONTROLS) {
+		writeFileSync(join(consumerDir, negativeControl.filename), negativeControl.source);
+	}
 }
 
 function compileFixtureConsumer(consumerDir: string): void {
@@ -223,31 +412,38 @@ function compileFixtureConsumer(consumerDir: string): void {
 }
 
 function assertNegativeControlFails(consumerDir: string): void {
-	const result = spawnSync(
-		"bun",
-		[
-			join(consumerDir, "node_modules", ".bin", "tsc"),
-			"--target",
-			"ES2022",
-			"--module",
-			"nodenext",
-			"--moduleResolution",
-			"nodenext",
-			"--strict",
-			"--noEmit",
-			"negative-control.ts",
-		],
-		{ cwd: consumerDir, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] },
-	);
-	if (result.status === 0) {
-		throw new Error(
-			"Negative control compiled cleanly: the fixture consumer is not detecting type errors, so the nodenext guard proves nothing.",
-		);
-	}
-	if (!`${result.stdout}\n${result.stderr}`.includes("TS2322")) {
-		throw new Error(
-			`Negative control failed for an unexpected reason (wanted TS2322):\n${result.stdout}\n${result.stderr}`,
+	for (const negativeControl of NEGATIVE_CONTROLS) {
+		const result = spawnSync(
+			"bun",
+			[
+				join(consumerDir, "node_modules", ".bin", "tsc"),
+				"--target",
+				"ES2022",
+				"--module",
+				"nodenext",
+				"--moduleResolution",
+				"nodenext",
+				"--strict",
+				"--noEmit",
+				negativeControl.filename,
+			],
+			{ cwd: consumerDir, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] },
 		);
+		if (result.status === 0) {
+			throw new Error(
+				'Negative control "' +
+					negativeControl.description +
+					'" (' +
+					negativeControl.filename +
+					") compiled cleanly: the fixture consumer is not detecting its error, so the guard proves nothing.",
+			);
+		}
+		const output = `${result.stdout}\n${result.stderr}`;
+		if (!output.includes(negativeControl.expectedCode)) {
+			throw new Error(
+				`Negative control "${negativeControl.description}" (${negativeControl.filename}) failed for an unexpected reason (wanted ${negativeControl.expectedCode}):\n${output}`,
+			);
+		}
 	}
 }
 

package/bin/apifuse-perf.ts

@@ -20,6 +20,7 @@ import {
 	type ProviderContext,
 	type ProviderDefinition,
 	ProviderError,
+	resolveProxy,
 	type Span,
 	type StealthClient,
 	type StealthResponse,
@@ -122,7 +123,7 @@ export async function main() {
 
 		let proxySuite: ProfileSuite | undefined;
 		if (args.compareProxy) {
-			assertProxyConfigured(config);
+			await assertProxyConfigured(provider);
 			proxySuite = await runProfileSuite({
 				args,
 				config,
@@ -454,14 +455,20 @@ async function loadFixtureReplay(providerDirectory: string): Promise<FixtureRepl
 	};
 }
 
-function assertProxyConfigured(config: ApiFuseConfig): void {
-	if (config.proxy?.url || process.env.APIFUSE__PROXY__URL) {
-		return;
+async function assertProxyConfigured(provider: ProviderDefinition): Promise<void> {
+	const policy = provider.proxy;
+	if (!policy || typeof policy !== "object" || policy.mode === "disabled") {
+		throw new Error(
+			"--compare-proxy requires an enabled ProviderProxyPolicy on the provider.",
+		);
 	}
 
-	throw new Error(
-		"--compare-proxy requires a proxy URL in apifuse.config.ts or APIFUSE__PROXY__URL.",
-	);
+	const resolved = await resolveProxy({ proxyPolicy: policy });
+	if (!resolved.url) {
+		throw new Error(
+			"--compare-proxy could not resolve the provider proxy policy; configure its allocator credentials (for smartproxy, APIFUSE__PROXY__SMARTPROXY_APP_KEY).",
+		);
+	}
 }
 
 async function runProfileSuite(options: {
@@ -629,22 +636,18 @@ function createBaseContext(options: {
 	traceContext: ReturnType<typeof createTraceContext>;
 }): ProviderContext {
 	const upstream = {
-		...{ proxy: options.provider.proxy },
-		proxy: options.proxyEnabled,
+		proxy: options.proxyEnabled ? options.provider.proxy : false,
 	};
-	const apifuseConfig = options.proxyEnabled ? options.config : {};
 	const http =
 		options.forceFixtureReplay && options.fixtureReplay
 			? createFixtureHttpClient(options.fixtureReplay.raw)
 			: createHttpClient(getProviderBaseUrl(options.provider), {
-					apifuseConfig,
 					upstream,
 				});
 	const stealth =
 		options.forceFixtureReplay && options.fixtureReplay
 			? createFixtureStealthClient(options.fixtureReplay.rawText)
 			: createStealthClient(getProviderBaseUrl(options.provider), {
-					apifuseConfig,
 					upstream,
 				});
 

package/bin/apifuse-record.ts

@@ -8,9 +8,11 @@ import { pathToFileURL } from "node:url";
 import {
 	createBypassProviderCache,
 	createHttpClient,
+	createOcrClientFromEnv,
 	createProviderChoiceContext,
 	createStealthClient,
 	createSttClientFromEnv,
+	createUnsupportedResolverClient,
 	executeOperation,
 	type HttpClient,
 	type HttpResponse,
@@ -536,7 +538,9 @@ function createCaptureContext(provider: ProviderRuntime, baseUrl: string, saniti
 				throw new Error("Auth prompts are not available in apifuse record.");
 			},
 		},
+		ocr: createOcrClientFromEnv(provider.ocr),
 		stt: createSttClientFromEnv(provider.stt),
+		resolver: createUnsupportedResolverClient("Resolver is not available in apifuse record"),
 		choice: createProviderChoiceContext({
 			providerId: provider.id,
 			env,

package/dist/config/loader.d.ts

@@ -2,7 +2,7 @@ import { Redis } from "ioredis";
 import type { ProviderProxyPolicy, TraceConfig } from "../types.js";
 import { type ProxyProtocol } from "../runtime/proxy-nodemaven.js";
 export type { ProxyProtocol } from "../runtime/proxy-nodemaven.js";
-/** Proxy vendors the SDK resolves natively (as opposed to the static env path). */
+/** Proxy vendors with SDK-managed resolution. */
 export type ProxyVendorName = "smartproxy" | "nodemaven";
 export declare const SMARTPROXY_APP_KEY_ENV = "APIFUSE__PROXY__SMARTPROXY_APP_KEY";
 export declare const SMARTPROXY_MAX_LIFETIME_MINUTES = 2000;
@@ -14,13 +14,6 @@ export declare const DEFAULT_PROXY_LIFETIME_ENV = "APIFUSE__PROXY__DEFAULT_LIFET
 export declare const PROVIDER_CACHE_REDIS_URL_ENV = "APIFUSE__PROVIDER__CACHE_REDIS_URL";
 export declare const PROVIDER_STATE_REDIS_URL_ENV = "APIFUSE__PROVIDER__STATE_REDIS_URL";
 export declare const REDIS_URL_ENV = "APIFUSE__REDIS__URL";
-export type ProxyOptions = {
-    url: string;
-};
-export type ProxyConfig = Partial<ProxyOptions> & {
-    provider?: string;
-    apiKey?: string;
-};
 export type BrowserConfig = {
     executablePath?: string;
     headless?: boolean;
@@ -30,7 +23,6 @@ export type SessionConfig = {
     path?: string;
 };
 export type ApiFuseConfig = {
-    proxy?: ProxyConfig;
     browser?: BrowserConfig;
     session?: SessionConfig;
     trace?: TraceConfig;
@@ -41,7 +33,6 @@ export type ProxyResolutionOptions = {
     upstream?: {
         proxy?: boolean | ProviderProxyPolicy;
     };
-    apifuseConfig?: Pick<ApiFuseConfig, "proxy">;
     proxyPolicy?: ProviderProxyPolicy;
     affinityKey?: string;
     /** Zero-based proxy-pool attempt index used by SDK transports for failover. */
@@ -179,7 +170,7 @@ export declare function resolveWithVendor(vendor: ProxyVendorName, policy: Provi
  * Ordered list of SDK-native proxy vendors declared by the policy. `providers`
  * takes precedence over the legacy singular `provider`; the platform default
  * env is the final fallback. Non-registry names (decodo/custom) are dropped so
- * an all-static chain falls through to the legacy env-URL path unchanged.
+ * an all-deprecated chain has no managed adapter.
  */
 export declare function resolveVendorChain(policy: ProviderProxyPolicy): ProxyVendorName[];
 /**
@@ -211,9 +202,8 @@ export declare function maxPolicyProxyPoolSpan(policy: ProviderProxyPolicy): num
  *  - the method is safe/idempotent — an unsafe request must never be duplicated
  *    across the pool even if some framework default would allow it;
  *  - the policy resolves a non-empty *registry* vendor chain (smartproxy /
- *    nodemaven). Static vendors (custom / decodo) and credential-less policies
- *    resolve no allocator pool, so every attempt would hit the same endpoint
- *    with no possible crossover — they keep the retry budget.
+ *    nodemaven). Deprecated vendors (custom / decodo) resolve no managed pool,
+ *    so there is no possible endpoint crossover — they keep the retry budget.
  *
  * The widened cap is bounded by the chain's true maximum span (sum of each
  * vendor's max pool size), so a large NodeMaven pool (≤50) stays reachable and
@@ -232,8 +222,8 @@ export declare function maxPolicyProxyPoolSpan(policy: ProviderProxyPolicy): num
  *    endpoint each attempt resolves (even a repeated one), so no de-duplication;
  *  - the method is safe/idempotent — an unsafe request is never duplicated;
  *  - the policy resolves a non-empty registry vendor chain (smartproxy /
- *    nodemaven). Static vendors (custom / decodo) resolve the same URL every
- *    attempt, so there is nothing to rotate or de-duplicate.
+ *    nodemaven). Deprecated vendors (custom / decodo) resolve no managed
+ *    endpoint, so there is nothing to rotate or de-duplicate.
  */
 export declare function policyRotatesTransportVendorChain(input: {
     policy: ProviderProxyPolicy | undefined;
@@ -252,9 +242,8 @@ export declare function resolvePolicyTransportAttemptCap(input: {
  * A registry vendor chain (smartproxy/nodemaven) resolves a potentially
  * *different* endpoint per flat attempt index, so a transport retry should
  * advance across endpoints and de-duplicate once the chain stops yielding new
- * ones. Static/custom/decodo policies (empty registry chain) resolve the *same*
- * URL every attempt by design — retrying that same endpoint is intended, so the
- * transport loop must not de-duplicate them.
+ * ones. Deprecated custom/decodo policies have an empty registry chain and no
+ * managed endpoint, so the transport loop has nothing to rotate or de-duplicate.
  */
 export declare function policyResolvesRegistryVendorChain(policy: ProviderProxyPolicy | undefined): boolean;
 /** Map a resolved proxy source label to the vendor that served it. */