@watchforge/browser 0.1.20 → 0.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@watchforge/browser",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",
   "description": "WatchForge JavaScript SDK for browser JavaScript, Next.js, React, Node.js, and Express.js",

package/src/client.js

@@ -97,6 +97,71 @@ function captureGlobalException(error, context = {}) {
   void captureException(normalizeException(error, context.message), context);
 }
 
+function normalizeStackFramePath(path) {
+  if (!path) return "";
+  try {
+    if (isBrowser) {
+      const url = new URL(String(path), window.location.href);
+      if (url.origin === window.location.origin) {
+        return url.pathname.replace(/^\/+/, "");
+      }
+    }
+  } catch {
+    // keep original path
+  }
+
+  return String(path)
+    .replace(/^webpack-internal:\/\/\/?/, "")
+    .replace(/^webpack:\/\/(?:\([^)]*\)\/)?/, "")
+    .replace(/^webpack:\/\/[^/]+\//, "")
+    .replace(/^\([^)]*\)\//, "")
+    .replace(/^file:\/\//, "")
+    .split("?")[0]
+    .split("#")[0]
+    .replace(/\\/g, "/")
+    .replace(/^\/+/, "")
+    .replace(/^\.\//, "");
+}
+
+function isOriginalSourcePath(path) {
+  const normalized = normalizeStackFramePath(path);
+  return /(?:^|\/)src\/.+\.(?:tsx?|jsx?)$/.test(normalized);
+}
+
+function applyBrowserLocationOverride(stacktrace, location) {
+  if (!stacktrace?.frames?.length || !location?.filename || !location?.lineno) {
+    return stacktrace;
+  }
+  if (!isOriginalSourcePath(location.filename)) return stacktrace;
+
+  const normalizedLocation = normalizeStackFramePath(location.filename);
+  const matchingFrames = stacktrace.frames.filter((frame) => {
+    const framePath = normalizeStackFramePath(
+      frame.abs_path || frame.module || frame.raw_abs_path || frame.filename
+    );
+    return (
+      frame.in_app &&
+      (framePath === normalizedLocation ||
+        framePath.endsWith(`/${normalizedLocation}`) ||
+        normalizedLocation.endsWith(`/${framePath}`))
+    );
+  });
+
+  const target = matchingFrames[matchingFrames.length - 1] || stacktrace.frames.find((f) => f.in_app);
+  if (!target) return stacktrace;
+
+  target.abs_path = normalizedLocation;
+  target.raw_abs_path = location.filename;
+  target.module = normalizedLocation;
+  target.filename = normalizedLocation.split("/").pop() || target.filename;
+  target.lineno = Number(location.lineno);
+  if (location.colno != null) target.colno = Number(location.colno);
+  target.function = target.function || "<anonymous>";
+  target.browser_location_override = true;
+
+  return stacktrace;
+}
+
 function getElementDescriptor(element) {
   if (!element || typeof element !== "object") return null;
   const tag = element.tagName ? String(element.tagName).toLowerCase() : "unknown";
@@ -236,6 +301,11 @@ function setupBrowserInstrumentation() {
         mechanism: "window.onerror",
       },
       extra: { url, line, col },
+      stackFrame: {
+        filename: url,
+        lineno: line,
+        colno: col,
+      },
       message: String(msg),
     });
   };
@@ -591,6 +661,9 @@ export function register({
   blockClass = "rr-block",
   ignoreClass = "rr-ignore",
   maskTextClass = "rr-mask",
+  inlineImages = true,
+  inlineStylesheet = true,
+  collectFonts = true,
   captureConsoleErrors = true,
   captureResourceErrors = true,
   captureFailedRequests = true,
@@ -610,6 +683,9 @@ export function register({
         blockClass,
         ignoreClass,
         maskTextClass,
+        inlineImages,
+        inlineStylesheet,
+        collectFonts,
         captureConsoleErrors,
         captureResourceErrors,
         captureFailedRequests,
@@ -667,6 +743,9 @@ export function register({
       blockClass,
       ignoreClass,
       maskTextClass,
+      inlineImages,
+      inlineStylesheet,
+      collectFonts,
       debug,
     });
   }
@@ -742,6 +821,9 @@ export async function captureException(error, context = {}) {
   if (!DSN) return;
 
   let stacktrace = buildStacktraceFromError(error);
+  if (stacktrace && context.stackFrame) {
+    stacktrace = applyBrowserLocationOverride(stacktrace, context.stackFrame);
+  }
   if (stacktrace) {
     stacktrace = await enrichStacktraceAsync(
       stacktrace,

package/src/index.d.ts

@@ -9,6 +9,9 @@ export interface WatchForgeRegisterOptions {
   blockClass?: string;
   ignoreClass?: string;
   maskTextClass?: string;
+  inlineImages?: boolean;
+  inlineStylesheet?: boolean;
+  collectFonts?: boolean;
   captureConsoleErrors?: boolean;
   captureResourceErrors?: boolean;
   captureFailedRequests?: boolean;
@@ -23,6 +26,11 @@ export interface WatchForgeCaptureContext {
   tags?: Record<string, unknown>;
   extra?: Record<string, unknown>;
   contexts?: Record<string, unknown>;
+  stackFrame?: {
+    filename?: string;
+    lineno?: number;
+    colno?: number;
+  };
 }
 
 export function register(options: WatchForgeRegisterOptions): void;

package/src/replay.js

@@ -13,6 +13,9 @@ let options = {
   blockClass: "rr-block",
   ignoreClass: "rr-ignore",
   maskTextClass: "rr-mask",
+  inlineImages: true,
+  inlineStylesheet: true,
+  collectFonts: true,
 };
 let stopRecording = null;
 let events = [];
@@ -112,6 +115,9 @@ export async function initReplay(config = {}) {
         tel: true,
         text: Boolean(options.maskAllInputs),
       },
+      inlineImages: options.inlineImages !== false,
+      inlineStylesheet: options.inlineStylesheet !== false,
+      collectFonts: options.collectFonts !== false,
     });
   } catch (error) {
     if (options.debug) {
@@ -172,7 +178,7 @@ export function flushReplayForEvent(dsn, eventId) {
     events,
     sdk: {
       name: "@watchforge/browser",
-      version: "0.1.12",
+      version: "0.1.22",
     },
   };