@statoss/sdk 0.0.0-stage → 0.1.0

package/dist/cjs/event.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventFromUnknown = eventFromUnknown;
+exports.addInitialFrame = addInitialFrame;
+const stack_js_1 = require("./stack.js");
+const utils_js_1 = require("./utils.js");
+const MAX_CAUSES = 5;
+function exceptionFromError(error, mechanism) {
+    const name = (0, utils_js_1.safely)(() => error.name);
+    const message = (0, utils_js_1.safely)(() => error.message);
+    const exception = {
+        type: typeof name === "string" && name ? name : "Error",
+        value: typeof message === "string" ? (0, utils_js_1.truncate)(message) : "",
+        mechanism,
+    };
+    const frames = (0, stack_js_1.parseStack)((0, utils_js_1.safely)(() => error.stack));
+    if (frames.length)
+        exception.stacktrace = { frames };
+    return exception;
+}
+/** The error and its causes, as Sentry orders them: the thrown one last. */
+function exceptionChain(error, mechanism) {
+    const chain = [];
+    let current = error;
+    while ((0, utils_js_1.isErrorLike)(current) &&
+        chain.length < MAX_CAUSES &&
+        !chain.includes(current)) {
+        chain.push(current);
+        current = (0, utils_js_1.safely)(() => current.cause);
+    }
+    const values = chain.map((e, i) => exceptionFromError(e, i === 0
+        ? chain.length > 1
+            ? { ...mechanism, exception_id: 0 }
+            : mechanism
+        : {
+            type: "chained",
+            handled: mechanism.handled,
+            source: "cause",
+            exception_id: i,
+            parent_id: i - 1,
+        }));
+    return values.reverse();
+}
+function keysForMessage(value) {
+    // Only the first keys: the message holds 40 characters of them.
+    const keys = [];
+    for (const key in value) {
+        if (keys.length >= 100)
+            break;
+        if (Object.prototype.hasOwnProperty.call(value, key))
+            keys.push(key);
+    }
+    keys.sort();
+    let out = "";
+    for (const key of keys) {
+        const next = out ? `${out}, ${key}` : key;
+        if (next.length > 40)
+            return out || (0, utils_js_1.truncate)(key, 40);
+        out = next;
+    }
+    return out || "[none]";
+}
+/**
+ * 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.
+ */
+function eventFromUnknown(input, mechanism, rejection = false) {
+    let value = input;
+    const tag = (0, utils_js_1.toStringTag)(value);
+    if (tag === "[object ErrorEvent]" &&
+        (0, utils_js_1.isObject)(value) &&
+        (0, utils_js_1.isErrorLike)(value.error)) {
+        value = value.error;
+    }
+    else if (tag === "[object PromiseRejectionEvent]" &&
+        (0, utils_js_1.isObject)(value) &&
+        "reason" in value) {
+        value = value.reason;
+    }
+    if ((0, utils_js_1.isErrorLike)(value)) {
+        return { exception: { values: exceptionChain(value, mechanism) } };
+    }
+    const synthetic = { ...mechanism, synthetic: true };
+    if ((0, utils_js_1.isObject)(value)) {
+        const name = (0, utils_js_1.safely)(() => value.name);
+        const message = (0, utils_js_1.safely)(() => value.message);
+        return {
+            exception: {
+                values: [
+                    {
+                        type: typeof name === "string" && name
+                            ? name
+                            : rejection
+                                ? "UnhandledRejection"
+                                : "Error",
+                        value: typeof message === "string"
+                            ? (0, utils_js_1.truncate)(message)
+                            : `Object captured as ${rejection ? "promise rejection" : "exception"} ${(0, utils_js_1.summarize)(value) ?? `with keys: ${keysForMessage(value)}`}`,
+                        mechanism: synthetic,
+                    },
+                ],
+            },
+            extra: { __serialized__: (0, utils_js_1.normalize)(value, 3) },
+        };
+    }
+    const text = (0, utils_js_1.safeString)(value);
+    return {
+        exception: {
+            values: [
+                {
+                    type: rejection ? "UnhandledRejection" : "Error",
+                    value: (0, utils_js_1.truncate)(rejection
+                        ? `Non-Error promise rejection captured with value: ${text}`
+                        : text),
+                    mechanism: synthetic,
+                },
+            ],
+        },
+    };
+}
+/** For a browser error event that carried no Error: the file and line it names. */
+function addInitialFrame(event, frame) {
+    const first = event.exception?.values[0];
+    if (first && !first.stacktrace)
+        first.stacktrace = { frames: [frame] };
+    return event;
+}

package/dist/cjs/hub.d.ts

@@ -0,0 +1,37 @@
+import type { Client } from "./client.js";
+import { Scope } from "./scope.js";
+import type { CaptureContext, Level } from "./types.js";
+interface ScopeStorage {
+    getStore(): Scope | undefined;
+    run<T>(store: Scope, callback: () => T): T;
+}
+export interface Carrier {
+    client?: Client;
+    root: Scope;
+    /** Without AsyncLocalStorage: the scopes of withScope callbacks still running synchronously. */
+    stack: Scope[];
+    /** Undefined until first needed, null when the runtime has none. */
+    storage?: ScopeStorage | null;
+    warnedNoStorage?: boolean;
+    lastEventId?: string;
+}
+export declare function getCarrier(): Carrier;
+export declare function getClient(): Client | undefined;
+export declare function getCurrentScope(): Scope;
+/**
+ * Runs callback with a copy of the current scope, so what it sets applies only
+ * to events captured inside it.
+ *
+ * With AsyncLocalStorage (Node 20.16+ and 22.3+, Bun, Deno, Vercel Edge,
+ * Workers with nodejs_compat) the copy follows the callback's async work.
+ * Without it (browsers, Workers without nodejs_compat) the copy is current
+ * only until the callback first awaits: it is never left current for other
+ * work to pick up, which would send one request's user with another's error.
+ * After an await, capture through the scope argument (scope.captureException).
+ */
+export declare function withScope<T>(callback: (scope: Scope) => T): T;
+/** Runs a capture against the client with the given scope, or the current one. */
+export declare function captureWith(scope: Scope | undefined, run: (client: Client, scope: Scope) => string): string;
+/** captureMessage's second argument: a level or a context. */
+export declare function messageContext(levelOrContext: Level | CaptureContext | undefined): CaptureContext | undefined;
+export {};

package/dist/cjs/hub.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCarrier = getCarrier;
+exports.getClient = getClient;
+exports.getCurrentScope = getCurrentScope;
+exports.withScope = withScope;
+exports.captureWith = captureWith;
+exports.messageContext = messageContext;
+const runtime_js_1 = require("./runtime.js");
+const scope_js_1 = require("./scope.js");
+const utils_js_1 = require("./utils.js");
+// On globalThis so the ESM and CJS builds, if both get loaded, share one SDK.
+const KEY = "__statossSdk";
+let fallback;
+function getCarrier() {
+    const g = globalThis;
+    const existing = g[KEY] ?? fallback;
+    if (existing)
+        return existing;
+    const carrier = { root: new scope_js_1.Scope(), stack: [] };
+    try {
+        Object.defineProperty(g, KEY, {
+            value: carrier,
+            configurable: true,
+            enumerable: false,
+            writable: true,
+        });
+    }
+    catch {
+        fallback = carrier;
+    }
+    return carrier;
+}
+function getClient() {
+    return getCarrier().client;
+}
+function getStorage(carrier) {
+    if (carrier.storage !== undefined)
+        return carrier.storage;
+    let storage = null;
+    try {
+        // Vercel Edge and Next.js edge expose it as a global; Node, Bun and Deno through node:async_hooks.
+        const global = globalThis
+            .AsyncLocalStorage;
+        const Ctor = typeof global === "function"
+            ? global
+            : (0, runtime_js_1.getBuiltin)("node:async_hooks")
+                ?.AsyncLocalStorage;
+        if (typeof Ctor === "function")
+            storage = new Ctor();
+    }
+    catch {
+        storage = null;
+    }
+    carrier.storage = storage;
+    return storage;
+}
+function getCurrentScope() {
+    const carrier = getCarrier();
+    const fromStorage = carrier.storage ? carrier.storage.getStore() : undefined;
+    if (fromStorage)
+        return fromStorage;
+    return carrier.stack.length > 0
+        ? carrier.stack[carrier.stack.length - 1]
+        : carrier.root;
+}
+/**
+ * Runs callback with a copy of the current scope, so what it sets applies only
+ * to events captured inside it.
+ *
+ * With AsyncLocalStorage (Node 20.16+ and 22.3+, Bun, Deno, Vercel Edge,
+ * Workers with nodejs_compat) the copy follows the callback's async work.
+ * Without it (browsers, Workers without nodejs_compat) the copy is current
+ * only until the callback first awaits: it is never left current for other
+ * work to pick up, which would send one request's user with another's error.
+ * After an await, capture through the scope argument (scope.captureException).
+ */
+function withScope(callback) {
+    const carrier = getCarrier();
+    const scope = getCurrentScope().clone();
+    const storage = getStorage(carrier);
+    if (storage)
+        return storage.run(scope, () => callback(scope));
+    const logger = carrier.client?.logger;
+    if (logger?.enabled && !carrier.warnedNoStorage) {
+        carrier.warnedNoStorage = true;
+        logger.warn("withScope cannot isolate across awaits here (no AsyncLocalStorage): its scope is current only until the callback first awaits. After that, capture with the scope it passes, such as scope.captureException(error).");
+    }
+    carrier.stack.push(scope);
+    try {
+        return callback(scope);
+    }
+    finally {
+        const i = carrier.stack.lastIndexOf(scope);
+        if (i >= 0)
+            carrier.stack.splice(i, 1);
+    }
+}
+/** Runs a capture against the client with the given scope, or the current one. */
+function captureWith(scope, run) {
+    try {
+        const carrier = getCarrier();
+        if (carrier.client) {
+            const id = run(carrier.client, scope ?? getCurrentScope());
+            carrier.lastEventId = id;
+            return id;
+        }
+    }
+    catch {
+        // never throw into the app
+    }
+    return (0, utils_js_1.uuid4)();
+}
+/** captureMessage's second argument: a level or a context. */
+function messageContext(levelOrContext) {
+    return typeof levelOrContext === "string"
+        ? { level: levelOrContext }
+        : levelOrContext;
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,38 @@
+import type { Breadcrumb, CaptureContext, Event, InitOptions, Level, Primitive, User } from "./types.js";
+export { withScope } from "./hub.js";
+export type { Scope } from "./scope.js";
+export { SDK_NAME, SDK_VERSION } from "./version.js";
+export type { Breadcrumb, BreadcrumbHint, CaptureContext, Event, EventHint, Exception, InitOptions, IntegrationToggles, Level, Mechanism, Primitive, RequestInfo, ScopeData, SdkInfo, SentryLevel, StackFrame, Transport, TransportRequest, TransportResponse, User, } from "./types.js";
+/**
+ * Starts the SDK. Call it once, as early as you can. Calling it again replaces
+ * the earlier setup. Without a valid DSN, or with enabled: false, nothing is
+ * sent and nothing is patched.
+ */
+export declare function init(options?: InitOptions): void;
+/** Sends an error (or anything thrown). Returns the event id. */
+export declare function captureException(error: unknown, context?: CaptureContext): string;
+/**
+ * Sends a message. The second argument is a level (Sentry's or your own) or
+ * a context. Returns the event id.
+ */
+export declare function captureMessage(message: string, levelOrContext?: Level | CaptureContext): string;
+/** Sends an event you built in Sentry's schema. Returns the event id. */
+export declare function captureEvent(event: Event, context?: CaptureContext): string;
+/** Pass null to forget the user. */
+export declare function setUser(user: User | null): void;
+export declare function setTag(key: string, value: Primitive): void;
+export declare function setTags(tags: Record<string, Primitive>): void;
+/** Pass null to remove the context. */
+export declare function setContext(name: string, context: Record<string, unknown> | null): void;
+export declare function setExtra(key: string, value: unknown): void;
+/** Records a breadcrumb on the current scope, through beforeBreadcrumb. Ignored before init. */
+export declare function addBreadcrumb(breadcrumb: Breadcrumb): void;
+/**
+ * Waits up to timeoutMs (default 2000) for captured events to be sent.
+ * Resolves true once nothing is left to send, false on timeout or before init.
+ */
+export declare function flush(timeoutMs?: number): Promise<boolean>;
+/** Flushes, then stops the SDK and removes its integrations. */
+export declare function close(timeoutMs?: number): Promise<boolean>;
+/** The id of the last event captured, sent or not. */
+export declare function lastEventId(): string | undefined;

package/dist/cjs/index.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDK_VERSION = exports.SDK_NAME = exports.withScope = void 0;
+exports.init = init;
+exports.captureException = captureException;
+exports.captureMessage = captureMessage;
+exports.captureEvent = captureEvent;
+exports.setUser = setUser;
+exports.setTag = setTag;
+exports.setTags = setTags;
+exports.setContext = setContext;
+exports.setExtra = setExtra;
+exports.addBreadcrumb = addBreadcrumb;
+exports.flush = flush;
+exports.close = close;
+exports.lastEventId = lastEventId;
+const client_js_1 = require("./client.js");
+const hub_js_1 = require("./hub.js");
+const utils_js_1 = require("./utils.js");
+var hub_js_2 = require("./hub.js");
+Object.defineProperty(exports, "withScope", { enumerable: true, get: function () { return hub_js_2.withScope; } });
+var version_js_1 = require("./version.js");
+Object.defineProperty(exports, "SDK_NAME", { enumerable: true, get: function () { return version_js_1.SDK_NAME; } });
+Object.defineProperty(exports, "SDK_VERSION", { enumerable: true, get: function () { return version_js_1.SDK_VERSION; } });
+/**
+ * Starts the SDK. Call it once, as early as you can. Calling it again replaces
+ * the earlier setup. Without a valid DSN, or with enabled: false, nothing is
+ * sent and nothing is patched.
+ */
+function init(options = {}) {
+    try {
+        const carrier = (0, hub_js_1.getCarrier)();
+        carrier.client?.teardown();
+        carrier.client = undefined;
+        const opts = (0, utils_js_1.isObject)(options) ? options : {};
+        const client = new client_js_1.Client(opts);
+        carrier.root._apply(opts.initialScope);
+        if (opts.tags)
+            carrier.root.setTags(opts.tags);
+        carrier.client = client;
+        client.setup();
+    }
+    catch (error) {
+        if ((0, utils_js_1.isObject)(options) && options.debug) {
+            (0, utils_js_1.safely)(() => console.error("[StatOSS] init failed:", error));
+        }
+    }
+}
+/** Sends an error (or anything thrown). Returns the event id. */
+function captureException(error, context) {
+    return (0, hub_js_1.captureWith)(undefined, (client, scope) => client.captureException(error, context, scope));
+}
+/**
+ * Sends a message. The second argument is a level (Sentry's or your own) or
+ * a context. Returns the event id.
+ */
+function captureMessage(message, levelOrContext) {
+    return (0, hub_js_1.captureWith)(undefined, (client, scope) => client.captureMessage(message, (0, hub_js_1.messageContext)(levelOrContext), scope));
+}
+/** Sends an event you built in Sentry's schema. Returns the event id. */
+function captureEvent(event, context) {
+    return (0, hub_js_1.captureWith)(undefined, (client, scope) => client.captureEvent(event, context, scope));
+}
+/** Pass null to forget the user. */
+function setUser(user) {
+    (0, utils_js_1.safely)(() => (0, hub_js_1.getCurrentScope)().setUser(user));
+}
+function setTag(key, value) {
+    (0, utils_js_1.safely)(() => (0, hub_js_1.getCurrentScope)().setTag(key, value));
+}
+function setTags(tags) {
+    (0, utils_js_1.safely)(() => (0, hub_js_1.getCurrentScope)().setTags(tags));
+}
+/** Pass null to remove the context. */
+function setContext(name, context) {
+    (0, utils_js_1.safely)(() => (0, hub_js_1.getCurrentScope)().setContext(name, context));
+}
+function setExtra(key, value) {
+    (0, utils_js_1.safely)(() => (0, hub_js_1.getCurrentScope)().setExtra(key, value));
+}
+/** Records a breadcrumb on the current scope, through beforeBreadcrumb. Ignored before init. */
+function addBreadcrumb(breadcrumb) {
+    (0, utils_js_1.safely)(() => (0, hub_js_1.getCarrier)().client?.addBreadcrumb(breadcrumb));
+}
+/**
+ * Waits up to timeoutMs (default 2000) for captured events to be sent.
+ * Resolves true once nothing is left to send, false on timeout or before init.
+ */
+function flush(timeoutMs) {
+    const client = (0, utils_js_1.safely)(() => (0, hub_js_1.getCarrier)().client);
+    if (!client)
+        return Promise.resolve(false);
+    return client.flush(timeoutMs).catch(() => false);
+}
+/** Flushes, then stops the SDK and removes its integrations. */
+function close(timeoutMs) {
+    const carrier = (0, utils_js_1.safely)(() => (0, hub_js_1.getCarrier)());
+    const client = carrier?.client;
+    if (!carrier || !client)
+        return Promise.resolve(false);
+    carrier.client = undefined;
+    return client.close(timeoutMs).catch(() => false);
+}
+/** The id of the last event captured, sent or not. */
+function lastEventId() {
+    return (0, utils_js_1.safely)(() => (0, hub_js_1.getCarrier)().lastEventId);
+}

package/dist/cjs/integrations/browser.d.ts

@@ -0,0 +1,7 @@
+import type { Client } from "../client.js";
+/** Breadcrumbs for pushState, replaceState and popstate. */
+export declare function installNavigation(client: Client): (() => void) | undefined;
+/** A short CSS-like path to an element, such as `div#app > button.buy[type="submit"]`. */
+export declare function selectorFor(target: unknown): string;
+/** A breadcrumb per click, once a second at most for the same element. */
+export declare function installClicks(client: Client): (() => void) | undefined;

package/dist/cjs/integrations/browser.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installNavigation = installNavigation;
+exports.selectorFor = selectorFor;
+exports.installClicks = installClicks;
+const utils_js_1 = require("../utils.js");
+function relative(url, origin) {
+    const clean = (0, utils_js_1.scrubUrl)(url);
+    return origin && clean.startsWith(`${origin}/`)
+        ? clean.slice(origin.length)
+        : clean;
+}
+/** Breadcrumbs for pushState, replaceState and popstate. */
+function installNavigation(client) {
+    const w = globalThis;
+    const history = w.history;
+    if (!history || !w.location)
+        return undefined;
+    let last = (0, utils_js_1.safely)(() => w.location?.href) ?? "";
+    const record = () => {
+        const to = (0, utils_js_1.safely)(() => w.location?.href);
+        if (typeof to !== "string" || to === last)
+            return;
+        const origin = (0, utils_js_1.safely)(() => w.location?.origin);
+        const from = last;
+        last = to;
+        client.addBreadcrumb({
+            category: "navigation",
+            data: { from: relative(from, origin), to: relative(to, origin) },
+        }, { from, to });
+    };
+    const restore = [];
+    for (const name of ["pushState", "replaceState"]) {
+        const original = history[name];
+        if (typeof original !== "function")
+            continue;
+        const fn = original;
+        const wrapper = function (...args) {
+            const result = fn.apply(this, args);
+            (0, utils_js_1.safely)(record);
+            return result;
+        };
+        history[name] = wrapper;
+        restore.push(() => {
+            if (history[name] === wrapper)
+                history[name] = original;
+        });
+    }
+    w.addEventListener?.("popstate", record);
+    return () => {
+        for (const undo of restore)
+            undo();
+        (0, utils_js_1.safely)(() => w.removeEventListener?.("popstate", record));
+    };
+}
+const ATTRIBUTES = ["name", "type", "title", "alt", "aria-label"];
+const MAX_SELECTOR = 80;
+const MAX_DEPTH = 5;
+function describeElement(el) {
+    if (typeof el.tagName !== "string")
+        return "";
+    let out = el.tagName.toLowerCase();
+    if (typeof el.id === "string" && el.id)
+        out += `#${el.id}`;
+    if (typeof el.className === "string" && el.className.trim()) {
+        out += el.className
+            .trim()
+            .split(/\s+/)
+            .slice(0, 3)
+            .map((c) => `.${c}`)
+            .join("");
+    }
+    for (const attr of ATTRIBUTES) {
+        const value = (0, utils_js_1.safely)(() => el.getAttribute?.(attr));
+        if (typeof value === "string" && value)
+            out += `[${attr}="${value.slice(0, 30)}"]`;
+    }
+    return out;
+}
+/** A short CSS-like path to an element, such as `div#app > button.buy[type="submit"]`. */
+function selectorFor(target) {
+    const parts = [];
+    let el = target;
+    let length = 0;
+    for (let depth = 0; (0, utils_js_1.isObject)(el) && depth < MAX_DEPTH; depth++) {
+        const part = describeElement(el);
+        if (!part || part === "html")
+            break;
+        if (parts.length > 0 && length + part.length + 3 > MAX_SELECTOR)
+            break;
+        parts.unshift(part);
+        length += part.length + 3;
+        el = el.parentElement;
+    }
+    return parts.join(" > ");
+}
+/** A breadcrumb per click, once a second at most for the same element. */
+function installClicks(client) {
+    const doc = globalThis.document;
+    if (!doc || typeof doc.addEventListener !== "function")
+        return undefined;
+    let lastTarget;
+    let lastTime = 0;
+    const onClick = (event) => {
+        (0, utils_js_1.safely)(() => {
+            const target = (0, utils_js_1.isObject)(event) ? event.target : undefined;
+            if (!(0, utils_js_1.isObject)(target))
+                return;
+            const time = Date.now();
+            if (target === lastTarget && time - lastTime < 1000)
+                return;
+            lastTarget = target;
+            lastTime = time;
+            const selector = selectorFor(target);
+            if (selector)
+                client.addBreadcrumb({ category: "ui.click", message: selector }, { event });
+        });
+    };
+    const options = { capture: true, passive: true };
+    doc.addEventListener("click", onClick, options);
+    return () => {
+        (0, utils_js_1.safely)(() => doc.removeEventListener?.("click", onClick, options));
+    };
+}

package/dist/cjs/integrations/console.d.ts

@@ -0,0 +1,3 @@
+import type { Client } from "../client.js";
+/** Breadcrumbs for console calls; the original methods still run, unchanged. */
+export declare function installConsole(client: Client): (() => void) | undefined;

package/dist/cjs/integrations/console.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installConsole = installConsole;
+const logger_js_1 = require("../logger.js");
+const utils_js_1 = require("../utils.js");
+const METHODS = [
+    "debug",
+    "info",
+    "warn",
+    "error",
+    "log",
+    "assert",
+];
+const LEVELS = {
+    debug: "debug",
+    info: "info",
+    warn: "warning",
+    error: "error",
+    log: "info",
+    assert: "error",
+};
+const MAX_MESSAGE = 1024;
+// Every part is cut before it is joined, so a huge argument is never copied whole.
+function format(arg) {
+    if (typeof arg === "string")
+        return (0, utils_js_1.truncate)(arg, MAX_MESSAGE);
+    if ((0, utils_js_1.isErrorLike)(arg)) {
+        return `${(0, utils_js_1.truncate)((0, utils_js_1.safeString)(arg.name), 200)}: ${(0, utils_js_1.truncate)((0, utils_js_1.safeString)(arg.message), MAX_MESSAGE)}`;
+    }
+    if (arg !== null && typeof arg === "object") {
+        const normalized = (0, utils_js_1.normalize)(arg, 2, 200, 20);
+        if (typeof normalized === "string")
+            return normalized;
+        try {
+            return (0, utils_js_1.truncate)(JSON.stringify(normalized), MAX_MESSAGE);
+        }
+        catch {
+            return "[Object]";
+        }
+    }
+    return (0, utils_js_1.truncate)((0, utils_js_1.safeString)(arg), MAX_MESSAGE);
+}
+function join(args) {
+    let out = "";
+    for (let i = 0; i < args.length && out.length <= MAX_MESSAGE; i++) {
+        out += (i > 0 ? " " : "") + format(args[i]);
+    }
+    return out;
+}
+/** Breadcrumbs for console calls; the original methods still run, unchanged. */
+function installConsole(client) {
+    const target = globalThis.console;
+    if (!target)
+        return undefined;
+    const wrapped = {};
+    let inside = false;
+    for (const method of METHODS) {
+        const original = target[method];
+        if (typeof original !== "function")
+            continue;
+        const fn = original;
+        logger_js_1.originalConsole[method] = fn;
+        // One breadcrumb per call: console.assert, for one, calls console.warn itself.
+        const wrapper = function (...args) {
+            if (inside)
+                return fn.apply(this, args);
+            inside = true;
+            try {
+                (0, utils_js_1.safely)(() => record(client, method, args));
+                return fn.apply(this, args);
+            }
+            finally {
+                inside = false;
+            }
+        };
+        wrapped[method] = wrapper;
+        target[method] = wrapper;
+    }
+    return () => {
+        for (const method of METHODS) {
+            // Leave it if something else has wrapped the console since.
+            if (wrapped[method] && target[method] === wrapped[method]) {
+                target[method] = logger_js_1.originalConsole[method];
+            }
+            delete logger_js_1.originalConsole[method];
+        }
+    };
+}
+function record(client, method, args) {
+    let message;
+    if (method === "assert") {
+        if (args[0])
+            return;
+        const rest = join(args.slice(1));
+        message = `Assertion failed: ${rest || "console.assert"}`;
+    }
+    else {
+        message = join(args);
+    }
+    client.addBreadcrumb({
+        category: "console",
+        level: LEVELS[method],
+        message: (0, utils_js_1.truncate)(message, MAX_MESSAGE),
+        data: { logger: "console" },
+    }, { input: args, level: method });
+}

package/dist/cjs/integrations/dedupe.d.ts

@@ -0,0 +1,7 @@
+import type { Event } from "../types.js";
+/**
+ * What makes two events the same for dedupe, as Sentry's Dedupe compares
+ * them: message, exception types and values, frames and fingerprint.
+ * Undefined for events with neither message nor exception.
+ */
+export declare function eventSignature(event: Event): string | undefined;