@vigilon/nextjs 0.0.0-stage → 0.2.15

package/dist/index.cjs

@@ -0,0 +1,86 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client/index.ts
+var client_exports = {};
+__export(client_exports, {
+  init: () => init,
+  linkServerTrace: () => linkServerTrace,
+  useReportError: () => useReportError
+});
+module.exports = __toCommonJS(client_exports);
+__reExport(client_exports, require("@vigilon/react"), module.exports);
+
+// src/client/init.ts
+var import_react = require("@vigilon/react");
+function init(options) {
+  const serverTrace = readServerTrace();
+  if (serverTrace === null) {
+    return (0, import_react.init)(options);
+  }
+  const { beforeSend } = options;
+  return (0, import_react.init)({
+    ...options,
+    beforeSend: (event) => {
+      const linked = linkServerTrace(event, serverTrace);
+      return beforeSend ? beforeSend(linked) : linked;
+    }
+  });
+}
+function readServerTrace() {
+  var _a;
+  if (typeof document === "undefined") {
+    return null;
+  }
+  const content = (_a = document.querySelector('meta[name="traceparent"]')) == null ? void 0 : _a.getAttribute("content");
+  const traceId = content == null ? void 0 : content.split("-")[1];
+  if (!traceId || !/^[0-9a-f]{32}$/.test(traceId) || /^0+$/.test(traceId)) {
+    return null;
+  }
+  return { traceId, url: withoutFragment(window.location.href) };
+}
+function linkServerTrace(event, serverTrace) {
+  if (event.traceId || withoutFragment(String(event.page.url)) !== serverTrace.url) {
+    return event;
+  }
+  return { ...event, traceId: serverTrace.traceId };
+}
+function withoutFragment(url) {
+  const hash = url.indexOf("#");
+  return hash === -1 ? url : url.slice(0, hash);
+}
+
+// src/client/use-report-error.ts
+var import_react2 = require("@vigilon/react");
+var import_react3 = require("react");
+function useReportError(error) {
+  (0, import_react3.useEffect)(() => {
+    (0, import_react2.captureException)(error, { mechanism: "react_error_boundary", handled: true });
+  }, [error]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  init,
+  linkServerTrace,
+  useReportError,
+  ...require("@vigilon/react")
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client/index.ts","../src/client/init.ts","../src/client/use-report-error.ts"],"sourcesContent":["/**\n * @vigilon/nextjs: the browser half, for instrumentation-client.ts and client\n * components. Re-exports @vigilon/react, with an init() that links events to\n * the server request that rendered the page.\n */\nexport * from \"@vigilon/react\";\nexport { init, linkServerTrace } from \"./init\";\nexport { useReportError } from \"./use-report-error\";\n","import { type BrowserEvent, init as initBrowser, type VigilonBrowserOptions } from \"@vigilon/react\";\n\n/**\n * Starts error monitoring in the browser, as @vigilon/browser's init() does.\n * With `withVigilon()` in next.config, Next.js renders the trace ID of the\n * request that rendered the page in a `traceparent` meta tag; every event\n * captured before the first client-side navigation carries it, so a hydration\n * or early render error links to its server trace.\n */\nexport function init(options: VigilonBrowserOptions): boolean {\n  const serverTrace = readServerTrace();\n  if (serverTrace === null) {\n    return initBrowser(options);\n  }\n  const { beforeSend } = options;\n  return initBrowser({\n    ...options,\n    beforeSend: (event) => {\n      const linked = linkServerTrace(event, serverTrace);\n      return beforeSend ? beforeSend(linked) : linked;\n    },\n  });\n}\n\ninterface ServerTrace {\n  traceId: string;\n  /** The page URL the server rendered, without its fragment. */\n  url: string;\n}\n\nfunction readServerTrace(): ServerTrace | null {\n  if (typeof document === \"undefined\") {\n    return null;\n  }\n  const content = document.querySelector('meta[name=\"traceparent\"]')?.getAttribute(\"content\");\n  // W3C traceparent: version-traceid-parentid-flags.\n  const traceId = content?.split(\"-\")[1];\n  if (!traceId || !/^[0-9a-f]{32}$/.test(traceId) || /^0+$/.test(traceId)) {\n    return null;\n  }\n  return { traceId, url: withoutFragment(window.location.href) };\n}\n\n/**\n * The trace belongs to the request that rendered the page, so it applies only\n * while the browser is still on that page's URL.\n */\nexport function linkServerTrace(event: BrowserEvent, serverTrace: ServerTrace): BrowserEvent {\n  if (event.traceId || withoutFragment(String(event.page.url)) !== serverTrace.url) {\n    return event;\n  }\n  return { ...event, traceId: serverTrace.traceId };\n}\n\nfunction withoutFragment(url: string): string {\n  const hash = url.indexOf(\"#\");\n  return hash === -1 ? url : url.slice(0, hash);\n}\n","import { captureException } from \"@vigilon/react\";\nimport { useEffect } from \"react\";\n\n/**\n * Reports the error an `error.tsx` or `global-error.tsx` boundary received.\n * Next.js creates the React root itself, so @vigilon/react's\n * rootErrorHandlers cannot be passed to it; this hook reports what those\n * boundaries catch instead.\n *\n * ```tsx\n * \"use client\";\n * export default function GlobalError({ error }: { error: Error & { digest?: string } }) {\n *   useReportError(error);\n *   return <html><body><h2>Something went wrong.</h2></body></html>;\n * }\n * ```\n */\nexport function useReportError(error: unknown): void {\n  useEffect(() => {\n    captureException(error, { mechanism: \"react_error_boundary\", handled: true });\n  }, [error]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,2BAAc,2BALd;;;ACAA,mBAAmF;AAS5E,SAAS,KAAK,SAAyC;AAC5D,QAAM,cAAc,gBAAgB;AACpC,MAAI,gBAAgB,MAAM;AACxB,eAAO,aAAAA,MAAY,OAAO;AAAA,EAC5B;AACA,QAAM,EAAE,WAAW,IAAI;AACvB,aAAO,aAAAA,MAAY;AAAA,IACjB,GAAG;AAAA,IACH,YAAY,CAAC,UAAU;AACrB,YAAM,SAAS,gBAAgB,OAAO,WAAW;AACjD,aAAO,aAAa,WAAW,MAAM,IAAI;AAAA,IAC3C;AAAA,EACF,CAAC;AACH;AAQA,SAAS,kBAAsC;AA9B/C;AA+BE,MAAI,OAAO,aAAa,aAAa;AACnC,WAAO;AAAA,EACT;AACA,QAAM,WAAU,cAAS,cAAc,0BAA0B,MAAjD,mBAAoD,aAAa;AAEjF,QAAM,UAAU,mCAAS,MAAM,KAAK;AACpC,MAAI,CAAC,WAAW,CAAC,iBAAiB,KAAK,OAAO,KAAK,OAAO,KAAK,OAAO,GAAG;AACvE,WAAO;AAAA,EACT;AACA,SAAO,EAAE,SAAS,KAAK,gBAAgB,OAAO,SAAS,IAAI,EAAE;AAC/D;AAMO,SAAS,gBAAgB,OAAqB,aAAwC;AAC3F,MAAI,MAAM,WAAW,gBAAgB,OAAO,MAAM,KAAK,GAAG,CAAC,MAAM,YAAY,KAAK;AAChF,WAAO;AAAA,EACT;AACA,SAAO,EAAE,GAAG,OAAO,SAAS,YAAY,QAAQ;AAClD;AAEA,SAAS,gBAAgB,KAAqB;AAC5C,QAAM,OAAO,IAAI,QAAQ,GAAG;AAC5B,SAAO,SAAS,KAAK,MAAM,IAAI,MAAM,GAAG,IAAI;AAC9C;;;ACzDA,IAAAC,gBAAiC;AACjC,IAAAA,gBAA0B;AAgBnB,SAAS,eAAe,OAAsB;AACnD,+BAAU,MAAM;AACd,wCAAiB,OAAO,EAAE,WAAW,wBAAwB,SAAS,KAAK,CAAC;AAAA,EAC9E,GAAG,CAAC,KAAK,CAAC;AACZ;","names":["initBrowser","import_react"]}

package/dist/index.d.mts

@@ -0,0 +1,39 @@
+import { VigilonBrowserOptions, BrowserEvent } from '@vigilon/react';
+export * from '@vigilon/react';
+
+/**
+ * Starts error monitoring in the browser, as @vigilon/browser's init() does.
+ * With `withVigilon()` in next.config, Next.js renders the trace ID of the
+ * request that rendered the page in a `traceparent` meta tag; every event
+ * captured before the first client-side navigation carries it, so a hydration
+ * or early render error links to its server trace.
+ */
+declare function init(options: VigilonBrowserOptions): boolean;
+interface ServerTrace {
+    traceId: string;
+    /** The page URL the server rendered, without its fragment. */
+    url: string;
+}
+/**
+ * The trace belongs to the request that rendered the page, so it applies only
+ * while the browser is still on that page's URL.
+ */
+declare function linkServerTrace(event: BrowserEvent, serverTrace: ServerTrace): BrowserEvent;
+
+/**
+ * Reports the error an `error.tsx` or `global-error.tsx` boundary received.
+ * Next.js creates the React root itself, so @vigilon/react's
+ * rootErrorHandlers cannot be passed to it; this hook reports what those
+ * boundaries catch instead.
+ *
+ * ```tsx
+ * "use client";
+ * export default function GlobalError({ error }: { error: Error & { digest?: string } }) {
+ *   useReportError(error);
+ *   return <html><body><h2>Something went wrong.</h2></body></html>;
+ * }
+ * ```
+ */
+declare function useReportError(error: unknown): void;
+
+export { init, linkServerTrace, useReportError };

package/dist/index.d.ts

@@ -0,0 +1,39 @@
+import { VigilonBrowserOptions, BrowserEvent } from '@vigilon/react';
+export * from '@vigilon/react';
+
+/**
+ * Starts error monitoring in the browser, as @vigilon/browser's init() does.
+ * With `withVigilon()` in next.config, Next.js renders the trace ID of the
+ * request that rendered the page in a `traceparent` meta tag; every event
+ * captured before the first client-side navigation carries it, so a hydration
+ * or early render error links to its server trace.
+ */
+declare function init(options: VigilonBrowserOptions): boolean;
+interface ServerTrace {
+    traceId: string;
+    /** The page URL the server rendered, without its fragment. */
+    url: string;
+}
+/**
+ * The trace belongs to the request that rendered the page, so it applies only
+ * while the browser is still on that page's URL.
+ */
+declare function linkServerTrace(event: BrowserEvent, serverTrace: ServerTrace): BrowserEvent;
+
+/**
+ * Reports the error an `error.tsx` or `global-error.tsx` boundary received.
+ * Next.js creates the React root itself, so @vigilon/react's
+ * rootErrorHandlers cannot be passed to it; this hook reports what those
+ * boundaries catch instead.
+ *
+ * ```tsx
+ * "use client";
+ * export default function GlobalError({ error }: { error: Error & { digest?: string } }) {
+ *   useReportError(error);
+ *   return <html><body><h2>Something went wrong.</h2></body></html>;
+ * }
+ * ```
+ */
+declare function useReportError(error: unknown): void;
+
+export { init, linkServerTrace, useReportError };

package/dist/index.mjs

@@ -0,0 +1,58 @@
+"use client";
+
+// src/client/index.ts
+export * from "@vigilon/react";
+
+// src/client/init.ts
+import { init as initBrowser } from "@vigilon/react";
+function init(options) {
+  const serverTrace = readServerTrace();
+  if (serverTrace === null) {
+    return initBrowser(options);
+  }
+  const { beforeSend } = options;
+  return initBrowser({
+    ...options,
+    beforeSend: (event) => {
+      const linked = linkServerTrace(event, serverTrace);
+      return beforeSend ? beforeSend(linked) : linked;
+    }
+  });
+}
+function readServerTrace() {
+  var _a;
+  if (typeof document === "undefined") {
+    return null;
+  }
+  const content = (_a = document.querySelector('meta[name="traceparent"]')) == null ? void 0 : _a.getAttribute("content");
+  const traceId = content == null ? void 0 : content.split("-")[1];
+  if (!traceId || !/^[0-9a-f]{32}$/.test(traceId) || /^0+$/.test(traceId)) {
+    return null;
+  }
+  return { traceId, url: withoutFragment(window.location.href) };
+}
+function linkServerTrace(event, serverTrace) {
+  if (event.traceId || withoutFragment(String(event.page.url)) !== serverTrace.url) {
+    return event;
+  }
+  return { ...event, traceId: serverTrace.traceId };
+}
+function withoutFragment(url) {
+  const hash = url.indexOf("#");
+  return hash === -1 ? url : url.slice(0, hash);
+}
+
+// src/client/use-report-error.ts
+import { captureException } from "@vigilon/react";
+import { useEffect } from "react";
+function useReportError(error) {
+  useEffect(() => {
+    captureException(error, { mechanism: "react_error_boundary", handled: true });
+  }, [error]);
+}
+export {
+  init,
+  linkServerTrace,
+  useReportError
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/client/index.ts","../src/client/init.ts","../src/client/use-report-error.ts"],"sourcesContent":["/**\n * @vigilon/nextjs: the browser half, for instrumentation-client.ts and client\n * components. Re-exports @vigilon/react, with an init() that links events to\n * the server request that rendered the page.\n */\nexport * from \"@vigilon/react\";\nexport { init, linkServerTrace } from \"./init\";\nexport { useReportError } from \"./use-report-error\";\n","import { type BrowserEvent, init as initBrowser, type VigilonBrowserOptions } from \"@vigilon/react\";\n\n/**\n * Starts error monitoring in the browser, as @vigilon/browser's init() does.\n * With `withVigilon()` in next.config, Next.js renders the trace ID of the\n * request that rendered the page in a `traceparent` meta tag; every event\n * captured before the first client-side navigation carries it, so a hydration\n * or early render error links to its server trace.\n */\nexport function init(options: VigilonBrowserOptions): boolean {\n  const serverTrace = readServerTrace();\n  if (serverTrace === null) {\n    return initBrowser(options);\n  }\n  const { beforeSend } = options;\n  return initBrowser({\n    ...options,\n    beforeSend: (event) => {\n      const linked = linkServerTrace(event, serverTrace);\n      return beforeSend ? beforeSend(linked) : linked;\n    },\n  });\n}\n\ninterface ServerTrace {\n  traceId: string;\n  /** The page URL the server rendered, without its fragment. */\n  url: string;\n}\n\nfunction readServerTrace(): ServerTrace | null {\n  if (typeof document === \"undefined\") {\n    return null;\n  }\n  const content = document.querySelector('meta[name=\"traceparent\"]')?.getAttribute(\"content\");\n  // W3C traceparent: version-traceid-parentid-flags.\n  const traceId = content?.split(\"-\")[1];\n  if (!traceId || !/^[0-9a-f]{32}$/.test(traceId) || /^0+$/.test(traceId)) {\n    return null;\n  }\n  return { traceId, url: withoutFragment(window.location.href) };\n}\n\n/**\n * The trace belongs to the request that rendered the page, so it applies only\n * while the browser is still on that page's URL.\n */\nexport function linkServerTrace(event: BrowserEvent, serverTrace: ServerTrace): BrowserEvent {\n  if (event.traceId || withoutFragment(String(event.page.url)) !== serverTrace.url) {\n    return event;\n  }\n  return { ...event, traceId: serverTrace.traceId };\n}\n\nfunction withoutFragment(url: string): string {\n  const hash = url.indexOf(\"#\");\n  return hash === -1 ? url : url.slice(0, hash);\n}\n","import { captureException } from \"@vigilon/react\";\nimport { useEffect } from \"react\";\n\n/**\n * Reports the error an `error.tsx` or `global-error.tsx` boundary received.\n * Next.js creates the React root itself, so @vigilon/react's\n * rootErrorHandlers cannot be passed to it; this hook reports what those\n * boundaries catch instead.\n *\n * ```tsx\n * \"use client\";\n * export default function GlobalError({ error }: { error: Error & { digest?: string } }) {\n *   useReportError(error);\n *   return <html><body><h2>Something went wrong.</h2></body></html>;\n * }\n * ```\n */\nexport function useReportError(error: unknown): void {\n  useEffect(() => {\n    captureException(error, { mechanism: \"react_error_boundary\", handled: true });\n  }, [error]);\n}\n"],"mappings":";;;AAKA,cAAc;;;ACLd,SAA4B,QAAQ,mBAA+C;AAS5E,SAAS,KAAK,SAAyC;AAC5D,QAAM,cAAc,gBAAgB;AACpC,MAAI,gBAAgB,MAAM;AACxB,WAAO,YAAY,OAAO;AAAA,EAC5B;AACA,QAAM,EAAE,WAAW,IAAI;AACvB,SAAO,YAAY;AAAA,IACjB,GAAG;AAAA,IACH,YAAY,CAAC,UAAU;AACrB,YAAM,SAAS,gBAAgB,OAAO,WAAW;AACjD,aAAO,aAAa,WAAW,MAAM,IAAI;AAAA,IAC3C;AAAA,EACF,CAAC;AACH;AAQA,SAAS,kBAAsC;AA9B/C;AA+BE,MAAI,OAAO,aAAa,aAAa;AACnC,WAAO;AAAA,EACT;AACA,QAAM,WAAU,cAAS,cAAc,0BAA0B,MAAjD,mBAAoD,aAAa;AAEjF,QAAM,UAAU,mCAAS,MAAM,KAAK;AACpC,MAAI,CAAC,WAAW,CAAC,iBAAiB,KAAK,OAAO,KAAK,OAAO,KAAK,OAAO,GAAG;AACvE,WAAO;AAAA,EACT;AACA,SAAO,EAAE,SAAS,KAAK,gBAAgB,OAAO,SAAS,IAAI,EAAE;AAC/D;AAMO,SAAS,gBAAgB,OAAqB,aAAwC;AAC3F,MAAI,MAAM,WAAW,gBAAgB,OAAO,MAAM,KAAK,GAAG,CAAC,MAAM,YAAY,KAAK;AAChF,WAAO;AAAA,EACT;AACA,SAAO,EAAE,GAAG,OAAO,SAAS,YAAY,QAAQ;AAClD;AAEA,SAAS,gBAAgB,KAAqB;AAC5C,QAAM,OAAO,IAAI,QAAQ,GAAG;AAC5B,SAAO,SAAS,KAAK,MAAM,IAAI,MAAM,GAAG,IAAI;AAC9C;;;ACzDA,SAAS,wBAAwB;AACjC,SAAS,iBAAiB;AAgBnB,SAAS,eAAe,OAAsB;AACnD,YAAU,MAAM;AACd,qBAAiB,OAAO,EAAE,WAAW,wBAAwB,SAAS,KAAK,CAAC;AAAA,EAC9E,GAAG,CAAC,KAAK,CAAC;AACZ;","names":[]}

package/dist/server.cjs

@@ -0,0 +1,224 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server/index.ts
+var server_exports = {};
+__export(server_exports, {
+  HTTP_RESPONSE_STATUS_CODE_ATTRIBUTE: () => HTTP_RESPONSE_STATUS_CODE_ATTRIBUTE,
+  HTTP_ROUTE_ATTRIBUTE: () => HTTP_ROUTE_ATTRIBUTE,
+  NEXT_ROUTE_ATTRIBUTE: () => NEXT_ROUTE_ATTRIBUTE,
+  NextRouteSpanProcessor: () => NextRouteSpanProcessor,
+  VercelFlushSpanProcessor: () => VercelFlushSpanProcessor,
+  VercelResponseStatusProcessor: () => VercelResponseStatusProcessor,
+  patchServerResponseStatus: () => patchServerResponseStatus,
+  register: () => register
+});
+module.exports = __toCommonJS(server_exports);
+__reExport(server_exports, require("@vigilon/node"), module.exports);
+
+// src/server/register.ts
+var import_node = require("@vigilon/node");
+
+// src/server/nextRouteSpanProcessor.ts
+var import_api = require("@opentelemetry/api");
+var import_core = require("@opentelemetry/core");
+var NEXT_ROUTE_ATTRIBUTE = "next.route";
+var HTTP_ROUTE_ATTRIBUTE = "http.route";
+var NEXT_SPAN_TYPE_ATTRIBUTE = "next.span_type";
+var NEXT_ENTRY_SPAN_TYPE = "BaseServer.handleRequest";
+var NextRouteSpanProcessor = class {
+  onStart(span, parentContext) {
+    const route = span.attributes[NEXT_ROUTE_ATTRIBUTE];
+    if (typeof route !== "string" || route.length === 0) return;
+    const rpcMetadata = (0, import_core.getRPCMetadata)(parentContext);
+    if (rpcMetadata?.type === import_core.RPCType.HTTP) {
+      rpcMetadata.route = route;
+    }
+    const parentSpan = import_api.trace.getSpan(parentContext);
+    if (!parentSpan?.isRecording()) return;
+    const parentAttributes = parentSpan.attributes;
+    if (parentAttributes?.[NEXT_SPAN_TYPE_ATTRIBUTE] === NEXT_ENTRY_SPAN_TYPE && parentAttributes[HTTP_ROUTE_ATTRIBUTE] === void 0) {
+      parentSpan.setAttribute(HTTP_ROUTE_ATTRIBUTE, route);
+      parentSpan.setAttribute(NEXT_ROUTE_ATTRIBUTE, route);
+    }
+  }
+  onEnd() {
+  }
+  forceFlush() {
+    return Promise.resolve();
+  }
+  shutdown() {
+    return Promise.resolve();
+  }
+};
+
+// src/server/entrySpan.ts
+var import_api2 = require("@opentelemetry/api");
+function isEntrySpan(span) {
+  if (span.kind !== import_api2.SpanKind.SERVER) return false;
+  const parent = span.parentSpanContext;
+  return !parent || parent.isRemote === true;
+}
+
+// src/server/vercelFlushSpanProcessor.ts
+var VERCEL_REQUEST_CONTEXT = /* @__PURE__ */ Symbol.for("@vercel/request-context");
+var KEEP_ALIVE_TIMEOUT_MS = 15e3;
+function vercelWaitUntil(promise) {
+  const requestContext = globalThis[VERCEL_REQUEST_CONTEXT];
+  requestContext?.get?.()?.waitUntil?.(promise);
+}
+var VercelFlushSpanProcessor = class {
+  constructor(flushables) {
+    this.flushables = flushables;
+    this.keepAlives = /* @__PURE__ */ new Map();
+  }
+  onStart(span, _parentContext) {
+    if (!isEntrySpan(span)) return;
+    let resolveKeepAlive;
+    const keepAlive = new Promise((resolve) => {
+      resolveKeepAlive = resolve;
+    });
+    vercelWaitUntil(keepAlive);
+    const backstop = setTimeout(resolveKeepAlive, KEEP_ALIVE_TIMEOUT_MS);
+    backstop.unref?.();
+    this.keepAlives.set(span.spanContext().spanId, () => {
+      clearTimeout(backstop);
+      resolveKeepAlive();
+    });
+  }
+  onEnd(span) {
+    if (!isEntrySpan(span)) return;
+    const spanId = span.spanContext().spanId;
+    const release = this.keepAlives.get(spanId);
+    this.keepAlives.delete(spanId);
+    const exportDone = Promise.allSettled(
+      this.flushables.map((flushable) => flushable.forceFlush())
+    ).then(() => void 0);
+    if (release) void exportDone.finally(release);
+  }
+  forceFlush() {
+    return Promise.resolve();
+  }
+  shutdown() {
+    for (const release of this.keepAlives.values()) release();
+    this.keepAlives.clear();
+    return Promise.resolve();
+  }
+};
+
+// src/server/vercelResponseStatusProcessor.ts
+var http = __toESM(require("http"));
+var import_api3 = require("@opentelemetry/api");
+var HTTP_RESPONSE_STATUS_CODE_ATTRIBUTE = "http.response.status_code";
+var VercelResponseStatusProcessor = class {
+  constructor() {
+    this.entrySpans = /* @__PURE__ */ new Map();
+  }
+  onStart(span, _parentContext) {
+    if (!isEntrySpan(span)) return;
+    this.entrySpans.set(span.spanContext().traceId, span);
+  }
+  onEnd(span) {
+    if (!isEntrySpan(span)) return;
+    this.entrySpans.delete(span.spanContext().traceId);
+  }
+  /** Called from the ServerResponse patch when a response's head is written. */
+  recordStatus(statusCode) {
+    const traceId = import_api3.trace.getActiveSpan()?.spanContext().traceId;
+    if (!traceId) return;
+    const entrySpan = this.entrySpans.get(traceId);
+    if (entrySpan?.isRecording()) {
+      entrySpan.setAttribute(HTTP_RESPONSE_STATUS_CODE_ATTRIBUTE, statusCode);
+    }
+  }
+  forceFlush() {
+    return Promise.resolve();
+  }
+  shutdown() {
+    this.entrySpans.clear();
+    return Promise.resolve();
+  }
+};
+var PATCHED_FLAG = /* @__PURE__ */ Symbol.for("vigilon.writeHead.patched");
+function patchServerResponseStatus(processor) {
+  const prototype = http.ServerResponse.prototype;
+  if (prototype[PATCHED_FLAG]) return;
+  prototype[PATCHED_FLAG] = true;
+  const originalWriteHead = prototype.writeHead;
+  prototype.writeHead = function patchedWriteHead(...args) {
+    const statusCode = typeof args[0] === "number" ? args[0] : this.statusCode;
+    try {
+      processor.recordStatus(statusCode);
+    } catch {
+    }
+    return originalWriteHead.apply(this, args);
+  };
+}
+
+// src/server/register.ts
+var NODE_REGISTER_STATE_KEY = /* @__PURE__ */ Symbol.for("vigilon.register.started");
+var NEXTJS_REGISTER_STATE_KEY = /* @__PURE__ */ Symbol.for("vigilon.register.nextjs");
+function register(params = {}) {
+  const globalState = globalThis;
+  if (globalState[NODE_REGISTER_STATE_KEY] && !globalState[NEXTJS_REGISTER_STATE_KEY]) {
+    console.warn(
+      "Vigilon is already registered by plain @vigilon/node (most likely a NODE_OPTIONS preload of @vigilon/node/register), so the Next.js extensions (route attribution and the Vercel runtime fixes) are not active. Preload @vigilon/nextjs/register instead, or remove the preload and register from instrumentation.ts."
+    );
+    return void 0;
+  }
+  const sdk = (0, import_node.register)({
+    ...params,
+    extendSpanProcessors: ({ batchSpanProcessor }) => {
+      const append = [];
+      if (process.env.VERCEL) {
+        append.push(new VercelFlushSpanProcessor([batchSpanProcessor]));
+        const responseStatusProcessor = new VercelResponseStatusProcessor();
+        append.push(responseStatusProcessor);
+        patchServerResponseStatus(responseStatusProcessor);
+      }
+      return { prepend: [new NextRouteSpanProcessor()], append };
+    }
+  });
+  globalState[NEXTJS_REGISTER_STATE_KEY] = true;
+  return sdk;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HTTP_RESPONSE_STATUS_CODE_ATTRIBUTE,
+  HTTP_ROUTE_ATTRIBUTE,
+  NEXT_ROUTE_ATTRIBUTE,
+  NextRouteSpanProcessor,
+  VercelFlushSpanProcessor,
+  VercelResponseStatusProcessor,
+  patchServerResponseStatus,
+  register,
+  ...require("@vigilon/node")
+});
+//# sourceMappingURL=server.cjs.map

package/dist/server.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/server/index.ts","../src/server/register.ts","../src/server/nextRouteSpanProcessor.ts","../src/server/entrySpan.ts","../src/server/vercelFlushSpanProcessor.ts","../src/server/vercelResponseStatusProcessor.ts"],"sourcesContent":["/**\n * @vigilon/nextjs/server: the Node.js runtime half of @vigilon/nextjs, for\n * instrumentation.ts. Re-exports @vigilon/node (recordException,\n * withJobMonitor, and the rest), with a Next.js-aware register().\n */\nexport * from \"@vigilon/node\";\nexport { register, type VigilonNextjsRegisterParams } from \"./register\";\nexport {\n  HTTP_ROUTE_ATTRIBUTE,\n  NEXT_ROUTE_ATTRIBUTE,\n  NextRouteSpanProcessor,\n} from \"./nextRouteSpanProcessor\";\nexport { type Flushable, VercelFlushSpanProcessor } from \"./vercelFlushSpanProcessor\";\nexport {\n  HTTP_RESPONSE_STATUS_CODE_ATTRIBUTE,\n  patchServerResponseStatus,\n  VercelResponseStatusProcessor,\n} from \"./vercelResponseStatusProcessor\";\n","import type { SpanProcessor } from \"@opentelemetry/sdk-trace-node\";\nimport { register as registerNode, type VigilonRegisterParams } from \"@vigilon/node\";\nimport { NextRouteSpanProcessor } from \"./nextRouteSpanProcessor\";\nimport { VercelFlushSpanProcessor } from \"./vercelFlushSpanProcessor\";\nimport {\n  patchServerResponseStatus,\n  VercelResponseStatusProcessor,\n} from \"./vercelResponseStatusProcessor\";\n\nexport type VigilonNextjsRegisterParams = Omit<VigilonRegisterParams, \"extendSpanProcessors\">;\n\n// Shared with @vigilon/node: set once any register() variant has started an\n// SDK in this process.\nconst NODE_REGISTER_STATE_KEY = Symbol.for(\"vigilon.register.started\");\n// Set only by this register(), so a plain @vigilon/node start followed by\n// this call is told apart from a harmless second call of this one.\nconst NEXTJS_REGISTER_STATE_KEY = Symbol.for(\"vigilon.register.nextjs\");\n\n/**\n * Starts Vigilon in the Next.js Node.js runtime: @vigilon/node's register()\n * plus route attribution from Next's own spans and, on Vercel, the\n * end-of-request flush and real response status. Call it from\n * instrumentation.ts. Every parameter is optional, as with @vigilon/node.\n */\nexport function register(\n  params: VigilonNextjsRegisterParams = {},\n): ReturnType<typeof registerNode> {\n  const globalState = globalThis as Record<symbol, unknown>;\n  if (globalState[NODE_REGISTER_STATE_KEY] && !globalState[NEXTJS_REGISTER_STATE_KEY]) {\n    console.warn(\n      \"Vigilon is already registered by plain @vigilon/node (most likely a NODE_OPTIONS preload of @vigilon/node/register), so the Next.js extensions (route attribution and the Vercel runtime fixes) are not active. Preload @vigilon/nextjs/register instead, or remove the preload and register from instrumentation.ts.\",\n    );\n    return undefined;\n  }\n  const sdk = registerNode({\n    ...params,\n    extendSpanProcessors: ({ batchSpanProcessor }) => {\n      const append: SpanProcessor[] = [];\n      // Vercel suspends the instance as soon as the response is sent, which\n      // stops the batch and export timers, so telemetry would leave late or\n      // not at all. Flush when each entry span ends instead. Must come after\n      // the batch processor so the ending span is already enqueued.\n      if (process.env.VERCEL) {\n        append.push(new VercelFlushSpanProcessor([batchSpanProcessor]));\n        // Vercel's bundled Next.js runtime stamps the entry span's status\n        // before the response is written (always 200), so the real status is\n        // recorded from ServerResponse.writeHead instead.\n        const responseStatusProcessor = new VercelResponseStatusProcessor();\n        append.push(responseStatusProcessor);\n        patchServerResponseStatus(responseStatusProcessor);\n      }\n      return { prepend: [new NextRouteSpanProcessor()], append };\n    },\n  });\n  globalState[NEXTJS_REGISTER_STATE_KEY] = true;\n  return sdk;\n}\n","import { Context, trace } from \"@opentelemetry/api\";\nimport { getRPCMetadata, RPCType } from \"@opentelemetry/core\";\nimport {\n  SpanProcessor,\n  Span,\n  ReadableSpan,\n} from \"@opentelemetry/sdk-trace-node\";\n\nexport const NEXT_ROUTE_ATTRIBUTE = \"next.route\";\nexport const HTTP_ROUTE_ATTRIBUTE = \"http.route\";\n\nconst NEXT_SPAN_TYPE_ATTRIBUTE = \"next.span_type\";\nconst NEXT_ENTRY_SPAN_TYPE = \"BaseServer.handleRequest\";\n\n/**\n * Propagates the route Next.js resolves to the two places the rest of the\n * pipeline reads it from, neither of which Next.js reliably fills itself:\n *\n * 1. The incoming request's RPC metadata — where the HTTP instrumentation\n *    reads `http.route` when labelling its server span. Express and Fastify\n *    instrumentations write the matched route there; Next.js never does.\n *\n * 2. Next's own `BaseServer.handleRequest` entry span. Next normally copies\n *    `next.route` onto it via a tracer-internal root-span-attribute store,\n *    but bundled runtimes (Vercel's serverless build) load private copies of\n *    Next's tracer per route chunk, so the route module writes to one store\n *    while the base server reads another and the entry span exports without\n *    a route. Endpoint metrics are collector-derived from entry spans, so\n *    every Vercel request was bucketed as \"unknown\".\n *\n * A span processor is used instead of patching Next's internals because the\n * global tracer provider is the one channel every bundled copy of Next's\n * tracer shares — proven by child spans parenting correctly even where the\n * attribute store is split.\n */\nexport class NextRouteSpanProcessor implements SpanProcessor {\n  onStart(span: Span, parentContext: Context): void {\n    const route = span.attributes[NEXT_ROUTE_ATTRIBUTE];\n    if (typeof route !== \"string\" || route.length === 0) return;\n\n    const rpcMetadata = getRPCMetadata(parentContext);\n    if (rpcMetadata?.type === RPCType.HTTP) {\n      rpcMetadata.route = route;\n    }\n\n    const parentSpan = trace.getSpan(parentContext);\n    if (!parentSpan?.isRecording()) return;\n    // Only SDK spans expose attributes; a NonRecordingSpan (remote or no-op\n    // parent) has none and is skipped by the checks below.\n    const parentAttributes = (parentSpan as unknown as ReadableSpan).attributes;\n    if (\n      parentAttributes?.[NEXT_SPAN_TYPE_ATTRIBUTE] === NEXT_ENTRY_SPAN_TYPE &&\n      parentAttributes[HTTP_ROUTE_ATTRIBUTE] === undefined\n    ) {\n      parentSpan.setAttribute(HTTP_ROUTE_ATTRIBUTE, route);\n      parentSpan.setAttribute(NEXT_ROUTE_ATTRIBUTE, route);\n    }\n  }\n\n  onEnd(): void {}\n\n  forceFlush(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  shutdown(): Promise<void> {\n    return Promise.resolve();\n  }\n}\n","import { SpanKind } from \"@opentelemetry/api\";\nimport { ReadableSpan, Span } from \"@opentelemetry/sdk-trace-node\";\n\n/**\n * A service-entry span: the one SERVER span that marks a request entering\n * this service — its parent is either absent or remote. Matches the\n * definition the collector counts for endpoint metrics.\n */\nexport function isEntrySpan(span: Span | ReadableSpan): boolean {\n  if (span.kind !== SpanKind.SERVER) return false;\n  const parent = (span as ReadableSpan).parentSpanContext;\n  return !parent || parent.isRemote === true;\n}\n","import { Context } from \"@opentelemetry/api\";\nimport { SpanProcessor, Span, ReadableSpan } from \"@opentelemetry/sdk-trace-node\";\nimport { isEntrySpan } from \"./entrySpan\";\n\nexport type Flushable = { forceFlush(): Promise<void> };\n\n// The request-context global that @vercel/functions uses to reach waitUntil.\n// Reading it directly keeps the SDK dependency-free; it is simply absent\n// outside Vercel's runtime.\nconst VERCEL_REQUEST_CONTEXT = Symbol.for(\"@vercel/request-context\");\n\n// Backstop so a request that never ends its entry span (crash, client\n// disconnect edge cases) cannot pin the instance — and its billing — open\n// indefinitely via the keep-alive registered at span start.\nconst KEEP_ALIVE_TIMEOUT_MS = 15_000;\n\nfunction vercelWaitUntil(promise: Promise<unknown>): void {\n  const requestContext = (\n    globalThis as Record<symbol, unknown> as {\n      [VERCEL_REQUEST_CONTEXT]?: {\n        get?: () => { waitUntil?: (p: Promise<unknown>) => void } | undefined;\n      };\n    }\n  )[VERCEL_REQUEST_CONTEXT];\n  requestContext?.get?.()?.waitUntil?.(promise);\n}\n\n/**\n * Exports telemetry at the end of every request instead of trusting timers.\n *\n * Vercel suspends the function instance the moment a response is sent, so the\n * BatchSpanProcessor's export timer rarely gets to run, and even an export\n * started at span end freezes mid-POST: it only completes if another request\n * thaws the instance before the connection dies.\n * Observed in production as \"N consecutive requests record N-1\", \"spaced-out\n * requests record nothing\", and stale spans surfacing alongside later\n * traffic.\n *\n * The keep-alive is therefore registered with Vercel's waitUntil when the\n * entry span STARTS — registrations made after the response settles are\n * silently dropped, and the entry span only ends after that point. The\n * deferred handed to waitUntil at start is resolved once the end-of-request\n * flush completes, so the instance stays alive exactly long enough for the\n * export POST to land.\n *\n * Must be registered AFTER the BatchSpanProcessor: processors run in order,\n * and the entry span must already be enqueued when the flush starts.\n */\nexport class VercelFlushSpanProcessor implements SpanProcessor {\n  private readonly keepAlives = new Map<string, () => void>();\n\n  constructor(private readonly flushables: Flushable[]) {}\n\n  onStart(span: Span, _parentContext: Context): void {\n    if (!isEntrySpan(span)) return;\n\n    let resolveKeepAlive!: () => void;\n    const keepAlive = new Promise<void>((resolve) => {\n      resolveKeepAlive = resolve;\n    });\n    vercelWaitUntil(keepAlive);\n\n    const backstop = setTimeout(resolveKeepAlive, KEEP_ALIVE_TIMEOUT_MS);\n    backstop.unref?.();\n    this.keepAlives.set(span.spanContext().spanId, () => {\n      clearTimeout(backstop);\n      resolveKeepAlive();\n    });\n  }\n\n  onEnd(span: ReadableSpan): void {\n    if (!isEntrySpan(span)) return;\n\n    const spanId = span.spanContext().spanId;\n    const release = this.keepAlives.get(spanId);\n    this.keepAlives.delete(spanId);\n\n    const exportDone = Promise.allSettled(\n      this.flushables.map((flushable) => flushable.forceFlush()),\n    ).then(() => undefined);\n    if (release) void exportDone.finally(release);\n  }\n\n  forceFlush(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  shutdown(): Promise<void> {\n    for (const release of this.keepAlives.values()) release();\n    this.keepAlives.clear();\n    return Promise.resolve();\n  }\n}\n","import * as http from \"node:http\";\nimport { Context, trace } from \"@opentelemetry/api\";\nimport {\n  SpanProcessor,\n  Span,\n  ReadableSpan,\n} from \"@opentelemetry/sdk-trace-node\";\nimport { isEntrySpan } from \"./entrySpan\";\n\nexport const HTTP_RESPONSE_STATUS_CODE_ATTRIBUTE = \"http.response.status_code\";\n\n/**\n * Records the real HTTP response status onto the service-entry span on Vercel.\n *\n * Vercel's bundled Next.js runtime stamps the entry span's status from the\n * response object before the handler's response is written, so the span always\n * reports the default 200 — a 429 or 500 to the client still exports as 200,\n * and warn/error rates flatline. The truth passes through\n * `ServerResponse.prototype.writeHead` when the response is actually written,\n * so this processor tracks live entry spans by trace id and a prototype patch\n * (see `patchServerResponseStatus`) reports the written status back to the\n * entry span of whichever trace is active.\n *\n * The stable `http.response.status_code` key is set deliberately: the bundled\n * runtime writes only the old `http.status_code` key, and the collector only\n * normalizes old → stable when the stable key is absent, so the value recorded\n * here survives regardless of what the runtime writes afterwards.\n */\nexport class VercelResponseStatusProcessor implements SpanProcessor {\n  private readonly entrySpans = new Map<string, Span>();\n\n  onStart(span: Span, _parentContext: Context): void {\n    if (!isEntrySpan(span)) return;\n    this.entrySpans.set(span.spanContext().traceId, span);\n  }\n\n  onEnd(span: ReadableSpan): void {\n    if (!isEntrySpan(span)) return;\n    this.entrySpans.delete(span.spanContext().traceId);\n  }\n\n  /** Called from the ServerResponse patch when a response's head is written. */\n  recordStatus(statusCode: number): void {\n    const traceId = trace.getActiveSpan()?.spanContext().traceId;\n    if (!traceId) return;\n    const entrySpan = this.entrySpans.get(traceId);\n    if (entrySpan?.isRecording()) {\n      entrySpan.setAttribute(HTTP_RESPONSE_STATUS_CODE_ATTRIBUTE, statusCode);\n    }\n  }\n\n  forceFlush(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  shutdown(): Promise<void> {\n    this.entrySpans.clear();\n    return Promise.resolve();\n  }\n}\n\nconst PATCHED_FLAG = Symbol.for(\"vigilon.writeHead.patched\");\n\n/**\n * Patches `ServerResponse.prototype.writeHead` to report the written status to\n * the processor. Prototype patching works regardless of when the server was\n * created, which is what makes this viable on Vercel where the runtime's\n * server exists before the SDK starts (the reason HttpInstrumentation never\n * engages there). Node's implicit header write on `res.end()` also goes\n * through `writeHead`, so unwritten-head responses are covered too.\n */\nexport function patchServerResponseStatus(\n  processor: VercelResponseStatusProcessor,\n): void {\n  const prototype = http.ServerResponse.prototype as typeof http.ServerResponse.prototype & {\n    [PATCHED_FLAG]?: boolean;\n  };\n  if (prototype[PATCHED_FLAG]) return;\n  prototype[PATCHED_FLAG] = true;\n\n  const originalWriteHead = prototype.writeHead;\n  prototype.writeHead = function patchedWriteHead(\n    this: http.ServerResponse,\n    ...args: Parameters<typeof originalWriteHead>\n  ) {\n    const statusCode = typeof args[0] === \"number\" ? args[0] : this.statusCode;\n    try {\n      processor.recordStatus(statusCode);\n    } catch {\n      // Never let telemetry break the response path.\n    }\n    return originalWriteHead.apply(this, args);\n  } as typeof originalWriteHead;\n}\n"],"mappings":"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","names":["import_api","import_api","registerNode"]}

package/dist/server.d.mts

@@ -0,0 +1,116 @@
+import { VigilonRegisterParams, register as register$1 } from '@vigilon/node';
+export * from '@vigilon/node';
+import { Context } from '@opentelemetry/api';
+import { SpanProcessor, Span, ReadableSpan } from '@opentelemetry/sdk-trace-node';
+
+type VigilonNextjsRegisterParams = Omit<VigilonRegisterParams, "extendSpanProcessors">;
+/**
+ * Starts Vigilon in the Next.js Node.js runtime: @vigilon/node's register()
+ * plus route attribution from Next's own spans and, on Vercel, the
+ * end-of-request flush and real response status. Call it from
+ * instrumentation.ts. Every parameter is optional, as with @vigilon/node.
+ */
+declare function register(params?: VigilonNextjsRegisterParams): ReturnType<typeof register$1>;
+
+declare const NEXT_ROUTE_ATTRIBUTE = "next.route";
+declare const HTTP_ROUTE_ATTRIBUTE = "http.route";
+/**
+ * Propagates the route Next.js resolves to the two places the rest of the
+ * pipeline reads it from, neither of which Next.js reliably fills itself:
+ *
+ * 1. The incoming request's RPC metadata — where the HTTP instrumentation
+ *    reads `http.route` when labelling its server span. Express and Fastify
+ *    instrumentations write the matched route there; Next.js never does.
+ *
+ * 2. Next's own `BaseServer.handleRequest` entry span. Next normally copies
+ *    `next.route` onto it via a tracer-internal root-span-attribute store,
+ *    but bundled runtimes (Vercel's serverless build) load private copies of
+ *    Next's tracer per route chunk, so the route module writes to one store
+ *    while the base server reads another and the entry span exports without
+ *    a route. Endpoint metrics are collector-derived from entry spans, so
+ *    every Vercel request was bucketed as "unknown".
+ *
+ * A span processor is used instead of patching Next's internals because the
+ * global tracer provider is the one channel every bundled copy of Next's
+ * tracer shares — proven by child spans parenting correctly even where the
+ * attribute store is split.
+ */
+declare class NextRouteSpanProcessor implements SpanProcessor {
+    onStart(span: Span, parentContext: Context): void;
+    onEnd(): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+
+type Flushable = {
+    forceFlush(): Promise<void>;
+};
+/**
+ * Exports telemetry at the end of every request instead of trusting timers.
+ *
+ * Vercel suspends the function instance the moment a response is sent, so the
+ * BatchSpanProcessor's export timer rarely gets to run, and even an export
+ * started at span end freezes mid-POST: it only completes if another request
+ * thaws the instance before the connection dies.
+ * Observed in production as "N consecutive requests record N-1", "spaced-out
+ * requests record nothing", and stale spans surfacing alongside later
+ * traffic.
+ *
+ * The keep-alive is therefore registered with Vercel's waitUntil when the
+ * entry span STARTS — registrations made after the response settles are
+ * silently dropped, and the entry span only ends after that point. The
+ * deferred handed to waitUntil at start is resolved once the end-of-request
+ * flush completes, so the instance stays alive exactly long enough for the
+ * export POST to land.
+ *
+ * Must be registered AFTER the BatchSpanProcessor: processors run in order,
+ * and the entry span must already be enqueued when the flush starts.
+ */
+declare class VercelFlushSpanProcessor implements SpanProcessor {
+    private readonly flushables;
+    private readonly keepAlives;
+    constructor(flushables: Flushable[]);
+    onStart(span: Span, _parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+
+declare const HTTP_RESPONSE_STATUS_CODE_ATTRIBUTE = "http.response.status_code";
+/**
+ * Records the real HTTP response status onto the service-entry span on Vercel.
+ *
+ * Vercel's bundled Next.js runtime stamps the entry span's status from the
+ * response object before the handler's response is written, so the span always
+ * reports the default 200 — a 429 or 500 to the client still exports as 200,
+ * and warn/error rates flatline. The truth passes through
+ * `ServerResponse.prototype.writeHead` when the response is actually written,
+ * so this processor tracks live entry spans by trace id and a prototype patch
+ * (see `patchServerResponseStatus`) reports the written status back to the
+ * entry span of whichever trace is active.
+ *
+ * The stable `http.response.status_code` key is set deliberately: the bundled
+ * runtime writes only the old `http.status_code` key, and the collector only
+ * normalizes old → stable when the stable key is absent, so the value recorded
+ * here survives regardless of what the runtime writes afterwards.
+ */
+declare class VercelResponseStatusProcessor implements SpanProcessor {
+    private readonly entrySpans;
+    onStart(span: Span, _parentContext: Context): void;
+    onEnd(span: ReadableSpan): void;
+    /** Called from the ServerResponse patch when a response's head is written. */
+    recordStatus(statusCode: number): void;
+    forceFlush(): Promise<void>;
+    shutdown(): Promise<void>;
+}
+/**
+ * Patches `ServerResponse.prototype.writeHead` to report the written status to
+ * the processor. Prototype patching works regardless of when the server was
+ * created, which is what makes this viable on Vercel where the runtime's
+ * server exists before the SDK starts (the reason HttpInstrumentation never
+ * engages there). Node's implicit header write on `res.end()` also goes
+ * through `writeHead`, so unwritten-head responses are covered too.
+ */
+declare function patchServerResponseStatus(processor: VercelResponseStatusProcessor): void;
+
+export { type Flushable, HTTP_RESPONSE_STATUS_CODE_ATTRIBUTE, HTTP_ROUTE_ATTRIBUTE, NEXT_ROUTE_ATTRIBUTE, NextRouteSpanProcessor, VercelFlushSpanProcessor, VercelResponseStatusProcessor, type VigilonNextjsRegisterParams, patchServerResponseStatus, register };