@statoss/sdk 0.0.0-stage → 0.1.0

package/dist/esm/client.d.ts

@@ -0,0 +1,50 @@
+import { type Logger } from "./logger.js";
+import { type RuntimeInfo } from "./runtime.js";
+import { type Scope } from "./scope.js";
+import type { Breadcrumb, BreadcrumbHint, CaptureContext, Event, InitOptions } from "./types.js";
+export declare class Client {
+    readonly logger: Logger;
+    readonly runtime: RuntimeInfo;
+    readonly enabled: boolean;
+    readonly integrations: string[];
+    private readonly options;
+    private readonly dsn?;
+    private readonly endpoint?;
+    private readonly sender?;
+    private readonly levels;
+    private readonly sampleRate;
+    private readonly maxBreadcrumbs;
+    private readonly discarded;
+    private readonly pending;
+    private readonly teardowns;
+    private reportTimer?;
+    private previousSignature?;
+    private closed;
+    constructor(options: InitOptions);
+    /** Installs the integrations that apply to this runtime. */
+    setup(): void;
+    captureException(error: unknown, context: CaptureContext | undefined, scope: Scope): string;
+    captureMessage(message: unknown, context: CaptureContext | undefined, scope: Scope): string;
+    captureEvent(event: Event, context: CaptureContext | undefined, scope: Scope): string;
+    /** Applies beforeBreadcrumb and keeps the breadcrumb on the current scope. */
+    addBreadcrumb(breadcrumb: Breadcrumb, hint?: BreadcrumbHint): void;
+    /** True for a URL this client sends envelopes to, so the fetch breadcrumbs skip it. */
+    isOwnUrl(url: string): boolean;
+    /** Counts something not sent, for the next client report. */
+    recordLoss(reason: string, category: string, quantity?: number): void;
+    sendClientReport(): void;
+    /** Waits for captured events to be sent; false if timeoutMs passed first. */
+    flush(timeoutMs?: number): Promise<boolean>;
+    /** Flushes, then removes the integrations. Nothing is captured afterwards. */
+    close(timeoutMs?: number): Promise<boolean>;
+    /** Removes the integrations at once, without waiting. */
+    teardown(): void;
+    private flushReportsWhenHidden;
+    private capture;
+    /** Merges scope, context and options into the event, in Sentry's field order. */
+    private prepare;
+    private process;
+    /** Makes what beforeSend handed back valid again: a Sentry level, string tags, a sane size. */
+    private finish;
+    private send;
+}

package/dist/esm/client.js

@@ -0,0 +1,458 @@
+import { authHeader, envelopeEndpoint, envelopeUrlWithQueryAuth, parseDsn, } from "./dsn.js";
+import { clientReportEnvelope, eventEnvelope, } from "./envelope.js";
+import { addInitialFrame, eventFromUnknown } from "./event.js";
+import { getCurrentScope } from "./hub.js";
+import { installClicks, installNavigation } from "./integrations/browser.js";
+import { installConsole } from "./integrations/console.js";
+import { eventSignature } from "./integrations/dedupe.js";
+import { installFetch } from "./integrations/fetch.js";
+import { installGlobalHandlers } from "./integrations/handlers.js";
+import { CATEGORY_TAG, chooseLevel, isSentryLevel, LEVEL_TAG, readCategory, readLevels, } from "./levels.js";
+import { makeLogger } from "./logger.js";
+import { describeRuntime } from "./runtime.js";
+import { MAX_BREADCRUMBS } from "./scope.js";
+import { fetchTransport, Sender } from "./transport.js";
+import { isObject, isThenable, normalize, now, safely, safeString, scrubUrl, truncate, unref, uuid4, } from "./utils.js";
+import { SDK_NAME, SDK_PACKAGE, SDK_VERSION } from "./version.js";
+const REPORT_INTERVAL_MS = 30000;
+const DEFAULT_FLUSH_MS = 2000;
+// The server drops event items over 1 MiB.
+const MAX_EVENT_CHARS = 1000000;
+const MAX_TAG_VALUE = 200;
+const KNOWN_KEYS = new Set([
+    "event_id",
+    "timestamp",
+    "platform",
+    "level",
+    "logger",
+    "transaction",
+    "server_name",
+    "environment",
+    "release",
+    "dist",
+    "message",
+    "exception",
+    "breadcrumbs",
+    "tags",
+    "extra",
+    "contexts",
+    "user",
+    "request",
+    "fingerprint",
+    "sdk",
+]);
+function cleanTags(tags) {
+    const out = {};
+    for (const [key, value] of Object.entries(tags)) {
+        if (value === undefined || value === null)
+            continue;
+        out[key] = truncate(typeof value === "string" ? value : safeString(value), MAX_TAG_VALUE);
+    }
+    return out;
+}
+function cleanContexts(contexts) {
+    const out = {};
+    for (const [name, value] of Object.entries(contexts)) {
+        if (isObject(value))
+            out[name] = normalize(value, 5);
+    }
+    return out;
+}
+function pageRequest() {
+    const g = globalThis;
+    const href = safely(() => g.location?.href);
+    const ua = safely(() => g.navigator?.userAgent);
+    const request = {};
+    if (typeof href === "string")
+        request.url = scrubUrl(href);
+    if (typeof ua === "string")
+        request.headers = { "User-Agent": ua };
+    return Object.keys(request).length ? request : undefined;
+}
+function crumbsOf(value) {
+    if (Array.isArray(value))
+        return value;
+    if (isObject(value) && Array.isArray(value.values))
+        return value.values;
+    return [];
+}
+function withTimeout(promise, ms) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => resolve(false), ms);
+        unref(timer);
+        promise.then(() => {
+            clearTimeout(timer);
+            resolve(true);
+        }, () => {
+            clearTimeout(timer);
+            resolve(true);
+        });
+    });
+}
+export class Client {
+    constructor(options) {
+        this.integrations = [];
+        this.discarded = new Map();
+        this.pending = new Set();
+        this.teardowns = [];
+        this.closed = false;
+        this.options = options;
+        this.logger = makeLogger(options.debug === true);
+        this.runtime = describeRuntime();
+        this.levels = readLevels(options.levels, this.logger);
+        const rate = options.sampleRate;
+        if (rate !== undefined &&
+            !(typeof rate === "number" && rate >= 0 && rate <= 1)) {
+            this.logger.warn("Ignored sampleRate: it should be a number from 0 to 1.");
+        }
+        this.sampleRate =
+            typeof rate === "number" && rate >= 0 && rate <= 1 ? rate : 1;
+        const max = options.maxBreadcrumbs;
+        this.maxBreadcrumbs =
+            typeof max === "number" && max >= 0
+                ? Math.min(Math.floor(max), MAX_BREADCRUMBS)
+                : MAX_BREADCRUMBS;
+        let dsn;
+        if (options.enabled === false) {
+            this.logger.log("Not started: enabled is false.");
+        }
+        else if (options.dsn === undefined || options.dsn === "") {
+            this.logger.warn("Not started: no DSN given.");
+        }
+        else {
+            const parsed = parseDsn(options.dsn);
+            if (parsed.error !== undefined)
+                this.logger.warn(`Not started: ${parsed.error}`);
+            dsn = parsed.dsn;
+        }
+        this.dsn = dsn;
+        this.enabled = dsn !== undefined;
+        if (!dsn)
+            return;
+        this.endpoint = envelopeEndpoint(dsn);
+        const browserLike = this.runtime.browserLike;
+        this.sender = new Sender({
+            url: browserLike ? envelopeUrlWithQueryAuth(dsn) : this.endpoint,
+            headers: browserLike
+                ? { "Content-Type": "text/plain;charset=UTF-8" }
+                : {
+                    "Content-Type": "application/x-sentry-envelope",
+                    "X-Sentry-Auth": authHeader(dsn),
+                },
+            browserLike,
+            transport: options.transport ?? fetchTransport(browserLike),
+            recordLoss: (reason, category, quantity) => this.recordLoss(reason, category, quantity),
+            logger: this.logger,
+        });
+        this.logger.log(`Started for app ${dsn.projectId} on ${dsn.host} (${this.runtime.name}, ${SDK_NAME} ${SDK_VERSION}).`);
+    }
+    /** Installs the integrations that apply to this runtime. */
+    setup() {
+        if (!this.enabled)
+            return;
+        const toggles = {
+            globalHandlers: true,
+            console: true,
+            fetch: true,
+            navigation: true,
+            clicks: true,
+            dedupe: true,
+            ...this.options.integrations,
+        };
+        const add = (name, on, install) => {
+            if (!on)
+                return;
+            const teardown = safely(install);
+            if (!teardown)
+                return;
+            this.integrations.push(name);
+            this.teardowns.push(teardown);
+        };
+        const browser = this.runtime.name === "browser";
+        add("GlobalHandlers", toggles.globalHandlers, () => installGlobalHandlers(this));
+        add("Console", toggles.console, () => installConsole(this));
+        add("Fetch", toggles.fetch, () => installFetch(this));
+        add("Navigation", browser && toggles.navigation, () => installNavigation(this));
+        add("Clicks", browser && toggles.clicks, () => installClicks(this));
+        if (toggles.dedupe)
+            this.integrations.push("Dedupe");
+        if (browser)
+            this.flushReportsWhenHidden();
+        this.logger.log(`Integrations: ${this.integrations.join(", ") || "none"}.`);
+    }
+    captureException(error, context, scope) {
+        return this.capture(() => eventFromUnknown(error, { type: "generic", handled: true }), context, scope, { originalException: error });
+    }
+    captureMessage(message, context, scope) {
+        return this.capture(() => ({ message: truncate(safeString(message)), level: "info" }), context, scope, {});
+    }
+    captureEvent(event, context, scope) {
+        const id = isObject(event) && typeof event.event_id === "string"
+            ? event.event_id
+            : "";
+        return this.capture(() => ({ ...event }), context, scope, {
+            eventId: /^[0-9a-f]{32}$/.test(id) ? id : undefined,
+        });
+    }
+    /** @internal Used by the global handlers. */
+    captureUnhandled(input, mechanism, level, options = {}) {
+        return this.capture(() => {
+            const event = eventFromUnknown(input, mechanism, options.rejection);
+            return options.frame ? addInitialFrame(event, options.frame) : event;
+        }, undefined, getCurrentScope(), { originalException: input, level });
+    }
+    /** Applies beforeBreadcrumb and keeps the breadcrumb on the current scope. */
+    addBreadcrumb(breadcrumb, hint) {
+        if (!this.enabled ||
+            this.closed ||
+            this.maxBreadcrumbs === 0 ||
+            !isObject(breadcrumb))
+            return;
+        try {
+            let crumb = { timestamp: now(), ...breadcrumb };
+            if (crumb.message !== undefined)
+                crumb.message = truncate(safeString(crumb.message), 1024);
+            if (crumb.data !== undefined) {
+                crumb.data = normalize(crumb.data, 3, 1024);
+            }
+            if (this.options.beforeBreadcrumb)
+                crumb = this.options.beforeBreadcrumb(crumb, hint);
+            if (!crumb)
+                return;
+            const scope = getCurrentScope();
+            scope._maxBreadcrumbs = this.maxBreadcrumbs;
+            scope.addBreadcrumb(crumb);
+        }
+        catch (error) {
+            this.logger.error("Could not add a breadcrumb:", error);
+        }
+    }
+    /** True for a URL this client sends envelopes to, so the fetch breadcrumbs skip it. */
+    isOwnUrl(url) {
+        return this.endpoint !== undefined && url.startsWith(this.endpoint);
+    }
+    /** Counts something not sent, for the next client report. */
+    recordLoss(reason, category, quantity = 1) {
+        const key = `${reason}:${category}`;
+        const entry = this.discarded.get(key);
+        if (entry)
+            entry.quantity += quantity;
+        else
+            this.discarded.set(key, { reason, category, quantity });
+        if (this.reportTimer === undefined && this.sender) {
+            this.reportTimer = safely(() => setTimeout(() => {
+                this.reportTimer = undefined;
+                this.sendClientReport();
+            }, REPORT_INTERVAL_MS));
+            unref(this.reportTimer);
+        }
+    }
+    sendClientReport() {
+        if (this.reportTimer !== undefined) {
+            clearTimeout(this.reportTimer);
+            this.reportTimer = undefined;
+        }
+        if (!this.discarded.size || !this.sender || !this.dsn)
+            return;
+        const discarded = [...this.discarded.values()];
+        this.discarded.clear();
+        this.sender.send(clientReportEnvelope(discarded, this.dsn));
+    }
+    /** Waits for captured events to be sent; false if timeoutMs passed first. */
+    async flush(timeoutMs = DEFAULT_FLUSH_MS) {
+        if (!this.sender)
+            return true;
+        const deadline = Date.now() + timeoutMs;
+        const left = () => Math.max(0, deadline - Date.now());
+        const processed = this.pending.size
+            ? await withTimeout(Promise.all([...this.pending]), timeoutMs)
+            : true;
+        this.sendClientReport();
+        let sent = await this.sender.flush(left());
+        // Report what this flush itself lost, such as events that hit a network error.
+        if (this.discarded.size) {
+            this.sendClientReport();
+            sent = (await this.sender.flush(left())) && sent;
+        }
+        return processed && sent;
+    }
+    /** Flushes, then removes the integrations. Nothing is captured afterwards. */
+    async close(timeoutMs = DEFAULT_FLUSH_MS) {
+        this.closed = true;
+        this.teardown();
+        return this.flush(timeoutMs);
+    }
+    /** Removes the integrations at once, without waiting. */
+    teardown() {
+        for (const teardown of this.teardowns.splice(0))
+            safely(teardown);
+    }
+    flushReportsWhenHidden() {
+        const doc = globalThis.document;
+        if (!doc || typeof doc.addEventListener !== "function")
+            return;
+        const onChange = () => {
+            if (doc.visibilityState === "hidden")
+                safely(() => this.sendClientReport());
+        };
+        doc.addEventListener("visibilitychange", onChange);
+        this.teardowns.push(() => doc.removeEventListener?.("visibilitychange", onChange));
+    }
+    capture(build, context, scope, hint) {
+        const eventId = hint.eventId ?? uuid4();
+        if (!this.enabled || this.closed)
+            return eventId;
+        try {
+            const event = this.prepare(build(), context, scope, eventId, hint.level);
+            const task = this.process(event, {
+                event_id: eventId,
+                originalException: hint.originalException,
+            }).catch((error) => {
+                this.logger.error("Could not send an event:", error);
+            });
+            this.pending.add(task);
+            void task.then(() => this.pending.delete(task));
+        }
+        catch (error) {
+            this.logger.error("Could not capture an event:", error);
+        }
+        return eventId;
+    }
+    /** Merges scope, context and options into the event, in Sentry's field order. */
+    prepare(base, context, scope, eventId, forcedLevel) {
+        const ctx = isObject(context) ? context : {};
+        const choice = chooseLevel([ctx.level, forcedLevel, scope._level, base.level], this.levels, "error", this.logger);
+        const tags = {
+            ...scope._tags,
+            ...ctx.tags,
+            ...base.tags,
+        };
+        if (choice.custom)
+            tags[LEVEL_TAG] = choice.custom;
+        const category = readCategory(ctx.category, this.logger);
+        if (category)
+            tags[CATEGORY_TAG] = category;
+        const user = {
+            ...scope._user,
+            ...ctx.user,
+            ...base.user,
+        };
+        if (this.options.sendDefaultPii &&
+            this.runtime.browserLike &&
+            user.ip_address === undefined) {
+            user.ip_address = "{{auto}}";
+        }
+        const request = this.runtime.browserLike
+            ? { ...pageRequest(), ...base.request }
+            : base.request;
+        const fingerprint = base.fingerprint ?? ctx.fingerprint ?? scope._fingerprint;
+        const allCrumbs = [...scope._breadcrumbs, ...crumbsOf(base.breadcrumbs)];
+        const breadcrumbs = allCrumbs.slice(Math.max(0, allCrumbs.length - this.maxBreadcrumbs));
+        const event = {
+            event_id: eventId,
+            timestamp: typeof base.timestamp === "number" ? base.timestamp : now(),
+            platform: base.platform ?? this.runtime.platform,
+            level: choice.level,
+        };
+        const set = (key, value) => {
+            if (value === undefined)
+                return;
+            if (isObject(value) &&
+                !Array.isArray(value) &&
+                Object.keys(value).length === 0)
+                return;
+            event[key] = value;
+        };
+        set("logger", base.logger);
+        set("transaction", base.transaction);
+        set("server_name", base.server_name ?? this.options.serverName ?? this.runtime.serverName);
+        set("environment", base.environment ?? this.options.environment ?? "production");
+        set("release", base.release ?? this.options.release);
+        set("dist", base.dist ?? this.options.dist);
+        set("message", base.message);
+        set("exception", base.exception);
+        set("breadcrumbs", breadcrumbs.length ? { values: breadcrumbs } : undefined);
+        set("tags", cleanTags(tags));
+        set("extra", normalize({ ...scope._extra, ...ctx.extra, ...base.extra }, 6));
+        set("contexts", cleanContexts({
+            ...this.runtime.contexts,
+            ...scope._contexts,
+            ...ctx.contexts,
+            ...base.contexts,
+        }));
+        set("user", normalize(user, 3));
+        set("request", request);
+        set("fingerprint", Array.isArray(fingerprint)
+            ? fingerprint.map((f) => safeString(f))
+            : undefined);
+        set("sdk", {
+            name: SDK_NAME,
+            version: SDK_VERSION,
+            integrations: [...this.integrations],
+            packages: [{ name: SDK_PACKAGE, version: SDK_VERSION }],
+        });
+        for (const key of Object.keys(base)) {
+            if (!KNOWN_KEYS.has(key) && base[key] !== undefined)
+                event[key] = base[key];
+        }
+        return event;
+    }
+    async process(event, hint) {
+        if (this.sampleRate < 1 && Math.random() >= this.sampleRate) {
+            this.logger.log("Dropped an event by sampleRate.");
+            this.recordLoss("sample_rate", "error");
+            return;
+        }
+        if (this.integrations.includes("Dedupe")) {
+            const signature = eventSignature(event);
+            if (signature !== undefined && signature === this.previousSignature) {
+                this.logger.log("Dropped an event identical to the one before it.");
+                this.recordLoss("event_processor", "error");
+                return;
+            }
+            this.previousSignature = signature;
+        }
+        let final = event;
+        if (this.options.beforeSend) {
+            try {
+                const result = this.options.beforeSend(event, hint);
+                final = isThenable(result) ? await result : result;
+            }
+            catch (error) {
+                this.logger.error("beforeSend threw, so the event was dropped:", error);
+                this.recordLoss("internal_sdk_error", "error");
+                return;
+            }
+            if (!isObject(final)) {
+                this.logger.log("beforeSend dropped an event.");
+                this.recordLoss("before_send", "error");
+                return;
+            }
+        }
+        this.send(this.finish(final));
+    }
+    /** Makes what beforeSend handed back valid again: a Sentry level, string tags, a sane size. */
+    finish(event) {
+        if (!isSentryLevel(event.level)) {
+            const choice = chooseLevel([event.level], this.levels, "error", this.logger);
+            event.level = choice.level;
+            if (choice.custom)
+                event.tags = { ...event.tags, [LEVEL_TAG]: choice.custom };
+        }
+        if (isObject(event.tags))
+            event.tags = cleanTags(event.tags);
+        const size = () => safely(() => JSON.stringify(event).length, 0) ?? 0;
+        if (size() > MAX_EVENT_CHARS) {
+            this.logger.warn("The event is over 1 MB; sending it without breadcrumbs and extra.");
+            delete event.breadcrumbs;
+            if (size() > MAX_EVENT_CHARS)
+                delete event.extra;
+        }
+        return event;
+    }
+    send(event) {
+        if (!this.sender || !this.dsn)
+            return;
+        this.sender.send(eventEnvelope(event, this.dsn));
+    }
+}

package/dist/esm/dsn.d.ts

@@ -0,0 +1,25 @@
+export interface Dsn {
+    protocol: "http" | "https";
+    publicKey: string;
+    host: string;
+    port: string;
+    /** Anything between the host and the app number, without slashes at the ends. */
+    path: string;
+    /** The app number (Sentry's project id). */
+    projectId: string;
+}
+export type DsnResult = {
+    dsn: Dsn;
+    error?: undefined;
+} | {
+    dsn?: undefined;
+    error: string;
+};
+/** Parses a DSN; a bad one comes back as a reason, never as an exception. */
+export declare function parseDsn(input: unknown): DsnResult;
+/** The DSN without any secret part, as Sentry writes it in envelope headers. */
+export declare function dsnToString(dsn: Dsn): string;
+export declare function envelopeEndpoint(dsn: Dsn): string;
+/** The endpoint with the key in the query, so browsers send without a CORS preflight. */
+export declare function envelopeUrlWithQueryAuth(dsn: Dsn): string;
+export declare function authHeader(dsn: Dsn): string;

package/dist/esm/dsn.js

@@ -0,0 +1,55 @@
+import { SDK_NAME, SDK_VERSION } from "./version.js";
+const DSN_RE = /^(https?):\/\/([^:@/?#\s]+)(?::[^@/?#\s]*)?@(\[[0-9a-fA-F:.]+\]|[^:/?#@\s[\]]+)(?::(\d{1,5}))?(\/[^?#\s]*)?$/;
+/** Parses a DSN; a bad one comes back as a reason, never as an exception. */
+export function parseDsn(input) {
+    if (typeof input !== "string" || input.trim() === "") {
+        return { error: "The DSN is empty." };
+    }
+    const text = input.trim();
+    if (!/^https?:\/\//.test(text)) {
+        return { error: "The DSN must start with https:// (or http://)." };
+    }
+    const m = DSN_RE.exec(text);
+    if (!m) {
+        return {
+            error: "The DSN should look like https://<key>@ingest.statoss.com/<app number>.",
+        };
+    }
+    const segments = (m[5] ?? "").split("/").filter(Boolean);
+    const projectId = segments.pop();
+    if (!projectId) {
+        return { error: "The DSN has no app number after the host." };
+    }
+    if (!/^\d+$/.test(projectId)) {
+        return {
+            error: `The DSN's app number must be digits, not "${projectId}".`,
+        };
+    }
+    return {
+        dsn: {
+            protocol: m[1],
+            publicKey: m[2],
+            host: m[3],
+            port: m[4] ?? "",
+            path: segments.join("/"),
+            projectId,
+        },
+    };
+}
+function origin(dsn) {
+    return `${dsn.protocol}://${dsn.host}${dsn.port ? `:${dsn.port}` : ""}`;
+}
+/** The DSN without any secret part, as Sentry writes it in envelope headers. */
+export function dsnToString(dsn) {
+    return `${dsn.protocol}://${dsn.publicKey}@${dsn.host}${dsn.port ? `:${dsn.port}` : ""}/${dsn.path ? `${dsn.path}/` : ""}${dsn.projectId}`;
+}
+export function envelopeEndpoint(dsn) {
+    return `${origin(dsn)}${dsn.path ? `/${dsn.path}` : ""}/api/${dsn.projectId}/envelope/`;
+}
+/** The endpoint with the key in the query, so browsers send without a CORS preflight. */
+export function envelopeUrlWithQueryAuth(dsn) {
+    return `${envelopeEndpoint(dsn)}?sentry_version=7&sentry_key=${encodeURIComponent(dsn.publicKey)}&sentry_client=${encodeURIComponent(`${SDK_NAME}/${SDK_VERSION}`)}`;
+}
+export function authHeader(dsn) {
+    return `Sentry sentry_version=7, sentry_key=${dsn.publicKey}, sentry_client=${SDK_NAME}/${SDK_VERSION}`;
+}

package/dist/esm/envelope.d.ts

@@ -0,0 +1,36 @@
+import { type Dsn } from "./dsn.js";
+import type { Event } from "./types.js";
+export interface DiscardedEvent {
+    reason: string;
+    category: string;
+    quantity: number;
+}
+export interface EnvelopeHeader {
+    event_id?: string;
+    sent_at: string;
+    dsn: string;
+    sdk: {
+        name: string;
+        version: string;
+    };
+}
+export type EventItem = [{
+    type: "event";
+}, Event];
+export type ClientReportItem = [
+    {
+        type: "client_report";
+    },
+    {
+        timestamp: number;
+        discarded_events: DiscardedEvent[];
+    }
+];
+export type EnvelopeItem = EventItem | ClientReportItem;
+export type Envelope = [EnvelopeHeader, EnvelopeItem[]];
+export declare function eventEnvelope(event: Event, dsn: Dsn): Envelope;
+export declare function clientReportEnvelope(discarded: DiscardedEvent[], dsn: Dsn, timestamp?: number): Envelope;
+/** Sentry's rate-limit category for an envelope item. */
+export declare function itemCategory(item: EnvelopeItem): string;
+/** Byte for byte what Sentry's serializeEnvelope produces for string payloads. */
+export declare function serializeEnvelope(envelope: Envelope): string;

package/dist/esm/envelope.js

@@ -0,0 +1,49 @@
+import { dsnToString } from "./dsn.js";
+import { normalize } from "./utils.js";
+import { SDK_NAME, SDK_VERSION } from "./version.js";
+function sdkHeader() {
+    return { name: SDK_NAME, version: SDK_VERSION };
+}
+export function eventEnvelope(event, dsn) {
+    return [
+        {
+            event_id: event.event_id,
+            sent_at: new Date().toISOString(),
+            dsn: dsnToString(dsn),
+            sdk: sdkHeader(),
+        },
+        [[{ type: "event" }, event]],
+    ];
+}
+export function clientReportEnvelope(discarded, dsn, timestamp = Date.now() / 1000) {
+    return [
+        {
+            sent_at: new Date().toISOString(),
+            dsn: dsnToString(dsn),
+            sdk: sdkHeader(),
+        },
+        [[{ type: "client_report" }, { timestamp, discarded_events: discarded }]],
+    ];
+}
+/** Sentry's rate-limit category for an envelope item. */
+export function itemCategory(item) {
+    return item[0].type === "event" ? "error" : "internal";
+}
+function stringify(payload) {
+    try {
+        return JSON.stringify(payload);
+    }
+    catch {
+        // beforeSend may have put something JSON cannot hold back in.
+        return JSON.stringify(normalize(payload, 10));
+    }
+}
+/** Byte for byte what Sentry's serializeEnvelope produces for string payloads. */
+export function serializeEnvelope(envelope) {
+    const [header, items] = envelope;
+    let out = JSON.stringify(header);
+    for (const [itemHeader, payload] of items) {
+        out += `\n${JSON.stringify(itemHeader)}\n${stringify(payload)}`;
+    }
+    return out;
+}

package/dist/esm/event.d.ts

@@ -0,0 +1,9 @@
+import type { Event, Mechanism, StackFrame } from "./types.js";
+/**
+ * Builds an event from anything thrown or rejected, as Sentry's SDKs do:
+ * errors with their stacks and causes, other objects and plain values as
+ * synthetic exceptions.
+ */
+export declare function eventFromUnknown(input: unknown, mechanism: Mechanism, rejection?: boolean): Event;
+/** For a browser error event that carried no Error: the file and line it names. */
+export declare function addInitialFrame(event: Event, frame: StackFrame): Event;