@squasher-ai/nextjs 0.3.0 → 0.4.0

package/dist/_vendor/node-sdk/actionable-telemetry.d.ts

@@ -0,0 +1,4 @@
+import type { ErrorEvent } from "./types.js";
+export declare function mergeActionableTelemetry(event: ErrorEvent, error: Error, options?: {
+    attributes?: ErrorEvent["attributes"];
+}): ErrorEvent;

package/dist/_vendor/node-sdk/actionable-telemetry.js

@@ -0,0 +1,32 @@
+import { getActionableErrorTelemetry } from "../sdk-runtime/runtime/public-sdk-runtime.js";
+export function mergeActionableTelemetry(event, error, options) {
+    const telemetry = getActionableErrorTelemetry(error);
+    if (!telemetry) {
+        return options?.attributes ? { ...event, attributes: options.attributes } : event;
+    }
+    return {
+        ...event,
+        attributes: {
+            ...telemetry.attributes,
+            ...options?.attributes,
+        },
+        extra: {
+            squasher_error: actionableContextJson(telemetry.extra.squasher_error),
+            ...event.extra,
+        },
+    };
+}
+function actionableContextJson(context) {
+    const result = {};
+    if (context.status !== undefined)
+        result.status = context.status;
+    if (context.why)
+        result.why = context.why;
+    if (context.fix)
+        result.fix = context.fix;
+    if (context.link)
+        result.link = context.link;
+    if (context.internal)
+        result.internal = context.internal;
+    return result;
+}

package/dist/_vendor/node-sdk/aws-lambda.d.ts

@@ -0,0 +1,19 @@
+import type { SquasherClient } from "./client.js";
+/** The small part of the AWS Lambda context that the wrapper uses. */
+export interface AwsLambdaContextLike {
+    awsRequestId?: string;
+    functionName?: string;
+    getRemainingTimeInMillis?: () => number;
+}
+export type AwsLambdaHandler<Event, Context extends AwsLambdaContextLike, Result> = (event: Event, context: Context) => Result | Promise<Result>;
+export interface AwsLambdaOptions {
+    /** Maximum time to wait for telemetry after the handler completes. Default: 1000 ms. */
+    flushTimeoutMs?: number;
+    /** Time left for the Lambda runtime after the telemetry flush. Default: 100 ms. */
+    remainingTimeReserveMs?: number;
+}
+/**
+ * Wrap an async AWS Lambda handler with failure capture and a deadline-aware flush.
+ * The wrapper has no AWS package or Lambda layer dependency.
+ */
+export declare function withAwsLambda<Event, Context extends AwsLambdaContextLike, Result>(client: SquasherClient, handler: AwsLambdaHandler<Event, Context, Result>, options?: AwsLambdaOptions): AwsLambdaHandler<Event, Context, Result>;

package/dist/_vendor/node-sdk/aws-lambda.js

@@ -0,0 +1,81 @@
+const DEFAULT_FLUSH_TIMEOUT_MS = 1_000;
+const DEFAULT_REMAINING_TIME_RESERVE_MS = 100;
+/**
+ * Wrap an async AWS Lambda handler with failure capture and a deadline-aware flush.
+ * The wrapper has no AWS package or Lambda layer dependency.
+ */
+export function withAwsLambda(client, handler, options = {}) {
+    return async (event, context) => {
+        try {
+            return await handler(event, context);
+        }
+        catch (cause) {
+            const error = cause instanceof Error ? cause : new Error(String(cause));
+            const metadata = lambdaMetadata(context);
+            try {
+                await client.captureError(error, {
+                    aws_lambda: metadata.extra,
+                }, {
+                    attributes: {
+                        "squasher.runtime.profile": "serverless",
+                        ...metadata.attributes,
+                    },
+                });
+            }
+            catch {
+                // Telemetry must not replace the handler failure.
+            }
+            throw cause;
+        }
+        finally {
+            try {
+                await flushWithin(client, resolveFlushTimeout(context, options));
+            }
+            catch {
+                // Telemetry must not change the handler result.
+            }
+        }
+    };
+}
+function lambdaMetadata(context) {
+    const attributes = {};
+    const extra = {};
+    if (context.awsRequestId) {
+        attributes["faas.invocation_id"] = context.awsRequestId;
+        extra.request_id = context.awsRequestId;
+    }
+    if (context.functionName) {
+        attributes["faas.name"] = context.functionName;
+        extra.function_name = context.functionName;
+    }
+    return { attributes, extra };
+}
+async function flushWithin(client, timeoutMs) {
+    if (timeoutMs === 0) {
+        await client.flush(0);
+        return;
+    }
+    let timeout;
+    try {
+        await Promise.race([
+            client.flush(timeoutMs),
+            new Promise((resolve) => {
+                timeout = setTimeout(resolve, timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
+function resolveFlushTimeout(context, options) {
+    const configuredTimeout = nonNegative(options.flushTimeoutMs ?? DEFAULT_FLUSH_TIMEOUT_MS);
+    if (!context.getRemainingTimeInMillis)
+        return configuredTimeout;
+    const reserve = nonNegative(options.remainingTimeReserveMs ?? DEFAULT_REMAINING_TIME_RESERVE_MS);
+    return Math.min(configuredTimeout, nonNegative(context.getRemainingTimeInMillis() - reserve));
+}
+function nonNegative(value) {
+    return Number.isFinite(value) ? Math.max(0, value) : 0;
+}

package/dist/_vendor/node-sdk/client.d.ts

@@ -0,0 +1,54 @@
+import { type DeliveryStats } from "./delivery-stats.js";
+import type { Breadcrumb, CaptureErrorOptions, ErrorEvent, JsonObject, Level, SquasherConfig, UserContext } from "./types.js";
+interface PendingRequest {
+    body: string;
+    eventCount: number;
+}
+export declare class SquasherClient {
+    private config;
+    private breadcrumbs;
+    private user;
+    private tags;
+    private queue;
+    private deliveryStats;
+    private inFlightFlushes;
+    protected flushTimer: ReturnType<typeof setInterval> | null;
+    protected disabled: boolean;
+    constructor(config: SquasherConfig);
+    setUser(user: UserContext | undefined): void;
+    setTag(key: string, value: string): void;
+    setTags(tags: Record<string, string>): void;
+    /** Local delivery health. Reading this snapshot never emits telemetry. */
+    getDeliveryStats(): DeliveryStats;
+    /** Ring buffer with FIFO eviction past `maxBreadcrumbs`. */
+    addBreadcrumb(crumb: Omit<Breadcrumb, "timestamp">): void;
+    captureError(error: Error, extra?: JsonObject, options?: CaptureErrorOptions): Promise<string | null>;
+    captureMessage(message: string, level?: Level): Promise<string | null>;
+    /** All capture* helpers funnel through here. Returns null if sampled out or disabled. */
+    captureTelemetry(event: ErrorEvent): Promise<string | null>;
+    track(eventName: string, properties?: JsonObject, context?: Partial<ErrorEvent>): Promise<string | null>;
+    identify(distinctId: string, traits?: JsonObject, context?: Partial<ErrorEvent>): Promise<string | null>;
+    page(name: string, properties?: JsonObject, context?: Partial<ErrorEvent>): Promise<string | null>;
+    screen(name: string, properties?: JsonObject, context?: Partial<ErrorEvent>): Promise<string | null>;
+    captureSpan(name: string, context?: Partial<ErrorEvent>): Promise<string | null>;
+    captureToolCall(name: string, context?: Partial<ErrorEvent>): Promise<string | null>;
+    captureGeneration(message: string, context?: Partial<ErrorEvent>): Promise<string | null>;
+    /** Drain the queue. Resolves when empty or timeout expires. Call before process exit. */
+    flush(timeoutMs?: number): Promise<void>;
+    close(): Promise<void>;
+    /**
+     * Install global error handlers (uncaughtException + unhandledRejection).
+     * Per spec §6: uncaughtException → capture + flush + exit(1).
+     * unhandledRejection → capture (no exit).
+     */
+    installGlobalHandlers(): void;
+    protected prepareEvent(event: ErrorEvent): ErrorEvent;
+    private buildErrorEvent;
+    protected parseStack(stack?: string): ErrorEvent["frames"];
+    protected buildRequests(events: ErrorEvent[]): PendingRequest[];
+    private enqueue;
+    private flushQueue;
+    protected sendWithRetry(request: PendingRequest): Promise<void>;
+    private attemptSend;
+}
+export {};

package/dist/_vendor/node-sdk/client.js

@@ -0,0 +1,479 @@
+import { attemptAsync } from "../result-runtime/attempt.js";
+import { buildBatches, DEFAULT_INGEST_ENDPOINT, detectRelease, getDefaultHeaders, nextBackoffMs, resolveDebugFlag, resolveTelemetrySampling, shouldRetry, shouldSampleTelemetry, sleep, } from "../sdk-runtime/runtime/public-sdk-runtime.js";
+import { mergeActionableTelemetry } from "./actionable-telemetry.js";
+import { DeliveryStatsTracker } from "./delivery-stats.js";
+import { createLocalEventSink, normalizeLocalEventSinkConfig, } from "./local-events/sink.js";
+const SDK_NAME = "@squasher-ai/node";
+const SDK_VERSION = "0.5.0";
+// Cached at module load — getDefaultHeaders is pure given package metadata
+// and platform detection in sdk-core memoizes its own probe. One allocation
+// per process, reused on every outbound request.
+const DEFAULT_TELEMETRY_HEADERS = getDefaultHeaders({
+    packageName: SDK_NAME,
+    packageVersion: SDK_VERSION,
+});
+async function settleBeforeDeadline(promise, deadline) {
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0)
+        return false;
+    let timeout;
+    const deadlineReached = new Promise((resolve) => {
+        timeout = setTimeout(() => resolve(false), remainingMs);
+        timeout.unref();
+    });
+    try {
+        return await Promise.race([promise.then(() => true), deadlineReached]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
+function resolveConfig(config) {
+    return {
+        apiKey: config.apiKey,
+        projectId: config.projectId,
+        endpoint: config.endpoint ?? DEFAULT_INGEST_ENDPOINT,
+        environment: config.environment,
+        release: config.release ?? detectRelease() ?? undefined,
+        debug: resolveDebugFlag(config.debug),
+        sampling: resolveTelemetrySampling(config.sampling),
+        beforeSend: config.beforeSend,
+        maxBreadcrumbs: config.maxBreadcrumbs ?? 50,
+        batchSize: config.batchSize ?? 25,
+        flushIntervalMs: config.flushIntervalMs ?? 5000,
+        maxRetries: config.maxRetries ?? 3,
+        resourceAttributes: config.resourceAttributes ?? {},
+        localEventSink: createLocalEventSink(normalizeLocalEventSinkConfig(config.localEventSink)),
+    };
+}
+export class SquasherClient {
+    config;
+    breadcrumbs = [];
+    user;
+    tags = {};
+    queue = [];
+    deliveryStats = new DeliveryStatsTracker();
+    inFlightFlushes = new Set();
+    flushTimer = null;
+    disabled;
+    constructor(config) {
+        // Missing (undefined/null) = throw. Empty string = disabled mode (per spec §2).
+        if (config.apiKey === undefined || config.apiKey === null)
+            throw new Error("Squasher: apiKey is required");
+        if (config.projectId === undefined || config.projectId === null)
+            throw new Error("Squasher: projectId is required");
+        this.config = resolveConfig(config);
+        this.disabled = config.apiKey.length === 0 || config.projectId.length === 0;
+        if (this.disabled && this.config.debug) {
+            console.warn("[squasher] SDK initialized in disabled mode (empty apiKey or projectId). Events will not be sent.");
+        }
+        if (!this.disabled) {
+            this.flushTimer = setInterval(() => {
+                void this.flushQueue();
+            }, this.config.flushIntervalMs);
+            // Unref so the interval doesn't keep the Node process alive.
+            this.flushTimer.unref();
+        }
+    }
+    setUser(user) {
+        this.user = user;
+    }
+    setTag(key, value) {
+        this.tags[key] = value;
+    }
+    setTags(tags) {
+        Object.assign(this.tags, tags);
+    }
+    /** Local delivery health. Reading this snapshot never emits telemetry. */
+    getDeliveryStats() {
+        return this.deliveryStats.snapshot(this.queue.length);
+    }
+    /** Ring buffer with FIFO eviction past `maxBreadcrumbs`. */
+    addBreadcrumb(crumb) {
+        this.breadcrumbs.push({
+            ...crumb,
+            timestamp: new Date().toISOString(),
+        });
+        if (this.breadcrumbs.length > this.config.maxBreadcrumbs) {
+            this.breadcrumbs = this.breadcrumbs.slice(-this.config.maxBreadcrumbs);
+        }
+    }
+    async captureError(error, extra, options) {
+        return this.captureTelemetry(this.buildErrorEvent(error, extra, options));
+    }
+    async captureMessage(message, level = "info") {
+        return this.captureTelemetry({
+            message,
+            level,
+        });
+    }
+    /** All capture* helpers funnel through here. Returns null if sampled out or disabled. */
+    async captureTelemetry(event) {
+        if (this.disabled)
+            return null;
+        let prepared = this.prepareEvent(event);
+        if (!this.config.debug && !shouldSampleTelemetry(prepared, this.config.sampling)) {
+            if (!prepared.measurements?.length)
+                return null;
+            prepared = markSampledOut(prepared);
+        }
+        if (this.config.beforeSend) {
+            const filtered = this.config.beforeSend(prepared);
+            if (!filtered)
+                return null;
+            prepared = filtered;
+        }
+        this.config.localEventSink?.write(prepared);
+        return this.enqueue(prepared);
+    }
+    async track(eventName, properties, context = {}) {
+        return this.captureTelemetry({
+            ...context,
+            message: context.message ?? eventName,
+            level: context.level ?? "info",
+            kind: context.kind ?? "analytics",
+            event_name: context.event_name ?? eventName,
+            analytics: {
+                ...context.analytics,
+                event: context.analytics?.event ?? eventName,
+                properties: properties ?? context.analytics?.properties,
+            },
+        });
+    }
+    async identify(distinctId, traits, context = {}) {
+        this.user = {
+            ...this.user,
+            ...context.user,
+            id: distinctId,
+        };
+        return this.captureTelemetry({
+            ...context,
+            message: context.message ?? `identify:${distinctId}`,
+            level: context.level ?? "info",
+            kind: "identify",
+            event_name: context.event_name ?? "identify",
+            distinct_id: context.distinct_id ?? distinctId,
+            analytics: {
+                ...context.analytics,
+                event: context.analytics?.event ?? "identify",
+                properties: traits ?? context.analytics?.properties,
+            },
+            user: {
+                ...context.user,
+                id: distinctId,
+            },
+        });
+    }
+    async page(name, properties, context = {}) {
+        return this.captureTelemetry({
+            ...context,
+            message: context.message ?? `page:${name}`,
+            level: context.level ?? "info",
+            kind: "page",
+            event_name: context.event_name ?? name,
+            analytics: {
+                ...context.analytics,
+                event: context.analytics?.event ?? name,
+                properties: properties ?? context.analytics?.properties,
+            },
+            page: {
+                ...context.page,
+                name: context.page?.name ?? name,
+            },
+        });
+    }
+    async screen(name, properties, context = {}) {
+        return this.captureTelemetry({
+            ...context,
+            message: context.message ?? `screen:${name}`,
+            level: context.level ?? "info",
+            kind: "screen",
+            event_name: context.event_name ?? name,
+            analytics: {
+                ...context.analytics,
+                event: context.analytics?.event ?? name,
+                properties: properties ?? context.analytics?.properties,
+            },
+            page: {
+                ...context.page,
+                name: context.page?.name ?? name,
+                screen_class: context.page?.screen_class ?? name,
+            },
+        });
+    }
+    async captureSpan(name, context = {}) {
+        return this.captureTelemetry({
+            ...context,
+            message: context.message ?? `span:${name}`,
+            level: context.level ?? "info",
+            kind: context.kind ?? "agent_span",
+            event_name: context.event_name ?? name,
+            trace: {
+                ...context.trace,
+                span_name: context.trace?.span_name ?? name,
+            },
+        });
+    }
+    async captureToolCall(name, context = {}) {
+        return this.captureTelemetry({
+            ...context,
+            message: context.message ?? `tool:${name}`,
+            level: context.level ?? "info",
+            kind: "tool_call",
+            event_name: context.event_name ?? name,
+            tool_call: {
+                ...context.tool_call,
+                name: context.tool_call?.name ?? name,
+            },
+        });
+    }
+    async captureGeneration(message, context = {}) {
+        return this.captureTelemetry({
+            ...context,
+            message,
+            level: context.level ?? "info",
+            kind: "llm_generation",
+            event_name: context.event_name ?? context.llm?.model ?? "llm_generation",
+        });
+    }
+    /** Drain the queue. Resolves when empty or timeout expires. Call before process exit. */
+    async flush(timeoutMs = 5000) {
+        const deadline = Date.now() + timeoutMs;
+        while ((this.queue.length > 0 || this.inFlightFlushes.size > 0) && Date.now() < deadline) {
+            const pending = this.queue.length > 0
+                ? this.flushQueue()
+                : Promise.all(this.inFlightFlushes).then(() => undefined);
+            if (!(await settleBeforeDeadline(pending, deadline)))
+                return;
+        }
+    }
+    async close() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+        await this.flush(5000);
+    }
+    /**
+     * Install global error handlers (uncaughtException + unhandledRejection).
+     * Per spec §6: uncaughtException → capture + flush + exit(1).
+     * unhandledRejection → capture (no exit).
+     */
+    installGlobalHandlers() {
+        process.on("uncaughtException", async (error) => {
+            await this.captureError(error);
+            await this.flush(5000);
+            process.exit(1);
+        });
+        process.on("unhandledRejection", (reason) => {
+            const error = reason instanceof Error ? reason : new Error(String(reason));
+            void this.captureError(error);
+        });
+    }
+    prepareEvent(event) {
+        const kind = event.kind ?? (event.level === "error" || event.level === "fatal" ? "error" : "log");
+        const mergedTags = { ...this.tags, ...event.tags };
+        const tags = Object.keys(mergedTags).length > 0 ? mergedTags : undefined;
+        const mergedResourceAttributes = {
+            ...this.config.resourceAttributes,
+            ...event.resource_attributes,
+        };
+        const resourceAttributes = Object.keys(mergedResourceAttributes).length > 0 ? mergedResourceAttributes : undefined;
+        return {
+            ...event,
+            level: event.level ?? "info",
+            kind,
+            distinct_id: event.distinct_id ?? event.user?.id ?? this.user?.id,
+            visitor: event.visitor ??
+                (event.session_id && ["analytics", "identify", "page", "screen", "visitor"].includes(kind)
+                    ? { anonymous_id: event.session_id }
+                    : undefined),
+            tags,
+            sdk: event.sdk ?? { name: SDK_NAME, version: SDK_VERSION },
+            timestamp: event.timestamp ?? new Date().toISOString(),
+            release: event.release ?? this.config.release,
+            environment: event.environment ?? this.config.environment,
+            user: event.user ?? (this.user ? { ...this.user } : undefined),
+            breadcrumbs: event.breadcrumbs ?? (this.breadcrumbs.length > 0 ? [...this.breadcrumbs] : undefined),
+            resource_attributes: resourceAttributes,
+        };
+    }
+    buildErrorEvent(error, extra, options) {
+        return mergeActionableTelemetry({
+            message: error.message,
+            type: error.name,
+            stack: error.stack,
+            frames: this.parseStack(error.stack),
+            level: options?.level ?? "error",
+            request: options?.request,
+            extra,
+        }, error, options);
+    }
+    parseStack(stack) {
+        if (!stack)
+            return undefined;
+        const lines = stack.split("\n").slice(1);
+        const frames = lines
+            .map((line) => {
+            const match = line.match(/\s+at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?/);
+            if (!match)
+                return null;
+            const [, fn, filename, lineno, colno] = match;
+            const isNodeInternal = filename?.includes("node_modules") || filename?.includes("node:") || false;
+            return {
+                function: fn || "<anonymous>",
+                filename,
+                lineno: lineno ? parseInt(lineno, 10) : undefined,
+                colno: colno ? parseInt(colno, 10) : undefined,
+                in_app: !isNodeInternal,
+            };
+        })
+            .filter((f) => f !== null);
+        return frames.length > 0 ? frames : undefined;
+    }
+    buildRequests(events) {
+        return buildBatches(events, {
+            batchPrefix: '{"events":[',
+            batchSuffix: "]}",
+            serializeSingle: (item) => JSON.stringify(item),
+        }).map((batch) => ({ body: batch.body, eventCount: batch.itemCount }));
+    }
+    enqueue(event) {
+        const eventId = crypto.randomUUID();
+        this.queue.push(event);
+        this.deliveryStats.recordQueueDepth(this.queue.length);
+        if (this.queue.length >= this.config.batchSize) {
+            void this.flushQueue();
+        }
+        return eventId;
+    }
+    async flushQueue() {
+        if (this.queue.length === 0)
+            return;
+        const startedAt = Date.now();
+        const events = this.queue.splice(0);
+        const requests = this.buildRequests(events);
+        const pending = Promise.allSettled(requests.map((request) => this.sendWithRetry(request))).then(() => undefined);
+        this.inFlightFlushes.add(pending);
+        try {
+            await pending;
+        }
+        finally {
+            this.inFlightFlushes.delete(pending);
+            this.deliveryStats.recordFlushDuration(Date.now() - startedAt);
+        }
+    }
+    async sendWithRetry(request) {
+        const url = `${this.config.endpoint}/v1/ingest/${this.config.projectId}`;
+        let attempt = 0;
+        this.deliveryStats.recordAttempt(request.eventCount);
+        while (true) {
+            const response = await this.attemptSend(url, request);
+            if (!response.res) {
+                attempt++;
+                if (attempt > this.config.maxRetries) {
+                    this.deliveryStats.recordDropped(request.eventCount, "network_error", null);
+                    if (this.config.debug) {
+                        console.error(`[squasher] Event dropped after ${attempt} retries:`, response.cause);
+                    }
+                    return;
+                }
+                this.deliveryStats.recordRetry(request.eventCount);
+                const backoff = Math.round(nextBackoffMs({ attempt: attempt - 1 }));
+                if (this.config.debug) {
+                    console.warn(`[squasher] Network error, retry ${attempt}/${this.config.maxRetries} in ${backoff}ms:`, response.cause);
+                }
+                await sleep(backoff);
+                continue;
+            }
+            if (response.res.ok) {
+                this.deliveryStats.recordSent(request.eventCount, response.res.status);
+                if (this.config.debug) {
+                    const label = request.eventCount === 1 ? "Event" : `${request.eventCount} events`;
+                    console.log(`[squasher] ${label} sent: ${response.data?.id ?? ""}`);
+                }
+                return;
+            }
+            if (response.res.status === 401) {
+                this.deliveryStats.recordDropped(request.eventCount, "unauthorized", 401);
+                console.error("[squasher] Invalid API key (401). Events will be dropped.");
+                this.disabled = true;
+                return;
+            }
+            if (response.res.status === 429) {
+                // Stay parity with prior behavior: stop after a single 429 so we
+                // don't pile on a rate-limited backend, but use the server-supplied
+                // Retry-After hint when available (capped at sdk-core's 8s).
+                const wait = Math.round(nextBackoffMs({
+                    attempt: attempt,
+                    headers: response.res.headers,
+                }));
+                if (this.config.debug) {
+                    console.warn("[squasher] Rate limited (429), backing off");
+                }
+                await sleep(wait);
+                this.deliveryStats.recordDropped(request.eventCount, "rate_limited", 429);
+                return;
+            }
+            const retryable = shouldRetry({
+                status: response.res.status,
+                headers: response.res.headers,
+            });
+            if (!retryable) {
+                this.deliveryStats.recordDropped(request.eventCount, "rejected", response.res.status);
+                if (this.config.debug) {
+                    console.error(`[squasher] Event rejected (HTTP ${response.res.status}), not retrying`);
+                }
+                return;
+            }
+            attempt++;
+            if (attempt > this.config.maxRetries) {
+                this.deliveryStats.recordDropped(request.eventCount, "server_error", response.res.status);
+                if (this.config.debug) {
+                    console.error(`[squasher] Event dropped after ${attempt} retries (HTTP ${response.res.status})`);
+                }
+                return;
+            }
+            this.deliveryStats.recordRetry(request.eventCount);
+            const backoff = Math.round(nextBackoffMs({
+                attempt: attempt - 1,
+                headers: response.res.headers,
+            }));
+            if (this.config.debug) {
+                console.warn(`[squasher] Server error (HTTP ${response.res.status}), retry ${attempt}/${this.config.maxRetries} in ${backoff}ms`);
+            }
+            await sleep(backoff);
+        }
+    }
+    async attemptSend(url, request) {
+        return attemptAsync({
+            try: async () => {
+                const res = await fetch(url, {
+                    method: "POST",
+                    headers: {
+                        ...DEFAULT_TELEMETRY_HEADERS,
+                        "Content-Type": "application/json",
+                        "x-squasher-key": this.config.apiKey,
+                    },
+                    body: request.body,
+                });
+                return {
+                    data: res.ok ? await res.json() : null,
+                    res,
+                };
+            },
+            catch: ({ cause }) => ({
+                cause: cause instanceof Error ? cause : new Error(String(cause)),
+                data: null,
+                res: null,
+            }),
+        });
+    }
+}
+function markSampledOut(event) {
+    return {
+        ...event,
+        attributes: { ...event.attributes, "squasher.sampled": false },
+    };
+}