@watchforge/browser 0.1.11 → 0.1.13

package/bin/watchforge.js

@@ -214,6 +214,7 @@ function createConfig(cwd, args) {
   replaysOnErrorSampleRate: ${Number(args.replaysOnError)},
   replaysSessionSampleRate: ${Number(args.replaysSession)},
   maskAllInputs: true,
+  projectRoot: process.env.INIT_CWD || process.env.PWD || "",
 };
 `;
   writeIfChanged(configPath, content);
@@ -308,21 +309,25 @@ import { watchforgeConfig } from "${configImport}";
 export default function GlobalError(${propsSignature}) {
   useEffect(() => {
     register(watchforgeConfig);
-    void captureException(error, {
-      tags: {
-        framework: "nextjs",
-        runtime: "error-boundary",
-      },
-      extra: {
-        digest: error.digest,
-      },
-      contexts: {
-        nextjs: {
-          error_boundary: "global-error",
-          digest: error.digest || null,
+    const timer = window.setTimeout(() => {
+      void captureException(error, {
+        tags: {
+          framework: "nextjs",
+          runtime: "error-boundary",
         },
-      },
-    });
+        extra: {
+          digest: error.digest,
+        },
+        contexts: {
+          nextjs: {
+            error_boundary: "global-error",
+            digest: error.digest || null,
+          },
+        },
+      });
+    }, 100);
+
+    return () => window.clearTimeout(timer);
   }, [error]);
 
   return (

package/package.json

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

@@ -2,6 +2,7 @@ import { sendEvent, parseDsn } from "./transport.js";
 import {
   buildStacktraceFromError,
   enrichStacktraceAsync,
+  setProjectRoot,
 } from "./stacktrace.js";
 import {
   getSdkMetadata,
@@ -13,6 +14,7 @@ import {
   flushReplayForEvent,
   getReplayContext,
   initReplay,
+  waitForReplayReady,
 } from "./replay.js";
 
 let DSN = null;
@@ -31,6 +33,7 @@ const MAX_BREADCRUMBS = 100;
 let breadcrumbs = [];
 let browserInstrumentationInstalled = false;
 let nodeInstrumentationInstalled = false;
+let replayInitPromise = null;
 
 export function addBreadcrumb(breadcrumb) {
   const entry = {
@@ -428,12 +431,17 @@ export function register({
   ignoreClass = "rr-ignore",
   maskTextClass = "rr-mask",
   captureConsoleErrors = true,
+  projectRoot = null,
 }) {
   DSN = dsn;
   APP_ENV = app_env;
   RELEASE = release;
   DEBUG = debug;
   CAPTURE_CONSOLE_ERRORS = Boolean(captureConsoleErrors);
+  setProjectRoot(
+    projectRoot ||
+      (isNode ? process.env.WATCHFORGE_PROJECT_ROOT || process.env.INIT_CWD : null)
+  );
   
   // Initialize tracing
   initTracing(dsn, app_env, debug);
@@ -460,7 +468,7 @@ export function register({
   // Browser: Set up full instrumentation (errors, breadcrumbs, HTTP, navigation)
   if (isBrowser) {
     setupBrowserInstrumentation();
-    initReplay({
+    replayInitPromise = initReplay({
       replaysSessionSampleRate,
       replaysOnErrorSampleRate,
       maskAllInputs,
@@ -497,7 +505,10 @@ export async function captureException(error, context = {}) {
 
   let stacktrace = buildStacktraceFromError(error);
   if (stacktrace) {
-    stacktrace = await enrichStacktraceAsync(stacktrace);
+    stacktrace = await enrichStacktraceAsync(
+      stacktrace,
+      error?.message || String(error || "")
+    );
   }
 
   const event = {
@@ -511,6 +522,15 @@ export async function captureException(error, context = {}) {
     sdk: getSdkMetadata(),
   };
 
+  if (isBrowser && replayInitPromise) {
+    try {
+      await replayInitPromise;
+      await waitForReplayReady();
+    } catch {
+      // Replay is best-effort; never block error delivery.
+    }
+  }
+
   const replay = flushReplayForEvent(DSN, event.event_id);
   if (replay) {
     event.replay_id = replay.replay_id;

package/src/contexts.js

@@ -7,7 +7,7 @@ const isNode =
   typeof process !== "undefined" && process.versions && process.versions.node;
 
 export const SDK_NAME = "@watchforge/browser";
-export const SDK_VERSION = "0.1.11";
+export const SDK_VERSION = "0.1.12";
 
 export function getSdkMetadata() {
   return {

package/src/index.d.ts

@@ -10,6 +10,7 @@ export interface WatchForgeRegisterOptions {
   ignoreClass?: string;
   maskTextClass?: string;
   captureConsoleErrors?: boolean;
+  projectRoot?: string | null;
 }
 
 export interface WatchForgeCaptureContext {

package/src/replay.js

@@ -120,6 +120,27 @@ export async function initReplay(config = {}) {
   }
 }
 
+export function waitForReplayReady(timeoutMs = 300) {
+  if (!isBrowser || !replayId || !sessionId) return Promise.resolve(false);
+  if (events.length > 0) return Promise.resolve(true);
+
+  return new Promise((resolve) => {
+    const started = Date.now();
+    const check = () => {
+      if (events.length > 0) {
+        resolve(true);
+        return;
+      }
+      if (Date.now() - started >= timeoutMs) {
+        resolve(false);
+        return;
+      }
+      setTimeout(check, 25);
+    };
+    check();
+  });
+}
+
 export function getReplayContext() {
   if (!isBrowser || !replayId || !sessionId) return null;
   return {
@@ -151,7 +172,7 @@ export function flushReplayForEvent(dsn, eventId) {
     events,
     sdk: {
       name: "@watchforge/browser",
-      version: "0.1.11",
+      version: "0.1.12",
     },
   };
 

package/src/stacktrace.js

@@ -60,6 +60,7 @@ export function buildStacktraceFromError(error) {
     return null;
   }
 
+  const errorMessage = error?.message || "";
   const stackLines = error.stack.split("\n");
   const frames = [];
 
@@ -88,6 +89,7 @@ export function buildStacktraceFromError(error) {
       post_context: [],
       vars: {},
       in_app: inApp,
+      error_message: errorMessage,
     });
   }
 
@@ -114,6 +116,45 @@ function applySourceContext(frame, sourceLines, lineno) {
     .map((l) => l.replace(/\r$/, ""));
 }
 
+function getUndefinedIdentifier(message) {
+  if (!message || typeof message !== "string") return null;
+  const match = message.match(/^([A-Za-z_$][\w$]*) is not defined$/);
+  return match?.[1] || null;
+}
+
+function inferLineFromErrorMessage(frame, sourceLines) {
+  const identifier = getUndefinedIdentifier(frame.error_message);
+  if (!identifier || !sourceLines?.length) return null;
+
+  const tokenPattern = new RegExp(`\\b${identifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`);
+  const functionName = frame.function && frame.function !== "<anonymous>"
+    ? String(frame.function)
+    : null;
+
+  const candidates = [];
+  for (let i = 0; i < sourceLines.length; i++) {
+    if (!tokenPattern.test(sourceLines[i])) continue;
+    candidates.push(i);
+  }
+
+  if (!candidates.length) return null;
+
+  if (functionName) {
+    const functionPattern = new RegExp(`\\b${functionName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`);
+    let nearestFunctionLine = -1;
+    for (let i = 0; i < sourceLines.length; i++) {
+      if (functionPattern.test(sourceLines[i])) {
+        nearestFunctionLine = i;
+      }
+      if (candidates.includes(i) && nearestFunctionLine !== -1) {
+        return i + 1;
+      }
+    }
+  }
+
+  return candidates[0] + 1;
+}
+
 function normalizeSourcePath(source) {
   if (!source) return "";
 
@@ -167,6 +208,114 @@ function getNodeModules() {
   return nodeModulesPromise;
 }
 
+let cachedProjectRoots = null;
+let configuredProjectRoot = null;
+
+export function setProjectRoot(projectRoot) {
+  configuredProjectRoot = projectRoot || null;
+  cachedProjectRoots = null;
+}
+
+function packageJsonHasNext(packageJson) {
+  return Boolean(packageJson.dependencies?.next || packageJson.devDependencies?.next);
+}
+
+async function findProjectRoots() {
+  if (cachedProjectRoots) return cachedProjectRoots;
+
+  const mods = await getNodeModules();
+  if (!mods) {
+    cachedProjectRoots = [process.cwd()];
+    return cachedProjectRoots;
+  }
+
+  const { fs, path } = mods;
+  const roots = new Set();
+  const seeds = [
+    configuredProjectRoot,
+    process.env.WATCHFORGE_PROJECT_ROOT,
+    process.env.INIT_CWD,
+    process.env.PWD,
+    process.cwd(),
+  ].filter(Boolean);
+
+  for (const seed of seeds) {
+    roots.add(seed);
+
+    let dir = seed;
+    for (let depth = 0; depth < 10; depth++) {
+      const packageJsonPath = path.join(dir, "package.json");
+      if (fs.existsSync(packageJsonPath)) {
+        try {
+          const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+          if (packageJsonHasNext(packageJson)) {
+            roots.add(dir);
+          }
+        } catch {
+          // ignore invalid package.json
+        }
+      }
+
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+
+  cachedProjectRoots = [...roots];
+  return cachedProjectRoots;
+}
+
+function readFileLines(fs, filePath) {
+  const stat = fs.statSync(filePath);
+  if (stat.size > MAX_SOURCE_FILE_BYTES) return null;
+  return fs.readFileSync(filePath, "utf8").split("\n");
+}
+
+function findFileUnderRoot(fs, path, root, normalizedPath, basename, maxDepth = 5) {
+  const suffix = normalizedPath.replace(/^\/+/, "");
+  const directCandidate = path.join(root, suffix);
+  if (fs.existsSync(directCandidate)) {
+    return directCandidate;
+  }
+
+  const stack = [{ dir: root, depth: 0 }];
+  let scannedFiles = 0;
+
+  while (stack.length > 0 && scannedFiles < 500) {
+    const { dir, depth } = stack.pop();
+    if (depth > maxDepth) continue;
+
+    let entries = [];
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (entry.name === "node_modules" || entry.name === ".next" || entry.name === ".git") {
+        continue;
+      }
+
+      const entryPath = path.join(dir, entry.name);
+      if (entry.isFile()) {
+        scannedFiles += 1;
+        if (entry.name === basename) {
+          const normalizedEntry = entryPath.replace(/\\/g, "/");
+          if (normalizedEntry.endsWith(suffix)) {
+            return entryPath;
+          }
+        }
+      } else if (entry.isDirectory()) {
+        stack.push({ dir: entryPath, depth: depth + 1 });
+      }
+    }
+  }
+
+  return null;
+}
+
 async function readNodeSourceLines(absPath) {
   if (!isNode || !absPath) return null;
 
@@ -185,26 +334,87 @@ async function readNodeSourceLines(absPath) {
       filePath = fileURLToPath(filePath);
     }
 
-    if (!path.isAbsolute(filePath)) {
-      filePath = path.resolve(process.cwd(), filePath);
+    const normalizedPath = normalizeSourcePath(filePath);
+    const roots = await findProjectRoots();
+    const candidates = new Set();
+
+    if (path.isAbsolute(filePath)) {
+      candidates.add(filePath);
+    }
+
+    for (const root of roots) {
+      candidates.add(path.resolve(root, filePath));
+      candidates.add(path.resolve(root, normalizedPath));
+
+      const srcMatch = normalizedPath.match(/(?:^|\/)?(src\/.+)$/);
+      if (srcMatch) {
+        candidates.add(path.resolve(root, srcMatch[1]));
+      }
+    }
+
+    for (const candidate of candidates) {
+      if (!candidate || !fs.existsSync(candidate)) continue;
+      const lines = readFileLines(fs, candidate);
+      if (lines) return lines;
     }
 
-    if (!fs.existsSync(filePath)) return null;
+    const basename = path.basename(normalizedPath);
+    for (const root of roots) {
+      const packageJsonPath = path.join(root, "package.json");
+      if (!fs.existsSync(packageJsonPath)) continue;
+
+      let isNextProject = root === process.env.INIT_CWD || root === process.env.PWD;
+      if (!isNextProject) {
+        try {
+          const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+          isNextProject = packageJsonHasNext(packageJson);
+        } catch {
+          isNextProject = false;
+        }
+      }
 
-    const stat = fs.statSync(filePath);
-    if (stat.size > MAX_SOURCE_FILE_BYTES) return null;
+      if (!isNextProject) continue;
+
+      const discovered = findFileUnderRoot(fs, path, root, normalizedPath, basename);
+      if (discovered && fs.existsSync(discovered)) {
+        const lines = readFileLines(fs, discovered);
+        if (lines) return lines;
+      }
+    }
 
-    const content = fs.readFileSync(filePath, "utf8");
-    return content.split("\n");
+    return null;
   } catch {
     return null;
   }
 }
 
+function resolveFrameLine(frame, lines) {
+  let lineno = frame.lineno;
+  if (!lines?.length || !lineno) return lineno;
+
+  if (lineno > lines.length) {
+    const inferredLine = inferLineFromErrorMessage(frame, lines);
+    if (inferredLine) {
+      lineno = inferredLine;
+      frame.lineno = inferredLine;
+      const identifier = getUndefinedIdentifier(frame.error_message);
+      if (identifier) {
+        const col = lines[inferredLine - 1].indexOf(identifier);
+        if (col >= 0) frame.colno = col + 1;
+      }
+    }
+  }
+
+  return lineno;
+}
+
 async function enrichFrameWithNodeSource(frame) {
   if (!frame.in_app || !frame.lineno) return;
   const lines = await readNodeSourceLines(frame.raw_abs_path || frame.abs_path);
-  if (lines) applySourceContext(frame, lines, frame.lineno);
+  if (!lines) return;
+
+  const lineno = resolveFrameLine(frame, lines);
+  applySourceContext(frame, lines, lineno);
 }
 
 function getBrowserSourceFetchCandidates(absPath, rawAbsPath) {
@@ -475,13 +685,21 @@ async function enrichFrameWithBrowserSource(frame) {
   await enrichFrameWithSourceMap(frame);
 }
 
-export async function enrichStacktraceAsync(stacktrace) {
+export async function enrichStacktraceAsync(stacktrace, errorMessage = null) {
   if (!stacktrace?.frames?.length) return stacktrace;
 
   const inAppFrames = stacktrace.frames.filter((f) => f.in_app);
   // Enrich the error frame first (last in-app frame), then nearby frames.
   const targets = [...inAppFrames.slice(-5)].reverse();
 
+  if (errorMessage) {
+    for (const frame of targets) {
+      if (!frame.error_message) {
+        frame.error_message = errorMessage;
+      }
+    }
+  }
+
   if (isNode) {
     await Promise.all(targets.map((frame) => enrichFrameWithNodeSource(frame)));
   } else if (isBrowser) {

package/src/tracing.js

@@ -118,7 +118,7 @@ class Transaction {
       request: this.request,
       platform: typeof window !== "undefined" ? "javascript" : "node",
       sdk_name: "watchforge-javascript",
-      sdk_version: "0.1.11",
+      sdk_version: "0.1.12",
     };
 
     if (DEBUG) {