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

package/src/runtime/state.ts

@@ -119,10 +119,7 @@ type RedisBackend = {
 
 const redisBackends = new Map<string, RedisBackend>();
 
-function getRedisBackend(
-	redisUrl: string,
-	injectedRedis?: ProviderRedisClient,
-): RedisBackend {
+function getRedisBackend(redisUrl: string, injectedRedis?: ProviderRedisClient): RedisBackend {
 	const existing = redisBackends.get(redisUrl);
 	if (existing) return existing;
 	const redis =
@@ -287,20 +284,11 @@ class RedisProviderStateNamespace implements ProviderStateNamespace {
 	) {}
 
 	private redisKey(key: string): string {
-		return providerStateKey(
-			this.providerId,
-			this.namespaceName,
-			this.scopeDiscriminator,
-			key,
-		);
+		return providerStateKey(this.providerId, this.namespaceName, this.scopeDiscriminator, key);
 	}
 
 	private statePrefix(): string {
-		return providerStatePrefix(
-			this.providerId,
-			this.namespaceName,
-			this.scopeDiscriminator,
-		);
+		return providerStatePrefix(this.providerId, this.namespaceName, this.scopeDiscriminator);
 	}
 
 	private indexKey(): string {
@@ -308,11 +296,7 @@ class RedisProviderStateNamespace implements ProviderStateNamespace {
 		// any state key (including "__index"), so a suffix inside the namespace
 		// could turn the ZSET into a string and break every subsequent write.
 		const namespaceIdentity = Buffer.from(
-			providerStatePrefix(
-				this.providerId,
-				this.namespaceName,
-				this.scopeDiscriminator,
-			),
+			providerStatePrefix(this.providerId, this.namespaceName, this.scopeDiscriminator),
 			"utf8",
 		).toString("base64url");
 		return `${REDIS_STATE_PREFIX}:index:${namespaceIdentity}`;
@@ -342,15 +326,17 @@ class RedisProviderStateNamespace implements ProviderStateNamespace {
 	private enforceValueSize(value: unknown): void {
 		const bytes = Buffer.byteLength(JSON.stringify(value), "utf8");
 		if (bytes > this.options.maxValueBytes) {
-			throw new UnsupportedProviderStateError(
+			throw stateViolationError(
 				`Provider runtime state value exceeds maxValueBytes (${bytes} > ${this.options.maxValueBytes})`,
+				"size",
 			);
 		}
 	}
 
 	private quotaExceeded(): UnsupportedProviderStateError {
-		return new UnsupportedProviderStateError(
+		return stateViolationError(
 			`Provider runtime state namespace quota exceeded (${this.options.maxEntries + 1} > ${this.options.maxEntries})`,
+			"quota",
 		);
 	}
 
@@ -362,8 +348,9 @@ class RedisProviderStateNamespace implements ProviderStateNamespace {
 		const ttlMs = parseStateDurationMs(ttl ?? this.options.defaultTtl);
 		const maxTtlMs = parseStateDurationMs(this.options.maxTtl);
 		if (ttlMs > maxTtlMs) {
-			throw new UnsupportedProviderStateError(
+			throw stateViolationError(
 				`Provider runtime state ttl exceeds maxTtl (${ttlMs} > ${maxTtlMs})`,
+				"ttl",
 			);
 		}
 		const expiresAtMs = Date.now() + ttlMs;
@@ -376,7 +363,7 @@ class RedisProviderStateNamespace implements ProviderStateNamespace {
 
 	async list<T>(options?: { limit?: number; prefix?: string }): Promise<StateValue<T>[]> {
 		const requestedLimit = Math.max(0, options?.limit ?? this.options.maxEntries);
-		if (requestedLimit === 0) return [];
+		if (requestedLimit === 0) return recordStateRedisNoop([]);
 		const keys = await this.indexedKeys(this.options.maxEntries);
 		if (keys.length === 0) return [];
 		const values = await withRequiredRedis(() => this.backend.redis.mget(keys));
@@ -453,12 +440,7 @@ class RedisProviderStateNamespace implements ProviderStateNamespace {
 		this.enforceValueSize(value);
 		const createdAt = new Date().toISOString();
 		const timing = this.writeTiming(options?.ttl);
-		const envelope = redisEnvelope(
-			value,
-			expectedVersion + 1,
-			createdAt,
-			timing.expiresAt,
-		);
+		const envelope = redisEnvelope(value, expectedVersion + 1, createdAt, timing.expiresAt);
 		await requireRedisReady(this.backend.redis);
 		const result = await withRequiredRedis(() =>
 			this.backend.redis.eval(
@@ -556,9 +538,34 @@ export class UnsupportedProviderStateError extends ProviderError {
 	constructor(message = "Provider runtime state is not available in this runtime") {
 		super(message, { code: "PROVIDER_STATE_UNSUPPORTED" });
 		this.name = "UnsupportedProviderStateError";
+		stateViolationKinds.set(this, "unsupported");
 	}
 }
 
+// Keep the exact no-command result out of band, without inspecting caller options twice.
+const stateRedisNoopResults = new WeakSet<object>();
+function recordStateRedisNoop<T extends object>(result: T): T {
+	stateRedisNoopResults.add(result);
+	return result;
+}
+export function isStateRedisNoop(result: unknown): boolean {
+	return result !== null && typeof result === "object" && stateRedisNoopResults.has(result);
+}
+
+type StateViolationKind = "quota" | "ttl" | "size" | "unsupported";
+const stateViolationKinds = new WeakMap<object, StateViolationKind>();
+function stateViolationError(
+	message: string,
+	kind: Exclude<StateViolationKind, "unsupported">,
+): UnsupportedProviderStateError {
+	const error = new UnsupportedProviderStateError(message);
+	stateViolationKinds.set(error, kind);
+	return error;
+}
+export function getStateViolation(error: unknown): StateViolationKind | undefined {
+	return error !== null && typeof error === "object" ? stateViolationKinds.get(error) : undefined;
+}
+
 class UnsupportedProviderStateNamespace implements ProviderStateNamespace {
 	async list<T>(_options?: { limit?: number; prefix?: string }): Promise<StateValue<T>[]> {
 		throw new UnsupportedProviderStateError();
@@ -619,8 +626,9 @@ class MemoryProviderStateNamespace implements ProviderStateNamespace {
 	private enforceValueSize(value: unknown): void {
 		const bytes = Buffer.byteLength(JSON.stringify(value), "utf8");
 		if (bytes > this.options.maxValueBytes) {
-			throw new UnsupportedProviderStateError(
+			throw stateViolationError(
 				`Provider runtime state value exceeds maxValueBytes (${bytes} > ${this.options.maxValueBytes})`,
+				"size",
 			);
 		}
 	}
@@ -630,13 +638,15 @@ class MemoryProviderStateNamespace implements ProviderStateNamespace {
 		const ttlMs = parseStateDurationMs(ttl ?? this.options.defaultTtl);
 		const maxTtlMs = parseStateDurationMs(this.options.maxTtl);
 		if (ttlMs > maxTtlMs) {
-			throw new UnsupportedProviderStateError(
+			throw stateViolationError(
 				`Provider runtime state ttl exceeds maxTtl (${ttlMs} > ${maxTtlMs})`,
+				"ttl",
 			);
 		}
 		if (!this.values.has(key) && this.values.size >= this.options.maxEntries) {
-			throw new UnsupportedProviderStateError(
+			throw stateViolationError(
 				`Provider runtime state namespace quota exceeded (${this.options.maxEntries + 1} > ${this.options.maxEntries})`,
+				"quota",
 			);
 		}
 	}
@@ -710,10 +720,7 @@ class MemoryProviderStateNamespace implements ProviderStateNamespace {
 			key,
 			value,
 			version: expectedVersion + 1,
-			expiresAt: resolveMemoryStateExpiresAt(
-				options?.ttl ?? this.options.defaultTtl,
-				this.now(),
-			),
+			expiresAt: resolveMemoryStateExpiresAt(options?.ttl ?? this.options.defaultTtl, this.now()),
 			createdAt: current?.createdAt ?? now,
 			updatedAt: now,
 		} satisfies StateValue<T>;
@@ -753,10 +760,7 @@ class MemoryProviderRuntimeState implements ProviderRuntimeState {
 	) {}
 
 	forConnection(connectionId: string | undefined): ProviderRuntimeState {
-		return new MemoryProviderRuntimeState(
-			this.backend,
-			connectionScopeDiscriminator(connectionId),
-		);
+		return new MemoryProviderRuntimeState(this.backend, connectionScopeDiscriminator(connectionId));
 	}
 
 	namespace(name: string, options: StateNamespaceOptions): ProviderStateNamespace {
@@ -771,10 +775,7 @@ class MemoryProviderRuntimeState implements ProviderRuntimeState {
 	}
 }
 
-function resolveMemoryStateExpiresAt(
-	ttl: StateWriteOptions["ttl"],
-	nowMs = Date.now(),
-): string {
+function resolveMemoryStateExpiresAt(ttl: StateWriteOptions["ttl"], nowMs = Date.now()): string {
 	const match = /^(\d+)(ms|s|m|h|d)$/.exec(ttl ?? "1h");
 	if (!match) return new Date(nowMs + 3_600_000).toISOString();
 	const amount = Number(match[1]);

package/src/runtime/stealth-cookies.ts

@@ -14,16 +14,32 @@ function isRecord(value: unknown): value is Record<PropertyKey, unknown> {
 
 const LEGACY_COOKIE_ORIGIN = "https://legacy-cookie.invalid/";
 
+/** Extract cookie values from Set-Cookie/header strings for request-scoped registration. */
+export function cookieValuesFromHeaders(headers: string | readonly string[]): string[] {
+	const values: string[] = [];
+	for (const header of typeof headers === "string" ? [headers] : headers) {
+		const cookie = Cookie.parse(header);
+		if (cookie?.value) values.push(cookie.value);
+	}
+	return values;
+}
+
 export class StealthCookieJar implements CookieJar, StealthSessionCookies {
 	private cookies: ToughCookieJar;
 	private readonly defaultUrl: string;
+	private readonly register: ((value: string) => void) | undefined;
 
-	constructor(cookieStrings: readonly string[], defaultUrl = LEGACY_COOKIE_ORIGIN) {
+	constructor(
+		cookieStrings: readonly string[],
+		defaultUrl = LEGACY_COOKIE_ORIGIN,
+		register?: (value: string) => void,
+	) {
 		this.cookies = new ToughCookieJar(undefined, {
 			allowSecureOnLocal: false,
 			rejectPublicSuffixes: true,
 		});
 		this.defaultUrl = this.normalizeUrl(defaultUrl) ?? LEGACY_COOKIE_ORIGIN;
+		this.register = register;
 		this.setFromCookieStrings(cookieStrings);
 	}
 
@@ -31,6 +47,7 @@ export class StealthCookieJar implements CookieJar, StealthSessionCookies {
 		const cookieUrl = this.normalizeUrl(url);
 		if (!cookieUrl) return;
 		for (const cookieString of cookieStrings) {
+			for (const value of cookieValuesFromHeaders(cookieString)) this.register?.(value);
 			this.cookies.setCookieSync(cookieString, cookieUrl, { ignoreError: true });
 		}
 	}
@@ -73,6 +90,7 @@ export class StealthCookieJar implements CookieJar, StealthSessionCookies {
 		this.clear();
 		for (const [name, value] of Object.entries(cookies)) {
 			if (!name) continue;
+			this.register?.(value);
 			this.cookies.setCookieSync(new Cookie({ key: name, path: "/", value }), this.defaultUrl, {
 				ignoreError: true,
 			});
@@ -111,6 +129,10 @@ export class StealthCookieJar implements CookieJar, StealthSessionCookies {
 		return undefined;
 	}
 
+	names(url?: string): string[] {
+		return this.getUniqueCookies(url ?? this.defaultUrl).map((cookie) => cookie.key);
+	}
+
 	private normalizeUrl(url: string): string | undefined {
 		try {
 			return new URL(url).toString();
@@ -124,6 +146,7 @@ export class StealthCookieJar implements CookieJar, StealthSessionCookies {
 		if (!cookieUrl) return [];
 		const names = new Set<string>();
 		return this.cookies.getCookiesSync(cookieUrl).filter((cookie) => {
+			if (cookie.value) this.register?.(cookie.value);
 			if (names.has(cookie.key)) return false;
 			names.add(cookie.key);
 			return true;

package/src/runtime/stealth-owned-headers.ts

@@ -0,0 +1,41 @@
+/**
+ * Header names the stealth transport owns.
+ *
+ * `ctx.stealth` composes these from the Chrome emulation and the request class,
+ * so a caller value is rejected at request time with `SDKError` code
+ * `STEALTH_HEADER_OVERRIDE_UNSUPPORTED` (`assertCallerHeadersSupported` in
+ * stealth.ts). The `browser-version-literal` lint reports a subset of these
+ * names — the `sec-fetch-*` and `sec-ch-ua*` families — in files that use
+ * `ctx.stealth` (`isReportedOwnedHeaderName` in lint.ts). Both read this
+ * module, so the lint cannot claim a rejection the runtime does not perform;
+ * it reports deliberately less than the runtime rejects (host, connection,
+ * accept-encoding and a non-literal user-agent stay silent — see that
+ * predicate for why), so a green `apifuse check` is not proof that no owned
+ * header is set.
+ *
+ * Leaf module by design: no imports, so the lazily loaded CLI lint path does
+ * not pull the stealth runtime in.
+ */
+export const SDK_OWNED_EXACT_CHROME_HEADERS: ReadonlySet<string> = new Set([
+	"host",
+	"connection",
+	"user-agent",
+	"sec-ch-ua",
+	"sec-ch-ua-mobile",
+	"sec-ch-ua-platform",
+	"accept-encoding",
+]);
+
+export const SDK_OWNED_CHROME_HEADER_PREFIX = "sec-fetch-";
+
+/**
+ * True when `ctx.stealth` rejects a caller value for `name` (case-insensitive):
+ * an exact member of {@link SDK_OWNED_EXACT_CHROME_HEADERS} or any
+ * `sec-fetch-*` name.
+ */
+export function isStealthOwnedHeaderName(name: string): boolean {
+	const lower = name.toLowerCase();
+	return (
+		SDK_OWNED_EXACT_CHROME_HEADERS.has(lower) || lower.startsWith(SDK_OWNED_CHROME_HEADER_PREFIX)
+	);
+}

package/src/runtime/stealth-telemetry.ts

@@ -0,0 +1,304 @@
+import { Buffer } from "node:buffer";
+
+import type {
+	StealthBrowser,
+	StealthChallengeClassification,
+	StealthOS,
+	StealthProfileDescriptor,
+} from "../types.js";
+import { type ClosedEnum, closedEnum, type TelemetryContributor } from "./request-telemetry.js";
+
+export type StealthTelemetryErrorCode =
+	| "transport_network_error"
+	| "transport_timeout"
+	| "transport_cancelled"
+	| "upstream_http_error"
+	| "response_too_large"
+	| "proxy_connect_failed"
+	| "PROXY_POOL_STALE"
+	| "PROXY_EDGE_AUTH_REJECTED"
+	| "PROXY_AUTH_IP_DENIED"
+	| "PROXY_EDGE_TLS_REJECTED"
+	| "PROXY_REQUIRED"
+	| "other";
+
+export type StealthTelemetryRequestClass = "navigation" | "script_navigation" | "xhr" | "post";
+
+export type StealthTelemetryAttemptKind = "request" | "resolver" | "proxy_diagnostic";
+
+export type StealthTelemetrySbsdOutcome =
+	| StealthChallengeClassification["outcome"]
+	| "detected"
+	| "refetch_clear";
+
+export type StealthTelemetryDiagnostics = {
+	readonly name?: string;
+	readonly message?: string;
+	readonly code?: string;
+};
+
+export type StealthTelemetryAttemptEvent = {
+	readonly ms: number;
+	readonly status?: number;
+	readonly errorCode?: StealthTelemetryErrorCode;
+	readonly diagnostics?: StealthTelemetryDiagnostics;
+	readonly profileId: StealthProfileDescriptor;
+	readonly proxyUsed: boolean;
+	readonly requestClass: StealthTelemetryRequestClass;
+	readonly kind?: StealthTelemetryAttemptKind;
+};
+
+export type StealthTelemetrySbsdEvent = {
+	readonly detected: boolean;
+	readonly outcome?: StealthTelemetrySbsdOutcome;
+};
+
+export interface StealthTelemetrySink {
+	recordAttempt(event: StealthTelemetryAttemptEvent): void;
+	recordPoolRefresh(): void;
+	recordRedirectHop(): void;
+	recordSbsd(event?: StealthTelemetrySbsdEvent | StealthTelemetrySbsdOutcome): void;
+	recordSafeRefetch(): void;
+}
+
+export type StealthTelemetryAttemptSample = {
+	n: number;
+	ms: number;
+	status?: number;
+	e?: StealthTelemetryErrorCode;
+	kind?: StealthTelemetryAttemptKind;
+	diagnostics?: StealthTelemetryDiagnostics;
+};
+
+export type StealthTelemetryLogPayload = {
+	attempts: number;
+	poolRefreshes: number;
+	redirectHops: number;
+	profileId?: StealthProfileDescriptor;
+	proxyUsed: boolean;
+	requestClass?: StealthTelemetryRequestClass;
+	sbsdDetected?: boolean;
+	sbsdOutcome?: StealthTelemetrySbsdOutcome;
+	safeRefetch: number;
+	lastStatus?: number;
+	ms: number;
+	attemptSamples?: StealthTelemetryAttemptSample[];
+	attemptSamplesDropped?: number;
+};
+
+export type StealthTelemetryHeaderPayload = {
+	attempts: number;
+	poolRefreshes: number;
+	redirectHops: number;
+	profileId?: {
+		browser: ClosedEnum<StealthBrowser>;
+		os: ClosedEnum<StealthOS>;
+	};
+	proxyUsed: boolean;
+	requestClass?: ClosedEnum<StealthTelemetryRequestClass>;
+	sbsdDetected?: boolean;
+	sbsdOutcome?: ClosedEnum<StealthTelemetrySbsdOutcome>;
+	safeRefetch: number;
+	lastStatus?: number;
+	ms: number;
+	attemptSamples?: {
+		n: number;
+		ms: number;
+		status?: number;
+		e?: ClosedEnum<StealthTelemetryErrorCode>;
+		kind?: ClosedEnum<StealthTelemetryAttemptKind>;
+	}[];
+};
+
+const MAX_ATTEMPT_SAMPLES = 24;
+const MAX_DIAGNOSTIC_TEXT = 300;
+
+function boundedInteger(value: number): number {
+	if (!Number.isFinite(value)) return Number.MAX_SAFE_INTEGER;
+	return Math.min(Number.MAX_SAFE_INTEGER, Math.max(0, Math.floor(value)));
+}
+
+function saturatingAdd(a: number, b: number): number {
+	if (!Number.isFinite(a) || !Number.isFinite(b)) return Number.MAX_SAFE_INTEGER;
+	return Math.min(Number.MAX_SAFE_INTEGER, boundedInteger(a) + boundedInteger(b));
+}
+
+function boundedText(value: string, redact?: (text: string) => string): string {
+	let result = value;
+	try {
+		result = redact?.(value) ?? value;
+	} catch {
+		result = "[REDACTION_FAILED]";
+	}
+	const length = Math.min(result.length, MAX_DIAGNOSTIC_TEXT);
+	const units = Buffer.alloc(length * 2);
+	for (let index = 0; index < length; index += 1) {
+		units.writeUInt16LE(result.charCodeAt(index), index * 2);
+	}
+	return units.toString("utf16le");
+}
+
+function cloneDiagnostics(
+	diagnostics: StealthTelemetryDiagnostics | undefined,
+	redact: ((text: string) => string) | undefined,
+): StealthTelemetryDiagnostics | undefined {
+	if (!diagnostics) return undefined;
+	const result: StealthTelemetryDiagnostics = {
+		...(diagnostics.name === undefined ? {} : { name: boundedText(diagnostics.name, redact) }),
+		...(diagnostics.message === undefined
+			? {}
+			: { message: boundedText(diagnostics.message, redact) }),
+		...(diagnostics.code === undefined ? {} : { code: boundedText(diagnostics.code, redact) }),
+	};
+	return Object.keys(result).length > 0 ? result : undefined;
+}
+
+function cloneProfile(profile: StealthProfileDescriptor): StealthProfileDescriptor {
+	return { browser: profile.browser, os: profile.os } as StealthProfileDescriptor;
+}
+
+export class StealthTelemetryCollector
+	implements
+		StealthTelemetrySink,
+		TelemetryContributor<StealthTelemetryLogPayload, StealthTelemetryHeaderPayload>
+{
+	readonly key = "stealth" as const;
+	readonly #redact: ((text: string) => string) | undefined;
+	#attempts = 0;
+	#poolRefreshes = 0;
+	#redirectHops = 0;
+	#profileId: StealthProfileDescriptor | undefined;
+	#proxyUsed = false;
+	#requestClass: StealthTelemetryRequestClass | undefined;
+	#sbsdDetected: boolean | undefined;
+	#sbsdOutcome: StealthTelemetrySbsdOutcome | undefined;
+	#safeRefetch = 0;
+	#lastStatus: number | undefined;
+	#ms = 0;
+	#attemptSamples: StealthTelemetryAttemptSample[] = [];
+	#attemptSamplesDropped = 0;
+
+	constructor(options: { redact?: (text: string) => string } = {}) {
+		this.#redact = options.redact;
+	}
+
+	recordAttempt(event: StealthTelemetryAttemptEvent): void {
+		const ms = boundedInteger(event.ms);
+		this.#attempts = saturatingAdd(this.#attempts, 1);
+		this.#ms = saturatingAdd(this.#ms, ms);
+		this.#profileId = cloneProfile(event.profileId);
+		this.#proxyUsed ||= event.proxyUsed;
+		this.#requestClass = event.requestClass;
+		if (event.status !== undefined) this.#lastStatus = boundedInteger(event.status);
+		if (this.#attemptSamples.length >= MAX_ATTEMPT_SAMPLES) {
+			this.#attemptSamplesDropped = saturatingAdd(this.#attemptSamplesDropped, 1);
+			return;
+		}
+		const sample: StealthTelemetryAttemptSample = {
+			n: this.#attempts,
+			ms,
+			...(event.status === undefined ? {} : { status: boundedInteger(event.status) }),
+			...(event.errorCode === undefined ? {} : { e: event.errorCode }),
+			...(event.kind === undefined ? {} : { kind: event.kind }),
+			...(event.diagnostics
+				? { diagnostics: cloneDiagnostics(event.diagnostics, this.#redact) }
+				: {}),
+		};
+		if (sample.diagnostics === undefined) delete sample.diagnostics;
+		this.#attemptSamples.push(sample);
+	}
+
+	recordPoolRefresh(): void {
+		this.#poolRefreshes = saturatingAdd(this.#poolRefreshes, 1);
+	}
+
+	recordRedirectHop(): void {
+		this.#redirectHops = saturatingAdd(this.#redirectHops, 1);
+	}
+
+	recordSbsd(event?: StealthTelemetrySbsdEvent | StealthTelemetrySbsdOutcome): void {
+		if (typeof event === "string") {
+			this.#sbsdDetected = true;
+			this.#sbsdOutcome = event;
+			return;
+		}
+		if (!event) return;
+		this.#sbsdDetected = (this.#sbsdDetected ?? false) || event.detected;
+		if (event.outcome !== undefined) this.#sbsdOutcome = event.outcome;
+	}
+
+	recordSafeRefetch(): void {
+		this.#safeRefetch = saturatingAdd(this.#safeRefetch, 1);
+	}
+
+	toLogPayload(): StealthTelemetryLogPayload | undefined {
+		if (
+			this.#attempts === 0 &&
+			this.#poolRefreshes === 0 &&
+			this.#redirectHops === 0 &&
+			this.#safeRefetch === 0 &&
+			this.#sbsdDetected === undefined
+		) {
+			return undefined;
+		}
+		return {
+			attempts: this.#attempts,
+			poolRefreshes: this.#poolRefreshes,
+			redirectHops: this.#redirectHops,
+			...(this.#profileId ? { profileId: cloneProfile(this.#profileId) } : {}),
+			proxyUsed: this.#proxyUsed,
+			...(this.#requestClass ? { requestClass: this.#requestClass } : {}),
+			...(this.#sbsdDetected === undefined ? {} : { sbsdDetected: this.#sbsdDetected }),
+			...(this.#sbsdOutcome ? { sbsdOutcome: this.#sbsdOutcome } : {}),
+			safeRefetch: this.#safeRefetch,
+			...(this.#lastStatus === undefined ? {} : { lastStatus: this.#lastStatus }),
+			ms: this.#ms,
+			...(this.#attemptSamples.length > 0
+				? {
+						attemptSamples: this.#attemptSamples.map((sample) => ({
+							...sample,
+							...(sample.diagnostics
+								? {
+										diagnostics: { ...sample.diagnostics },
+									}
+								: {}),
+						})),
+					}
+				: {}),
+			...(this.#attemptSamplesDropped > 0
+				? { attemptSamplesDropped: this.#attemptSamplesDropped }
+				: {}),
+		};
+	}
+
+	toHeaderPayload(log: StealthTelemetryLogPayload): StealthTelemetryHeaderPayload {
+		const attemptSamples = log.attemptSamples?.map((sample) => ({
+			n: sample.n,
+			ms: sample.ms,
+			...(sample.status === undefined ? {} : { status: sample.status }),
+			...(sample.e ? { e: closedEnum(sample.e) } : {}),
+			...(sample.kind ? { kind: closedEnum(sample.kind) } : {}),
+		}));
+		return {
+			attempts: log.attempts,
+			poolRefreshes: log.poolRefreshes,
+			redirectHops: log.redirectHops,
+			...(log.profileId
+				? {
+						profileId: {
+							browser: closedEnum(log.profileId.browser),
+							os: closedEnum(log.profileId.os),
+						},
+					}
+				: {}),
+			proxyUsed: log.proxyUsed,
+			...(log.requestClass ? { requestClass: closedEnum(log.requestClass) } : {}),
+			...(log.sbsdDetected === undefined ? {} : { sbsdDetected: log.sbsdDetected }),
+			...(log.sbsdOutcome ? { sbsdOutcome: closedEnum(log.sbsdOutcome) } : {}),
+			safeRefetch: log.safeRefetch,
+			...(log.lastStatus === undefined ? {} : { lastStatus: log.lastStatus }),
+			ms: log.ms,
+			...(attemptSamples && attemptSamples.length > 0 ? { attemptSamples } : {}),
+		};
+	}
+}