@watchforge/browser 0.1.7 → 0.1.10

package/bin/watchforge.js

@@ -136,6 +136,16 @@ function findPagesApp(cwd) {
   return candidates.find(fileExists) || null;
 }
 
+function findNextConfig(cwd) {
+  const candidates = [
+    "next.config.ts",
+    "next.config.mts",
+    "next.config.js",
+    "next.config.mjs",
+  ];
+  return candidates.map((candidate) => path.join(cwd, candidate)).find(fileExists) || null;
+}
+
 function writeIfChanged(filePath, content) {
   if (fileExists(filePath) && fs.readFileSync(filePath, "utf8") === content) {
     return false;
@@ -361,6 +371,39 @@ export async function register() {
   log(`wrote ${path.relative(cwd, instrumentationPath)}`);
 }
 
+function patchNextConfig(cwd) {
+  const configPath = findNextConfig(cwd);
+  if (!configPath) {
+    log("could not find next.config.* to patch for compiler error capture");
+    log('wrap your Next config with withWatchForgeConfig(config, watchforgeConfig) from "@watchforge/browser/next/config"');
+    return;
+  }
+
+  let content = fs.readFileSync(configPath, "utf8");
+  if (content.includes("withWatchForgeConfig")) {
+    log(`${path.relative(cwd, configPath)} already contains WatchForge compiler setup`);
+    return;
+  }
+
+  const configImport = toImportPath(path.dirname(configPath), getConfigPath(cwd));
+  content = `import { withWatchForgeConfig } from "@watchforge/browser/next/config";\nimport { watchforgeConfig } from "${configImport}";\n${content}`;
+
+  const exportDefaultMatch = content.match(/export\s+default\s+([^;]+);/);
+  if (!exportDefaultMatch) {
+    log(`skipped ${path.relative(cwd, configPath)} because export default could not be patched automatically`);
+    log('wrap your exported config with withWatchForgeConfig(config, watchforgeConfig)');
+    return;
+  }
+
+  content = content.replace(
+    exportDefaultMatch[0],
+    `export default withWatchForgeConfig(${exportDefaultMatch[1]}, watchforgeConfig);`
+  );
+
+  fs.writeFileSync(configPath, content);
+  log(`patched ${path.relative(cwd, configPath)} for compiler error capture`);
+}
+
 function patchPagesRouter(cwd, appPath) {
   const pagesDir = path.dirname(appPath);
   const configImport = toImportPath(pagesDir, getConfigPath(cwd));
@@ -522,6 +565,7 @@ function initNextjs(args) {
 
   const layoutPath = findNextLayout(cwd);
   if (layoutPath) {
+    patchNextConfig(cwd);
     patchAppRouter(cwd, layoutPath);
     createNextGlobalError(cwd, layoutPath);
     createNextInstrumentation(cwd, layoutPath);
@@ -530,6 +574,7 @@ function initNextjs(args) {
 
   const appPath = findPagesApp(cwd);
   if (appPath) {
+    patchNextConfig(cwd);
     patchPagesRouter(cwd, appPath);
     return;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@watchforge/browser",
-  "version": "0.1.7",
+  "version": "0.1.10",
   "main": "./src/index.js",
   "types": "./src/index.d.ts",
   "description": "WatchForge JavaScript SDK for browser JavaScript, Next.js, React, Node.js, and Express.js",
@@ -33,6 +33,10 @@
       "types": "./src/next-server.d.ts",
       "default": "./src/next-server.js"
     },
+    "./next/config": {
+      "types": "./src/next-config.d.ts",
+      "default": "./src/next-config.js"
+    },
     "./express": {
       "types": "./src/express.d.ts",
       "default": "./src/express.js"

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.1";
+export const SDK_VERSION = "0.1.10";
 
 export function getSdkMetadata() {
   return {
@@ -73,10 +73,14 @@ export function getPerformanceContext() {
 
 let nodeOsPromise = null;
 
+// Hide from bundlers (Next.js/webpack) so client builds don't resolve Node built-ins.
+const importNodeBuiltin = (specifier) =>
+  new Function("specifier", "return import(specifier)")(specifier);
+
 async function getNodeOs() {
   if (!isNode) return null;
   if (!nodeOsPromise) {
-    nodeOsPromise = import("os").catch(() => null);
+    nodeOsPromise = importNodeBuiltin("os").catch(() => null);
   }
   return nodeOsPromise;
 }

package/src/next-config.d.ts

@@ -0,0 +1,6 @@
+import type { WatchForgeRegisterOptions } from "./index";
+
+export function withWatchForgeConfig<T extends Record<string, unknown>>(
+  nextConfig?: T,
+  watchforgeOptions?: WatchForgeRegisterOptions
+): T;

package/src/next-config.js

@@ -0,0 +1,135 @@
+import { captureException, register } from "./client.js";
+
+const PLUGIN_NAME = "WatchForgeNextCompilerPlugin";
+const sentCompilerErrors = new Set();
+let registeredDsn = null;
+
+function getLoc(rawError) {
+  const loc = rawError?.loc || rawError?.module?.loc;
+
+  if (typeof loc === "string") {
+    const match = loc.match(/(\d+)(?::(\d+))?/);
+    if (match) {
+      return {
+        line: Number(match[1]),
+        column: Number(match[2] || 1),
+      };
+    }
+  }
+
+  if (loc && typeof loc === "object") {
+    const start = loc.start || loc;
+    return {
+      line: Number(start.line || start.lineNumber || 1),
+      column: Number(start.column || start.col || 1),
+    };
+  }
+
+  return { line: 1, column: 1 };
+}
+
+function getModulePath(rawError) {
+  return (
+    rawError?.module?.resource ||
+    rawError?.module?.resourceResolveData?.path ||
+    rawError?.file ||
+    rawError?.moduleName ||
+    null
+  );
+}
+
+function createCompilerException(rawError) {
+  const message =
+    rawError?.message ||
+    rawError?.details ||
+    String(rawError || "Next.js compiler error");
+  const error = new Error(message);
+  error.name = rawError?.name || "NextWebpackCompilationError";
+
+  const filePath = getModulePath(rawError);
+  if (filePath) {
+    const { line, column } = getLoc(rawError);
+    error.stack = `${error.name}: ${message}\n    at Next.js compilation (${filePath}:${line}:${column})`;
+    if (rawError?.stack) {
+      error.stack += `\n${String(rawError.stack).split("\n").slice(1).join("\n")}`;
+    }
+  } else if (rawError?.stack) {
+    error.stack = rawError.stack;
+  }
+
+  return error;
+}
+
+function getCompilerErrorFingerprint(rawError, compilerName, hash) {
+  const filePath = getModulePath(rawError) || "";
+  const loc = getLoc(rawError);
+  const message = rawError?.message || String(rawError || "");
+  return [hash || "", compilerName || "", filePath, loc.line, loc.column, message].join("|");
+}
+
+function createCompilerPlugin() {
+  return {
+    name: PLUGIN_NAME,
+    apply(compiler) {
+      compiler.hooks.done.tapPromise(PLUGIN_NAME, async (stats) => {
+        if (!stats?.hasErrors?.()) return;
+
+        const errors = stats.compilation?.errors || [];
+        const compilerName = compiler.name || stats.compilation?.name || null;
+
+        for (const rawError of errors) {
+          const fingerprint = getCompilerErrorFingerprint(rawError, compilerName, stats.hash);
+          if (sentCompilerErrors.has(fingerprint)) continue;
+          sentCompilerErrors.add(fingerprint);
+
+          await captureException(createCompilerException(rawError), {
+            tags: {
+              framework: "nextjs",
+              runtime: "compiler",
+              compiler: compilerName,
+            },
+            contexts: {
+              nextjs: {
+                compiler_error: true,
+                module: getModulePath(rawError),
+                loc: rawError?.loc || rawError?.module?.loc || null,
+              },
+            },
+            extra: {
+              details: rawError?.details || null,
+              module_identifier: rawError?.module?.identifier?.() || null,
+              module_name: rawError?.module?.readableIdentifier?.({}) || rawError?.moduleName || null,
+            },
+          });
+        }
+      });
+    },
+  };
+}
+
+function ensureRegistered(options) {
+  if (!options?.dsn || registeredDsn === options.dsn) return;
+  registeredDsn = options.dsn;
+  register(options);
+}
+
+export function withWatchForgeConfig(nextConfig = {}, watchforgeOptions = {}) {
+  ensureRegistered(watchforgeOptions);
+
+  const userWebpack = nextConfig.webpack;
+
+  return {
+    ...nextConfig,
+    webpack(config, options) {
+      const finalConfig = userWebpack ? userWebpack(config, options) || config : config;
+      finalConfig.plugins = finalConfig.plugins || [];
+
+      const hasPlugin = finalConfig.plugins.some((plugin) => plugin?.name === PLUGIN_NAME);
+      if (!hasPlugin) {
+        finalConfig.plugins.push(createCompilerPlugin());
+      }
+
+      return finalConfig;
+    },
+  };
+}

package/src/replay.js

@@ -3,6 +3,8 @@ import { sendReplay } from "./transport.js";
 const isBrowser = typeof window !== "undefined";
 const MAX_BUFFER_MS = 60 * 1000;
 const MAX_EVENTS = 500;
+const RRWEB_FULL_SNAPSHOT = 2;
+const RRWEB_META = 4;
 
 let options = {
   replaysSessionSampleRate: 0,
@@ -37,9 +39,43 @@ function shouldSample(rate) {
 
 function trimBuffer(now = Date.now()) {
   events = events.filter((event) => now - event.timestamp <= MAX_BUFFER_MS);
-  if (events.length > MAX_EVENTS) {
-    events = events.slice(-MAX_EVENTS);
+  if (events.length <= MAX_EVENTS) return;
+
+  const tail = events.slice(-MAX_EVENTS);
+  if (tail.some((event) => event.type === RRWEB_FULL_SNAPSHOT)) {
+    events = tail;
+    return;
+  }
+
+  const fullSnapshotIndex = findLastEventIndex(events, RRWEB_FULL_SNAPSHOT);
+  if (fullSnapshotIndex === -1) {
+    events = tail;
+    return;
+  }
+
+  const metaIndex = findLastEventIndex(
+    events.slice(0, fullSnapshotIndex),
+    RRWEB_META
+  );
+  const anchorEvents = [
+    ...(metaIndex >= 0 ? [events[metaIndex]] : []),
+    events[fullSnapshotIndex],
+  ];
+  const remainingSlots = Math.max(MAX_EVENTS - anchorEvents.length, 0);
+  const recentEvents = events
+    .slice(fullSnapshotIndex + 1)
+    .slice(-remainingSlots);
+
+  events = [...anchorEvents, ...recentEvents].sort(
+    (a, b) => (a.timestamp || 0) - (b.timestamp || 0)
+  );
+}
+
+function findLastEventIndex(list, type) {
+  for (let i = list.length - 1; i >= 0; i--) {
+    if (list[i]?.type === type) return i;
   }
+  return -1;
 }
 
 export async function initReplay(config = {}) {
@@ -115,7 +151,7 @@ export function flushReplayForEvent(dsn, eventId) {
     events,
     sdk: {
       name: "@watchforge/browser",
-      version: "0.1.3",
+      version: "0.1.10",
     },
   };