@apifuse/provider-sdk 2.2.0-beta.3 → 2.2.0-beta.4

package/src/runtime/proxy-telemetry.ts

@@ -4,7 +4,7 @@ import type {
 	ProxyResolutionTelemetryEvent,
 	ProxyTelemetrySink,
 	SmartproxyAllocatorBodyClass,
-} from "../config/loader";
+} from "../config/loader.js";
 
 export const PROVIDER_TELEMETRY_HEADER = "X-ApiFuse-Provider-Telemetry";
 
@@ -55,31 +55,18 @@ const CACHE_STATUS_SEVERITY: Record<ProxyCacheStatus, number> = {
 	allocator: 7,
 };
 
-function sumOptional(
-	left: number | undefined,
-	right: number | undefined,
-): number | undefined {
+function sumOptional(left: number | undefined, right: number | undefined): number | undefined {
 	const total = (left ?? 0) + (right ?? 0);
 	return total > 0 ? total : undefined;
 }
 
-function maxOptional(
-	left: number | undefined,
-	right: number | undefined,
-): number | undefined {
-	const values = [left, right].filter(
-		(value): value is number => typeof value === "number",
-	);
+function maxOptional(left: number | undefined, right: number | undefined): number | undefined {
+	const values = [left, right].filter((value): value is number => typeof value === "number");
 	return values.length > 0 ? Math.max(...values) : undefined;
 }
 
-function worseStatus(
-	left: ProxyCacheStatus,
-	right: ProxyCacheStatus,
-): ProxyCacheStatus {
-	return CACHE_STATUS_SEVERITY[right] > CACHE_STATUS_SEVERITY[left]
-		? right
-		: left;
+function worseStatus(left: ProxyCacheStatus, right: ProxyCacheStatus): ProxyCacheStatus {
+	return CACHE_STATUS_SEVERITY[right] > CACHE_STATUS_SEVERITY[left] ? right : left;
 }
 
 function encodeBase64Url(value: string): string {
@@ -97,9 +84,7 @@ export class ProxyTelemetryCollector implements ProxyTelemetrySink {
 			cacheHit: event.cacheHit,
 			resolutionMs: Math.max(0, Math.floor(event.resolutionMs)),
 			allocatorMs:
-				event.allocatorMs === undefined
-					? undefined
-					: Math.max(0, Math.floor(event.allocatorMs)),
+				event.allocatorMs === undefined ? undefined : Math.max(0, Math.floor(event.allocatorMs)),
 			allocatorStatus:
 				event.allocatorStatus === undefined
 					? undefined
@@ -110,30 +95,20 @@ export class ProxyTelemetryCollector implements ProxyTelemetrySink {
 					? undefined
 					: Math.max(1, Math.floor(event.allocatorAttempts)),
 			lockWaitMs:
-				event.lockWaitMs === undefined
-					? undefined
-					: Math.max(0, Math.floor(event.lockWaitMs)),
+				event.lockWaitMs === undefined ? undefined : Math.max(0, Math.floor(event.lockWaitMs)),
 			redisReadMs:
-				event.redisReadMs === undefined
-					? undefined
-					: Math.max(0, Math.floor(event.redisReadMs)),
+				event.redisReadMs === undefined ? undefined : Math.max(0, Math.floor(event.redisReadMs)),
 			redisWriteMs:
-				event.redisWriteMs === undefined
-					? undefined
-					: Math.max(0, Math.floor(event.redisWriteMs)),
+				event.redisWriteMs === undefined ? undefined : Math.max(0, Math.floor(event.redisWriteMs)),
 			poolAgeMs:
-				event.poolAgeMs === undefined
-					? undefined
-					: Math.max(0, Math.floor(event.poolAgeMs)),
+				event.poolAgeMs === undefined ? undefined : Math.max(0, Math.floor(event.poolAgeMs)),
 			poolExpiresInMs:
 				event.poolExpiresInMs === undefined
 					? undefined
 					: Math.max(0, Math.floor(event.poolExpiresInMs)),
 			attempts: Math.max(1, Math.floor(event.attempts || 1)),
 			refreshes:
-				event.refreshes === undefined
-					? undefined
-					: Math.max(0, Math.floor(event.refreshes)),
+				event.refreshes === undefined ? undefined : Math.max(0, Math.floor(event.refreshes)),
 		});
 	}
 
@@ -148,9 +123,7 @@ export class ProxyTelemetryCollector implements ProxyTelemetrySink {
 			...(event.proxyHash ? { proxyHash: event.proxyHash.slice(0, 16) } : {}),
 			outcome: event.outcome === "ok" ? "ok" : "error",
 			...(event.errorCode ? { errorCode: event.errorCode.slice(0, 80) } : {}),
-			...(event.status === undefined
-				? {}
-				: { status: Math.max(0, Math.floor(event.status)) }),
+			...(event.status === undefined ? {} : { status: Math.max(0, Math.floor(event.status)) }),
 			...(event.durationMs === undefined
 				? {}
 				: { durationMs: Math.max(0, Math.floor(event.durationMs)) }),
@@ -170,18 +143,12 @@ export class ProxyTelemetryCollector implements ProxyTelemetrySink {
 				allocatorMs: sumOptional(acc.allocatorMs, event.allocatorMs),
 				allocatorStatus: event.allocatorStatus ?? acc.allocatorStatus,
 				allocatorBodyClass: event.allocatorBodyClass ?? acc.allocatorBodyClass,
-				allocatorAttempts: sumOptional(
-					acc.allocatorAttempts,
-					event.allocatorAttempts,
-				),
+				allocatorAttempts: sumOptional(acc.allocatorAttempts, event.allocatorAttempts),
 				lockWaitMs: sumOptional(acc.lockWaitMs, event.lockWaitMs),
 				redisReadMs: sumOptional(acc.redisReadMs, event.redisReadMs),
 				redisWriteMs: sumOptional(acc.redisWriteMs, event.redisWriteMs),
 				poolAgeMs: maxOptional(acc.poolAgeMs, event.poolAgeMs),
-				poolExpiresInMs: maxOptional(
-					acc.poolExpiresInMs,
-					event.poolExpiresInMs,
-				),
+				poolExpiresInMs: maxOptional(acc.poolExpiresInMs, event.poolExpiresInMs),
 				attempts: acc.attempts + event.attempts,
 				refreshes: sumOptional(acc.refreshes, event.refreshes),
 			}),
@@ -194,9 +161,7 @@ export class ProxyTelemetryCollector implements ProxyTelemetrySink {
 				cacheStatus: aggregate.cacheStatus,
 				cacheHit: aggregate.cacheHit,
 				resolutionMs: aggregate.resolutionMs,
-				...(aggregate.allocatorMs !== undefined
-					? { allocatorMs: aggregate.allocatorMs }
-					: {}),
+				...(aggregate.allocatorMs !== undefined ? { allocatorMs: aggregate.allocatorMs } : {}),
 				...(aggregate.allocatorStatus !== undefined
 					? { allocatorStatus: aggregate.allocatorStatus }
 					: {}),
@@ -206,40 +171,26 @@ export class ProxyTelemetryCollector implements ProxyTelemetrySink {
 				...(aggregate.allocatorAttempts !== undefined
 					? { allocatorAttempts: aggregate.allocatorAttempts }
 					: {}),
-				...(aggregate.lockWaitMs !== undefined
-					? { lockWaitMs: aggregate.lockWaitMs }
-					: {}),
-				...(aggregate.redisReadMs !== undefined
-					? { redisReadMs: aggregate.redisReadMs }
-					: {}),
-				...(aggregate.redisWriteMs !== undefined
-					? { redisWriteMs: aggregate.redisWriteMs }
-					: {}),
-				...(aggregate.poolAgeMs !== undefined
-					? { poolAgeMs: aggregate.poolAgeMs }
-					: {}),
+				...(aggregate.lockWaitMs !== undefined ? { lockWaitMs: aggregate.lockWaitMs } : {}),
+				...(aggregate.redisReadMs !== undefined ? { redisReadMs: aggregate.redisReadMs } : {}),
+				...(aggregate.redisWriteMs !== undefined ? { redisWriteMs: aggregate.redisWriteMs } : {}),
+				...(aggregate.poolAgeMs !== undefined ? { poolAgeMs: aggregate.poolAgeMs } : {}),
 				...(aggregate.poolExpiresInMs !== undefined
 					? { poolExpiresInMs: aggregate.poolExpiresInMs }
 					: {}),
 				attempts: aggregate.attempts,
-				...(aggregate.refreshes !== undefined
-					? { refreshes: aggregate.refreshes }
-					: {}),
+				...(aggregate.refreshes !== undefined ? { refreshes: aggregate.refreshes } : {}),
 				...(this.#attempts.length > 0
 					? {
 							attemptSamples: this.#attempts.map((attempt, index) => ({
 								n: index + 1,
 								a: attempt.attempt,
-								...(attempt.poolIndex === undefined
-									? {}
-									: { i: attempt.poolIndex }),
+								...(attempt.poolIndex === undefined ? {} : { i: attempt.poolIndex }),
 								...(attempt.proxyHash ? { h: attempt.proxyHash } : {}),
 								o: attempt.outcome,
 								...(attempt.errorCode ? { c: attempt.errorCode } : {}),
 								...(attempt.status === undefined ? {} : { s: attempt.status }),
-								...(attempt.durationMs === undefined
-									? {}
-									: { d: attempt.durationMs }),
+								...(attempt.durationMs === undefined ? {} : { d: attempt.durationMs }),
 							})),
 						}
 					: {}),

package/src/runtime/redis.ts

@@ -1,4 +1,4 @@
-import Redis from "ioredis";
+import { Redis } from "ioredis";
 
 export type ProviderRedisClient = Redis;
 
@@ -43,9 +43,7 @@ export async function withRedisTimeout<T>(
 				}
 			}, options.timeoutMs);
 		});
-		const operationResult = options.onError
-			? operation().catch(options.onError)
-			: operation();
+		const operationResult = options.onError ? operation().catch(options.onError) : operation();
 		return await Promise.race([operationResult, timeout]);
 	} finally {
 		if (timeoutId) clearTimeout(timeoutId);
@@ -56,10 +54,7 @@ export function redisStatus(redis: ProviderRedisClient): string {
 	return redis.status;
 }
 
-async function waitForRedisReady(
-	redis: ProviderRedisClient,
-	timeoutMs: number,
-): Promise<boolean> {
+async function waitForRedisReady(redis: ProviderRedisClient, timeoutMs: number): Promise<boolean> {
 	let timeoutId: ReturnType<typeof setTimeout> | undefined;
 	let settled = false;
 
@@ -80,10 +75,7 @@ async function waitForRedisReady(
 		const onReady = () => finish(true);
 		const onUnavailable = () => finish(false);
 
-		timeoutId = setTimeout(
-			() => finish(redisStatus(redis) === "ready"),
-			timeoutMs,
-		);
+		timeoutId = setTimeout(() => finish(redisStatus(redis) === "ready"), timeoutMs);
 		redis.once("ready", onReady);
 		redis.once("close", onUnavailable);
 		redis.once("end", onUnavailable);

package/src/runtime/request-options.ts

@@ -1,12 +1,6 @@
-import type {
-	RequestParamPrimitive,
-	RequestParams,
-	RequestParamValue,
-} from "../types";
+import type { RequestParamPrimitive, RequestParams, RequestParamValue } from "../types.js";
 
-function isParamArray(
-	value: RequestParamValue,
-): value is readonly RequestParamPrimitive[] {
+function isParamArray(value: RequestParamValue): value is readonly RequestParamPrimitive[] {
 	return Array.isArray(value);
 }
 
@@ -29,8 +23,7 @@ export function appendQueryParams(url: string, params?: RequestParams): string {
 	const parsed = new URL(url);
 	for (const [key, value] of Object.entries(params)) {
 		if (isParamArray(value)) {
-			for (const item of value)
-				appendQueryValue(parsed.searchParams, key, item);
+			for (const item of value) appendQueryValue(parsed.searchParams, key, item);
 			continue;
 		}
 		appendQueryValue(parsed.searchParams, key, value);
@@ -39,9 +32,7 @@ export function appendQueryParams(url: string, params?: RequestParams): string {
 	return parsed.toString();
 }
 
-export function normalizeHttpRequestBody(
-	body: unknown,
-): string | Buffer | undefined {
+export function normalizeHttpRequestBody(body: unknown): string | Buffer | undefined {
 	if (body === undefined) {
 		return undefined;
 	}

package/src/runtime/state.ts

@@ -1,5 +1,5 @@
-import { providerStateRedisUrlFromEnv } from "../config/loader";
-import { ProviderError } from "../errors";
+import { providerStateRedisUrlFromEnv } from "../config/loader.js";
+import { ProviderError } from "../errors.js";
 import type {
 	ProviderRuntimeState,
 	ProviderStateNamespace,
@@ -7,13 +7,13 @@ import type {
 	StateNamespaceOptions,
 	StateValue,
 	StateWriteOptions,
-} from "../types";
+} from "../types.js";
 import {
 	createProviderRedisClient,
 	ensureRedisReady,
 	type ProviderRedisClient,
 	withRedisTimeout,
-} from "./redis";
+} from "./redis.js";
 
 const DEFAULT_REDIS_TIMEOUT_MS = 250;
 const REDIS_STATE_PREFIX = "apifuse:provider-state:v1";
@@ -57,37 +57,24 @@ async function withRequiredRedis<T>(operation: () => Promise<T>): Promise<T> {
 	return await withRedisTimeout(operation, {
 		timeoutMs: DEFAULT_REDIS_TIMEOUT_MS,
 		onTimeout: () => {
-			throw new UnsupportedProviderStateError(
-				"Provider runtime state Redis timed out",
-			);
+			throw new UnsupportedProviderStateError("Provider runtime state Redis timed out");
 		},
 		onError: () => {
-			throw new UnsupportedProviderStateError(
-				"Provider runtime state Redis is unavailable",
-			);
+			throw new UnsupportedProviderStateError("Provider runtime state Redis is unavailable");
 		},
 	});
 }
 
 async function requireRedisReady(redis: ProviderRedisClient): Promise<void> {
 	if (await ensureRedisReady(redis, DEFAULT_REDIS_TIMEOUT_MS)) return;
-	throw new UnsupportedProviderStateError(
-		"Provider runtime state Redis is unavailable",
-	);
+	throw new UnsupportedProviderStateError("Provider runtime state Redis is unavailable");
 }
 
-function providerStatePrefix(
-	providerId: string | undefined,
-	namespace: string,
-): string {
+function providerStatePrefix(providerId: string | undefined, namespace: string): string {
 	return `${REDIS_STATE_PREFIX}:${providerId ?? "default"}:${namespace}`;
 }
 
-function providerStateKey(
-	providerId: string | undefined,
-	namespace: string,
-	key: string,
-): string {
+function providerStateKey(providerId: string | undefined, namespace: string, key: string): string {
 	return `${providerStatePrefix(providerId, namespace)}:${key}`;
 }
 
@@ -132,9 +119,7 @@ function envelopeFromJson(
 	if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
 		return null;
 	}
-	const record: Record<string, unknown> = Object.fromEntries(
-		Object.entries(parsed),
-	);
+	const record: Record<string, unknown> = Object.fromEntries(Object.entries(parsed));
 	if (
 		typeof record.version !== "number" ||
 		typeof record.expiresAt !== "string" ||
@@ -182,9 +167,7 @@ class RedisProviderStateNamespace implements ProviderStateNamespace {
 
 	private async activeKeys(): Promise<string[]> {
 		await requireRedisReady(this.backend.redis);
-		return await withRequiredRedis(() =>
-			this.backend.redis.keys(`${this.prefix()}*`),
-		);
+		return await withRequiredRedis(() => this.backend.redis.keys(`${this.prefix()}*`));
 	}
 
 	private enforceValueSize(value: unknown): void {
@@ -207,47 +190,29 @@ class RedisProviderStateNamespace implements ProviderStateNamespace {
 		}
 	}
 
-	async list<T>(options?: {
-		limit?: number;
-		prefix?: string;
-	}): Promise<StateValue<T>[]> {
+	async list<T>(options?: { limit?: number; prefix?: string }): Promise<StateValue<T>[]> {
 		const keys = (await this.activeKeys()).filter((key) => {
-			const publicKey = publicStateKey(
-				this.providerId,
-				this.namespaceName,
-				key,
-			);
+			const publicKey = publicStateKey(this.providerId, this.namespaceName, key);
 			return options?.prefix ? publicKey.startsWith(options.prefix) : true;
 		});
 		const limited = keys.slice(0, Math.max(0, options?.limit ?? keys.length));
 		if (limited.length === 0) return [];
-		const values = await withRequiredRedis(() =>
-			this.backend.redis.mget(limited),
-		);
+		const values = await withRequiredRedis(() => this.backend.redis.mget(limited));
 		return values.flatMap((raw, index) => {
 			const key = limited[index];
 			if (!key) return [];
-			const value = envelopeFromJson(
-				publicStateKey(this.providerId, this.namespaceName, key),
-				raw,
-			);
+			const value = envelopeFromJson(publicStateKey(this.providerId, this.namespaceName, key), raw);
 			return value ? [value] : [];
 		});
 	}
 
 	async get<T>(key: string): Promise<StateValue<T> | null> {
 		await requireRedisReady(this.backend.redis);
-		const raw = await withRequiredRedis(() =>
-			this.backend.redis.get(this.redisKey(key)),
-		);
+		const raw = await withRequiredRedis(() => this.backend.redis.get(this.redisKey(key)));
 		return envelopeFromJson(key, raw);
 	}
 
-	async set<T>(
-		key: string,
-		value: T,
-		options?: StateWriteOptions,
-	): Promise<StateValue<T>> {
+	async set<T>(key: string, value: T, options?: StateWriteOptions): Promise<StateValue<T>> {
 		this.enforceValueSize(value);
 		await this.enforceMaxEntries(key);
 		const current = await this.get<T>(key);
@@ -258,12 +223,7 @@ class RedisProviderStateNamespace implements ProviderStateNamespace {
 		const expiresAt = resolveExpiresAt(ttl);
 		const envelope = redisEnvelope(value, version, createdAt, expiresAt);
 		await withRequiredRedis(() =>
-			this.backend.redis.set(
-				this.redisKey(key),
-				JSON.stringify(envelope),
-				"PX",
-				ttlMs,
-			),
+			this.backend.redis.set(this.redisKey(key), JSON.stringify(envelope), "PX", ttlMs),
 		);
 		return {
 			key,
@@ -313,11 +273,7 @@ class RedisProviderStateNamespace implements ProviderStateNamespace {
 	): Promise<StateValue<Record<string, unknown>>> {
 		const current = (await this.get<Record<string, unknown>>(key))?.value ?? {};
 		const previous = typeof current[field] === "number" ? current[field] : 0;
-		return await this.set(
-			key,
-			{ ...current, [field]: previous + delta },
-			options,
-		);
+		return await this.set(key, { ...current, [field]: previous + delta }, options);
 	}
 }
 
@@ -330,43 +286,26 @@ class RedisProviderRuntimeState implements ProviderRuntimeState {
 		this.providerId = options.providerId;
 	}
 
-	namespace(
-		name: string,
-		options: StateNamespaceOptions,
-	): ProviderStateNamespace {
-		return new RedisProviderStateNamespace(
-			this.backend,
-			this.providerId,
-			name,
-			options,
-		);
+	namespace(name: string, options: StateNamespaceOptions): ProviderStateNamespace {
+		return new RedisProviderStateNamespace(this.backend, this.providerId, name, options);
 	}
 }
 
 export class UnsupportedProviderStateError extends ProviderError {
-	constructor(
-		message = "Provider runtime state is not available in this runtime",
-	) {
+	constructor(message = "Provider runtime state is not available in this runtime") {
 		super(message, { code: "PROVIDER_STATE_UNSUPPORTED" });
 		this.name = "UnsupportedProviderStateError";
 	}
 }
 
 class UnsupportedProviderStateNamespace implements ProviderStateNamespace {
-	async list<T>(_options?: {
-		limit?: number;
-		prefix?: string;
-	}): Promise<StateValue<T>[]> {
+	async list<T>(_options?: { limit?: number; prefix?: string }): Promise<StateValue<T>[]> {
 		throw new UnsupportedProviderStateError();
 	}
 	async get<T>(_key: string): Promise<StateValue<T> | null> {
 		throw new UnsupportedProviderStateError();
 	}
-	async set<T>(
-		_key: string,
-		_value: T,
-		_options?: StateWriteOptions,
-	): Promise<StateValue<T>> {
+	async set<T>(_key: string, _value: T, _options?: StateWriteOptions): Promise<StateValue<T>> {
 		throw new UnsupportedProviderStateError();
 	}
 	async patch<T extends Record<string, unknown>>(
@@ -398,10 +337,7 @@ class UnsupportedProviderStateNamespace implements ProviderStateNamespace {
 }
 
 class UnsupportedProviderRuntimeState implements ProviderRuntimeState {
-	namespace(
-		_name: string,
-		_options: StateNamespaceOptions,
-	): ProviderStateNamespace {
+	namespace(_name: string, _options: StateNamespaceOptions): ProviderStateNamespace {
 		return new UnsupportedProviderStateNamespace();
 	}
 }
@@ -420,10 +356,7 @@ class MemoryProviderStateNamespace implements ProviderStateNamespace {
 		}
 	}
 
-	async list<T>(_options?: {
-		limit?: number;
-		prefix?: string;
-	}): Promise<StateValue<T>[]> {
+	async list<T>(_options?: { limit?: number; prefix?: string }): Promise<StateValue<T>[]> {
 		this.pruneExpired();
 		const rows = Array.from(this.values.values()).filter((value) =>
 			_options?.prefix ? value.key.startsWith(_options.prefix) : true,
@@ -436,17 +369,11 @@ class MemoryProviderStateNamespace implements ProviderStateNamespace {
 		return this.values.get(key) ?? null;
 	}
 
-	async set<T>(
-		key: string,
-		value: T,
-		options?: StateWriteOptions,
-	): Promise<StateValue<T>> {
+	async set<T>(key: string, value: T, options?: StateWriteOptions): Promise<StateValue<T>> {
 		this.pruneExpired();
 		const now = new Date().toISOString();
 		const current = this.values.get(key);
-		const expiresAt = resolveMemoryStateExpiresAt(
-			options?.ttl ?? this.options.defaultTtl,
-		);
+		const expiresAt = resolveMemoryStateExpiresAt(options?.ttl ?? this.options.defaultTtl);
 		const row = {
 			key,
 			value,
@@ -499,10 +426,7 @@ class MemoryProviderStateNamespace implements ProviderStateNamespace {
 class MemoryProviderRuntimeState implements ProviderRuntimeState {
 	readonly namespaces = new Map<string, MemoryProviderStateNamespace>();
 
-	namespace(
-		name: string,
-		_options: StateNamespaceOptions,
-	): ProviderStateNamespace {
+	namespace(name: string, _options: StateNamespaceOptions): ProviderStateNamespace {
 		const existing = this.namespaces.get(name);
 		if (existing) return existing;
 		const created = new MemoryProviderStateNamespace(_options);
@@ -536,10 +460,7 @@ export function createRedisProviderRuntimeState(
 }
 
 export function createProviderRuntimeStateFromEnv(
-	options: {
-		readonly providerId?: string;
-		readonly allowMemoryFallback?: boolean;
-	} = {},
+	options: { readonly providerId?: string; readonly allowMemoryFallback?: boolean } = {},
 ): ProviderRuntimeState {
 	const redisUrl = providerStateRedisUrlFromEnv();
 	if (redisUrl) {

package/src/runtime/stealth.ts

@@ -2,16 +2,16 @@ import { createHash } from "node:crypto";
 import type { Browser, ImpitOptions, ImpitResponse, RequestInit } from "impit";
 import { Impit } from "impit";
 
-import type { ProxyResolutionOptions } from "../config/loader";
+import type { ProxyResolutionOptions } from "../config/loader.js";
 import {
 	DEFAULT_SMARTPROXY_POOL_SIZE,
 	invalidateProxyResolutionCacheAsync,
 	ProxyResolutionError,
 	resolveProxyConfigAsync,
 	SMARTPROXY_MAX_POOL_SIZE,
-} from "../config/loader";
-import { SDKError, TransportError } from "../errors";
-import { getStealthProfile } from "../stealth/profiles";
+} from "../config/loader.js";
+import { SDKError, TransportError } from "../errors.js";
+import { getStealthProfile } from "../stealth/profiles.js";
 import type {
 	CookieJar,
 	HttpMethod,
@@ -20,7 +20,7 @@ import type {
 	StealthRedirectHop,
 	StealthResponse,
 	StealthSession,
-} from "../types";
+} from "../types.js";
 import {
 	createProxyAuthIpDeniedError,
 	createProxyEdgeAuthRejectedError,
@@ -35,7 +35,7 @@ import {
 	isProxyPoolStaleStatus,
 	PROXY_EDGE_AUTH_REJECTED_CODE,
 	PROXY_POOL_STALE_CODE,
-} from "./proxy-errors";
+} from "./proxy-errors.js";
 import {
 	computeProxyAttemptIndex,
 	computeProxyTransportRetryDelayMs,
@@ -43,8 +43,8 @@ import {
 	normalizeProxyTransportRetryOptions,
 	shouldRetryProxyTransportAttempt,
 	validateUnsafeProxyTransportRetryMethods,
-} from "./proxy-retry-policy";
-import { appendQueryParams } from "./request-options";
+} from "./proxy-retry-policy.js";
+import { appendQueryParams } from "./request-options.js";
 
 const DEFAULT_PROFILE = "chrome-146";