@watchforge/browser 0.1.20 → 0.1.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@watchforge/browser",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "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),
     });
   };
@@ -742,6 +812,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

@@ -23,6 +23,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;