@bigbertha/sdk 0.0.0-stage → 0.1.1

package/dist/cli.js

@@ -0,0 +1,89 @@
+// bertha deploy | bertha sourcemaps upload <dir>
+import { parseArgs } from "node:util";
+import { detectRelease, lastCommit, processDirectory, reason } from "./build/index.js";
+import { VERSION } from "./core/version.js";
+const HELP = `bertha ${VERSION}
+
+Usage
+  bertha deploy [--release <r>] [--env <environment>]
+      Record a deploy, with the last commit's details.
+  bertha sourcemaps upload <dir> [--release <r>] [--keep-maps]
+      Give bundles in <dir> debug ids, upload their maps and remove the maps.
+
+Options
+  --url <url>   bertha's URL. Default: BERTHA_URL, NEXT_PUBLIC_BERTHA_URL or VITE_BERTHA_URL.
+  --key <key>   The project's upload key. Default: BERTHA_UPLOAD_KEY.
+
+The release defaults to BERTHA_RELEASE, the CI's commit sha, or git HEAD.`;
+export async function main(argv, out = console.log) {
+    let args;
+    try {
+        args = parseArgs({
+            args: argv,
+            allowPositionals: true,
+            options: {
+                release: { type: "string" },
+                env: { type: "string" },
+                url: { type: "string" },
+                key: { type: "string" },
+                "keep-maps": { type: "boolean" },
+                help: { type: "boolean", short: "h" },
+                version: { type: "boolean", short: "v" },
+            },
+        });
+    }
+    catch (e) {
+        out(`${e.message}\n\n${HELP}`);
+        return 2;
+    }
+    const { values: v, positionals: [command, ...rest] } = args;
+    if (v.version)
+        return out(VERSION), 0;
+    if (v.help || !command)
+        return out(HELP), command || v.help ? 0 : 2;
+    const url = v.url ?? process.env.BERTHA_URL ?? process.env.NEXT_PUBLIC_BERTHA_URL ?? process.env.VITE_BERTHA_URL;
+    const key = v.key ?? process.env.BERTHA_UPLOAD_KEY;
+    const release = v.release ?? detectRelease();
+    if (command === "deploy") {
+        if (!url || !key)
+            return out("Set BERTHA_URL and BERTHA_UPLOAD_KEY, or pass --url and --key."), 1;
+        if (!release)
+            return out("No release found. Pass --release or set BERTHA_RELEASE."), 1;
+        const body = { release, environment: v.env ?? "production" };
+        const commit = lastCommit();
+        if (commit)
+            body.commit = commit;
+        try {
+            const res = await fetch(`${url.replace(/\/+$/, "")}/ingest/v1/deploys`, {
+                method: "POST",
+                headers: { authorization: `Bearer ${key}`, "content-type": "application/json" },
+                body: JSON.stringify(body),
+                signal: AbortSignal.timeout(30_000),
+            });
+            if (!res.ok)
+                return out(`bertha didn't record the deploy: ${await reason(res)}`), 1;
+            const recorded = (await res.json());
+            out(`Recorded ${release} in ${body.environment} (${recorded.releaseId}).`);
+            return 0;
+        }
+        catch (e) {
+            return out(`Couldn't reach bertha at ${url}: ${e.message}`), 1;
+        }
+    }
+    if (command === "sourcemaps" && rest[0] === "upload") {
+        const dir = rest[1];
+        if (!dir)
+            return out("Which directory? bertha sourcemaps upload <dir>"), 2;
+        if (!url || !key)
+            return out("Set BERTHA_URL and BERTHA_UPLOAD_KEY, or pass --url and --key."), 1;
+        try {
+            const report = await processDirectory({ dir, release, url, uploadKey: key, keepMaps: v["keep-maps"], log: out });
+            return report.failed > 0 ? 1 : 0;
+        }
+        catch (e) {
+            return out(`Couldn't process ${dir}: ${e.message}`), 1;
+        }
+    }
+    out(`Unknown command: ${[command, ...rest].join(" ")}\n\n${HELP}`);
+    return 2;
+}

package/dist/core/client.d.ts

@@ -0,0 +1,39 @@
+import type { IngestException, IngestSdk } from "../generated/ingest.ts";
+import type { CaptureContext, IngestBreadcrumb, IngestEvent, IngestUser, Options, Transport } from "./types.ts";
+export declare const MAX_BREADCRUMBS = 100;
+export declare const BATCH = 100;
+type Context = IngestEvent["context"];
+export declare class Client {
+    readonly options: Options;
+    private readonly transport;
+    private readonly sdk;
+    private readonly context;
+    private user;
+    private tags;
+    private crumbs;
+    private queue;
+    private timer;
+    private sending;
+    private seen;
+    private window;
+    private pausedUntil;
+    private warned;
+    constructor(options: Options, transport: Transport, sdk: IngestSdk, context?: Context);
+    captureException(error: unknown, ctx?: CaptureContext): string | undefined;
+    captureMessage(message: string, ctx?: CaptureContext): string | undefined;
+    setUser(user: IngestUser | null): void;
+    setTag(key: string, value: string | null): void;
+    addBreadcrumb(crumb: Omit<IngestBreadcrumb, "timestamp"> & {
+        timestamp?: string;
+    }): void;
+    /** Sends everything queued. `final` when the page or process is going away. */
+    flush(final?: boolean): Promise<void>;
+    private capture;
+    private drain;
+    private log;
+}
+export declare function toException(error: unknown, depth: number): IngestException;
+export declare function uuid(): string;
+/** Seconds from a 429 body or Retry-After header. */
+export declare function retryAfter(res: Response): Promise<number | undefined>;
+export {};

package/dist/core/client.js

@@ -0,0 +1,211 @@
+// One client per app: builds events, scrubs them, batches them and sends them,
+// backing off when bertha asks it to.
+import { builtRelease, debugIdsFor } from "./debug-ids.js";
+import { scrubText, scrubUrl } from "./scrub.js";
+import { parseStack } from "./stack.js";
+export const MAX_BREADCRUMBS = 100;
+export const BATCH = 100;
+const DEBOUNCE_MS = 1000;
+const PER_MINUTE = 100;
+const MAX_CAUSES = 5;
+const RETRIES = 3;
+export class Client {
+    options;
+    transport;
+    sdk;
+    context;
+    user;
+    tags;
+    crumbs = [];
+    queue = [];
+    timer;
+    sending;
+    seen = new WeakSet();
+    window = { start: 0, count: 0 };
+    pausedUntil = 0;
+    warned = false;
+    constructor(options, transport, sdk, context) {
+        this.options = options;
+        this.transport = transport;
+        this.sdk = sdk;
+        this.context = context;
+        this.tags = { ...options.tags };
+    }
+    captureException(error, ctx = {}) {
+        if (error && typeof error === "object") {
+            // The same error object often arrives twice (a boundary, then the global handler).
+            if (this.seen.has(error))
+                return undefined;
+            this.seen.add(error);
+        }
+        return this.capture({ exception: toException(error, 0), level: ctx.level ?? "error" }, ctx);
+    }
+    captureMessage(message, ctx = {}) {
+        return this.capture({ message, level: ctx.level ?? "warning" }, ctx);
+    }
+    setUser(user) {
+        this.user = user ?? undefined;
+    }
+    setTag(key, value) {
+        if (value === null)
+            delete this.tags[key];
+        else
+            this.tags[key] = value;
+    }
+    addBreadcrumb(crumb) {
+        this.crumbs.push({ ...crumb, timestamp: crumb.timestamp ?? new Date().toISOString() });
+        if (this.crumbs.length > MAX_BREADCRUMBS)
+            this.crumbs.shift();
+    }
+    /** Sends everything queued. `final` when the page or process is going away. */
+    async flush(final = false) {
+        clearTimeout(this.timer);
+        this.timer = undefined;
+        while (this.sending)
+            await this.sending;
+        if (!this.queue.length)
+            return;
+        this.sending = this.drain(final).finally(() => (this.sending = undefined));
+        await this.sending;
+    }
+    capture(base, ctx) {
+        const o = this.options;
+        if (o.sampleRate !== undefined && Math.random() >= o.sampleRate)
+            return undefined;
+        const now = Date.now();
+        if (now - this.window.start > 60_000)
+            this.window = { start: now, count: 0 };
+        if (++this.window.count > PER_MINUTE)
+            return undefined;
+        const id = uuid();
+        let event = {
+            ...base,
+            id,
+            timestamp: new Date(now).toISOString(),
+            release: o.release ?? builtRelease(),
+            environment: o.environment,
+            breadcrumbs: this.crumbs.slice(),
+            user: this.user,
+            context: this.context,
+            tags: { ...this.tags, ...ctx.tags },
+            fingerprint: ctx.fingerprint,
+            request: ctx.request,
+        };
+        if (o.scrub !== false)
+            scrubEvent(event);
+        if (event.exception)
+            event.debugIds = debugIdsFor(files(event.exception));
+        try {
+            event = o.beforeSend ? o.beforeSend(event) : event;
+        }
+        catch (e) {
+            this.log("beforeSend threw; sending the event as it was", e);
+        }
+        if (!event)
+            return undefined;
+        this.queue.push(event);
+        this.log("queued", event);
+        if (this.queue.length >= BATCH)
+            void this.flush();
+        else
+            this.timer ??= setTimeout(() => void this.flush(), DEBOUNCE_MS);
+        return id;
+    }
+    async drain(final) {
+        while (this.queue.length) {
+            if (Date.now() < this.pausedUntil && !final) {
+                this.timer ??= setTimeout(() => void this.flush(), this.pausedUntil - Date.now());
+                return;
+            }
+            const batch = this.queue.splice(0, BATCH);
+            const body = JSON.stringify({ sdk: this.sdk, events: batch });
+            let attempt = 0;
+            for (;;) {
+                const res = await this.transport.send(body, final).catch(() => "offline");
+                if (res === "offline") {
+                    if (final || ++attempt > RETRIES)
+                        break;
+                    await sleep(500 * 2 ** attempt);
+                    continue;
+                }
+                if (res.status === 429 || res.status === 503) {
+                    this.pausedUntil = Date.now() + (res.retryAfter ?? 60) * 1000;
+                    if (!final)
+                        this.queue.unshift(...batch);
+                    break;
+                }
+                if (res.status >= 400 && !this.warned) {
+                    this.warned = true;
+                    console.warn(`[bertha] bertha refused the events (HTTP ${res.status}). Check the key and URL.`);
+                }
+                break;
+            }
+        }
+    }
+    log(...args) {
+        if (this.options.debug)
+            console.debug("[bertha]", ...args);
+    }
+}
+export function toException(error, depth) {
+    if (!(error instanceof Error) && !isErrorLike(error)) {
+        return { type: "Error", message: describe(error), frames: [] };
+    }
+    const e = error;
+    const out = {
+        type: e.name || e.constructor?.name || "Error",
+        message: String(e.message ?? ""),
+        frames: parseStack(e.stack),
+    };
+    if (e.cause !== undefined && depth < MAX_CAUSES)
+        out.cause = toException(e.cause, depth + 1);
+    return out;
+}
+function isErrorLike(v) {
+    return !!v && typeof v === "object" && "message" in v && "stack" in v;
+}
+function describe(v) {
+    if (typeof v === "string")
+        return v;
+    try {
+        return `Non-error thrown: ${JSON.stringify(v)?.slice(0, 500) ?? String(v)}`;
+    }
+    catch {
+        return `Non-error thrown: ${String(v)}`;
+    }
+}
+function* files(e) {
+    for (; e; e = e.cause)
+        for (const f of e.frames)
+            yield f.file;
+}
+function scrubEvent(e) {
+    if (e.message)
+        e.message = scrubText(e.message);
+    for (let x = e.exception; x; x = x.cause)
+        x.message = scrubText(x.message);
+    e.breadcrumbs = e.breadcrumbs?.map((b) => ({ ...b, message: scrubText(b.message) }));
+    if (e.request)
+        e.request = { ...e.request, url: scrubUrl(e.request.url) };
+}
+export function uuid() {
+    // randomUUID is missing on plain-http pages.
+    const c = globalThis.crypto;
+    if (c?.randomUUID)
+        return c.randomUUID();
+    return "10000000-1000-4000-8000-100000000000".replace(/[018]/g, (c) => (Number(c) ^ ((Math.random() * 16) >> (Number(c) / 4))).toString(16));
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Seconds from a 429 body or Retry-After header. */
+export async function retryAfter(res) {
+    const header = Number(res.headers.get("retry-after"));
+    if (header > 0)
+        return header;
+    try {
+        const body = (await res.json());
+        return body.retryAfter;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/core/debug-ids.d.ts

@@ -0,0 +1,3 @@
+export declare function debugIdsFor(files: Iterable<string>): Record<string, string> | undefined;
+/** The release the build step stamped into the bundles, if any. */
+export declare function builtRelease(): string | undefined;

package/dist/core/debug-ids.js

@@ -0,0 +1,35 @@
+// Which bundle files have uploaded source maps. The build step appends a line to
+// each bundle that records `new Error().stack` against the bundle's debug id; here
+// those stacks are read back to learn each bundle's URL (whatever CDN or path it was
+// served from).
+import { parseStack } from "./stack.js";
+const byFile = new Map();
+let seen = 0;
+function registry() {
+    return globalThis;
+}
+export function debugIdsFor(files) {
+    const ids = registry().__berthaIds;
+    if (!ids)
+        return undefined;
+    const stacks = Object.keys(ids);
+    if (stacks.length !== seen) {
+        for (const stack of stacks) {
+            const file = parseStack(stack)[0]?.file;
+            if (file)
+                byFile.set(file, ids[stack]);
+        }
+        seen = stacks.length;
+    }
+    let out;
+    for (const f of files) {
+        const id = byFile.get(f);
+        if (id)
+            (out ??= {})[f] = id;
+    }
+    return out;
+}
+/** The release the build step stamped into the bundles, if any. */
+export function builtRelease() {
+    return registry().__berthaRelease;
+}

package/dist/core/env.d.ts

@@ -0,0 +1,2 @@
+export declare function env(name: string): string | undefined;
+export declare function firstEnv(...names: string[]): string | undefined;

package/dist/core/env.js

@@ -0,0 +1,18 @@
+// Environment variables, wherever the runtime keeps them.
+export function env(name) {
+    try {
+        const v = globalThis.process?.env?.[name];
+        return v === "" ? undefined : v;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function firstEnv(...names) {
+    for (const n of names) {
+        const v = env(n);
+        if (v)
+            return v;
+    }
+    return undefined;
+}

package/dist/core/hub.d.ts

@@ -0,0 +1,12 @@
+import type { Client } from "./client.ts";
+import type { CaptureContext, IngestBreadcrumb, IngestUser } from "./types.ts";
+export declare function setClient(c: Client | undefined): void;
+export declare function getClient(): Client | undefined;
+export declare function captureException(error: unknown, ctx?: CaptureContext): string | undefined;
+export declare function captureMessage(message: string, ctx?: CaptureContext): string | undefined;
+export declare function setUser(user: IngestUser | null): void;
+export declare function setTag(key: string, value: string | null): void;
+export declare function addBreadcrumb(crumb: Omit<IngestBreadcrumb, "timestamp"> & {
+    timestamp?: string;
+}): void;
+export declare function flush(): Promise<void>;

package/dist/core/hub.js

@@ -0,0 +1,27 @@
+// The module-level client behind `captureException` and friends, so apps don't
+// have to pass a client around.
+let current;
+export function setClient(c) {
+    current = c;
+}
+export function getClient() {
+    return current;
+}
+export function captureException(error, ctx) {
+    return current?.captureException(error, ctx);
+}
+export function captureMessage(message, ctx) {
+    return current?.captureMessage(message, ctx);
+}
+export function setUser(user) {
+    current?.setUser(user);
+}
+export function setTag(key, value) {
+    current?.setTag(key, value);
+}
+export function addBreadcrumb(crumb) {
+    current?.addBreadcrumb(crumb);
+}
+export function flush() {
+    return current?.flush() ?? Promise.resolve();
+}

package/dist/core/scrub.d.ts

@@ -0,0 +1,2 @@
+export declare function scrubText(s: string): string;
+export declare function scrubUrl(url: string): string;

package/dist/core/scrub.js

@@ -0,0 +1,11 @@
+// On by default: no email addresses, bearer tokens or secret-looking query values
+// leave the app. Turn off with `scrub: false`.
+const EMAIL = /[\w.+-]+@[\w-]+\.[\w.-]+/g;
+const BEARER = /\b(Bearer|Basic)\s+[\w.~+/=-]+/gi;
+const SECRET_PARAM = /([?&](?:[^=&#]*(?:token|key|secret|password|passwd|auth|session|code|sig)[^=&#]*)=)[^&#\s]*/gi;
+export function scrubText(s) {
+    return s.replace(EMAIL, "[email]").replace(BEARER, "$1 [redacted]").replace(SECRET_PARAM, "$1[redacted]");
+}
+export function scrubUrl(url) {
+    return url.replace(SECRET_PARAM, "$1[redacted]");
+}

package/dist/core/stack.d.ts

@@ -0,0 +1,5 @@
+import type { IngestFrame } from "../generated/ingest.ts";
+export declare const MAX_FRAMES = 100;
+export declare function parseStack(stack: string | undefined): IngestFrame[];
+/** Library code: the server decides the rest from the path. */
+export declare function isLibrary(file: string): boolean;

package/dist/core/stack.js

@@ -0,0 +1,45 @@
+// Stack strings into frames, innermost first. V8 (Chrome, Node, Edge, Deno) and
+// SpiderMonkey/JavaScriptCore (Firefox, Safari) formats.
+const V8 = /^\s*at (?:(.+?) \()?(.+?):(\d+):(\d+)\)?\s*$/;
+const GECKO = /^\s*(.*?)@(.+?):(\d+):(\d+)\s*$/;
+export const MAX_FRAMES = 100;
+export function parseStack(stack) {
+    if (!stack)
+        return [];
+    const frames = [];
+    for (const line of stack.split("\n")) {
+        const m = V8.exec(line) ?? GECKO.exec(line);
+        if (!m)
+            continue;
+        const [, fn, rawFile, ln, col] = m;
+        let file = rawFile;
+        // `at eval (eval at f (file.js:1:2), <anonymous>:1:1)`: keep the outer file.
+        const evalAt = /\(eval at .*?\((.+?):\d+:\d+\)/.exec(line);
+        if (evalAt)
+            file = evalAt[1];
+        if (file === "<anonymous>" || file === "native")
+            continue;
+        const name = cleanFunction(fn);
+        const frame = { file, line: Number(ln), column: Number(col) };
+        if (name)
+            frame.function = name;
+        if (isLibrary(file))
+            frame.inApp = false;
+        frames.push(frame);
+        if (frames.length >= MAX_FRAMES)
+            break;
+    }
+    return frames;
+}
+function cleanFunction(fn) {
+    if (!fn)
+        return undefined;
+    const name = fn.replace(/^async /, "").replace(/^new /, "").replace(/ \[as .+\]$/, "").trim();
+    if (!name || name === "<anonymous>" || name === "Object.<anonymous>")
+        return undefined;
+    return name;
+}
+/** Library code: the server decides the rest from the path. */
+export function isLibrary(file) {
+    return file.includes("/node_modules/") || file.startsWith("node:") || file.startsWith("internal/");
+}

package/dist/core/transport.d.ts

@@ -0,0 +1,15 @@
+import type { Transport } from "./types.ts";
+export interface FetchTransportOptions {
+    url: string;
+    key: string;
+    /** Key in the query string instead of a header (browsers). */
+    keyInQuery?: boolean;
+    gzip?: (body: string) => Promise<BodyInit | undefined>;
+    /** Hand-off for unloads (navigator.sendBeacon). Returns false if it couldn't. */
+    beacon?: (url: string, body: string) => boolean;
+    fetch?: typeof fetch;
+}
+export declare function endpoint(base: string, path: string): string;
+export declare function fetchTransport(o: FetchTransportOptions): Transport;
+/** Gzip with CompressionStream (browsers, edge runtimes, Node 18+). */
+export declare function streamGzip(body: string): Promise<BodyInit | undefined>;

package/dist/core/transport.js

@@ -0,0 +1,48 @@
+// Sending over fetch. Browsers authenticate with `?key=` and send `text/plain` so no
+// CORS preflight is needed; servers use the Authorization header. Gzip is detected by
+// the server from the bytes, so no Content-Encoding header is sent either.
+import { retryAfter } from "./client.js";
+/** Keepalive requests are capped at 64KB by browsers. */
+const KEEPALIVE_BYTES = 60_000;
+const GZIP_FROM = 1024;
+export function endpoint(base, path) {
+    return `${base.replace(/\/+$/, "")}/ingest/v1/${path}`;
+}
+export function fetchTransport(o) {
+    const f = o.fetch ?? globalThis.fetch.bind(globalThis);
+    const url = endpoint(o.url, "events") + (o.keyInQuery ? `?key=${encodeURIComponent(o.key)}` : "");
+    const headers = { "content-type": "text/plain" };
+    if (!o.keyInQuery)
+        headers.authorization = `Bearer ${o.key}`;
+    return {
+        async send(body, final) {
+            if (final && o.beacon?.(url, body))
+                return { status: 202 };
+            let payload = body;
+            if (o.gzip && body.length >= GZIP_FROM)
+                payload = (await o.gzip(body).catch(() => undefined)) ?? body;
+            try {
+                const res = await f(url, {
+                    method: "POST",
+                    headers,
+                    body: payload,
+                    keepalive: body.length < KEEPALIVE_BYTES,
+                    credentials: "omit",
+                });
+                return { status: res.status, retryAfter: res.status === 429 ? await retryAfter(res) : undefined };
+            }
+            catch {
+                return "offline";
+            }
+        },
+    };
+}
+/** Gzip with CompressionStream (browsers, edge runtimes, Node 18+). */
+export async function streamGzip(body) {
+    // Read off globalThis so bundlers' runtime checks don't flag it.
+    const CS = globalThis.CompressionStream;
+    if (!CS)
+        return undefined;
+    const stream = new Blob([body]).stream().pipeThrough(new CS("gzip"));
+    return new Uint8Array(await new Response(stream).arrayBuffer());
+}

package/dist/core/types.d.ts

@@ -0,0 +1,37 @@
+import type { IngestBreadcrumb, IngestEvent, IngestLevel, IngestUser } from "../generated/ingest.ts";
+export type { IngestBreadcrumb, IngestEvent, IngestLevel, IngestUser };
+export interface Options {
+    /** The project's ingest key. Public: safe to ship to browsers. */
+    key: string;
+    /** Where bertha runs, e.g. "https://bertha.example.com". */
+    url: string;
+    /** Defaults to the release stamped in at build time. */
+    release?: string;
+    /** "production", "staging" or "development"; free text is mapped. */
+    environment?: string;
+    /** Share of events to send, 0 to 1. Defaults to 1. */
+    sampleRate?: number;
+    /** Change or drop (return null) an event before it is sent. */
+    beforeSend?: (event: IngestEvent) => IngestEvent | null;
+    /** Redacts emails, bearer tokens and secret-looking query values. On by default. */
+    scrub?: boolean;
+    /** Tags on every event. */
+    tags?: Record<string, string>;
+    /** Log what the SDK does to the console. */
+    debug?: boolean;
+}
+export interface CaptureContext {
+    level?: IngestLevel;
+    tags?: Record<string, string>;
+    fingerprint?: string[];
+    request?: IngestEvent["request"];
+}
+/** What a send came back with; "offline" means it never reached bertha. */
+export type SendResult = {
+    status: number;
+    retryAfter?: number;
+} | "offline";
+export interface Transport {
+    /** `final`: the page or process is going away, so don't wait on anything. */
+    send(body: string, final: boolean): Promise<SendResult>;
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "0.1.1";

package/dist/core/version.js

@@ -0,0 +1 @@
+export const VERSION = "0.1.1";

package/dist/edge/index.d.ts

@@ -0,0 +1,5 @@
+import { Client } from "../core/client.ts";
+import type { Options } from "../core/types.ts";
+export { addBreadcrumb, captureException, captureMessage, flush, getClient, setTag, setUser } from "../core/hub.ts";
+export type { CaptureContext, IngestEvent, Options } from "../core/types.ts";
+export declare function init(options?: Partial<Options>): Client | undefined;

package/dist/edge/index.js

@@ -0,0 +1,25 @@
+// @bigbertha/sdk/edge: for edge runtimes (Next middleware and edge routes, Workers).
+// No process to hook into, so errors are reported where they are caught.
+import { Client } from "../core/client.js";
+import { firstEnv } from "../core/env.js";
+import { setClient } from "../core/hub.js";
+import { fetchTransport, streamGzip } from "../core/transport.js";
+import { VERSION } from "../core/version.js";
+export { addBreadcrumb, captureException, captureMessage, flush, getClient, setTag, setUser } from "../core/hub.js";
+export function init(options = {}) {
+    const key = options.key ?? firstEnv("BERTHA_KEY", "NEXT_PUBLIC_BERTHA_KEY");
+    const url = options.url ?? firstEnv("BERTHA_URL", "NEXT_PUBLIC_BERTHA_URL");
+    if (!key || !url) {
+        console.warn("[bertha] Set BERTHA_KEY and BERTHA_URL (or pass key and url). Nothing will be sent.");
+        return undefined;
+    }
+    const client = new Client({
+        ...options,
+        key,
+        url,
+        release: options.release ?? firstEnv("BERTHA_RELEASE"),
+        environment: options.environment ?? firstEnv("BERTHA_ENVIRONMENT", "NODE_ENV"),
+    }, fetchTransport({ url, key, gzip: streamGzip }), { name: "bertha.edge", version: VERSION }, { runtime: "Edge" });
+    setClient(client);
+    return client;
+}