@apifuse/provider-sdk 2.2.0-beta.62 → 2.2.0-beta.63

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

@@ -117,6 +117,7 @@ export type ResolverTelemetryHeaderPayload = {
         c?: ClosedEnum<string>;
     }[];
 };
+export declare function boundedText(value: string, redact?: (text: string) => string): string;
 export declare class ResolverTelemetryCollector implements ResolverTelemetrySink, TelemetryContributor<ResolverTelemetryLogPayload, ResolverTelemetryHeaderPayload> {
     #private;
     readonly key: "resolver";

package/dist/runtime/resolver-telemetry.js

@@ -8,7 +8,7 @@ const HEADER_TOKEN = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,63}$/;
 function boundedInteger(value) {
     return Math.max(0, Math.floor(Number.isFinite(value) ? value : 0));
 }
-function boundedText(value, redact) {
+export function boundedText(value, redact) {
     let result = value;
     try {
         result = redact?.(value) ?? value;

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

@@ -1,6 +1,7 @@
 import type { BrowserClient, ChallengeSolution, ProviderChallenge } from "../../types.js";
 import { type BrowserClientOptions } from "../browser.js";
 import type { TraceRecorder } from "../trace.js";
+import type { BrowserTelemetrySink } from "../browser-telemetry.js";
 import { type ResolverIdentity, type ResolverVendorAdapter } from "./types.js";
 type BrowserClientFactory = (options: BrowserClientOptions) => BrowserClient;
 /** Internal test seam; deliberately not re-exported from the package root. */
@@ -11,6 +12,7 @@ export interface BrowserResolverVendorOptions {
     readonly pollIntervalMs?: number;
     readonly allowedHosts: readonly string[];
     readonly createClient?: BrowserClientFactory;
+    readonly telemetry?: BrowserTelemetrySink;
 }
 export interface BrowserResolverVendorAdapter extends ResolverVendorAdapter {
     readonly id: "browser";

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

@@ -12,6 +12,44 @@ const SUCCESS_COOKIE_NAMES = {
     aws_waf: "aws-waf-token",
     cloudflare_interstitial: "cf_clearance",
 };
+const RESOLVER_PAGE_METHODS = new Set([
+    "goto",
+    "evaluate",
+    "fill",
+    "click",
+    "type",
+    "waitForSelector",
+    "content",
+    "screenshot",
+    "cookies",
+    "url",
+    "title",
+    "userAgent",
+]);
+function instrumentResolverBrowser(client, recorder) {
+    const wrapPage = (page) => new Proxy(page, {
+        get(target, property, receiver) {
+            const value = Reflect.get(target, property, receiver);
+            if (typeof property !== "string" ||
+                !RESOLVER_PAGE_METHODS.has(property) ||
+                typeof value !== "function")
+                return value;
+            return (...args) => recorder.runSpan(`browser.page.${property}`, () => Reflect.apply(value, target, args));
+        },
+    });
+    return new Proxy(client, {
+        get(target, property, receiver) {
+            const value = Reflect.get(target, property, receiver);
+            if (property === "newPage" && typeof value === "function")
+                return () => recorder.runSpan("browser.newPage", async () => wrapPage(await Reflect.apply(value, target, [])));
+            if (property === "rawPage" && typeof value === "function")
+                return () => recorder.runSpan("browser.rawPage", async () => wrapPage(await Reflect.apply(value, target, [])));
+            if (property === "withIsolatedContext" && typeof value === "function")
+                return (handler) => recorder.runSpan("browser.withIsolatedContext", () => Reflect.apply(value, target, [(page) => handler(wrapPage(page))]));
+            return value;
+        },
+    });
+}
 let createResolverBrowserClient = createBrowserClient;
 /** Internal test seam; deliberately not re-exported from the package root. */
 export function swapBrowserResolverClientFactoryForTests(factory) {
@@ -324,7 +362,15 @@ export function createBrowserResolverVendorAdapter(options) {
                     ...(proxyUrl === undefined ? {} : { proxy: proxyUrl }),
                     requireCdpPool: cdpUrl !== undefined,
                     serviceWorkers: "block",
+                    telemetry: options.telemetry,
                 });
+                /**
+                 * Direct vendor callers without a telemetry sink keep the historical trace shape.
+                 * Bound server requests record browser page spans under resolver.vendor.attempt,
+                 * with resolver.vendor.cleanup as a sibling of the browser context span.
+                 */
+                if (traceRecorder && options.telemetry)
+                    client = instrumentResolverBrowser(client, traceRecorder);
                 const contextOperation = client.withIsolatedContext(async (page) => {
                     handlerEntered = true;
                     return await solveInPage(page, challengeKind, challenge.pageUrl, options.allowedHosts, SUCCESS_COOKIE_NAMES[challengeKind], pollIntervalMs, options.timeoutMs, blockedRequests, solveController.signal);

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

@@ -1,2 +1,23 @@
+import type { ProviderResolverVendor } from "../../types.js";
+/**
+ * Exact SDK-owned service hosts each vendor's adapter may reach through its bound
+ * transport, in addition to the provider's declared `allowedHosts`. This table is
+ * the trust boundary for `ResolverVendorAdapter.transportAllowedHosts`: a
+ * declaration outside its vendor's entry is rejected, whoever supplied the adapter.
+ * Only Hyper's observed-IP reflector rides the identity-bound transport (ADR-0008
+ * v1.1 amend, PR #251); every other vendor talks to its own service directly.
+ * Frozen at runtime, not just in the type: the Hyper adapter hands its entry out by
+ * reference as `transportAllowedHosts`, so a mutable table would let any holder of a
+ * registry adapter widen the boundary for every later adapter in the process.
+ */
+export declare const RESOLVER_VENDOR_TRANSPORT_HOSTS: Readonly<{
+    "2captcha": readonly [];
+    browser: readonly [];
+    capmonster: readonly [];
+    capsolver: readonly [];
+    custom: readonly [];
+    hypersolutions: readonly ["ip.hypersolutions.co"];
+}>;
 export declare function normalizedResolverHostname(hostname: string): string;
 export declare function assertResolverHostAllowed(targetUrl: string, allowedHosts: readonly string[]): void;
+export declare function assertResolverVendorTransportHosts(vendor: ProviderResolverVendor, declaredHosts: readonly string[]): void;

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

@@ -1,4 +1,23 @@
 import { ProviderError } from "../../errors.js";
+/**
+ * Exact SDK-owned service hosts each vendor's adapter may reach through its bound
+ * transport, in addition to the provider's declared `allowedHosts`. This table is
+ * the trust boundary for `ResolverVendorAdapter.transportAllowedHosts`: a
+ * declaration outside its vendor's entry is rejected, whoever supplied the adapter.
+ * Only Hyper's observed-IP reflector rides the identity-bound transport (ADR-0008
+ * v1.1 amend, PR #251); every other vendor talks to its own service directly.
+ * Frozen at runtime, not just in the type: the Hyper adapter hands its entry out by
+ * reference as `transportAllowedHosts`, so a mutable table would let any holder of a
+ * registry adapter widen the boundary for every later adapter in the process.
+ */
+export const RESOLVER_VENDOR_TRANSPORT_HOSTS = Object.freeze({
+    "2captcha": Object.freeze([]),
+    browser: Object.freeze([]),
+    capmonster: Object.freeze([]),
+    capsolver: Object.freeze([]),
+    custom: Object.freeze([]),
+    hypersolutions: Object.freeze(["ip.hypersolutions.co"]),
+});
 export function normalizedResolverHostname(hostname) {
     return hostname.trim().toLowerCase().replace(/\.$/, "");
 }
@@ -31,3 +50,19 @@ export function assertResolverHostAllowed(targetUrl, allowedHosts) {
         fix: "Add the exact target hostname to the provider's allowedHosts declaration.",
     });
 }
+export function assertResolverVendorTransportHosts(vendor, declaredHosts) {
+    // A vendor id outside the table (only reachable from untyped callers) owns no hosts and
+    // is rejected below like any other overreach; `hasOwn` keeps prototype keys out too.
+    const ownedHosts = Object.hasOwn(RESOLVER_VENDOR_TRANSPORT_HOSTS, vendor)
+        ? RESOLVER_VENDOR_TRANSPORT_HOSTS[vendor]
+        : [];
+    for (const declaredHost of declaredHosts) {
+        const normalizedHost = normalizedResolverHostname(declaredHost);
+        if (ownedHosts.some((host) => normalizedResolverHostname(host) === normalizedHost))
+            continue;
+        throw new ProviderError(`Resolver vendor "${vendor}" may not declare transport host "${normalizedHost}"`, {
+            code: "RESOLVER_VENDOR_HOST_NOT_ALLOWED",
+            fix: "Remove the host from transportAllowedHosts: an adapter reaches only the provider's allowedHosts plus the SDK-owned service hosts of its vendor.",
+        });
+    }
+}

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

@@ -1,6 +1,6 @@
 import { isIP } from "node:net";
 import { recordPaidResolverCreate } from "../resolver-usage.js";
-import { assertResolverHostAllowed } from "./hosts.js";
+import { assertResolverHostAllowed, RESOLVER_VENDOR_TRANSPORT_HOSTS } from "./hosts.js";
 import { ResolverChallengeVerdictError, ResolverVendorUnavailableError, } from "./types.js";
 const HYPERSOLUTIONS_VENDOR_ID = "hypersolutions";
 const HYPER_SBSD_URL = "https://akm.hypersolutions.co/sbsd";
@@ -10,7 +10,7 @@ const HYPER_IP_URL = "https://ip.hypersolutions.co/ip";
  * egress address the upstream will see. The payload-generation POST carries no
  * identity and goes direct, as in the measured zozotown source.
  */
-const HYPER_TRANSPORT_HOSTS = ["ip.hypersolutions.co"];
+const HYPER_TRANSPORT_HOSTS = RESOLVER_VENDOR_TRANSPORT_HOSTS.hypersolutions;
 const IP_RESPONSE_MAX_BYTES = 4_096;
 /** Measured bound shared by the script, the Hyper envelope, and the payload submission. */
 const BODY_MAX_BYTES = 1_000_000;

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

@@ -82,10 +82,11 @@ export interface ResolverVendorAdapter {
     readonly id: ProviderResolverVendor;
     readonly requiresTransport?: boolean | ((kind: ProviderChallengeKind) => boolean);
     /**
-     * Exact SDK-owned service hosts this adapter may reach through its bound transport.
-     * Honored for every adapter the chain runs, so whoever supplies `adapters` to
-     * `createResolverClient` is the trust boundary; the engine path
-     * (`createResolverClientFromEnv`) only constructs registry adapters.
+     * Exact SDK-owned service hosts this adapter may reach through its bound transport,
+     * in addition to the provider's `allowedHosts`. Every host must appear in the
+     * SDK-owned `RESOLVER_VENDOR_TRANSPORT_HOSTS` entry for `id`; the chain rejects any
+     * other declaration with `RESOLVER_VENDOR_HOST_NOT_ALLOWED`, whoever supplied the
+     * adapter. The transport handed to `solve` is revoked once `solve` settles.
      */
     readonly transportAllowedHosts?: readonly string[];
     supports(kind: ProviderChallengeKind): boolean;

package/dist/runtime/resolver.d.ts

@@ -2,6 +2,7 @@ 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";
+import type { BrowserTelemetrySink } from "./browser-telemetry.js";
 import type { ResolverTelemetrySink } from "./resolver-telemetry.js";
 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__HYPERSOLUTIONS__API_KEY, APIFUSE__RESOLVER__TIMEOUT_MS, DEFAULT_RESOLVER_TIMEOUT_MS, } from "./resolver-config.js";
@@ -15,6 +16,8 @@ export interface ResolverRuntimeOptions {
     readonly cache?: ProviderCache;
     /** Optional request-scoped observability sink; never used as resolver identity. */
     readonly telemetry?: ResolverTelemetrySink;
+    /** Request-scoped browser sink used by the resolver-owned browser vendor. */
+    readonly browserTelemetry?: BrowserTelemetrySink;
     /** Inputs for SDK-owned lazy proxy resolution. The SDK never accepts a caller-built identity. */
     readonly proxyIntent?: {
         readonly mode: ProviderProxyMode;
@@ -39,7 +42,7 @@ export type ResolverInstrumentationMetadata = {
     readonly target: ResolverContext;
     readonly traceRecorder: TraceRecorder;
 };
-export type ResolverAdapterFactory = (configuration: string | undefined, timeoutMs: number, allowedHosts: readonly string[]) => ResolverVendorAdapter;
+export type ResolverAdapterFactory = (configuration: string | undefined, timeoutMs: number, allowedHosts: readonly string[], telemetry?: BrowserTelemetrySink) => 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. */

package/dist/runtime/resolver.js

@@ -8,7 +8,7 @@ import { RESOLVER_CHALLENGE_BINDINGS, resolverChallengeAllowsDirectCache, resolv
 import { createBrowserResolverVendorAdapter } from "./resolver-vendors/browser.js";
 import { createCapsolverResolverVendorAdapter } from "./resolver-vendors/capsolver.js";
 import { createHypersolutionsResolverVendorAdapter } from "./resolver-vendors/hypersolutions.js";
-import { assertResolverHostAllowed } from "./resolver-vendors/hosts.js";
+import { assertResolverHostAllowed, assertResolverVendorTransportHosts, } from "./resolver-vendors/hosts.js";
 import { createTwoCaptchaResolverVendorAdapter } from "./resolver-vendors/twocaptcha.js";
 import { RESOLVER_VENDOR_CAPABILITIES, ResolverVendorUnavailableError, attachResolverVendorPollObserver, resolveProviderResolverVendors, resolverVendorSupports, } from "./resolver-vendors/types.js";
 import { createUnsupportedResolverClient, inheritResolverTelemetryBinding, registerResolverTelemetryBinding, RESOLVER_INSTRUMENTATION_METADATA, } from "./resolver-shared.js";
@@ -77,11 +77,12 @@ const resolverAdapterRegistry = {
             timeoutMs,
         });
     },
-    browser(configuration, timeoutMs, allowedHosts) {
+    browser(configuration, timeoutMs, allowedHosts, telemetry) {
         return createBrowserResolverVendorAdapter({
             allowedHosts,
             cdpUrl: configuration,
             timeoutMs,
+            telemetry,
         });
     },
     hypersolutions(configuration, timeoutMs, allowedHosts) {
@@ -169,7 +170,7 @@ function createUnavailableAdapter(vendor, reason) {
         },
     };
 }
-function createAdapter(vendor, timeoutMs, allowedHosts, adapterFactories) {
+function createAdapter(vendor, timeoutMs, allowedHosts, adapterFactories, browserTelemetry) {
     const factory = adapterFactories[vendor.vendor];
     if (!factory && !KNOWN_UNIMPLEMENTED_RESOLVER_VENDORS.has(vendor.vendor)) {
         throw new Error(`Resolver adapter factory is missing for implemented vendor "${vendor.vendor}"`);
@@ -178,7 +179,7 @@ function createAdapter(vendor, timeoutMs, allowedHosts, adapterFactories) {
         return createUnavailableAdapter(vendor.vendor, vendor.reason);
     }
     if (factory) {
-        return factory(vendor.configuration, timeoutMs, allowedHosts);
+        return factory(vendor.configuration, timeoutMs, allowedHosts, browserTelemetry);
     }
     return createUnavailableAdapter(vendor.vendor, "not_implemented");
 }
@@ -260,12 +261,23 @@ function sanitizeCauseMessage(message) {
         .join(" ")
         .slice(0, 512);
 }
+function assertResolverTransportLive(revoked) {
+    if (!revoked)
+        return;
+    throw new ProviderError("Resolver transport was revoked when the vendor solve settled", {
+        code: "RESOLVER_TRANSPORT_REVOKED",
+        fix: "Complete every bound-transport call before solve() settles; the transport is per-attempt and must not be retained.",
+    });
+}
 function restrictResolverTransport(transport, allowedHosts) {
-    return {
+    // A retained reference must fail closed once the adapter's solve has settled.
+    let revoked = false;
+    const restricted = {
         sessionHeaders: transport.sessionHeaders,
         ...(transport.getCookie
             ? {
                 getCookie(name, url) {
+                    assertResolverTransportLive(revoked);
                     // Jar reads are gated like fetches: an adapter may only read state for declared hosts.
                     assertResolverHostAllowed(url, allowedHosts);
                     return transport.getCookie?.(name, url);
@@ -273,6 +285,7 @@ function restrictResolverTransport(transport, allowedHosts) {
             }
             : {}),
         async fetch(url, init) {
+            assertResolverTransportLive(revoked);
             // Empty declarations remain deny-by-default, matching the adapter-factory/browser path.
             assertResolverHostAllowed(url, allowedHosts);
             const response = await transport.fetch(url, { ...init, redirect: "manual" });
@@ -286,6 +299,12 @@ function restrictResolverTransport(transport, allowedHosts) {
             return response;
         },
     };
+    return {
+        transport: restricted,
+        revoke() {
+            revoked = true;
+        },
+    };
 }
 function safeCause(error) {
     if (error.cause === undefined)
@@ -699,7 +718,7 @@ async function resolveResolverIdentity(proxyIntent) {
     }
 }
 function createChainTelemetryBinding(options) {
-    return (telemetry) => createResolverChainClient({ ...options, telemetry });
+    return (telemetry, browserTelemetry) => createResolverChainClient({ ...options, telemetry, browserTelemetry });
 }
 function createResolverChainClient(options) {
     assertClientProfileTransportContract(options.clientProfile, options.transport);
@@ -791,7 +810,7 @@ function createResolverChainClient(options) {
                 }
                 const attempts = [];
                 for (const [entryIndex, entry] of supportingEntries.entries()) {
-                    const adapter = entry.createAdapter();
+                    const adapter = entry.createAdapter(options.browserTelemetry);
                     const attemptStartedAt = Date.now();
                     const diagnostics = {};
                     const telemetryTraceRecorder = createResolverTelemetryTraceRecorder({
@@ -803,7 +822,11 @@ function createResolverChainClient(options) {
                     });
                     let solution;
                     try {
-                        const solveAttempt = () => {
+                        const solveAttempt = async () => {
+                            // Boundary first: an overreaching declaration is a caller fault even when no
+                            // transport is configured, not a "missing_transport" vendor unavailability.
+                            const adapterHosts = adapter.transportAllowedHosts ?? [];
+                            assertResolverVendorTransportHosts(adapter.id, adapterHosts);
                             const requiresTransport = adapterRequiresTransport(adapter, challenge.kind);
                             const unrestrictedTransport = options.transport ??
                                 (requiresTransport
@@ -815,10 +838,10 @@ function createResolverChainClient(options) {
                             if (requiresTransport && unrestrictedTransport === undefined) {
                                 throw new ResolverVendorUnavailableError(adapter.id, "missing_transport");
                             }
-                            const transport = unrestrictedTransport
+                            const boundTransport = unrestrictedTransport
                                 ? restrictResolverTransport(unrestrictedTransport, [
                                     ...(options.allowedHosts ?? []),
-                                    ...(adapter.transportAllowedHosts ?? []),
+                                    ...adapterHosts,
                                 ])
                                 : undefined;
                             const usage = {
@@ -832,7 +855,12 @@ function createResolverChainClient(options) {
                                     }
                                     : {}),
                             };
-                            return adapter.solve(challenge, identity, signal, telemetryTraceRecorder, transport, usage);
+                            try {
+                                return await adapter.solve(challenge, identity, signal, telemetryTraceRecorder, boundTransport?.transport, usage);
+                            }
+                            finally {
+                                boundTransport?.revoke();
+                            }
                         };
                         solution = traceRecorder
                             ? await traceRecorder.runSpan("resolver.vendor.attempt", solveAttempt, {
@@ -948,11 +976,15 @@ function createResolverChainClient(options) {
         },
     };
     resolverCaches.set(client, cache ?? null);
-    const reusableOptions = { ...options, telemetry: undefined };
+    const reusableOptions = { ...options, telemetry: undefined, browserTelemetry: undefined };
     registerResolverTelemetryBinding(client, createChainTelemetryBinding(reusableOptions));
     return client;
 }
 export function createResolverClient(options) {
+    for (const adapter of options.adapters) {
+        // Fail at construction, not on the first solve, when a supplied adapter oversteps its vendor.
+        assertResolverVendorTransportHosts(adapter.id, adapter.transportAllowedHosts ?? []);
+    }
     return createResolverChainClient({
         kinds: options.kinds,
         entries: options.adapters.map((adapter) => ({
@@ -1037,7 +1069,7 @@ function createResolverClientFromEnvInternal(config, env, options, adapterFactor
             return {
                 id: vendor,
                 supports: (kind) => resolverVendorSupports(vendor, kind),
-                createAdapter: () => createAdapter(resolveVendorAvailability(vendor, env), timeoutMs, allowedHosts, adapterFactories),
+                createAdapter: (browserTelemetry) => createAdapter(resolveVendorAvailability(vendor, env), timeoutMs, allowedHosts, adapterFactories, browserTelemetry),
             };
         }),
         usingDefaultVendors: config.vendors === undefined,
@@ -1049,6 +1081,7 @@ function createResolverClientFromEnvInternal(config, env, options, adapterFactor
         clientProfile: config.clientProfile,
         allowedHosts,
         telemetry: options.telemetry,
+        browserTelemetry: options.browserTelemetry,
     });
 }
 export function createResolverClientFromEnv(config, env = process.env, options = {}) {

package/dist/runtime/state-telemetry.d.ts

@@ -0,0 +1,79 @@
+import type { ProviderRuntimeState } from "../types.js";
+import { type ClosedEnum, type SpanIndex, type TelemetryContributor } from "./request-telemetry.js";
+export type StateTelemetryOperation = "list" | "get" | "set" | "patch" | "delete" | "cas" | "increment";
+export type StateTelemetryBackend = "redis" | "memory" | "unsupported";
+export type StateTelemetryViolation = "quota" | "ttl" | "size" | "unsupported" | "error";
+export type StateTelemetrySample = {
+    key: string;
+    op: StateTelemetryOperation;
+    ms: number;
+    backend: StateTelemetryBackend;
+};
+export type StateTelemetryLogPayload = {
+    telemetryFailed?: true;
+    ops: {
+        list: number;
+        get: number;
+        set: number;
+        patch: number;
+        delete: number;
+        cas: number;
+        increment: number;
+    };
+    casConflicts: number;
+    violations: {
+        quota: number;
+        ttl: number;
+        size: number;
+        unsupported: number;
+        error: number;
+    };
+    backend: ClosedEnum<StateTelemetryBackend>;
+    /** State fails closed on Redis errors, so this remains 0 until a fallback exists. */
+    redisFallbacks: number;
+    redisMode: ClosedEnum<"not_configured" | "configured" | "degraded">;
+    /** Successful state operations that touch Redis; each operation counts once, regardless of command count. */
+    redisRoundTrips: number;
+    ms: number;
+    samples: StateTelemetrySample[];
+    dropped: number;
+};
+export type StateTelemetryHeaderPayload = Omit<StateTelemetryLogPayload, "samples" | "telemetryFailed">;
+export interface StateTelemetrySink {
+    markTelemetryFailed?(): void;
+    setRedisConfigured?(configured: boolean): void;
+    record(event: {
+        op: StateTelemetryOperation;
+        key?: string;
+        ms: number;
+        backend: StateTelemetryBackend;
+        ok: boolean;
+        conflict?: boolean;
+        violation?: StateTelemetryViolation;
+        /** False for successful Redis-backed operations that execute no Redis commands. */
+        redisTouched?: boolean;
+    }): void;
+}
+export declare class StateTelemetryCollector implements TelemetryContributor<StateTelemetryLogPayload, StateTelemetryHeaderPayload>, StateTelemetrySink {
+    #private;
+    readonly key: "state";
+    constructor(options?: {
+        redact?: (text: string) => string;
+    });
+    markTelemetryFailed(): void;
+    setRedisConfigured(configured: boolean): void;
+    record(event: {
+        op: StateTelemetryOperation;
+        key?: string;
+        ms: number;
+        backend: StateTelemetryBackend;
+        ok: boolean;
+        conflict?: boolean;
+        violation?: StateTelemetryViolation;
+        /** False for successful Redis-backed operations that execute no Redis commands. */
+        redisTouched?: boolean;
+    }): void;
+    toLogPayload(_spans: SpanIndex): StateTelemetryLogPayload | undefined;
+    toHeaderPayload(log: StateTelemetryLogPayload): StateTelemetryHeaderPayload;
+}
+export declare function instrumentProviderRuntimeState(state: ProviderRuntimeState, sink: StateTelemetrySink, redact?: (text: string) => string): ProviderRuntimeState;