@aj-2000-test/goodlogs-sdk 0.1.20 → 0.3.0

package/bin/goodlogs.cjs

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+/**
+ * goodlogs CLI — small helper for release-time tasks.
+ *
+ * Currently supported:
+ *   goodlogs upload-sourcemaps --release <name> --api-key <gl_sk_...> [--endpoint URL] <dir-or-file>...
+ *
+ * Walks each path, finds *.js.map files, and PUTs them to the GoodLogs API.
+ * Honours the //# debugId=<uuid> comment in the matching .js file when
+ * present so symbolication survives URL changes.
+ *
+ * Designed to be stable + dependency-free so it can run inside any CI pipeline
+ * without extra installs. Node 18+ required (uses fetch).
+ */
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+function parseArgs(argv) {
+  const out = { _: [], release: null, apiKey: null, endpoint: "https://api.goodlogs.io", verbose: false };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--release") out.release = argv[++i];
+    else if (a === "--api-key") out.apiKey = argv[++i];
+    else if (a === "--endpoint") out.endpoint = argv[++i];
+    else if (a === "-v" || a === "--verbose") out.verbose = true;
+    else if (a === "--help" || a === "-h") { printHelp(); process.exit(0); }
+    else out._.push(a);
+  }
+  return out;
+}
+
+function printHelp() {
+  process.stdout.write([
+    "goodlogs — release helpers",
+    "",
+    "Usage:",
+    "  goodlogs upload-sourcemaps --release <name> --api-key <gl_sk_...> [--endpoint URL] <path>...",
+    "",
+    "  --release    Release identifier (e.g. v1.2.3 or commit SHA)",
+    "  --api-key    Secret API key with 'ingest' scope",
+    "  --endpoint   API endpoint (default https://api.goodlogs.io)",
+    "  -v           Verbose output",
+    "  -h           Show help",
+    "",
+    "Env: GOODLOGS_API_KEY, GOODLOGS_ENDPOINT, GOODLOGS_RELEASE override CLI flags.",
+    "",
+  ].join("\n"));
+}
+
+/** Recursively yield .map files under a path. */
+function* findMaps(root) {
+  const stat = fs.statSync(root);
+  if (stat.isFile()) {
+    if (root.endsWith(".map")) yield root;
+    return;
+  }
+  for (const ent of fs.readdirSync(root, { withFileTypes: true })) {
+    if (ent.name === "node_modules" || ent.name.startsWith(".")) continue;
+    const p = path.join(root, ent.name);
+    if (ent.isDirectory()) yield* findMaps(p);
+    else if (ent.name.endsWith(".map")) yield p;
+  }
+}
+
+/** Read the //# debugId=<uuid> comment from the matching .js (or the .map's
+ *  embedded `debugId` field, written by some bundlers). Returns null when
+ *  unavailable. */
+function extractDebugId(mapPath) {
+  try {
+    const raw = fs.readFileSync(mapPath, "utf8");
+    // Bundlers like esbuild + sentry-cli inject debugId at the top of the map JSON.
+    try {
+      const j = JSON.parse(raw);
+      if (typeof j.debugId === "string") return j.debugId;
+      if (typeof j.debug_id === "string") return j.debug_id;
+    } catch { /* not JSON or malformed; fall through */ }
+  } catch { /* unreadable */ }
+
+  // Fall back to scanning the sibling .js for the //# debugId= comment.
+  const jsPath = mapPath.replace(/\.map$/, "");
+  try {
+    if (!fs.existsSync(jsPath)) return null;
+    // Read the last 4KB only — comments are at the file tail.
+    const fd = fs.openSync(jsPath, "r");
+    const size = fs.fstatSync(fd).size;
+    const len = Math.min(size, 4096);
+    const buf = Buffer.alloc(len);
+    fs.readSync(fd, buf, 0, len, size - len);
+    fs.closeSync(fd);
+    const tail = buf.toString("utf8");
+    const m = tail.match(/[#@]\s*debugId\s*=\s*([a-f0-9-]{32,40})/i);
+    return m ? m[1] : null;
+  } catch { return null; }
+}
+
+async function uploadOne(opts, mapPath) {
+  const body = fs.readFileSync(mapPath);
+  const filename = path.basename(mapPath);
+  const debugId = extractDebugId(mapPath);
+  const headers = {
+    "Authorization": `Bearer ${opts.apiKey}`,
+    "X-Goodlogs-Release": opts.release,
+    "X-Goodlogs-Filename": filename,
+    "Content-Type": "application/octet-stream",
+  };
+  if (debugId) headers["X-Goodlogs-Debug-Id"] = debugId;
+
+  const url = `${opts.endpoint.replace(/\/+$/, "")}/v1/artifacts`;
+  const res = await fetch(url, { method: "PUT", headers, body });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`${res.status} ${res.statusText}: ${text}`);
+  }
+  return res.json();
+}
+
+async function cmdUploadSourcemaps(opts) {
+  if (!opts.release) { console.error("--release is required"); process.exit(2); }
+  if (!opts.apiKey)  { console.error("--api-key is required"); process.exit(2); }
+  if (opts._.length === 0) { console.error("Need at least one path"); process.exit(2); }
+
+  const targets = [];
+  for (const root of opts._) {
+    if (!fs.existsSync(root)) {
+      console.error(`Path not found: ${root}`);
+      process.exit(2);
+    }
+    for (const m of findMaps(root)) targets.push(m);
+  }
+  if (targets.length === 0) {
+    console.error("No .map files found");
+    process.exit(2);
+  }
+
+  let ok = 0, fail = 0, total = 0;
+  for (const m of targets) {
+    total++;
+    try {
+      const res = await uploadOne(opts, m);
+      ok++;
+      if (opts.verbose) console.log(`  ✓ ${m} → ${res.id} ${res.created ? "(created)" : "(updated)"}`);
+    } catch (e) {
+      fail++;
+      console.error(`  ✗ ${m}: ${e.message}`);
+    }
+  }
+  console.log(`uploaded ${ok}/${total} sourcemaps for release ${opts.release}` + (fail ? ` (${fail} failed)` : ""));
+  process.exit(fail === 0 ? 0 : 1);
+}
+
+async function main() {
+  const argv = process.argv;
+  const cmd = argv[2];
+  if (!cmd || cmd === "-h" || cmd === "--help") { printHelp(); process.exit(0); }
+
+  const opts = parseArgs(argv);
+  opts.release ||= process.env.GOODLOGS_RELEASE || null;
+  opts.apiKey ||= process.env.GOODLOGS_API_KEY || null;
+  if (process.env.GOODLOGS_ENDPOINT) opts.endpoint = process.env.GOODLOGS_ENDPOINT;
+
+  // The first positional ends up as the subcommand; strip it.
+  if (opts._.length > 0 && opts._[0] === cmd) opts._.shift();
+
+  switch (cmd) {
+    case "upload-sourcemaps":
+      await cmdUploadSourcemaps(opts);
+      break;
+    default:
+      console.error(`Unknown command: ${cmd}`);
+      printHelp();
+      process.exit(2);
+  }
+}
+
+main().catch((e) => {
+  console.error(e.stack || e.message || String(e));
+  process.exit(1);
+});

package/dist/client-w3t1Yzjd.d.cts

@@ -0,0 +1,231 @@
+type Severity = "debug" | "info" | "warn" | "error" | "fatal";
+interface GoodLogsOptions {
+    /** API key (gl_sk_... for logs, gl_pk_... for events only) */
+    apiKey: string;
+    /** API endpoint (default: auto-resolved from API key region) */
+    endpoint?: string;
+    /** Flush interval in ms (default: 5000) */
+    flushInterval?: number;
+    /** Max batch size before auto-flush (default: 50) */
+    batchSize?: number;
+    /** Default context merged into every log/event */
+    defaultContext?: Record<string, unknown>;
+    /** Called on flush errors */
+    onError?: (error: Error) => void;
+    /** Disable SDK (useful for tests) */
+    disabled?: boolean;
+    /** Send SDK diagnostics to platform logs (default: true) */
+    telemetry?: boolean;
+    /** Auto-capture click events on elements with data-gl-event attribute (default: true in browser) */
+    autocapture?: boolean;
+    /** Use the unified /v1/envelope endpoint (NDJSON) instead of /v1/logs + /v1/events.
+     *  Default: false (legacy). Opt-in during M0.1; will become the default once the
+     *  legacy endpoints are retired. */
+    useEnvelope?: boolean;
+    /** Auto-instrument the browser `fetch` API.
+     *  Default: true when `useEnvelope` is on and autocapture is not disabled.
+     *  Each fetch call becomes a `op:http.client` span with http.url/method/status_code. */
+    autoFetch?: boolean;
+}
+interface LogEntry {
+    severity: Severity;
+    message: string;
+    properties?: Record<string, unknown>;
+    timestamp?: string;
+}
+interface EventEntry {
+    event: string;
+    distinctId?: string;
+    properties?: Record<string, unknown>;
+    timestamp?: string;
+}
+/** Stack frame in OTel/Sentry-compatible shape (server matches this). */
+interface ErrorFrame {
+    function?: string;
+    filename?: string;
+    lineno?: number;
+    colno?: number;
+    abs_path?: string;
+    module?: string;
+    in_app?: boolean;
+}
+interface ErrorBreadcrumb {
+    ts?: string;
+    category?: string;
+    message?: string;
+    level?: string;
+    data?: Record<string, unknown>;
+}
+interface ErrorEntry {
+    level?: "fatal" | "error" | "warning" | "info";
+    platform?: string;
+    exception_type?: string;
+    message: string;
+    frames?: ErrorFrame[];
+    breadcrumbs?: ErrorBreadcrumb[];
+    fingerprint?: string[];
+    tags?: Record<string, unknown>;
+    extra?: Record<string, unknown>;
+    user_id?: string;
+    release?: string;
+    environment?: string;
+    service?: string;
+    trace_id?: string;
+    span_id?: string;
+    timestamp?: string;
+}
+/** Options for `captureException`. */
+interface CaptureContext {
+    tags?: Record<string, unknown>;
+    extra?: Record<string, unknown>;
+    fingerprint?: string[];
+    level?: "fatal" | "error" | "warning" | "info";
+    user_id?: string;
+}
+/** Options to startTransaction / startSpan. */
+interface StartSpanOptions {
+    name?: string;
+    op?: string;
+    kind?: "internal" | "server" | "client" | "producer" | "consumer";
+    attributes?: Record<string, unknown>;
+    /** Parent span. When unset, this becomes a root span (a transaction). */
+    parent?: {
+        trace_id: string;
+        span_id: string;
+    };
+    /** Explicit trace id (e.g. for cross-service propagation via W3C traceparent). */
+    trace_id?: string;
+}
+/** Returned by startTransaction / startSpan; finish() emits the span. */
+interface SpanHandle {
+    span_id: string;
+    trace_id: string;
+    setAttribute(key: string, value: unknown): void;
+    setStatus(status: "ok" | "error"): void;
+    addEvent(name: string, attributes?: Record<string, unknown>): void;
+    startChild(opts?: StartSpanOptions): SpanHandle;
+    finish(): void;
+}
+
+declare class GoodLogs {
+    private apiKey;
+    private endpoint;
+    private flushInterval;
+    private batchSize;
+    private defaultContext;
+    private onError;
+    private disabled;
+    private telemetry;
+    private useEnvelope;
+    private autoFetch;
+    private originalFetch;
+    /** Backup of XMLHttpRequest.prototype.{open,send} so detach() can restore. */
+    private xhrPatched;
+    private logBuffer;
+    private eventBuffer;
+    private errorBuffer;
+    private vitalBuffer;
+    private spanBuffer;
+    /** Rolling breadcrumb trail (last N), attached to each captured error. */
+    private breadcrumbBuffer;
+    private static readonly MAX_BREADCRUMBS;
+    private timer;
+    private visibilityHandler;
+    private clickHandler;
+    private lastPath;
+    /** Active op:navigation transaction; finished on next route change or shutdown. */
+    private navTransaction;
+    private errorHandler;
+    private rejectionHandler;
+    private anonymousId;
+    private sessionId;
+    constructor(options: GoodLogsOptions);
+    log(severity: Severity, message: string, properties?: Record<string, unknown>): void;
+    debug(message: string, properties?: Record<string, unknown>): void;
+    info(message: string, properties?: Record<string, unknown>): void;
+    warn(message: string, properties?: Record<string, unknown>): void;
+    error(message: string, properties?: Record<string, unknown>): void;
+    fatal(message: string, properties?: Record<string, unknown>): void;
+    /** Set the user ID for all subsequent events. Replaces the anonymous ID. */
+    identify(userId: string): void;
+    /** Get the current anonymous/user ID. */
+    getDistinctId(): string;
+    /** Reset identity — generates a new anonymous ID (e.g., on logout). */
+    reset(): void;
+    /** Get the current session ID. */
+    getSessionId(): string;
+    /** Start a new session (e.g., on navigation reset). */
+    newSession(): void;
+    /** Set a specific session ID. */
+    setSessionId(id: string): void;
+    track(event: string, properties?: Record<string, unknown> & {
+        distinctId?: string;
+    }): void;
+    /** Record a breadcrumb (timestamped trail event). Attached to subsequent errors. */
+    addBreadcrumb(crumb: ErrorBreadcrumb): void;
+    /** Capture an exception. Stack is parsed best-effort; falls back to a single frame. */
+    captureException(err: unknown, ctx?: CaptureContext): void;
+    /** Capture a string message as an issue. */
+    captureMessage(message: string, ctx?: CaptureContext): void;
+    private buildErrorEntry;
+    /** Send a Web Vitals sample. Routed as type:vital when useEnvelope=true;
+     *  falls back to a tracked event in legacy mode. */
+    captureVital(metric: "lcp" | "inp" | "cls" | "fcp" | "ttfb" | "tbt" | "longtask", value_ms: number, extra?: {
+        route?: string;
+        rating?: "good" | "needs-improvement" | "poor";
+        attributes?: Record<string, unknown>;
+    }): void;
+    /** Start a new root span (transaction). */
+    startTransaction(opts?: StartSpanOptions): SpanHandle;
+    /** Start a child of `opts.parent`. If no parent is given a root span is
+     *  created — equivalent to startTransaction. */
+    startSpan(opts?: StartSpanOptions): SpanHandle;
+    private makeSpan;
+    flush(): Promise<void>;
+    /** Flush remaining data and stop the timer */
+    shutdown(): Promise<void>;
+    private sendLogs;
+    private sendEvents;
+    /** Send a mixed batch through the unified /v1/envelope NDJSON endpoint. */
+    private sendEnvelope;
+    private postEnvelopeWithRetry;
+    private postWithRetry;
+    private startTimer;
+    private stopTimer;
+    /**
+     * In browsers: flush via fetch+keepalive when page goes hidden or closes.
+     * keepalive lets the request complete even after the page unloads,
+     * while still supporting custom headers (unlike sendBeacon).
+     */
+    private attachPageLifecycle;
+    /** Auto-capture Core Web Vitals using PerformanceObserver */
+    private captureWebVitals;
+    /** Auto-capture page views on route changes (SPA-aware via History API) */
+    private attachPageviewCapture;
+    /** Start an op:navigation transaction for the given route. Finishes the previous one. */
+    private startNavTransaction;
+    /** Attach global window.onerror + unhandledrejection handlers. Browser only.
+     *  Each uncaught error becomes a captureException(...) tagged with the
+     *  active op:navigation transaction's trace_id/span_id. Idempotent — only
+     *  attaches when no handlers were previously installed by this instance. */
+    private attachGlobalErrorHandlers;
+    private detachGlobalErrorHandlers;
+    /** Wrap globalThis.fetch so every call becomes a span. Idempotent. */
+    private attachFetchInstrumentation;
+    private detachFetchInstrumentation;
+    /** Wrap XMLHttpRequest so every call becomes a span. Idempotent.
+     *  Patches the prototype globally — uses Symbol marker so multiple SDK
+     *  instances or hot-reloads don't double-wrap. */
+    private attachXhrInstrumentation;
+    private detachXhrInstrumentation;
+    /** Auto-capture clicks on elements with text content or data-gl-event */
+    private attachClickCapture;
+    private detachClickCapture;
+    private detachPageLifecycle;
+    /** Fire-and-forget flush using fetch with keepalive — survives page unload */
+    private keepaliveFlush;
+    /** Fire-and-forget telemetry to platform logs. Never throws, never recurses. */
+    private sendTelemetry;
+}
+
+export { type CaptureContext as C, type ErrorBreadcrumb as E, GoodLogs as G, type LogEntry as L, type Severity as S, type ErrorEntry as a, type ErrorFrame as b, type EventEntry as c, type GoodLogsOptions as d };

package/dist/client-w3t1Yzjd.d.ts

@@ -0,0 +1,231 @@
+type Severity = "debug" | "info" | "warn" | "error" | "fatal";
+interface GoodLogsOptions {
+    /** API key (gl_sk_... for logs, gl_pk_... for events only) */
+    apiKey: string;
+    /** API endpoint (default: auto-resolved from API key region) */
+    endpoint?: string;
+    /** Flush interval in ms (default: 5000) */
+    flushInterval?: number;
+    /** Max batch size before auto-flush (default: 50) */
+    batchSize?: number;
+    /** Default context merged into every log/event */
+    defaultContext?: Record<string, unknown>;
+    /** Called on flush errors */
+    onError?: (error: Error) => void;
+    /** Disable SDK (useful for tests) */
+    disabled?: boolean;
+    /** Send SDK diagnostics to platform logs (default: true) */
+    telemetry?: boolean;
+    /** Auto-capture click events on elements with data-gl-event attribute (default: true in browser) */
+    autocapture?: boolean;
+    /** Use the unified /v1/envelope endpoint (NDJSON) instead of /v1/logs + /v1/events.
+     *  Default: false (legacy). Opt-in during M0.1; will become the default once the
+     *  legacy endpoints are retired. */
+    useEnvelope?: boolean;
+    /** Auto-instrument the browser `fetch` API.
+     *  Default: true when `useEnvelope` is on and autocapture is not disabled.
+     *  Each fetch call becomes a `op:http.client` span with http.url/method/status_code. */
+    autoFetch?: boolean;
+}
+interface LogEntry {
+    severity: Severity;
+    message: string;
+    properties?: Record<string, unknown>;
+    timestamp?: string;
+}
+interface EventEntry {
+    event: string;
+    distinctId?: string;
+    properties?: Record<string, unknown>;
+    timestamp?: string;
+}
+/** Stack frame in OTel/Sentry-compatible shape (server matches this). */
+interface ErrorFrame {
+    function?: string;
+    filename?: string;
+    lineno?: number;
+    colno?: number;
+    abs_path?: string;
+    module?: string;
+    in_app?: boolean;
+}
+interface ErrorBreadcrumb {
+    ts?: string;
+    category?: string;
+    message?: string;
+    level?: string;
+    data?: Record<string, unknown>;
+}
+interface ErrorEntry {
+    level?: "fatal" | "error" | "warning" | "info";
+    platform?: string;
+    exception_type?: string;
+    message: string;
+    frames?: ErrorFrame[];
+    breadcrumbs?: ErrorBreadcrumb[];
+    fingerprint?: string[];
+    tags?: Record<string, unknown>;
+    extra?: Record<string, unknown>;
+    user_id?: string;
+    release?: string;
+    environment?: string;
+    service?: string;
+    trace_id?: string;
+    span_id?: string;
+    timestamp?: string;
+}
+/** Options for `captureException`. */
+interface CaptureContext {
+    tags?: Record<string, unknown>;
+    extra?: Record<string, unknown>;
+    fingerprint?: string[];
+    level?: "fatal" | "error" | "warning" | "info";
+    user_id?: string;
+}
+/** Options to startTransaction / startSpan. */
+interface StartSpanOptions {
+    name?: string;
+    op?: string;
+    kind?: "internal" | "server" | "client" | "producer" | "consumer";
+    attributes?: Record<string, unknown>;
+    /** Parent span. When unset, this becomes a root span (a transaction). */
+    parent?: {
+        trace_id: string;
+        span_id: string;
+    };
+    /** Explicit trace id (e.g. for cross-service propagation via W3C traceparent). */
+    trace_id?: string;
+}
+/** Returned by startTransaction / startSpan; finish() emits the span. */
+interface SpanHandle {
+    span_id: string;
+    trace_id: string;
+    setAttribute(key: string, value: unknown): void;
+    setStatus(status: "ok" | "error"): void;
+    addEvent(name: string, attributes?: Record<string, unknown>): void;
+    startChild(opts?: StartSpanOptions): SpanHandle;
+    finish(): void;
+}
+
+declare class GoodLogs {
+    private apiKey;
+    private endpoint;
+    private flushInterval;
+    private batchSize;
+    private defaultContext;
+    private onError;
+    private disabled;
+    private telemetry;
+    private useEnvelope;
+    private autoFetch;
+    private originalFetch;
+    /** Backup of XMLHttpRequest.prototype.{open,send} so detach() can restore. */
+    private xhrPatched;
+    private logBuffer;
+    private eventBuffer;
+    private errorBuffer;
+    private vitalBuffer;
+    private spanBuffer;
+    /** Rolling breadcrumb trail (last N), attached to each captured error. */
+    private breadcrumbBuffer;
+    private static readonly MAX_BREADCRUMBS;
+    private timer;
+    private visibilityHandler;
+    private clickHandler;
+    private lastPath;
+    /** Active op:navigation transaction; finished on next route change or shutdown. */
+    private navTransaction;
+    private errorHandler;
+    private rejectionHandler;
+    private anonymousId;
+    private sessionId;
+    constructor(options: GoodLogsOptions);
+    log(severity: Severity, message: string, properties?: Record<string, unknown>): void;
+    debug(message: string, properties?: Record<string, unknown>): void;
+    info(message: string, properties?: Record<string, unknown>): void;
+    warn(message: string, properties?: Record<string, unknown>): void;
+    error(message: string, properties?: Record<string, unknown>): void;
+    fatal(message: string, properties?: Record<string, unknown>): void;
+    /** Set the user ID for all subsequent events. Replaces the anonymous ID. */
+    identify(userId: string): void;
+    /** Get the current anonymous/user ID. */
+    getDistinctId(): string;
+    /** Reset identity — generates a new anonymous ID (e.g., on logout). */
+    reset(): void;
+    /** Get the current session ID. */
+    getSessionId(): string;
+    /** Start a new session (e.g., on navigation reset). */
+    newSession(): void;
+    /** Set a specific session ID. */
+    setSessionId(id: string): void;
+    track(event: string, properties?: Record<string, unknown> & {
+        distinctId?: string;
+    }): void;
+    /** Record a breadcrumb (timestamped trail event). Attached to subsequent errors. */
+    addBreadcrumb(crumb: ErrorBreadcrumb): void;
+    /** Capture an exception. Stack is parsed best-effort; falls back to a single frame. */
+    captureException(err: unknown, ctx?: CaptureContext): void;
+    /** Capture a string message as an issue. */
+    captureMessage(message: string, ctx?: CaptureContext): void;
+    private buildErrorEntry;
+    /** Send a Web Vitals sample. Routed as type:vital when useEnvelope=true;
+     *  falls back to a tracked event in legacy mode. */
+    captureVital(metric: "lcp" | "inp" | "cls" | "fcp" | "ttfb" | "tbt" | "longtask", value_ms: number, extra?: {
+        route?: string;
+        rating?: "good" | "needs-improvement" | "poor";
+        attributes?: Record<string, unknown>;
+    }): void;
+    /** Start a new root span (transaction). */
+    startTransaction(opts?: StartSpanOptions): SpanHandle;
+    /** Start a child of `opts.parent`. If no parent is given a root span is
+     *  created — equivalent to startTransaction. */
+    startSpan(opts?: StartSpanOptions): SpanHandle;
+    private makeSpan;
+    flush(): Promise<void>;
+    /** Flush remaining data and stop the timer */
+    shutdown(): Promise<void>;
+    private sendLogs;
+    private sendEvents;
+    /** Send a mixed batch through the unified /v1/envelope NDJSON endpoint. */
+    private sendEnvelope;
+    private postEnvelopeWithRetry;
+    private postWithRetry;
+    private startTimer;
+    private stopTimer;
+    /**
+     * In browsers: flush via fetch+keepalive when page goes hidden or closes.
+     * keepalive lets the request complete even after the page unloads,
+     * while still supporting custom headers (unlike sendBeacon).
+     */
+    private attachPageLifecycle;
+    /** Auto-capture Core Web Vitals using PerformanceObserver */
+    private captureWebVitals;
+    /** Auto-capture page views on route changes (SPA-aware via History API) */
+    private attachPageviewCapture;
+    /** Start an op:navigation transaction for the given route. Finishes the previous one. */
+    private startNavTransaction;
+    /** Attach global window.onerror + unhandledrejection handlers. Browser only.
+     *  Each uncaught error becomes a captureException(...) tagged with the
+     *  active op:navigation transaction's trace_id/span_id. Idempotent — only
+     *  attaches when no handlers were previously installed by this instance. */
+    private attachGlobalErrorHandlers;
+    private detachGlobalErrorHandlers;
+    /** Wrap globalThis.fetch so every call becomes a span. Idempotent. */
+    private attachFetchInstrumentation;
+    private detachFetchInstrumentation;
+    /** Wrap XMLHttpRequest so every call becomes a span. Idempotent.
+     *  Patches the prototype globally — uses Symbol marker so multiple SDK
+     *  instances or hot-reloads don't double-wrap. */
+    private attachXhrInstrumentation;
+    private detachXhrInstrumentation;
+    /** Auto-capture clicks on elements with text content or data-gl-event */
+    private attachClickCapture;
+    private detachClickCapture;
+    private detachPageLifecycle;
+    /** Fire-and-forget flush using fetch with keepalive — survives page unload */
+    private keepaliveFlush;
+    /** Fire-and-forget telemetry to platform logs. Never throws, never recurses. */
+    private sendTelemetry;
+}
+
+export { type CaptureContext as C, type ErrorBreadcrumb as E, GoodLogs as G, type LogEntry as L, type Severity as S, type ErrorEntry as a, type ErrorFrame as b, type EventEntry as c, type GoodLogsOptions as d };