@watchforge/browser 0.1.18 → 0.1.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@watchforge/browser",
-  "version": "0.1.18",
+  "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;

package/src/stacktrace.js

@@ -139,7 +139,7 @@ function isJsonParseError(message) {
 
 function isUriError(message) {
   if (!message || typeof message !== "string") return false;
-  return /URI(?:Error| malformed)/i.test(message) || /decodeURIComponent/i.test(message);
+  return /URI\s+malformed/i.test(message) || /URIError/i.test(message);
 }
 
 function isInvalidArrayLengthError(message) {
@@ -717,13 +717,19 @@ function resolveFrameLine(frame, lines) {
   return lineno;
 }
 
+function applyResolvedSourceContext(frame, sourceLines) {
+  if (!sourceLines?.length) return false;
+  const lineno = resolveFrameLine(frame, sourceLines);
+  applySourceContext(frame, sourceLines, lineno);
+  return Boolean(frame.context_line);
+}
+
 async function enrichFrameWithNodeSource(frame) {
   if (!frame.in_app || !frame.lineno) return;
   const lines = await readNodeSourceLines(frame.raw_abs_path || frame.abs_path);
   if (!lines) return;
 
-  const lineno = resolveFrameLine(frame, lines);
-  applySourceContext(frame, lines, lineno);
+  applyResolvedSourceContext(frame, lines);
 }
 
 function getBrowserSourceFetchCandidates(absPath, rawAbsPath) {
@@ -917,12 +923,10 @@ function applyOriginalSourceFrameContext(frame, sourceMap) {
 
   const sourceContent = getSourceMapContentForFrame(frame, sourceMap);
   if (!sourceContent?.lines?.length) return false;
-  if (frame.lineno > sourceContent.lines.length) return false;
 
   frame.abs_path = sourceContent.source;
   frame.filename = normalizeSourcePath(sourceContent.source).split("/").pop() || frame.filename;
-  applySourceContext(frame, sourceContent.lines, frame.lineno);
-  return Boolean(frame.context_line);
+  return applyResolvedSourceContext(frame, sourceContent.lines);
 }
 
 async function findSourceMapForFrame(frame) {
@@ -1081,12 +1085,9 @@ function getWebpackFrameArtifacts(frame) {
 async function enrichFrameWithBrowserSource(frame) {
   if (!frame.in_app || !frame.lineno) return;
 
-  if (isOriginalSourceFrame(frame)) {
-    const lines = await fetchBrowserSourceLines(frame.abs_path, frame.raw_abs_path);
-    if (lines) {
-      applySourceContext(frame, lines, frame.lineno);
-      if (frame.context_line) return;
-    }
+  const lines = await fetchBrowserSourceLines(frame.abs_path, frame.raw_abs_path);
+  if (lines && applyResolvedSourceContext(frame, lines)) {
+    return;
   }
 
   const webpackArtifacts = getWebpackFrameArtifacts(frame);
@@ -1096,16 +1097,7 @@ async function enrichFrameWithBrowserSource(frame) {
   }
 
   if (webpackArtifacts?.lines && !webpackArtifacts?.sourceMap) {
-    const lineno = resolveFrameLine(frame, webpackArtifacts.lines);
-    applySourceContext(frame, webpackArtifacts.lines, lineno);
-    if (frame.context_line) return;
-  }
-
-  const lines = await fetchBrowserSourceLines(frame.abs_path, frame.raw_abs_path);
-  if (lines) {
-    const lineno = resolveFrameLine(frame, lines);
-    applySourceContext(frame, lines, lineno);
-    if (frame.context_line) return;
+    if (applyResolvedSourceContext(frame, webpackArtifacts.lines)) return;
   }
 
   await enrichFrameWithSourceMap(frame);