@genn-inc/cluebase-frontend-sdk 0.0.1

package/dist/exporter/client.d.ts

@@ -0,0 +1,92 @@
+import type { InternalMetricsStore } from "../internal/metrics.js";
+import { type BrowserSourceEvent } from "./source-event.js";
+import { type IngestRetryStrategy } from "./delivery-response.js";
+import type { DiagnosticStore } from "./diagnostics.js";
+import type { IngestUsageGovernorFeedback } from "../provider/types.js";
+export declare const CLUEBASE_SDK_REQUEST_HEADER = "x-cluebase-sdk-request";
+export declare const CLUEBASE_SDK_VERSION_HEADER = "x-cluebase-sdk-version";
+export declare const CLUEBASE_SOURCE_SCHEMA_VERSION_HEADER = "x-cluebase-source-schema-version";
+export declare const CLUEBASE_BROWSER_TOKEN_HEADER = "x-cluebase-browser-token";
+export declare const CANONICAL_BROWSER_INGEST_PATH = "/api/v1/ingest/browser";
+export declare const CANONICAL_BROWSER_TOKEN_PATH = "/api/v1/ingest/browser-tokens";
+export declare const resolveCanonicalIngestEndpoint: (endpoint: string) => string;
+export type IngestClientOptions = {
+    endpoint: string;
+    projectKey: string;
+    sdkType: "browser";
+    sdkVersion: string;
+    schemaVersion: number;
+    metrics?: InternalMetricsStore;
+    diagnostics?: DiagnosticStore;
+};
+export declare const resolveBrowserTokenEndpoint: (endpoint: string) => string;
+export type SendEventsOptions = {
+    keepalive?: boolean;
+    useBeacon?: boolean;
+    signal?: AbortSignal;
+    requireCachedBrowserToken?: boolean;
+    maxPayloadBytes?: number;
+    metadata?: BatchEnvelopeMetadata;
+    /** Absolute monotonic deadline shared by one SDK flush or close operation. */
+    deadlineAt?: number;
+};
+export type SendEventsResult = {
+    ok: boolean;
+    status: number | null;
+    attempts: number;
+    governor: IngestUsageGovernorFeedback | null;
+    retryStrategy: IngestRetryStrategy | null;
+    observationIngestBatchId?: string;
+    partial?: boolean;
+    droppedEventCount?: number;
+    reason?: string | null;
+};
+export type BatchEnvelopeMetadata = {
+    batch_id: string;
+    idempotency_key: string;
+    sent_at: string;
+};
+export type { IngestRetryStrategy } from "./delivery-response.js";
+export declare class IngestClient {
+    private readonly endpoint;
+    private readonly browserTokenEndpoint;
+    private readonly projectKey;
+    private readonly sourceIdentifier;
+    private readonly producerId;
+    private readonly sdkType;
+    private readonly sdkVersion;
+    private readonly schemaVersion;
+    private readonly metrics;
+    private readonly diagnostics;
+    private cachedToken;
+    private pendingTokenRequest;
+    constructor(options: IngestClientOptions);
+    send(events: BrowserSourceEvent[], options?: SendEventsOptions): Promise<SendEventsResult>;
+    measurePayloadBytes(events: BrowserSourceEvent[], metadata?: BatchEnvelopeMetadata): number;
+    private stringifyPayload;
+    private withSourceEvidence;
+    createBatchEnvelopeMetadata(): BatchEnvelopeMetadata;
+    hasUsableBrowserToken(nowMs?: number): boolean;
+    warmupBrowserToken(signal?: AbortSignal): Promise<boolean>;
+    private failedSend;
+    private recordDecision;
+    private postBatch;
+    private createId;
+    /**
+     * Obtain a browser ingest token directly from the Cluebase backend.
+     *
+     * The SDK POSTs `{ projectKey }` to
+     * `<endpoint>/api/v1/ingest/browser-tokens`; the browser stamps the `Origin`
+     * header automatically and the Cluebase backend validates project key + origin
+     * before minting a short-lived token.
+     *
+     * Tokens are cached in-memory until they are within
+     * `BROWSER_TOKEN_REFRESH_LEEWAY_MS` of expiry, at which point the next
+     * `ensureBrowserToken()` call transparently refreshes them. The function
+     * throws on transport / HTTP errors so the caller (`send`) can mark the
+     * batch as failed without bypassing the credentialled boundary.
+     */
+    private getUsableCachedBrowserToken;
+    private ensureBrowserToken;
+    private safeEnsureBrowserToken;
+}

package/dist/exporter/client.js

@@ -0,0 +1,541 @@
+import { canonicalize as canonicalJsonStringify } from "json-canonicalize";
+import { CONSENT_DENIED_ABORT_REASON, DEFAULT_FRONTEND_SOURCE_IDENTIFIER, } from "../provider/constants.js";
+import { SDK_SOURCE_SIGNAL_EVENT_NAME, SDK_SOURCE_SIGNAL_EVENT_TYPE, isBrowserSourceSignalEvent, } from "./source-event.js";
+import { generateEventId } from "./event-id.js";
+import { classifyIngestHttpStatus, evaluateBrowserDeliveryResponse, } from "./delivery-response.js";
+import { computeRetryDelay, RETRY_CONFIG } from "./retry.js";
+import { appliedPrivacyPolicyToken, applyDeliveredPrivacyPolicy, } from "../provider/privacy-policy-store.js";
+export const CLUEBASE_SDK_REQUEST_HEADER = "x-cluebase-sdk-request";
+export const CLUEBASE_SDK_VERSION_HEADER = "x-cluebase-sdk-version";
+export const CLUEBASE_SOURCE_SCHEMA_VERSION_HEADER = "x-cluebase-source-schema-version";
+export const CLUEBASE_BROWSER_TOKEN_HEADER = "x-cluebase-browser-token";
+export const CANONICAL_BROWSER_INGEST_PATH = "/api/v1/ingest/browser";
+export const CANONICAL_BROWSER_TOKEN_PATH = "/api/v1/ingest/browser-tokens";
+const CANONICAL_INGEST_PATH_SUFFIX = CANONICAL_BROWSER_INGEST_PATH.replace(/^\/api\/v1/, "");
+export const resolveCanonicalIngestEndpoint = (endpoint) => {
+    if (!endpoint) {
+        return endpoint;
+    }
+    if (endpoint.endsWith(CANONICAL_INGEST_PATH_SUFFIX)) {
+        return endpoint;
+    }
+    // Strip a trailing slash if the host app provided only the base URL.
+    const trimmed = endpoint.endsWith("/") ? endpoint.slice(0, -1) : endpoint;
+    if (trimmed.endsWith("/api/v1")) {
+        return `${trimmed}${CANONICAL_INGEST_PATH_SUFFIX}`;
+    }
+    // Host apps typically pass the bare API origin (e.g. `http://api.example.com`
+    // or `http://127.0.0.1:4000`). Append the full canonical ingest path so the
+    // SDK can POST to a real Cluebase endpoint instead of the origin root. This
+    // mirrors `resolveBrowserTokenEndpoint`, which already rewrites the pathname
+    // unconditionally — keeping the two resolvers in sync prevents the SDK from
+    // silently posting events to `/` while still successfully fetching tokens.
+    try {
+        const parsed = new URL(trimmed);
+        if (parsed.pathname === "" || parsed.pathname === "/") {
+            parsed.pathname = CANONICAL_BROWSER_INGEST_PATH;
+            parsed.search = "";
+            parsed.hash = "";
+            return parsed.toString();
+        }
+    }
+    catch {
+        // Relative / malformed endpoints fall through unchanged.
+    }
+    return endpoint;
+};
+// Refresh the cached token this many milliseconds before its real expiry so
+// transports do not race a token that expires mid-flight.
+const BROWSER_TOKEN_REFRESH_LEEWAY_MS = 60000;
+class BrowserTokenRequestError extends Error {
+    constructor(status) {
+        super("browser_token_request_failed");
+        this.status = status;
+        this.name = "BrowserTokenRequestError";
+    }
+}
+export const resolveBrowserTokenEndpoint = (endpoint) => {
+    if (!endpoint) {
+        return CANONICAL_BROWSER_TOKEN_PATH;
+    }
+    // `endpoint` may already point at an ingest path. Derive the API root, then
+    // append the canonical browser-tokens path.
+    try {
+        const parsed = new URL(endpoint);
+        parsed.pathname = CANONICAL_BROWSER_TOKEN_PATH;
+        parsed.search = "";
+        parsed.hash = "";
+        return parsed.toString();
+    }
+    catch {
+        // Fall back to a string-based rewrite for unusual / relative endpoints.
+        const trimmed = endpoint.endsWith("/") ? endpoint.slice(0, -1) : endpoint;
+        const apiV1Idx = trimmed.indexOf("/api/v1");
+        if (apiV1Idx >= 0) {
+            return `${trimmed.slice(0, apiV1Idx)}${CANONICAL_BROWSER_TOKEN_PATH}`;
+        }
+        return `${trimmed}${CANONICAL_BROWSER_TOKEN_PATH}`;
+    }
+};
+const NORMAL_ATTEMPT_TIMEOUT_MS = 15000;
+export class IngestClient {
+    constructor(options) {
+        this.sourceIdentifier = DEFAULT_FRONTEND_SOURCE_IDENTIFIER;
+        this.producerId = DEFAULT_FRONTEND_SOURCE_IDENTIFIER;
+        // Memory-only token cache. Refreshed before expiry so the next ingest POST
+        // always has a live token.
+        this.cachedToken = null;
+        this.pendingTokenRequest = null;
+        this.endpoint = resolveCanonicalIngestEndpoint(options.endpoint);
+        this.browserTokenEndpoint = resolveBrowserTokenEndpoint(options.endpoint);
+        this.projectKey = options.projectKey;
+        this.sdkType = options.sdkType;
+        this.sdkVersion = options.sdkVersion;
+        this.schemaVersion = options.schemaVersion;
+        this.metrics = options.metrics ?? null;
+        this.diagnostics = options.diagnostics ?? null;
+    }
+    async send(events, options = {}) {
+        if (!hasDeadlineRemaining(options.deadlineAt)) {
+            return this.failedSend(null, 0, "retry_same_batch");
+        }
+        const sourceSignalEvents = events.filter(isBrowserSourceSignalEvent);
+        const droppedEventCount = events.length - sourceSignalEvents.length;
+        if (droppedEventCount > 0) {
+            this.metrics?.increment("dropped_count", droppedEventCount);
+        }
+        if (sourceSignalEvents.length === 0) {
+            return {
+                ok: true,
+                status: null,
+                attempts: 0,
+                governor: null,
+                retryStrategy: null,
+            };
+        }
+        const maxPayloadBytes = Math.max(1024, options.maxPayloadBytes ?? Number.MAX_SAFE_INTEGER);
+        const metadata = options.metadata ?? this.createBatchEnvelopeMetadata();
+        const payload = this.stringifyPayload(sourceSignalEvents, metadata);
+        const keepalive = options.keepalive ?? options.useBeacon ?? false;
+        const payloadSize = new TextEncoder().encode(payload).byteLength;
+        this.metrics?.increment("payload_size_bytes", payloadSize);
+        if (payloadSize > maxPayloadBytes) {
+            this.metrics?.increment("dropped_count", events.length);
+            this.metrics?.increment("send_failure_count");
+            this.metrics?.increment("transport_failed_count");
+            return {
+                ok: false,
+                status: null,
+                attempts: 0,
+                governor: null,
+                retryStrategy: null,
+            };
+        }
+        const browserTokenResult = await this.safeEnsureBrowserToken({
+            signal: options.signal,
+            requireCachedToken: options.requireCachedBrowserToken,
+            deadlineAt: options.deadlineAt,
+        });
+        if (!browserTokenResult.ok) {
+            this.metrics?.increment("send_failure_count");
+            this.metrics?.increment("transport_failed_count");
+            return {
+                ok: false,
+                status: null,
+                attempts: 0,
+                governor: null,
+                retryStrategy: browserTokenResult.retryStrategy ??
+                    (options.requireCachedBrowserToken ? "drop_event" : null),
+            };
+        }
+        let browserToken = browserTokenResult.token;
+        let refreshedToken = false;
+        let lastStatus = null;
+        for (let attempts = 1; attempts <= RETRY_CONFIG.maxAttempts; attempts += 1) {
+            if (options.signal?.aborted ||
+                !hasDeadlineRemaining(options.deadlineAt)) {
+                return this.failedSend(lastStatus, attempts - 1, isConsentAbort(options.signal) ? "drop_event" : "retry_same_batch");
+            }
+            const attempt = await this.postBatch({
+                payload,
+                browserToken,
+                keepalive,
+                signal: options.signal,
+                deadlineAt: options.deadlineAt,
+                localSubmittedCount: sourceSignalEvents.length,
+            });
+            lastStatus = attempt.status;
+            const decision = attempt.decision;
+            this.recordDecision(decision, lastStatus, attempts, payload);
+            if (decision.ok) {
+                if (decision.droppedEventCount > 0) {
+                    this.metrics?.increment("ingest_dropped_event_count", decision.droppedEventCount);
+                }
+                this.metrics?.increment("sent_count", decision.acceptedEventCount);
+                return {
+                    ok: true,
+                    status: lastStatus,
+                    attempts,
+                    governor: decision.governor,
+                    retryStrategy: null,
+                    observationIngestBatchId: decision.observationIngestBatchId,
+                    partial: decision.acceptedPartial,
+                    droppedEventCount: decision.droppedEventCount,
+                    reason: decision.reason,
+                };
+            }
+            if (decision.droppedEventCount > 0) {
+                this.metrics?.increment("ingest_dropped_event_count", decision.droppedEventCount);
+            }
+            if (!options.requireCachedBrowserToken &&
+                !refreshedToken &&
+                (decision.reason === "expired_browser_token" ||
+                    decision.reason === "stale_browser_token")) {
+                this.cachedToken = null;
+                const refreshed = await this.safeEnsureBrowserToken({
+                    signal: options.signal,
+                    deadlineAt: options.deadlineAt,
+                });
+                if (!refreshed.ok) {
+                    return this.failedSend(lastStatus, attempts, refreshed.retryStrategy ?? "retry_same_batch");
+                }
+                browserToken = refreshed.token;
+                refreshedToken = true;
+                continue;
+            }
+            if (decision.retryStrategy !== "retry_same_batch" ||
+                attempts === RETRY_CONFIG.maxAttempts) {
+                return this.failedSend(lastStatus, attempts, decision.retryStrategy, decision.governor);
+            }
+            this.metrics?.increment("retry_count");
+            this.metrics?.increment("transport_retry_count");
+            this.diagnostics?.record({
+                code: "retry_scheduled",
+                strategy: "retry_same_batch",
+                http_status: lastStatus ?? undefined,
+                attempt: attempts,
+                batch_fingerprint: this.diagnostics.batchFingerprint(diagnosticCanonicalPayload(payload)),
+            });
+            if (!(await sleep(computeRetryDelay(attempts, RETRY_CONFIG), options.signal, options.deadlineAt))) {
+                return this.failedSend(lastStatus, attempts, isConsentAbort(options.signal) ? "drop_event" : "retry_same_batch");
+            }
+        }
+        return this.failedSend(lastStatus, RETRY_CONFIG.maxAttempts, "retry_same_batch");
+    }
+    measurePayloadBytes(events, metadata = {
+        batch_id: "batch_00000000-0000-4000-8000-000000000000",
+        idempotency_key: "idem_00000000-0000-4000-8000-000000000000",
+        sent_at: "2026-01-01T00:00:00.000Z",
+    }) {
+        return new TextEncoder().encode(this.stringifyPayload(events, metadata))
+            .byteLength;
+    }
+    stringifyPayload(events, metadata) {
+        // Emit the canonical batch envelope against `/ingest/browser`. Field names
+        // follow the camelCase `observationSourceEventBatchRequestSchema`.
+        return JSON.stringify({
+            sourceType: "frontend_sdk",
+            sourceSchemaVersion: String(this.schemaVersion),
+            batchId: metadata.batch_id,
+            idempotencyKey: metadata.idempotency_key,
+            sentAt: metadata.sent_at,
+            // いま適用している方針の合印。受付側は違う時だけ本体を返す。持っていなければ
+            // 省く（= まだ全部伏せている）ので、受付側は必ず本体を返してくれる。
+            privacyPolicyToken: appliedPrivacyPolicyToken(),
+            producerMetadata: {
+                producer_id: this.producerId,
+                sdk_type: this.sdkType,
+                sdk_version: this.sdkVersion,
+            },
+            events: events.map((event) => this.withSourceEvidence(event)),
+        });
+    }
+    withSourceEvidence(event) {
+        // Privacy metadata is explicit at the transport boundary. Re-apply the
+        // strictest fallback so malformed upstream events never ship without
+        // privacy declaration.
+        return {
+            ...event,
+            source_event_id: event.source_event_id ?? event.event_id,
+            source_schema_version: String(this.schemaVersion),
+            source_event_type: SDK_SOURCE_SIGNAL_EVENT_TYPE,
+            source_event_kind: SDK_SOURCE_SIGNAL_EVENT_TYPE,
+            event_name: SDK_SOURCE_SIGNAL_EVENT_NAME,
+            event_category: "context",
+            producer_id: this.producerId,
+            service_name: event.service_name ?? this.sourceIdentifier,
+            privacy_state: event.privacy_state ?? "masked",
+            privacy_level: event.privacy_level ?? "default_masked",
+            masking_state: event.masking_state ?? "masked",
+            allowed_value_keys: event.allowed_value_keys ?? [],
+        };
+    }
+    createBatchEnvelopeMetadata() {
+        const id = this.createId();
+        return {
+            batch_id: `batch_${id}`,
+            idempotency_key: `idem_${id}`,
+            sent_at: new Date().toISOString(),
+        };
+    }
+    hasUsableBrowserToken(nowMs = Date.now()) {
+        return this.getUsableCachedBrowserToken(nowMs) !== null;
+    }
+    async warmupBrowserToken(signal) {
+        const result = await this.safeEnsureBrowserToken({ signal });
+        return result.ok;
+    }
+    failedSend(status, attempts, retryStrategy, governor = null) {
+        this.metrics?.increment("send_failure_count");
+        this.metrics?.increment("transport_failed_count");
+        return { ok: false, status, attempts, governor, retryStrategy };
+    }
+    recordDecision(decision, status, attempt, payload) {
+        if (!this.diagnostics)
+            return;
+        if (decision.reason === "invalid_response") {
+            this.diagnostics.record({
+                code: "invalid_response",
+                http_status: status ?? undefined,
+                attempt,
+                batch_fingerprint: this.diagnostics.batchFingerprint(diagnosticCanonicalPayload(payload)),
+            });
+            return;
+        }
+        if (status !== null && status >= 300 && status < 400) {
+            this.diagnostics.record({
+                code: "protocol_redirect",
+                http_status: status,
+                attempt,
+                batch_fingerprint: this.diagnostics.batchFingerprint(diagnosticCanonicalPayload(payload)),
+            });
+        }
+    }
+    async postBatch(input) {
+        try {
+            const response = await fetchWithDeadline(this.endpoint, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    "x-cluebase-project-key": this.projectKey,
+                    [CLUEBASE_BROWSER_TOKEN_HEADER]: input.browserToken,
+                    [CLUEBASE_SDK_REQUEST_HEADER]: this.sdkType,
+                    [CLUEBASE_SDK_VERSION_HEADER]: this.sdkVersion,
+                    [CLUEBASE_SOURCE_SCHEMA_VERSION_HEADER]: String(this.schemaVersion),
+                },
+                body: input.payload,
+                keepalive: input.keepalive,
+                credentials: "omit",
+                redirect: "error",
+            }, input.signal, input.deadlineAt);
+            const decision = evaluateBrowserDeliveryResponse({
+                status: response.status,
+                bodyText: await response.text(),
+                localSubmittedCount: input.localSubmittedCount,
+            });
+            // 受付側が方針を返した時だけ適用する。読めない形なら全部伏せた側へ戻る。
+            if (decision.privacyPolicy !== undefined) {
+                applyDeliveredPrivacyPolicy(decision.privacyPolicy);
+            }
+            return {
+                status: response.status,
+                decision,
+            };
+        }
+        catch {
+            return {
+                status: null,
+                decision: {
+                    ok: false,
+                    retryStrategy: isConsentAbort(input.signal)
+                        ? "drop_event"
+                        : "retry_same_batch",
+                    governor: null,
+                    droppedEventCount: 0,
+                    acceptedEventCount: 0,
+                    acceptedPartial: false,
+                    reason: isConsentAbort(input.signal)
+                        ? "consent_denied"
+                        : "transport_timeout",
+                },
+            };
+        }
+    }
+    createId() {
+        return generateEventId();
+    }
+    /**
+     * Obtain a browser ingest token directly from the Cluebase backend.
+     *
+     * The SDK POSTs `{ projectKey }` to
+     * `<endpoint>/api/v1/ingest/browser-tokens`; the browser stamps the `Origin`
+     * header automatically and the Cluebase backend validates project key + origin
+     * before minting a short-lived token.
+     *
+     * Tokens are cached in-memory until they are within
+     * `BROWSER_TOKEN_REFRESH_LEEWAY_MS` of expiry, at which point the next
+     * `ensureBrowserToken()` call transparently refreshes them. The function
+     * throws on transport / HTTP errors so the caller (`send`) can mark the
+     * batch as failed without bypassing the credentialled boundary.
+     */
+    getUsableCachedBrowserToken(nowMs = Date.now()) {
+        if (this.cachedToken &&
+            this.cachedToken.expiresAtMs > nowMs + BROWSER_TOKEN_REFRESH_LEEWAY_MS) {
+            return this.cachedToken.token;
+        }
+        return null;
+    }
+    async ensureBrowserToken(signal, deadlineAt) {
+        const nowMs = Date.now();
+        const cachedToken = this.getUsableCachedBrowserToken(nowMs);
+        if (cachedToken) {
+            return cachedToken;
+        }
+        if (this.pendingTokenRequest) {
+            return await awaitWithAbort(this.pendingTokenRequest, signal);
+        }
+        // `x-cluebase-project-key` lets the Cluebase API resolve project-scoped CORS and
+        // token issuance consistently with the JSON body.
+        const request = (async () => {
+            const response = await fetchWithDeadline(this.browserTokenEndpoint, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    "x-cluebase-project-key": this.projectKey,
+                },
+                body: JSON.stringify({
+                    projectKey: this.projectKey,
+                }),
+                credentials: "omit",
+                redirect: "error",
+            }, signal, deadlineAt);
+            if (!response.ok) {
+                throw new BrowserTokenRequestError(response.status);
+            }
+            const tokenBody = asObject(await response.json());
+            const token = typeof tokenBody?.token === "string" ? tokenBody.token.trim() : "";
+            const expiresAt = typeof tokenBody?.expiresAt === "string" ? tokenBody.expiresAt : "";
+            const expiresAtMs = Date.parse(expiresAt);
+            if (token.length === 0 || Number.isNaN(expiresAtMs)) {
+                throw new BrowserTokenRequestError(response.status);
+            }
+            this.cachedToken = {
+                token,
+                expiresAtMs,
+            };
+            return token;
+        })();
+        this.pendingTokenRequest = request;
+        try {
+            return await request;
+        }
+        finally {
+            if (this.pendingTokenRequest === request) {
+                this.pendingTokenRequest = null;
+            }
+        }
+    }
+    async safeEnsureBrowserToken(options = {}) {
+        if (options.requireCachedToken) {
+            const cachedToken = this.getUsableCachedBrowserToken();
+            if (cachedToken) {
+                return { ok: true, token: cachedToken };
+            }
+            this.metrics?.increment("browser_token_missing_cached_count");
+            return { ok: false, retryStrategy: "drop_event" };
+        }
+        try {
+            return {
+                ok: true,
+                token: await this.ensureBrowserToken(options.signal, options.deadlineAt),
+            };
+        }
+        catch (error) {
+            this.metrics?.increment("browser_token_failure_count");
+            if (isConsentAbort(options.signal)) {
+                return { ok: false, retryStrategy: "drop_event" };
+            }
+            // A transport failure carries no status and may succeed later. Anything
+            // that did reach Cluebase is classified by the same owner batch delivery
+            // uses, so a refusal the token endpoint will repeat forever — a malformed
+            // body, a bad key, a wrong path — stops instead of being replayed.
+            if (!(error instanceof BrowserTokenRequestError) || error.status === null) {
+                return { ok: false, retryStrategy: "retry_same_batch" };
+            }
+            return {
+                ok: false,
+                retryStrategy: classifyIngestHttpStatus(error.status),
+            };
+        }
+    }
+}
+const asObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : null;
+const diagnosticCanonicalPayload = (payload) => {
+    try {
+        return canonicalJsonStringify(JSON.parse(payload));
+    }
+    catch {
+        return "{}";
+    }
+};
+const isConsentAbort = (signal) => signal?.aborted === true && signal.reason === CONSENT_DENIED_ABORT_REASON;
+const sleep = (milliseconds, signal, deadlineAt) => new Promise((resolve) => {
+    const remaining = remainingDeadlineMs(deadlineAt);
+    if (signal?.aborted || (remaining !== null && remaining <= 0)) {
+        resolve(false);
+        return;
+    }
+    const abort = () => {
+        clearTimeout(timeout);
+        resolve(false);
+    };
+    const timeoutMs = Math.min(milliseconds, remaining ?? milliseconds);
+    const timeout = setTimeout(() => {
+        signal?.removeEventListener("abort", abort);
+        resolve(timeoutMs === milliseconds);
+    }, timeoutMs);
+    signal?.addEventListener("abort", abort, { once: true });
+});
+const awaitWithAbort = async (promise, signal) => {
+    if (!signal)
+        return await promise;
+    if (signal.aborted)
+        throw new DOMException("aborted", "AbortError");
+    return await new Promise((resolve, reject) => {
+        const abort = () => reject(new DOMException("aborted", "AbortError"));
+        signal.addEventListener("abort", abort, { once: true });
+        void promise.then((value) => {
+            signal.removeEventListener("abort", abort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener("abort", abort);
+            reject(error);
+        });
+    });
+};
+const fetchWithDeadline = async (input, init, externalSignal, deadlineAt) => {
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    if (externalSignal?.aborted)
+        abort();
+    externalSignal?.addEventListener("abort", abort, { once: true });
+    const remaining = remainingDeadlineMs(deadlineAt);
+    if (remaining !== null && remaining <= 0)
+        abort();
+    const timeout = setTimeout(abort, Math.min(NORMAL_ATTEMPT_TIMEOUT_MS, remaining ?? NORMAL_ATTEMPT_TIMEOUT_MS));
+    try {
+        return await fetch(input, { ...init, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timeout);
+        externalSignal?.removeEventListener("abort", abort);
+    }
+};
+const monotonicNow = () => typeof performance !== "undefined" ? performance.now() : Date.now();
+const remainingDeadlineMs = (deadlineAt) => deadlineAt === undefined ? null : Math.max(0, deadlineAt - monotonicNow());
+const hasDeadlineRemaining = (deadlineAt) => {
+    const remaining = remainingDeadlineMs(deadlineAt);
+    return remaining === null || remaining > 0;
+};