npm - @nexttrace/next - Versions diffs - 0.1.0 - Mend

@nexttrace/next 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/README.md ADDED Viewed

@@ -0,0 +1,78 @@
+# @nexttrace/next
+> Next.js integration for **NextTrace** — the local-first, privacy-respecting API debugging overlay and developer observability toolkit.
+## Features
+- ⚡ **Zero External Telemetry**: All events remain in local browser/server memory.
+- 🔒 **Deep Secret Redaction**: Automatically redacts Bearer tokens, API keys, passwords, and custom sensitive fields.
+- 🎯 **App Router Native**: Seamlessly captures client-side `fetch` and outgoing server-side `fetch` via Next.js instrumentation.
+- 🛠️ **Dev-Only Gating**: Tree-shaken in production; renders `null` unless `NODE_ENV === 'development'`.
+## Installation
+```bash
+# npm
+npm install --save-dev @nexttrace/next @nexttrace/core
+# pnpm
+pnpm add -D @nexttrace/next @nexttrace/core
+```
+## Quick Start
+### 1. Mount the Client Overlay
+Add `<NextTraceOverlay />` to your root layout (`app/layout.tsx`):
+```tsx
+import { NextTraceOverlay } from '@nexttrace/next';
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en">
+      <body>
+        {children}
+        <NextTraceOverlay defaultPosition="bottom" />
+      </body>
+    </html>
+  );
+}
+```
+### 2. (Optional) Trace Server-Side `fetch`
+To capture outgoing `fetch` calls made inside Server Components, Server Actions, or Route Handlers:
+1. Enable the instrumentation hook in `next.config.js`:
+```js
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  experimental: {
+    instrumentationHook: true,
+  },
+};
+module.exports = nextConfig;
+```
+2. Register server tracing in `instrumentation.ts` in your project root:
+```ts
+export async function register() {
+  if (process.env.NEXT_RUNTIME === 'nodejs') {
+    const { traceNextServer } = await import('@nexttrace/next/server');
+    traceNextServer();
+  }
+}
+```
+3. Expose the dev-only collector route at `app/api/__nexttrace/route.ts`:
+```ts
+import { createNextTraceRouteHandler } from '@nexttrace/next/server';
+export const { GET, POST } = createNextTraceRouteHandler();
+```
+## License
+MIT © NextTrace Team

package/dist/chunk-7FTNN4TD.mjs ADDED Viewed

@@ -0,0 +1,191 @@
+// src/server.ts
+import {
+  redactHeaders,
+  sanitizeUrlAndQuery,
+  sanitizeBodyPreview,
+  DEFAULT_DENY_HEADERS,
+  DEFAULT_DENY_QUERY_PARAMS,
+  DEFAULT_DENY_JSON_KEYS
+} from "@nexttrace/core";
+var serverEventQueue = [];
+var MAX_SERVER_EVENTS = 100;
+var isServerInstrumented = false;
+var originalGlobalFetch = null;
+function generateEventId() {
+  return "srv_" + Math.random().toString(36).substring(2, 10) + Date.now().toString(36);
+}
+function instrumentServerFetch() {
+  if (process.env.NODE_ENV !== "development") {
+    return () => {
+    };
+  }
+  if (isServerInstrumented || typeof globalThis.fetch === "undefined") {
+    return () => {
+    };
+  }
+  originalGlobalFetch = globalThis.fetch;
+  isServerInstrumented = true;
+  globalThis.fetch = async function(input, init) {
+    if (!originalGlobalFetch) return fetch(input, init);
+    const urlString = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    if (urlString.includes("/__nexttrace") || urlString.includes("/_next/")) {
+      return originalGlobalFetch.call(globalThis, input, init);
+    }
+    const eventId = generateEventId();
+    const startTime = performance.now();
+    const timestamp = Date.now();
+    let method = "GET";
+    const rawHeaders = {};
+    let reqBodyText = null;
+    if (init) {
+      if (init.method) method = init.method.toUpperCase();
+      if (init.headers) {
+        if (init.headers instanceof Headers) {
+          init.headers.forEach((v, k) => {
+            rawHeaders[k] = v;
+          });
+        } else if (Array.isArray(init.headers)) {
+          init.headers.forEach(([k, v]) => {
+            rawHeaders[k] = v;
+          });
+        } else {
+          Object.entries(init.headers).forEach(([k, v]) => {
+            rawHeaders[k] = String(v);
+          });
+        }
+      }
+      if (init.body && typeof init.body === "string") {
+        reqBodyText = init.body;
+      }
+    }
+    const { sanitizedUrl, queryParams, wasRedacted: queryRedacted } = sanitizeUrlAndQuery(
+      urlString,
+      DEFAULT_DENY_QUERY_PARAMS
+    );
+    const { sanitized: sanitizedReqHeaders, wasRedacted: headersRedacted } = redactHeaders(
+      rawHeaders,
+      DEFAULT_DENY_HEADERS
+    );
+    const { preview: reqBodyPreview, wasRedacted: bodyRedacted } = sanitizeBodyPreview(
+      reqBodyText,
+      25e3,
+      DEFAULT_DENY_JSON_KEYS
+    );
+    const event = {
+      schemaVersion: "1.0.0",
+      eventId,
+      timestamp,
+      phase: "start",
+      runtime: "node",
+      sourceAdapter: "server-fetch",
+      request: {
+        method,
+        url: urlString,
+        sanitizedUrl,
+        queryParams,
+        headers: sanitizedReqHeaders,
+        bodyPreview: reqBodyPreview,
+        bodySize: reqBodyText ? reqBodyText.length : 0,
+        isTruncated: false
+      },
+      timing: {
+        startTime
+      },
+      context: {
+        attributionMethod: "stack-derived",
+        confidence: "medium"
+      },
+      flags: {
+        isInternal: false,
+        isRedacted: queryRedacted || headersRedacted || bodyRedacted,
+        isTruncated: false,
+        isInferred: false
+      }
+    };
+    serverEventQueue.push(event);
+    if (serverEventQueue.length > MAX_SERVER_EVENTS) {
+      serverEventQueue.shift();
+    }
+    try {
+      const response = await originalGlobalFetch.call(globalThis, input, init);
+      const endTime = performance.now();
+      const duration = Math.round(endTime - startTime);
+      const resHeaders = {};
+      response.headers.forEach((v, k) => {
+        resHeaders[k] = v;
+      });
+      const { sanitized: sanitizedResHeaders, wasRedacted: resHeadersRedacted } = redactHeaders(
+        resHeaders,
+        DEFAULT_DENY_HEADERS
+      );
+      const contentType = response.headers.get("content-type") || "";
+      let resBodyPreview = null;
+      if (contentType.includes("application/json") || contentType.includes("text/")) {
+        try {
+          const clone = response.clone();
+          const raw = await clone.text();
+          const sanitized = sanitizeBodyPreview(raw, 25e3, DEFAULT_DENY_JSON_KEYS);
+          resBodyPreview = sanitized.preview;
+        } catch {
+        }
+      }
+      event.phase = response.ok ? "complete" : "error";
+      event.timing.endTime = endTime;
+      event.timing.duration = duration;
+      event.flags.isSlow = duration >= 1e3;
+      event.flags.isRedacted = event.flags.isRedacted || resHeadersRedacted;
+      event.response = {
+        status: response.status,
+        statusText: response.statusText,
+        headers: sanitizedResHeaders,
+        bodyPreview: resBodyPreview,
+        contentType,
+        bodySize: resBodyPreview ? resBodyPreview.length : 0,
+        isTruncated: false
+      };
+      return response;
+    } catch (err) {
+      const endTime = performance.now();
+      event.phase = "error";
+      event.timing.endTime = endTime;
+      event.timing.duration = Math.round(endTime - startTime);
+      event.error = {
+        name: err instanceof Error ? err.name : "ServerError",
+        message: err instanceof Error ? err.message : String(err)
+      };
+      throw err;
+    }
+  };
+  return () => {
+    if (isServerInstrumented && originalGlobalFetch) {
+      globalThis.fetch = originalGlobalFetch;
+      originalGlobalFetch = null;
+      isServerInstrumented = false;
+    }
+  };
+}
+function createNextTraceRouteHandler() {
+  return async function GET() {
+    if (process.env.NODE_ENV !== "development") {
+      return new Response(JSON.stringify({ error: "Forbidden in production" }), {
+        status: 403,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    const events = [...serverEventQueue];
+    serverEventQueue.length = 0;
+    return new Response(JSON.stringify({ events }), {
+      status: 200,
+      headers: {
+        "Content-Type": "application/json",
+        "Cache-Control": "no-store, no-cache",
+        "x-nexttrace-internal": "true"
+      }
+    });
+  };
+}
+export {
+  instrumentServerFetch,
+  createNextTraceRouteHandler
+};

package/dist/index.d.mts ADDED Viewed

@@ -0,0 +1,14 @@
+import React from 'react';
+import { NextTraceStore } from '@nexttrace/core';
+import { DockPosition, DevToolsTheme } from '@nexttrace/devtools';
+interface NextTraceOverlayProps {
+    store?: NextTraceStore;
+    defaultPosition?: DockPosition;
+    defaultTheme?: DevToolsTheme;
+    initialOpen?: boolean;
+    enableServerSync?: boolean;
+}
+declare const NextTraceOverlay: React.FC<NextTraceOverlayProps>;
+export { NextTraceOverlay, type NextTraceOverlayProps };

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,14 @@
+import React from 'react';
+import { NextTraceStore } from '@nexttrace/core';
+import { DockPosition, DevToolsTheme } from '@nexttrace/devtools';
+interface NextTraceOverlayProps {
+    store?: NextTraceStore;
+    defaultPosition?: DockPosition;
+    defaultTheme?: DevToolsTheme;
+    initialOpen?: boolean;
+    enableServerSync?: boolean;
+}
+declare const NextTraceOverlay: React.FC<NextTraceOverlayProps>;
+export { NextTraceOverlay, type NextTraceOverlayProps };

package/dist/index.js ADDED Viewed

@@ -0,0 +1,83 @@
+'use client';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  NextTraceOverlay: () => NextTraceOverlay
+});
+module.exports = __toCommonJS(index_exports);
+// src/client.tsx
+var import_react = require("react");
+var import_core = require("@nexttrace/core");
+var import_devtools = require("@nexttrace/devtools");
+var import_jsx_runtime = require("react/jsx-runtime");
+var NextTraceOverlay = ({
+  store: propStore,
+  defaultPosition = "bottom",
+  defaultTheme = "dark",
+  initialOpen = false,
+  enableServerSync = true
+}) => {
+  if (process.env.NODE_ENV !== "development") {
+    return null;
+  }
+  const store = propStore || (0, import_core.getGlobalStore)();
+  (0, import_react.useEffect)(() => {
+    const uninstallFetch = (0, import_core.installFetchInterceptor)(store);
+    let syncInterval = null;
+    if (enableServerSync) {
+      syncInterval = setInterval(async () => {
+        try {
+          const res = await fetch("/api/__nexttrace", {
+            headers: { "x-nexttrace-internal": "true" }
+          });
+          if (res.ok) {
+            const data = await res.json();
+            if (data.events && Array.isArray(data.events)) {
+              data.events.forEach((srvEvent) => {
+                store.recordEvent(srvEvent);
+              });
+            }
+          }
+        } catch {
+        }
+      }, 2e3);
+    }
+    return () => {
+      uninstallFetch();
+      if (syncInterval) clearInterval(syncInterval);
+    };
+  }, [store, enableServerSync]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_devtools.NextTraceDevTools,
+    {
+      store,
+      defaultPosition,
+      defaultTheme,
+      initialOpen
+    }
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NextTraceOverlay
+});

package/dist/index.mjs ADDED Viewed

@@ -0,0 +1,60 @@
+'use client';
+// src/client.tsx
+import { useEffect } from "react";
+import {
+  installFetchInterceptor,
+  getGlobalStore
+} from "@nexttrace/core";
+import { NextTraceDevTools } from "@nexttrace/devtools";
+import { jsx } from "react/jsx-runtime";
+var NextTraceOverlay = ({
+  store: propStore,
+  defaultPosition = "bottom",
+  defaultTheme = "dark",
+  initialOpen = false,
+  enableServerSync = true
+}) => {
+  if (process.env.NODE_ENV !== "development") {
+    return null;
+  }
+  const store = propStore || getGlobalStore();
+  useEffect(() => {
+    const uninstallFetch = installFetchInterceptor(store);
+    let syncInterval = null;
+    if (enableServerSync) {
+      syncInterval = setInterval(async () => {
+        try {
+          const res = await fetch("/api/__nexttrace", {
+            headers: { "x-nexttrace-internal": "true" }
+          });
+          if (res.ok) {
+            const data = await res.json();
+            if (data.events && Array.isArray(data.events)) {
+              data.events.forEach((srvEvent) => {
+                store.recordEvent(srvEvent);
+              });
+            }
+          }
+        } catch {
+        }
+      }, 2e3);
+    }
+    return () => {
+      uninstallFetch();
+      if (syncInterval) clearInterval(syncInterval);
+    };
+  }, [store, enableServerSync]);
+  return /* @__PURE__ */ jsx(
+    NextTraceDevTools,
+    {
+      store,
+      defaultPosition,
+      defaultTheme,
+      initialOpen
+    }
+  );
+};
+export {
+  NextTraceOverlay
+};

package/dist/server.d.mts ADDED Viewed

@@ -0,0 +1,15 @@
+/**
+ * NextTrace Server-Side Outgoing Fetch Collector & Route Handler
+ * Captures outgoing HTTP calls made in Server Components, Route Handlers, or Server Actions.
+ */
+/**
+ * Instruments globalThis.fetch on the Node.js server side in development
+ */
+declare function instrumentServerFetch(): () => void;
+/**
+ * Next.js App Router Route Handler for `app/api/__nexttrace/route.ts`
+ * Exposes server events in dev mode only.
+ */
+declare function createNextTraceRouteHandler(): () => Promise<Response>;
+export { createNextTraceRouteHandler, instrumentServerFetch };

package/dist/server.d.ts ADDED Viewed

@@ -0,0 +1,15 @@
+/**
+ * NextTrace Server-Side Outgoing Fetch Collector & Route Handler
+ * Captures outgoing HTTP calls made in Server Components, Route Handlers, or Server Actions.
+ */
+/**
+ * Instruments globalThis.fetch on the Node.js server side in development
+ */
+declare function instrumentServerFetch(): () => void;
+/**
+ * Next.js App Router Route Handler for `app/api/__nexttrace/route.ts`
+ * Exposes server events in dev mode only.
+ */
+declare function createNextTraceRouteHandler(): () => Promise<Response>;
+export { createNextTraceRouteHandler, instrumentServerFetch };

package/dist/server.js ADDED Viewed

@@ -0,0 +1,209 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  createNextTraceRouteHandler: () => createNextTraceRouteHandler,
+  instrumentServerFetch: () => instrumentServerFetch
+});
+module.exports = __toCommonJS(server_exports);
+var import_core = require("@nexttrace/core");
+var serverEventQueue = [];
+var MAX_SERVER_EVENTS = 100;
+var isServerInstrumented = false;
+var originalGlobalFetch = null;
+function generateEventId() {
+  return "srv_" + Math.random().toString(36).substring(2, 10) + Date.now().toString(36);
+}
+function instrumentServerFetch() {
+  if (process.env.NODE_ENV !== "development") {
+    return () => {
+    };
+  }
+  if (isServerInstrumented || typeof globalThis.fetch === "undefined") {
+    return () => {
+    };
+  }
+  originalGlobalFetch = globalThis.fetch;
+  isServerInstrumented = true;
+  globalThis.fetch = async function(input, init) {
+    if (!originalGlobalFetch) return fetch(input, init);
+    const urlString = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    if (urlString.includes("/__nexttrace") || urlString.includes("/_next/")) {
+      return originalGlobalFetch.call(globalThis, input, init);
+    }
+    const eventId = generateEventId();
+    const startTime = performance.now();
+    const timestamp = Date.now();
+    let method = "GET";
+    const rawHeaders = {};
+    let reqBodyText = null;
+    if (init) {
+      if (init.method) method = init.method.toUpperCase();
+      if (init.headers) {
+        if (init.headers instanceof Headers) {
+          init.headers.forEach((v, k) => {
+            rawHeaders[k] = v;
+          });
+        } else if (Array.isArray(init.headers)) {
+          init.headers.forEach(([k, v]) => {
+            rawHeaders[k] = v;
+          });
+        } else {
+          Object.entries(init.headers).forEach(([k, v]) => {
+            rawHeaders[k] = String(v);
+          });
+        }
+      }
+      if (init.body && typeof init.body === "string") {
+        reqBodyText = init.body;
+      }
+    }
+    const { sanitizedUrl, queryParams, wasRedacted: queryRedacted } = (0, import_core.sanitizeUrlAndQuery)(
+      urlString,
+      import_core.DEFAULT_DENY_QUERY_PARAMS
+    );
+    const { sanitized: sanitizedReqHeaders, wasRedacted: headersRedacted } = (0, import_core.redactHeaders)(
+      rawHeaders,
+      import_core.DEFAULT_DENY_HEADERS
+    );
+    const { preview: reqBodyPreview, wasRedacted: bodyRedacted } = (0, import_core.sanitizeBodyPreview)(
+      reqBodyText,
+      25e3,
+      import_core.DEFAULT_DENY_JSON_KEYS
+    );
+    const event = {
+      schemaVersion: "1.0.0",
+      eventId,
+      timestamp,
+      phase: "start",
+      runtime: "node",
+      sourceAdapter: "server-fetch",
+      request: {
+        method,
+        url: urlString,
+        sanitizedUrl,
+        queryParams,
+        headers: sanitizedReqHeaders,
+        bodyPreview: reqBodyPreview,
+        bodySize: reqBodyText ? reqBodyText.length : 0,
+        isTruncated: false
+      },
+      timing: {
+        startTime
+      },
+      context: {
+        attributionMethod: "stack-derived",
+        confidence: "medium"
+      },
+      flags: {
+        isInternal: false,
+        isRedacted: queryRedacted || headersRedacted || bodyRedacted,
+        isTruncated: false,
+        isInferred: false
+      }
+    };
+    serverEventQueue.push(event);
+    if (serverEventQueue.length > MAX_SERVER_EVENTS) {
+      serverEventQueue.shift();
+    }
+    try {
+      const response = await originalGlobalFetch.call(globalThis, input, init);
+      const endTime = performance.now();
+      const duration = Math.round(endTime - startTime);
+      const resHeaders = {};
+      response.headers.forEach((v, k) => {
+        resHeaders[k] = v;
+      });
+      const { sanitized: sanitizedResHeaders, wasRedacted: resHeadersRedacted } = (0, import_core.redactHeaders)(
+        resHeaders,
+        import_core.DEFAULT_DENY_HEADERS
+      );
+      const contentType = response.headers.get("content-type") || "";
+      let resBodyPreview = null;
+      if (contentType.includes("application/json") || contentType.includes("text/")) {
+        try {
+          const clone = response.clone();
+          const raw = await clone.text();
+          const sanitized = (0, import_core.sanitizeBodyPreview)(raw, 25e3, import_core.DEFAULT_DENY_JSON_KEYS);
+          resBodyPreview = sanitized.preview;
+        } catch {
+        }
+      }
+      event.phase = response.ok ? "complete" : "error";
+      event.timing.endTime = endTime;
+      event.timing.duration = duration;
+      event.flags.isSlow = duration >= 1e3;
+      event.flags.isRedacted = event.flags.isRedacted || resHeadersRedacted;
+      event.response = {
+        status: response.status,
+        statusText: response.statusText,
+        headers: sanitizedResHeaders,
+        bodyPreview: resBodyPreview,
+        contentType,
+        bodySize: resBodyPreview ? resBodyPreview.length : 0,
+        isTruncated: false
+      };
+      return response;
+    } catch (err) {
+      const endTime = performance.now();
+      event.phase = "error";
+      event.timing.endTime = endTime;
+      event.timing.duration = Math.round(endTime - startTime);
+      event.error = {
+        name: err instanceof Error ? err.name : "ServerError",
+        message: err instanceof Error ? err.message : String(err)
+      };
+      throw err;
+    }
+  };
+  return () => {
+    if (isServerInstrumented && originalGlobalFetch) {
+      globalThis.fetch = originalGlobalFetch;
+      originalGlobalFetch = null;
+      isServerInstrumented = false;
+    }
+  };
+}
+function createNextTraceRouteHandler() {
+  return async function GET() {
+    if (process.env.NODE_ENV !== "development") {
+      return new Response(JSON.stringify({ error: "Forbidden in production" }), {
+        status: 403,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    const events = [...serverEventQueue];
+    serverEventQueue.length = 0;
+    return new Response(JSON.stringify({ events }), {
+      status: 200,
+      headers: {
+        "Content-Type": "application/json",
+        "Cache-Control": "no-store, no-cache",
+        "x-nexttrace-internal": "true"
+      }
+    });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNextTraceRouteHandler,
+  instrumentServerFetch
+});

package/dist/server.mjs ADDED Viewed

@@ -0,0 +1,190 @@
+// src/server.ts
+import {
+  redactHeaders,
+  sanitizeUrlAndQuery,
+  sanitizeBodyPreview,
+  DEFAULT_DENY_HEADERS,
+  DEFAULT_DENY_QUERY_PARAMS,
+  DEFAULT_DENY_JSON_KEYS
+} from "@nexttrace/core";
+var serverEventQueue = [];
+var MAX_SERVER_EVENTS = 100;
+var isServerInstrumented = false;
+var originalGlobalFetch = null;
+function generateEventId() {
+  return "srv_" + Math.random().toString(36).substring(2, 10) + Date.now().toString(36);
+}
+function instrumentServerFetch() {
+  if (process.env.NODE_ENV !== "development") {
+    return () => {
+    };
+  }
+  if (isServerInstrumented || typeof globalThis.fetch === "undefined") {
+    return () => {
+    };
+  }
+  originalGlobalFetch = globalThis.fetch;
+  isServerInstrumented = true;
+  globalThis.fetch = async function(input, init) {
+    if (!originalGlobalFetch) return fetch(input, init);
+    const urlString = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    if (urlString.includes("/__nexttrace") || urlString.includes("/_next/")) {
+      return originalGlobalFetch.call(globalThis, input, init);
+    }
+    const eventId = generateEventId();
+    const startTime = performance.now();
+    const timestamp = Date.now();
+    let method = "GET";
+    const rawHeaders = {};
+    let reqBodyText = null;
+    if (init) {
+      if (init.method) method = init.method.toUpperCase();
+      if (init.headers) {
+        if (init.headers instanceof Headers) {
+          init.headers.forEach((v, k) => {
+            rawHeaders[k] = v;
+          });
+        } else if (Array.isArray(init.headers)) {
+          init.headers.forEach(([k, v]) => {
+            rawHeaders[k] = v;
+          });
+        } else {
+          Object.entries(init.headers).forEach(([k, v]) => {
+            rawHeaders[k] = String(v);
+          });
+        }
+      }
+      if (init.body && typeof init.body === "string") {
+        reqBodyText = init.body;
+      }
+    }
+    const { sanitizedUrl, queryParams, wasRedacted: queryRedacted } = sanitizeUrlAndQuery(
+      urlString,
+      DEFAULT_DENY_QUERY_PARAMS
+    );
+    const { sanitized: sanitizedReqHeaders, wasRedacted: headersRedacted } = redactHeaders(
+      rawHeaders,
+      DEFAULT_DENY_HEADERS
+    );
+    const { preview: reqBodyPreview, wasRedacted: bodyRedacted } = sanitizeBodyPreview(
+      reqBodyText,
+      25e3,
+      DEFAULT_DENY_JSON_KEYS
+    );
+    const event = {
+      schemaVersion: "1.0.0",
+      eventId,
+      timestamp,
+      phase: "start",
+      runtime: "node",
+      sourceAdapter: "server-fetch",
+      request: {
+        method,
+        url: urlString,
+        sanitizedUrl,
+        queryParams,
+        headers: sanitizedReqHeaders,
+        bodyPreview: reqBodyPreview,
+        bodySize: reqBodyText ? reqBodyText.length : 0,
+        isTruncated: false
+      },
+      timing: {
+        startTime
+      },
+      context: {
+        attributionMethod: "stack-derived",
+        confidence: "medium"
+      },
+      flags: {
+        isInternal: false,
+        isRedacted: queryRedacted || headersRedacted || bodyRedacted,
+        isTruncated: false,
+        isInferred: false
+      }
+    };
+    serverEventQueue.push(event);
+    if (serverEventQueue.length > MAX_SERVER_EVENTS) {
+      serverEventQueue.shift();
+    }
+    try {
+      const response = await originalGlobalFetch.call(globalThis, input, init);
+      const endTime = performance.now();
+      const duration = Math.round(endTime - startTime);
+      const resHeaders = {};
+      response.headers.forEach((v, k) => {
+        resHeaders[k] = v;
+      });
+      const { sanitized: sanitizedResHeaders, wasRedacted: resHeadersRedacted } = redactHeaders(
+        resHeaders,
+        DEFAULT_DENY_HEADERS
+      );
+      const contentType = response.headers.get("content-type") || "";
+      let resBodyPreview = null;
+      if (contentType.includes("application/json") || contentType.includes("text/")) {
+        try {
+          const clone = response.clone();
+          const raw = await clone.text();
+          const sanitized = sanitizeBodyPreview(raw, 25e3, DEFAULT_DENY_JSON_KEYS);
+          resBodyPreview = sanitized.preview;
+        } catch {
+        }
+      }
+      event.phase = response.ok ? "complete" : "error";
+      event.timing.endTime = endTime;
+      event.timing.duration = duration;
+      event.flags.isSlow = duration >= 1e3;
+      event.flags.isRedacted = event.flags.isRedacted || resHeadersRedacted;
+      event.response = {
+        status: response.status,
+        statusText: response.statusText,
+        headers: sanitizedResHeaders,
+        bodyPreview: resBodyPreview,
+        contentType,
+        bodySize: resBodyPreview ? resBodyPreview.length : 0,
+        isTruncated: false
+      };
+      return response;
+    } catch (err) {
+      const endTime = performance.now();
+      event.phase = "error";
+      event.timing.endTime = endTime;
+      event.timing.duration = Math.round(endTime - startTime);
+      event.error = {
+        name: err instanceof Error ? err.name : "ServerError",
+        message: err instanceof Error ? err.message : String(err)
+      };
+      throw err;
+    }
+  };
+  return () => {
+    if (isServerInstrumented && originalGlobalFetch) {
+      globalThis.fetch = originalGlobalFetch;
+      originalGlobalFetch = null;
+      isServerInstrumented = false;
+    }
+  };
+}
+function createNextTraceRouteHandler() {
+  return async function GET() {
+    if (process.env.NODE_ENV !== "development") {
+      return new Response(JSON.stringify({ error: "Forbidden in production" }), {
+        status: 403,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    const events = [...serverEventQueue];
+    serverEventQueue.length = 0;
+    return new Response(JSON.stringify({ events }), {
+      status: 200,
+      headers: {
+        "Content-Type": "application/json",
+        "Cache-Control": "no-store, no-cache",
+        "x-nexttrace-internal": "true"
+      }
+    });
+  };
+}
+export {
+  createNextTraceRouteHandler,
+  instrumentServerFetch
+};

package/package.json ADDED Viewed

@@ -0,0 +1,60 @@
+{
+  "name": "@nexttrace/next",
+  "version": "0.1.0",
+  "description": "Next.js integration for NextTrace with dev-only gating, server fetch collection, and overlay component",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.mjs",
+      "require": "./dist/server.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "nextjs",
+    "app-router",
+    "devtools",
+    "nexttrace",
+    "tracing"
+  ],
+  "author": "NextTrace Team",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@nexttrace/core": "0.1.0",
+    "@nexttrace/devtools": "0.1.0"
+  },
+  "peerDependencies": {
+    "next": ">=13.0.0 || >=14.0.0 || >=15.0.0",
+    "react": ">=18.0.0 || >=19.0.0",
+    "react-dom": ">=18.0.0 || >=19.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "@types/react": "^18.3.5",
+    "@types/react-dom": "^18.3.0",
+    "next": "^14.2.13",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "tsup": "^8.2.4",
+    "typescript": "^5.5.4"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "lint": "tsc --noEmit",
+    "typecheck": "tsc --noEmit"
+  }
+}