@newtalaria/browser 0.1.18 → 0.1.19

package/dist/index.js

@@ -270,6 +270,259 @@ async function collectBrowserContext() {
   return base;
 }
 
+// src/utils/tags.ts
+var MAX_TAGS_PER_EVENT = 20;
+var MAX_TAG_KEY_LENGTH = 64;
+var MAX_TAG_VALUE_LENGTH = 128;
+var MAX_TAG_TOTAL_UTF8_BYTES = 2048;
+var KEY_PATTERN = /^[a-z0-9_.-]+$/;
+var HIGH_CARDINALITY_TAG_KEYS = /* @__PURE__ */ new Set([
+  "user_id",
+  "userid",
+  "request_id",
+  "requestid",
+  "business_id",
+  "order_id",
+  "email",
+  "url",
+  "uuid",
+  "session_id",
+  "trace_id",
+  "span_id"
+]);
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var EMAIL_RE = /^[^@\s]+@[^@\s]+\.[^@\s]+$/;
+var LONG_NUMERIC_RE = /^\d{8,}$/;
+function utf8Bytes(s) {
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(s).length;
+  }
+  return unescape(encodeURIComponent(s)).length;
+}
+function normalizeKey(raw) {
+  const key = raw.trim().toLowerCase();
+  if (!key || key.length > MAX_TAG_KEY_LENGTH) return null;
+  if (!KEY_PATTERN.test(key)) return null;
+  return key;
+}
+function normalizeValue(raw) {
+  if (raw == null) return null;
+  const value = String(raw).trim();
+  if (!value) return null;
+  return value.length <= MAX_TAG_VALUE_LENGTH ? value : value.slice(0, MAX_TAG_VALUE_LENGTH);
+}
+function normalizeTags(tags) {
+  if (!tags) return {};
+  const result2 = {};
+  let totalBytes = 0;
+  for (const [rawKey, rawValue] of Object.entries(tags)) {
+    if (Object.keys(result2).length >= MAX_TAGS_PER_EVENT) break;
+    const key = normalizeKey(rawKey);
+    if (!key) continue;
+    const value = normalizeValue(rawValue);
+    if (value == null) continue;
+    if (result2[key] != null) {
+      totalBytes -= utf8Bytes(key) + utf8Bytes(result2[key]);
+    }
+    const entryBytes = utf8Bytes(key) + utf8Bytes(value);
+    if (totalBytes + entryBytes > MAX_TAG_TOTAL_UTF8_BYTES) continue;
+    result2[key] = value;
+    totalBytes += entryBytes;
+  }
+  return result2;
+}
+function mergeTags(...parts) {
+  const merged = {};
+  for (const part of parts) {
+    if (!part) continue;
+    Object.assign(merged, part);
+  }
+  return normalizeTags(merged);
+}
+function looksHighCardinalityValue(value) {
+  return UUID_RE.test(value) || EMAIL_RE.test(value) || LONG_NUMERIC_RE.test(value);
+}
+function warnSuspiciousTags(tags, environment) {
+  if (!environment || environment === "production") return;
+  if (typeof console === "undefined" || typeof console.warn !== "function") {
+    return;
+  }
+  for (const [key, value] of Object.entries(tags)) {
+    if (HIGH_CARDINALITY_TAG_KEYS.has(key)) {
+      console.warn(
+        `@newtalaria/browser: Tag "${key}" appears to have high cardinality. Consider moving it to context/extra.`
+      );
+      continue;
+    }
+    if (looksHighCardinalityValue(value)) {
+      console.warn(
+        `@newtalaria/browser: Tag "${key}" value looks high-cardinality. Consider moving it to context/extra.`
+      );
+    }
+  }
+}
+var RESERVED_TAG_KEYS = [
+  "service",
+  "platform",
+  "feature",
+  "operation",
+  "component",
+  "runtime",
+  "runtime_version"
+];
+
+// src/utils/stacktrace.ts
+var V8_FRAME = /^\s*at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?\s*$/;
+var V8_FRAME_BARE = /^\s*at\s+(.+)\s*$/;
+var EXTENSION_URL2 = /(?:chrome|moz|safari|safari-web|ms-browser)-extension:\/\//i;
+function parseStackTrace(stack, inAppOptions) {
+  if (!stack || !stack.trim()) return void 0;
+  const parsed = [];
+  for (const line of stack.split("\n")) {
+    const frame = parseStackLine(line, inAppOptions);
+    if (frame) parsed.push(frame);
+  }
+  if (parsed.length === 0) return void 0;
+  parsed.reverse();
+  return { frames: parsed };
+}
+function parseStackLine(line, inAppOptions) {
+  if (!/^\s*at\s+/.test(line)) return null;
+  const v8 = V8_FRAME.exec(line);
+  if (v8) {
+    const functionName = cleanFunction(v8[1]);
+    const absPath = stripQuery(v8[2] ?? "");
+    const lineno = Number.parseInt(v8[3] ?? "", 10);
+    const colno = Number.parseInt(v8[4] ?? "", 10);
+    return {
+      functionName,
+      absPath: absPath || void 0,
+      filename: basename(absPath),
+      lineno: Number.isFinite(lineno) ? lineno : void 0,
+      colno: Number.isFinite(colno) ? colno : void 0,
+      inApp: isInAppFrame(absPath, inAppOptions),
+      platform: "javascript"
+    };
+  }
+  const bare = V8_FRAME_BARE.exec(line);
+  if (bare) {
+    const functionName = cleanFunction(bare[1]);
+    if (!functionName) return null;
+    return {
+      functionName,
+      inApp: false,
+      platform: "javascript"
+    };
+  }
+  return null;
+}
+function applySourceLocation(stacktrace, source, inAppOptions) {
+  if (!source) return stacktrace;
+  const filename = source.filename?.trim() || void 0;
+  const lineno = typeof source.lineno === "number" && source.lineno > 0 ? source.lineno : void 0;
+  const colno = typeof source.colno === "number" && source.colno >= 0 ? source.colno : void 0;
+  if (!filename && lineno == null && colno == null) return stacktrace;
+  if (!stacktrace || stacktrace.frames.length === 0) {
+    if (!filename && lineno == null) return stacktrace;
+    const absPath = filename;
+    return {
+      frames: [
+        {
+          filename: absPath ? basename(absPath) : void 0,
+          absPath,
+          lineno,
+          colno,
+          inApp: absPath ? isInAppFrame(absPath, inAppOptions) : true,
+          platform: "javascript"
+        }
+      ]
+    };
+  }
+  const frames = stacktrace.frames.slice();
+  const top = { ...frames[frames.length - 1] };
+  if (filename) {
+    top.absPath = filename;
+    top.filename = basename(filename);
+    top.inApp = isInAppFrame(filename, inAppOptions);
+  }
+  if (lineno != null) top.lineno = lineno;
+  if (colno != null) top.colno = colno;
+  frames[frames.length - 1] = top;
+  return { ...stacktrace, frames };
+}
+function isInAppFrame(path, options) {
+  const lower = path.toLowerCase();
+  if (!lower) return true;
+  if (lower.includes("node_modules")) return false;
+  if (EXTENSION_URL2.test(path) || lower.includes("webkit-masked-url://")) {
+    return false;
+  }
+  if (lower.includes("@newtalaria/browser")) return false;
+  if (matchesUrlList(path, options?.denyUrls)) return false;
+  if (matchesUrlList(path, options?.allowUrls)) return true;
+  const frameOrigin = tryParseOrigin(path);
+  if (frameOrigin != null) {
+    const pageOrigin = normalizeOrigin(options?.pageOrigin);
+    if (pageOrigin && frameOrigin === pageOrigin) return true;
+    const extra = options?.inAppOrigins ?? [];
+    for (const origin of extra) {
+      if (normalizeOrigin(origin) === frameOrigin) return true;
+    }
+    return false;
+  }
+  return true;
+}
+function matchesUrlList(path, patterns) {
+  if (!patterns || patterns.length === 0) return false;
+  for (const pattern of patterns) {
+    if (typeof pattern === "string") {
+      if (pattern && path.includes(pattern)) return true;
+    } else if (pattern.test(path)) {
+      return true;
+    }
+  }
+  return false;
+}
+function tryParseOrigin(path) {
+  if (!/^https?:\/\//i.test(path)) return null;
+  try {
+    return new URL(path).origin;
+  } catch {
+    return null;
+  }
+}
+function normalizeOrigin(origin) {
+  if (!origin || !origin.trim()) return null;
+  const trimmed = origin.trim();
+  try {
+    if (/^https?:\/\//i.test(trimmed)) {
+      return new URL(trimmed).origin;
+    }
+    return trimmed;
+  } catch {
+    return trimmed;
+  }
+}
+function resolvePageOrigin(originOrUrl) {
+  return normalizeOrigin(originOrUrl) ?? void 0;
+}
+function cleanFunction(raw) {
+  if (raw == null) return void 0;
+  const value = raw.trim();
+  return value.length === 0 ? void 0 : value;
+}
+function stripQuery(path) {
+  const q = path.indexOf("?");
+  return q >= 0 ? path.slice(0, q) : path;
+}
+function basename(path) {
+  if (!path) return void 0;
+  const normalized = stripQuery(path);
+  const parts = normalized.split(/[/\\]/);
+  const last = parts[parts.length - 1];
+  return last || normalized;
+}
+
 // src/sdk_meta.ts
 var SDK_NAME = "@newtalaria/browser";
 var SDK_VERSION = "0.1.18";
@@ -330,6 +583,9 @@ async function ingestEvent(transport, params) {
   if (params.eventType) input2.eventType = params.eventType;
   if (params.title) input2.title = params.title;
   if (params.stackTrace) input2.stackTrace = params.stackTrace;
+  if (params.exception) input2.exception = serializeException(params.exception);
+  if (params.debugMeta) input2.debugMeta = serializeDebugMeta(params.debugMeta);
+  if (params.platform) input2.platform = params.platform;
   if (params.release) input2.release = params.release;
   if (params.userId) input2.userId = params.userId;
   if (params.sessionId) input2.sessionId = params.sessionId;
@@ -346,6 +602,89 @@ async function ingestEvent(transport, params) {
     { keepalive: params.keepalive }
   );
 }
+function serializeException(data) {
+  return {
+    __className__: "ExceptionDataDto",
+    values: data.values.map(serializeExceptionValue)
+  };
+}
+function serializeExceptionValue(value) {
+  const out = {
+    __className__: "ExceptionValueDto"
+  };
+  if (value.type != null) out.type = value.type;
+  if (value.value != null) out.value = value.value;
+  if (value.module != null) out.module = value.module;
+  if (value.threadId != null) out.threadId = value.threadId;
+  if (value.code != null) out.code = value.code;
+  if (value.mechanism) out.mechanism = serializeMechanism(value.mechanism);
+  if (value.stacktrace) out.stacktrace = serializeStackTrace(value.stacktrace);
+  return out;
+}
+function serializeMechanism(mechanism) {
+  const out = {
+    __className__: "ExceptionMechanismDto",
+    type: mechanism.type
+  };
+  if (mechanism.handled != null) out.handled = mechanism.handled;
+  if (mechanism.synthetic != null) out.synthetic = mechanism.synthetic;
+  return out;
+}
+function serializeStackTrace(stack) {
+  const out = {
+    __className__: "StackTraceDto",
+    frames: stack.frames.map(serializeStackFrame)
+  };
+  if (stack.registers) out.registers = stack.registers;
+  return out;
+}
+function serializeStackFrame(frame) {
+  const out = {
+    __className__: "StackFrameDto"
+  };
+  if (frame.filename != null) out.filename = frame.filename;
+  if (frame.absPath != null) out.absPath = frame.absPath;
+  if (frame.functionName != null) out.functionName = frame.functionName;
+  if (frame.rawFunction != null) out.rawFunction = frame.rawFunction;
+  if (frame.module != null) out.module = frame.module;
+  if (frame.package != null) out.package = frame.package;
+  if (frame.platform != null) out.platform = frame.platform;
+  if (frame.lineno != null) out.lineno = frame.lineno;
+  if (frame.colno != null) out.colno = frame.colno;
+  if (frame.inApp != null) out.inApp = frame.inApp;
+  if (frame.instructionAddr != null) out.instructionAddr = frame.instructionAddr;
+  if (frame.symbolAddr != null) out.symbolAddr = frame.symbolAddr;
+  if (frame.imageAddr != null) out.imageAddr = frame.imageAddr;
+  if (frame.addrMode != null) out.addrMode = frame.addrMode;
+  if (frame.contextLine != null) out.contextLine = frame.contextLine;
+  if (frame.preContext != null) out.preContext = frame.preContext;
+  if (frame.postContext != null) out.postContext = frame.postContext;
+  if (frame.vars != null) out.vars = frame.vars;
+  if (frame.stackStart != null) out.stackStart = frame.stackStart;
+  return out;
+}
+function serializeDebugMeta(meta) {
+  const out = {
+    __className__: "DebugMetaDto"
+  };
+  if (meta.images) {
+    out.images = meta.images.map((image) => {
+      const img = {
+        __className__: "DebugImageDto"
+      };
+      if (image.type != null) img.type = image.type;
+      if (image.imageAddr != null) img.imageAddr = image.imageAddr;
+      if (image.imageSize != null) img.imageSize = image.imageSize;
+      if (image.debugId != null) img.debugId = image.debugId;
+      if (image.debugFile != null) img.debugFile = image.debugFile;
+      if (image.codeId != null) img.codeId = image.codeId;
+      if (image.codeFile != null) img.codeFile = image.codeFile;
+      if (image.arch != null) img.arch = image.arch;
+      return img;
+    });
+  }
+  return out;
+}
 
 // src/utils/gzip.ts
 async function gzipBytes(data) {
@@ -13767,7 +14106,7 @@ function normalizeNetworkOrigin(raw) {
     }
   }
 }
-function resolvePageOrigin(pageOrigin) {
+function resolvePageOrigin2(pageOrigin) {
   if (pageOrigin) {
     try {
       return new URL(pageOrigin).origin;
@@ -13792,12 +14131,12 @@ function isAllowedNetworkOrigin(requestOrigin, opts) {
   if (!requestOrigin) return false;
   const allow = opts.networkErrorOrigins.map(normalizeNetworkOrigin);
   if (allow.includes("*")) return true;
-  const page = resolvePageOrigin(opts.pageOrigin);
+  const page = resolvePageOrigin2(opts.pageOrigin);
   if (page && requestOrigin === page) return true;
   return allow.includes(requestOrigin);
 }
 function classifyNetworkParty(requestOrigin, pageOrigin) {
-  const page = resolvePageOrigin(pageOrigin);
+  const page = resolvePageOrigin2(pageOrigin);
   if (page && requestOrigin && requestOrigin === page) return "first_party";
   return "third_party";
 }
@@ -14014,6 +14353,16 @@ function installNetworkHook(options = {}) {
 }
 
 // src/client.ts
+var PLATFORM_JAVASCRIPT = "javascript";
+var EXTRA_LOCATION_KEYS = /* @__PURE__ */ new Set([
+  "exception_class",
+  "file",
+  "line",
+  "code",
+  "filename",
+  "lineno",
+  "colno"
+]);
 function networkExceptionClass(failure) {
   if (failure.failureKind === "http") return "HttpError";
   if (failure.failureKind === "timeout") return "TimeoutError";
@@ -14056,14 +14405,59 @@ function networkFailureExtra(failure) {
       aborted: failure.aborted ?? false,
       ok: failure.ok ?? false
     },
-    // Top-level for server fingerprint compatibility.
+    // Top-level for server fingerprint compatibility (status only —
+    // exception type lives on first-class `exception.values[0].type`).
     status_code: statusCode,
-    exception_class: networkExceptionClass(failure),
     durationMs: failure.durationMs,
     aborted: failure.aborted ?? false,
     ok: failure.ok ?? false
   };
 }
+function networkExceptionData(failure, message) {
+  return {
+    values: [
+      {
+        type: networkExceptionClass(failure),
+        value: message,
+        mechanism: {
+          type: "http",
+          handled: true,
+          synthetic: true
+        }
+      }
+    ]
+  };
+}
+function scrubLegacyExceptionExtra(extra) {
+  if (!extra) return void 0;
+  const out = {};
+  for (const [key, value] of Object.entries(extra)) {
+    if (EXTRA_LOCATION_KEYS.has(key)) continue;
+    out[key] = value;
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function buildExceptionFromError(err, context, inAppOptions) {
+  const mechanism = context?.mechanism ?? {
+    type: "generic",
+    handled: true
+  };
+  const stacktrace = applySourceLocation(
+    parseStackTrace(err.stack, inAppOptions),
+    context?.source,
+    inAppOptions
+  );
+  return {
+    values: [
+      {
+        type: err.name || "Error",
+        value: err.message || err.name || "Error",
+        mechanism,
+        ...stacktrace ? { stacktrace } : {}
+      }
+    ]
+  };
+}
 function mergeNetworkFailureContext(context, failure) {
   return {
     ...context,
@@ -14100,14 +14494,17 @@ function resolveOptions(options) {
     inlineStylesheet: options.inlineStylesheet ?? false,
     blockSelector: options.blockSelector ?? "",
     userId: options.userId,
-    tags: options.tags,
+    tags: mergeTags(options.tags),
     disableDefaultIntegrations: options.disableDefaultIntegrations ?? false,
     captureFailedRequests: options.captureFailedRequests ?? true,
     captureNetworkErrors: options.captureNetworkErrors ?? true,
     networkErrorOrigins: options.networkErrorOrigins ?? [],
     includeNetworkUrlQuery: options.captureRequestQueryParameters ?? options.includeNetworkUrlQuery ?? false,
     failedRequestStatusCodes: options.failedRequestStatusCodes ?? [[500, 599]],
-    failedRequestIgnoreUrls: options.failedRequestIgnoreUrls ?? []
+    failedRequestIgnoreUrls: options.failedRequestIgnoreUrls ?? [],
+    inAppAllowUrls: options.inAppAllowUrls ?? [],
+    inAppDenyUrls: options.inAppDenyUrls ?? [],
+    inAppOrigins: options.inAppOrigins ?? []
   };
 }
 var RECENT_NETWORK_FAILURE_MS = 5e3;
@@ -14254,17 +14651,21 @@ var TalariaClient = class {
             failureKind: "http",
             aborted: false
           };
-          void this.captureMessage(
-            `HTTP ${status}: ${method} ${url}`,
-            status >= 500 ? "error" : "warning",
-            {
+          const message = `HTTP ${status}: ${method} ${url}`;
+          void this.capture({
+            message,
+            level: status >= 500 ? "error" : "warning",
+            title: networkExceptionClass(enriched),
+            exception: networkExceptionData(enriched, message),
+            platform: PLATFORM_JAVASCRIPT,
+            context: {
               tags: {
                 ...networkFailureTags(enriched),
                 "http.status_code": String(status)
               },
               extra: networkFailureExtra(enriched)
             }
-          );
+          });
         },
         onNetworkError: (meta) => {
           this.rememberNetworkFailure(meta, { promoted: true });
@@ -14272,14 +14673,18 @@ var TalariaClient = class {
           const url = meta.url || "(unknown url)";
           const errLabel = meta.errorName && meta.errorMessage ? `${meta.errorName}: ${meta.errorMessage}` : meta.errorMessage || meta.errorName || "Failed to fetch";
           const prefix = meta.failureKind === "timeout" ? "Timeout error" : "Network error";
-          void this.captureMessage(
-            `${prefix}: ${method} ${url} \u2014 ${errLabel}`,
-            "error",
-            {
+          const message = `${prefix}: ${method} ${url} \u2014 ${errLabel}`;
+          void this.capture({
+            message,
+            level: "error",
+            title: networkExceptionClass(meta),
+            exception: networkExceptionData(meta, message),
+            platform: PLATFORM_JAVASCRIPT,
+            context: {
               tags: networkFailureTags(meta),
               extra: networkFailureExtra(meta)
             }
-          );
+          });
         }
       }),
       installVisibilityResumeHook(() => this.onForegroundResume())
@@ -14316,7 +14721,7 @@ var TalariaClient = class {
     if (this.capturing || this.ingestDisabled) return;
     const err = error instanceof Error ? error : new Error(typeof error === "string" ? error : "Unknown error");
     if (isAbortError(err)) return;
-    const filename = typeof context?.extra?.filename === "string" ? context.extra.filename : void 0;
+    const filename = context?.source?.filename;
     if (isBrowserExtensionNoise({
       message: err.message,
       stack: err.stack,
@@ -14338,6 +14743,12 @@ var TalariaClient = class {
         level: "error",
         title: err.name || "Error",
         stackTrace: err.stack,
+        exception: buildExceptionFromError(
+          err,
+          mergedContext,
+          this.inAppFrameOptions()
+        ),
+        platform: PLATFORM_JAVASCRIPT,
         context: mergedContext
       });
     } finally {
@@ -14353,6 +14764,13 @@ var TalariaClient = class {
       context
     });
   }
+  /**
+   * Returns a scoped capture facade that merges [tags] into every event.
+   * Nested `withTags` calls merge further (later keys win).
+   */
+  withTags(tags) {
+    return createScopedTalaria(this, mergeTags(tags));
+  }
   async flush(opts) {
     if (!this.options || !this.transport || this.closed) return;
     const keepalive = opts?.keepalive ?? false;
@@ -14517,13 +14935,17 @@ var TalariaClient = class {
     }
     const queuedMs = Math.max(0, Date.now() - occurredAt.getTime());
     const tags = applyReplayCaptureTags(
-      {
-        ...this.browserContext ? browserContextTags(this.browserContext) : {},
-        ...this.options.tags ?? {},
-        ...args.context?.tags ?? {}
-      },
+      mergeTags(
+        this.browserContext ? browserContextTags(this.browserContext) : {},
+        this.options.tags,
+        args.context?.tags
+      ),
       errorClipOutcome
     );
+    warnSuspiciousTags(tags, this.options.environment);
+    const scrubbedContextExtra = scrubLegacyExceptionExtra(
+      args.context?.extra
+    );
     const extra = mergeReplayCaptureExtra(
       {
         ...this.browserContext ? {
@@ -14545,7 +14967,7 @@ var TalariaClient = class {
           // Time spent in capture() before ingest (mostly replay flush).
           ...queuedMs >= 50 ? { queuedMs } : {}
         },
-        ...args.context?.extra
+        ...scrubbedContextExtra ?? {}
       },
       errorClipOutcome
     );
@@ -14557,6 +14979,8 @@ var TalariaClient = class {
         eventType: levelToEventType(args.level),
         title: args.title ?? args.context?.title,
         stackTrace: args.stackTrace,
+        exception: args.exception,
+        platform: args.platform,
         release: this.options.release,
         userId: args.context?.userId ?? this.options.userId,
         sessionId: this.sessionId ?? void 0,
@@ -14806,6 +15230,23 @@ var TalariaClient = class {
       this.resetToBufferMode();
     }
   }
+  inAppFrameOptions() {
+    const opts = this.options;
+    let pageOrigin;
+    try {
+      pageOrigin = resolvePageOrigin(
+        typeof window !== "undefined" ? window.location?.origin : void 0
+      );
+    } catch {
+      pageOrigin = void 0;
+    }
+    return {
+      pageOrigin,
+      allowUrls: opts?.inAppAllowUrls,
+      denyUrls: opts?.inAppDenyUrls,
+      inAppOrigins: opts?.inAppOrigins
+    };
+  }
   pruneRecentNetworkFailures(now = Date.now()) {
     this.recentNetworkFailures = this.recentNetworkFailures.filter(
       (f) => now - f.at <= RECENT_NETWORK_FAILURE_MS
@@ -14880,7 +15321,8 @@ var TalariaClient = class {
         return;
       }
       void this.captureException(error, {
-        extra: {
+        mechanism: { type: "onerror", handled: false },
+        source: {
           filename: event.filename,
           lineno: event.lineno,
           colno: event.colno
@@ -14902,7 +15344,9 @@ var TalariaClient = class {
       })) {
         return;
       }
-      void this.captureException(reason);
+      void this.captureException(reason, {
+        mechanism: { type: "unhandledrejection", handled: false }
+      });
     };
     window.addEventListener("error", onError);
     window.addEventListener("unhandledrejection", onRejection);
@@ -15164,6 +15608,23 @@ var TalariaClient = class {
     }
   }
 };
+function createScopedTalaria(client2, scopeTags) {
+  const mergeContext = (context) => ({
+    ...context,
+    tags: mergeTags(scopeTags, context?.tags)
+  });
+  return {
+    captureException(error, context) {
+      return client2.captureException(error, mergeContext(context));
+    },
+    captureMessage(message, level, context) {
+      return client2.captureMessage(message, level, mergeContext(context));
+    },
+    withTags(tags) {
+      return createScopedTalaria(client2, mergeTags(scopeTags, tags));
+    }
+  };
+}
 
 // src/index.ts
 var client = new TalariaClient();
@@ -15177,6 +15638,9 @@ var Talaria = {
   captureMessage(message, level, context) {
     return client.captureMessage(message, level, context);
   },
+  withTags(tags) {
+    return client.withTags(tags);
+  },
   getReplayId() {
     return client.getReplayId();
   },
@@ -15194,14 +15658,22 @@ export {
   MAX_SEGMENTS_ERROR_CLIP,
   REPLAY_CAPTURE_REASON_TAG,
   REPLAY_CAPTURE_TAG,
+  RESERVED_TAG_KEYS,
   TARGET_COMPRESSED_SEGMENT_BYTES,
   Talaria,
   TalariaClient,
+  applySourceLocation,
   computeErrorClipDeadlineMs,
   index_default as default,
   fitCompressedPrefix,
   isErrorClipBudgetExhausted,
-  planOversizedRetry
+  isInAppFrame,
+  mergeTags,
+  normalizeTags,
+  parseStackLine,
+  parseStackTrace,
+  planOversizedRetry,
+  resolvePageOrigin
 };
 /*! Bundled license information: