@interfere/next 9.0.1 → 10.0.0

package/dist/internal/server/console-bridge.mjs

@@ -0,0 +1,112 @@
+import { context, trace } from "@opentelemetry/api";
+import { logs } from "@opentelemetry/api-logs";
+//#region src/internal/server/console-bridge.ts
+const ATTR_EXCEPTION_TYPE = "exception.type";
+const ATTR_EXCEPTION_MESSAGE = "exception.message";
+const ATTR_EXCEPTION_STACKTRACE = "exception.stacktrace";
+const CONSOLE_METHODS = [
+	"debug",
+	"log",
+	"info",
+	"warn",
+	"error"
+];
+const SEVERITY = {
+	debug: 5,
+	log: 9,
+	info: 9,
+	warn: 13,
+	error: 17
+};
+/**
+* Bound at first failure log; subsequent failures only re-log every Nth
+* occurrence so a misconfigured logger backend doesn't itself spam the
+* console with bridge errors at line rate.
+*/
+const BRIDGE_FAILURE_LOG_INTERVAL = 100;
+function stringify(value) {
+	if (typeof value === "string") return value;
+	if (value instanceof Error) return value.stack ?? `${value.name}: ${value.message}`;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return String(value);
+	}
+}
+function extractException(args) {
+	for (const arg of args) if (arg instanceof Error) return arg;
+}
+function buildExceptionAttributes(args) {
+	const exception = extractException(args);
+	if (!exception) return;
+	const attrs = {
+		[ATTR_EXCEPTION_TYPE]: exception.name,
+		[ATTR_EXCEPTION_MESSAGE]: exception.message
+	};
+	if (exception.stack) attrs[ATTR_EXCEPTION_STACKTRACE] = exception.stack;
+	return attrs;
+}
+/**
+* Patches `console.{debug,log,info,warn,error}` to additionally emit OTel
+* `LogRecord`s alongside the original output. Every log record carries
+* the active span's context (so trace ↔ log correlation works in
+* dashboards) and any `Error` arg gets unpacked into semconv exception
+* attrs.
+*
+* Returns a disposer that restores the original `console.*` methods.
+*
+* Cycle protection: `emitting` guards against the bridge re-entering
+* itself if a logger backend itself logs to console (which would
+* recursively emit forever). Failures are bounded-rate logged via the
+* original `console.error` so a broken backend doesn't drown the
+* customer's logs in bridge-failure messages.
+*/
+function bridgeConsoleToOtel() {
+	const logger = logs.getLogger("@interfere/next/console");
+	let emitting = false;
+	let bridgeFailures = 0;
+	const original = {
+		debug: console.debug,
+		log: console.log,
+		info: console.info,
+		warn: console.warn,
+		error: console.error
+	};
+	function emitLog(orig, severity, method, body, activeContext, activeSpan, attributes) {
+		if (emitting) return;
+		emitting = true;
+		try {
+			logger.emit({
+				severityNumber: severity,
+				severityText: method.toUpperCase(),
+				body,
+				...activeSpan ? { context: activeContext } : {},
+				...attributes ? { attributes } : {}
+			});
+		} catch (error) {
+			bridgeFailures++;
+			if (bridgeFailures % BRIDGE_FAILURE_LOG_INTERVAL === 1) orig.call(console, `[interfere] console→OTel bridge emission failed (${bridgeFailures} total):`, error);
+		} finally {
+			emitting = false;
+		}
+	}
+	for (const method of CONSOLE_METHODS) {
+		const orig = original[method];
+		const severity = SEVERITY[method];
+		console[method] = (...args) => {
+			orig.apply(console, args);
+			const body = args.map(stringify).join(" ");
+			const activeContext = context.active();
+			const activeSpan = trace.getSpan(activeContext);
+			const attributes = buildExceptionAttributes(args);
+			queueMicrotask(() => {
+				emitLog(orig, severity, method, body, activeContext, activeSpan, attributes);
+			});
+		};
+	}
+	return () => {
+		for (const method of CONSOLE_METHODS) console[method] = original[method];
+	};
+}
+//#endregion
+export { bridgeConsoleToOtel };

package/dist/internal/server/console-bridge.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"console-bridge.mjs","names":[],"sources":["../../../src/internal/server/console-bridge.ts"],"sourcesContent":["import { context, trace } from \"@opentelemetry/api\";\nimport { logs, type SeverityNumber } from \"@opentelemetry/api-logs\";\n\nconst ATTR_EXCEPTION_TYPE = \"exception.type\" as const;\nconst ATTR_EXCEPTION_MESSAGE = \"exception.message\" as const;\nconst ATTR_EXCEPTION_STACKTRACE = \"exception.stacktrace\" as const;\n\nconst CONSOLE_METHODS = [\"debug\", \"log\", \"info\", \"warn\", \"error\"] as const;\ntype ConsoleMethod = (typeof CONSOLE_METHODS)[number];\n\nconst SEVERITY: Record<ConsoleMethod, SeverityNumber> = {\n  debug: 5,\n  log: 9,\n  info: 9,\n  warn: 13,\n  error: 17,\n};\n\n/**\n * Bound at first failure log; subsequent failures only re-log every Nth\n * occurrence so a misconfigured logger backend doesn't itself spam the\n * console with bridge errors at line rate.\n */\nconst BRIDGE_FAILURE_LOG_INTERVAL = 100;\n\nfunction stringify(value: unknown): string {\n  if (typeof value === \"string\") {\n    return value;\n  }\n  if (value instanceof Error) {\n    return value.stack ?? `${value.name}: ${value.message}`;\n  }\n  try {\n    return JSON.stringify(value);\n  } catch {\n    return String(value);\n  }\n}\n\nfunction extractException(args: unknown[]): Error | undefined {\n  for (const arg of args) {\n    if (arg instanceof Error) {\n      return arg;\n    }\n  }\n  return;\n}\n\nfunction buildExceptionAttributes(\n  args: unknown[]\n): Record<string, string> | undefined {\n  const exception = extractException(args);\n  if (!exception) {\n    return;\n  }\n  const attrs: Record<string, string> = {\n    [ATTR_EXCEPTION_TYPE]: exception.name,\n    [ATTR_EXCEPTION_MESSAGE]: exception.message,\n  };\n  if (exception.stack) {\n    attrs[ATTR_EXCEPTION_STACKTRACE] = exception.stack;\n  }\n  return attrs;\n}\n\n/**\n * Patches `console.{debug,log,info,warn,error}` to additionally emit OTel\n * `LogRecord`s alongside the original output. Every log record carries\n * the active span's context (so trace ↔ log correlation works in\n * dashboards) and any `Error` arg gets unpacked into semconv exception\n * attrs.\n *\n * Returns a disposer that restores the original `console.*` methods.\n *\n * Cycle protection: `emitting` guards against the bridge re-entering\n * itself if a logger backend itself logs to console (which would\n * recursively emit forever). Failures are bounded-rate logged via the\n * original `console.error` so a broken backend doesn't drown the\n * customer's logs in bridge-failure messages.\n */\nexport function bridgeConsoleToOtel(): () => void {\n  const logger = logs.getLogger(\"@interfere/next/console\");\n  let emitting = false;\n  let bridgeFailures = 0;\n\n  const original: Record<ConsoleMethod, (...args: unknown[]) => void> = {\n    debug: console.debug,\n    log: console.log,\n    info: console.info,\n    warn: console.warn,\n    error: console.error,\n  };\n\n  function emitLog(\n    orig: (...args: unknown[]) => void,\n    severity: SeverityNumber,\n    method: ConsoleMethod,\n    body: string,\n    activeContext: ReturnType<typeof context.active>,\n    activeSpan: ReturnType<typeof trace.getSpan>,\n    attributes: Record<string, string> | undefined\n  ): void {\n    if (emitting) {\n      return;\n    }\n    emitting = true;\n    try {\n      logger.emit({\n        severityNumber: severity,\n        severityText: method.toUpperCase(),\n        body,\n        ...(activeSpan ? { context: activeContext } : {}),\n        ...(attributes ? { attributes } : {}),\n      });\n    } catch (error) {\n      bridgeFailures++;\n      if (bridgeFailures % BRIDGE_FAILURE_LOG_INTERVAL === 1) {\n        orig.call(\n          console,\n          `[interfere] console→OTel bridge emission failed (${bridgeFailures} total):`,\n          error\n        );\n      }\n    } finally {\n      emitting = false;\n    }\n  }\n\n  for (const method of CONSOLE_METHODS) {\n    const orig = original[method];\n    const severity = SEVERITY[method];\n    console[method] = (...args: unknown[]) => {\n      orig.apply(console, args);\n\n      const body = args.map(stringify).join(\" \");\n      const activeContext = context.active();\n      const activeSpan = trace.getSpan(activeContext);\n      const attributes = buildExceptionAttributes(args);\n\n      // Defer emission via microtask so the synchronous return path\n      // out of `console.X` doesn't include the LoggerProvider's batch\n      // logic. Customer code's `console.error(...)` call should feel\n      // synchronous; the OTel emission rides the next microtask.\n      // `queueMicrotask` (not `setTimeout(0)`): macrotask-deferred\n      // emissions risk being lost on hard process exit.\n      queueMicrotask(() => {\n        emitLog(\n          orig,\n          severity,\n          method,\n          body,\n          activeContext,\n          activeSpan,\n          attributes\n        );\n      });\n    };\n  }\n\n  return () => {\n    for (const method of CONSOLE_METHODS) {\n      console[method] = original[method];\n    }\n  };\n}\n"],"mappings":";;;AAGA,MAAM,sBAAsB;AAC5B,MAAM,yBAAyB;AAC/B,MAAM,4BAA4B;AAElC,MAAM,kBAAkB;CAAC;CAAS;CAAO;CAAQ;CAAQ;CAAQ;AAGjE,MAAM,WAAkD;CACtD,OAAO;CACP,KAAK;CACL,MAAM;CACN,MAAM;CACN,OAAO;CACR;;;;;;AAOD,MAAM,8BAA8B;AAEpC,SAAS,UAAU,OAAwB;CACzC,IAAI,OAAO,UAAU,UACnB,OAAO;CAET,IAAI,iBAAiB,OACnB,OAAO,MAAM,SAAS,GAAG,MAAM,KAAK,IAAI,MAAM;CAEhD,IAAI;EACF,OAAO,KAAK,UAAU,MAAM;SACtB;EACN,OAAO,OAAO,MAAM;;;AAIxB,SAAS,iBAAiB,MAAoC;CAC5D,KAAK,MAAM,OAAO,MAChB,IAAI,eAAe,OACjB,OAAO;;AAMb,SAAS,yBACP,MACoC;CACpC,MAAM,YAAY,iBAAiB,KAAK;CACxC,IAAI,CAAC,WACH;CAEF,MAAM,QAAgC;GACnC,sBAAsB,UAAU;GAChC,yBAAyB,UAAU;EACrC;CACD,IAAI,UAAU,OACZ,MAAM,6BAA6B,UAAU;CAE/C,OAAO;;;;;;;;;;;;;;;;;AAkBT,SAAgB,sBAAkC;CAChD,MAAM,SAAS,KAAK,UAAU,0BAA0B;CACxD,IAAI,WAAW;CACf,IAAI,iBAAiB;CAErB,MAAM,WAAgE;EACpE,OAAO,QAAQ;EACf,KAAK,QAAQ;EACb,MAAM,QAAQ;EACd,MAAM,QAAQ;EACd,OAAO,QAAQ;EAChB;CAED,SAAS,QACP,MACA,UACA,QACA,MACA,eACA,YACA,YACM;EACN,IAAI,UACF;EAEF,WAAW;EACX,IAAI;GACF,OAAO,KAAK;IACV,gBAAgB;IAChB,cAAc,OAAO,aAAa;IAClC;IACA,GAAI,aAAa,EAAE,SAAS,eAAe,GAAG,EAAE;IAChD,GAAI,aAAa,EAAE,YAAY,GAAG,EAAE;IACrC,CAAC;WACK,OAAO;GACd;GACA,IAAI,iBAAiB,gCAAgC,GACnD,KAAK,KACH,SACA,oDAAoD,eAAe,WACnE,MACD;YAEK;GACR,WAAW;;;CAIf,KAAK,MAAM,UAAU,iBAAiB;EACpC,MAAM,OAAO,SAAS;EACtB,MAAM,WAAW,SAAS;EAC1B,QAAQ,WAAW,GAAG,SAAoB;GACxC,KAAK,MAAM,SAAS,KAAK;GAEzB,MAAM,OAAO,KAAK,IAAI,UAAU,CAAC,KAAK,IAAI;GAC1C,MAAM,gBAAgB,QAAQ,QAAQ;GACtC,MAAM,aAAa,MAAM,QAAQ,cAAc;GAC/C,MAAM,aAAa,yBAAyB,KAAK;GAQjD,qBAAqB;IACnB,QACE,MACA,UACA,QACA,MACA,eACA,YACA,WACD;KACD;;;CAIN,aAAa;EACX,KAAK,MAAM,UAAU,iBACnB,QAAQ,UAAU,SAAS"}

package/dist/internal/server/id-generator.d.mts

@@ -0,0 +1,38 @@
+import { IdGenerator } from "@opentelemetry/sdk-trace-base";
+
+//#region src/internal/server/id-generator.d.ts
+/**
+ * IdGenerator hybrid that uses OTel's default `RandomIdGenerator` whenever
+ * available and falls back to a counter-based generator inside Next 16's
+ * prerender contexts.
+ *
+ * Why: Next 16's prerender extension throws synchronously on any
+ * `Math.random()` / `crypto.getRandomValues()` call inside a Server
+ * Component that hasn't first awaited Request data
+ * (`next-prerender-random` / `next-prerender-crypto`). OTel's default
+ * generator hits `Math.random()` on every span creation, so spans Next
+ * opens around prerendered route renders blow up the build.
+ *
+ * The hybrid path keeps full 128-bit trace IDs / 64-bit span IDs for the
+ * common case (SSR, runtime requests, fluid-compute invocations) and only
+ * degrades inside prerender — where the alternative is build failure.
+ *
+ * Inside prerender, IDs are minted from a per-process random prefix
+ * (seeded once at construction time, outside any prerender ALS frame) plus
+ * a monotonic counter. Counter widths are masked to keep IDs at their
+ * spec-mandated lengths even after wrap.
+ */
+declare class PrerenderSafeIdGenerator implements IdGenerator {
+  private readonly random;
+  private readonly tracePrefix;
+  private readonly spanPrefix;
+  private traceCounter;
+  private spanCounter;
+  constructor();
+  generateTraceId(): string;
+  generateSpanId(): string;
+  private fallbackTraceId;
+  private fallbackSpanId;
+}
+//#endregion
+export { PrerenderSafeIdGenerator };

package/dist/internal/server/id-generator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"id-generator.d.mts","names":[],"sources":["../../../src/internal/server/id-generator.ts"],"mappings":";;;;;AAoCA;;;;;;;;;;;;;;;;;;;cAAa,wBAAA,YAAoC,WAAA;EAAA,iBAC9B,MAAA;EAAA,iBACA,WAAA;EAAA,iBACA,UAAA;EAAA,QACT,YAAA;EAAA,QACA,WAAA;;EAaR,eAAA,CAAA;EAQA,cAAA,CAAA;EAAA,QAQQ,eAAA;EAAA,QAQA,cAAA;AAAA"}

package/dist/internal/server/id-generator.mjs

@@ -0,0 +1,68 @@
+import { RandomIdGenerator } from "@opentelemetry/sdk-trace-base";
+import { randomBytes } from "node:crypto";
+//#region src/internal/server/id-generator.ts
+const TRACE_ID_HEX_LEN = 32;
+const SPAN_ID_HEX_LEN = 16;
+const TRACE_PREFIX_HEX_LEN = 24;
+const SPAN_PREFIX_HEX_LEN = 12;
+const TRACE_COUNTER_HEX_LEN = TRACE_ID_HEX_LEN - TRACE_PREFIX_HEX_LEN;
+const SPAN_COUNTER_HEX_LEN = SPAN_ID_HEX_LEN - SPAN_PREFIX_HEX_LEN;
+const TRACE_COUNTER_MODULUS = 2 ** (TRACE_COUNTER_HEX_LEN * 4);
+const SPAN_COUNTER_MODULUS = 2 ** (SPAN_COUNTER_HEX_LEN * 4);
+/**
+* IdGenerator hybrid that uses OTel's default `RandomIdGenerator` whenever
+* available and falls back to a counter-based generator inside Next 16's
+* prerender contexts.
+*
+* Why: Next 16's prerender extension throws synchronously on any
+* `Math.random()` / `crypto.getRandomValues()` call inside a Server
+* Component that hasn't first awaited Request data
+* (`next-prerender-random` / `next-prerender-crypto`). OTel's default
+* generator hits `Math.random()` on every span creation, so spans Next
+* opens around prerendered route renders blow up the build.
+*
+* The hybrid path keeps full 128-bit trace IDs / 64-bit span IDs for the
+* common case (SSR, runtime requests, fluid-compute invocations) and only
+* degrades inside prerender — where the alternative is build failure.
+*
+* Inside prerender, IDs are minted from a per-process random prefix
+* (seeded once at construction time, outside any prerender ALS frame) plus
+* a monotonic counter. Counter widths are masked to keep IDs at their
+* spec-mandated lengths even after wrap.
+*/
+var PrerenderSafeIdGenerator = class {
+	random = new RandomIdGenerator();
+	tracePrefix;
+	spanPrefix;
+	traceCounter = 0;
+	spanCounter = 0;
+	constructor() {
+		const seed = randomBytes((TRACE_PREFIX_HEX_LEN + SPAN_PREFIX_HEX_LEN) / 2);
+		this.tracePrefix = seed.subarray(0, TRACE_PREFIX_HEX_LEN / 2).toString("hex");
+		this.spanPrefix = seed.subarray(TRACE_PREFIX_HEX_LEN / 2).toString("hex");
+	}
+	generateTraceId() {
+		try {
+			return this.random.generateTraceId();
+		} catch {
+			return this.fallbackTraceId();
+		}
+	}
+	generateSpanId() {
+		try {
+			return this.random.generateSpanId();
+		} catch {
+			return this.fallbackSpanId();
+		}
+	}
+	fallbackTraceId() {
+		this.traceCounter = (this.traceCounter + 1) % TRACE_COUNTER_MODULUS;
+		return this.tracePrefix + this.traceCounter.toString(16).padStart(TRACE_COUNTER_HEX_LEN, "0");
+	}
+	fallbackSpanId() {
+		this.spanCounter = (this.spanCounter + 1) % SPAN_COUNTER_MODULUS;
+		return this.spanPrefix + this.spanCounter.toString(16).padStart(SPAN_COUNTER_HEX_LEN, "0");
+	}
+};
+//#endregion
+export { PrerenderSafeIdGenerator };

package/dist/internal/server/id-generator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"id-generator.mjs","names":[],"sources":["../../../src/internal/server/id-generator.ts"],"sourcesContent":["import { randomBytes } from \"node:crypto\";\nimport {\n  type IdGenerator,\n  RandomIdGenerator,\n} from \"@opentelemetry/sdk-trace-base\";\n\nconst TRACE_ID_HEX_LEN = 32;\nconst SPAN_ID_HEX_LEN = 16;\nconst TRACE_PREFIX_HEX_LEN = 24;\nconst SPAN_PREFIX_HEX_LEN = 12;\nconst TRACE_COUNTER_HEX_LEN = TRACE_ID_HEX_LEN - TRACE_PREFIX_HEX_LEN;\nconst SPAN_COUNTER_HEX_LEN = SPAN_ID_HEX_LEN - SPAN_PREFIX_HEX_LEN;\nconst TRACE_COUNTER_MODULUS = 2 ** (TRACE_COUNTER_HEX_LEN * 4);\nconst SPAN_COUNTER_MODULUS = 2 ** (SPAN_COUNTER_HEX_LEN * 4);\n\n/**\n * IdGenerator hybrid that uses OTel's default `RandomIdGenerator` whenever\n * available and falls back to a counter-based generator inside Next 16's\n * prerender contexts.\n *\n * Why: Next 16's prerender extension throws synchronously on any\n * `Math.random()` / `crypto.getRandomValues()` call inside a Server\n * Component that hasn't first awaited Request data\n * (`next-prerender-random` / `next-prerender-crypto`). OTel's default\n * generator hits `Math.random()` on every span creation, so spans Next\n * opens around prerendered route renders blow up the build.\n *\n * The hybrid path keeps full 128-bit trace IDs / 64-bit span IDs for the\n * common case (SSR, runtime requests, fluid-compute invocations) and only\n * degrades inside prerender — where the alternative is build failure.\n *\n * Inside prerender, IDs are minted from a per-process random prefix\n * (seeded once at construction time, outside any prerender ALS frame) plus\n * a monotonic counter. Counter widths are masked to keep IDs at their\n * spec-mandated lengths even after wrap.\n */\nexport class PrerenderSafeIdGenerator implements IdGenerator {\n  private readonly random = new RandomIdGenerator();\n  private readonly tracePrefix: string;\n  private readonly spanPrefix: string;\n  private traceCounter = 0;\n  private spanCounter = 0;\n\n  constructor() {\n    // Seeded once at `register()` time — module init runs outside any\n    // prerender ALS frame, so `randomBytes` is permitted here even if\n    // every later call from inside a render is not.\n    const seed = randomBytes((TRACE_PREFIX_HEX_LEN + SPAN_PREFIX_HEX_LEN) / 2);\n    this.tracePrefix = seed\n      .subarray(0, TRACE_PREFIX_HEX_LEN / 2)\n      .toString(\"hex\");\n    this.spanPrefix = seed.subarray(TRACE_PREFIX_HEX_LEN / 2).toString(\"hex\");\n  }\n\n  generateTraceId(): string {\n    try {\n      return this.random.generateTraceId();\n    } catch {\n      return this.fallbackTraceId();\n    }\n  }\n\n  generateSpanId(): string {\n    try {\n      return this.random.generateSpanId();\n    } catch {\n      return this.fallbackSpanId();\n    }\n  }\n\n  private fallbackTraceId(): string {\n    this.traceCounter = (this.traceCounter + 1) % TRACE_COUNTER_MODULUS;\n    return (\n      this.tracePrefix +\n      this.traceCounter.toString(16).padStart(TRACE_COUNTER_HEX_LEN, \"0\")\n    );\n  }\n\n  private fallbackSpanId(): string {\n    this.spanCounter = (this.spanCounter + 1) % SPAN_COUNTER_MODULUS;\n    return (\n      this.spanPrefix +\n      this.spanCounter.toString(16).padStart(SPAN_COUNTER_HEX_LEN, \"0\")\n    );\n  }\n}\n"],"mappings":";;;AAMA,MAAM,mBAAmB;AACzB,MAAM,kBAAkB;AACxB,MAAM,uBAAuB;AAC7B,MAAM,sBAAsB;AAC5B,MAAM,wBAAwB,mBAAmB;AACjD,MAAM,uBAAuB,kBAAkB;AAC/C,MAAM,wBAAwB,MAAM,wBAAwB;AAC5D,MAAM,uBAAuB,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;AAuB1D,IAAa,2BAAb,MAA6D;CAC3D,SAA0B,IAAI,mBAAmB;CACjD;CACA;CACA,eAAuB;CACvB,cAAsB;CAEtB,cAAc;EAIZ,MAAM,OAAO,aAAa,uBAAuB,uBAAuB,EAAE;EAC1E,KAAK,cAAc,KAChB,SAAS,GAAG,uBAAuB,EAAE,CACrC,SAAS,MAAM;EAClB,KAAK,aAAa,KAAK,SAAS,uBAAuB,EAAE,CAAC,SAAS,MAAM;;CAG3E,kBAA0B;EACxB,IAAI;GACF,OAAO,KAAK,OAAO,iBAAiB;UAC9B;GACN,OAAO,KAAK,iBAAiB;;;CAIjC,iBAAyB;EACvB,IAAI;GACF,OAAO,KAAK,OAAO,gBAAgB;UAC7B;GACN,OAAO,KAAK,gBAAgB;;;CAIhC,kBAAkC;EAChC,KAAK,gBAAgB,KAAK,eAAe,KAAK;EAC9C,OACE,KAAK,cACL,KAAK,aAAa,SAAS,GAAG,CAAC,SAAS,uBAAuB,IAAI;;CAIvE,iBAAiC;EAC/B,KAAK,eAAe,KAAK,cAAc,KAAK;EAC5C,OACE,KAAK,aACL,KAAK,YAAY,SAAS,GAAG,CAAC,SAAS,sBAAsB,IAAI"}

package/dist/internal/server/instrumentation-options.d.mts

@@ -0,0 +1,86 @@
+import { LogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { MetricReader } from "@opentelemetry/sdk-metrics";
+import { SpanProcessor } from "@opentelemetry/sdk-trace-base";
+
+//#region src/internal/server/instrumentation-options.d.ts
+/**
+ * Per-instrumentation tuning for the server-side `register()`. Mirrors
+ * the browser-side `TracingOptions` — same names, same semantics —
+ * so a customer running both client + server with the same SDK has
+ * one mental model.
+ *
+ * The shape lives in its own module (rather than alongside
+ * `instrumentation.ts`) so the Node entry (`instrumentation.ts`) and the
+ * Edge no-op entry (`instrumentation.edge.ts`) can both pull the same
+ * type contract — the Edge entry never imports the Node-only OTel
+ * implementation, but its `register()` signature must stay byte-for-byte
+ * compatible so customer code compiles unchanged when bundled for either
+ * runtime.
+ *
+ * `LogRecordProcessor`, `MetricReader`, and `SpanProcessor` come from
+ * the OTel "base" packages (`@opentelemetry/sdk-logs`,
+ * `@opentelemetry/sdk-metrics`, `@opentelemetry/sdk-trace-base`),
+ * which are edge-safe at the import level. They're also `import type` here
+ * so they're erased before bundling — the Edge runtime bundle never sees
+ * them at all.
+ */
+interface ServerInstrumentationOptions {
+  /**
+   * @internal
+   *
+   * Extra log-record processors fanned into the LoggerProvider's
+   * processor list. Used by `@interfere/observability` for internal-only
+   * dual-write to BetterStack from `interfere/homepage` +
+   * `interfere/dashboard`. Customers don't get a fan-out hook on the
+   * SDK surface; this is a private bridge for our own dogfood apps.
+   */
+  _internalAdditionalLogRecordProcessors?: LogRecordProcessor[];
+  /**
+   * @internal
+   *
+   * Extra metric readers fanned into the MeterProvider's reader list.
+   * See `_internalAdditionalLogRecordProcessors`. Used to keep
+   * `http.client.request.duration` (from `UndiciInstrumentation`) and
+   * any first-party `metrics.getMeter(...)` counters landing on the
+   * BetterStack-fronting OTel collector after the `@vercel/otel` →
+   * `@interfere/next` migration removed the default metric reader
+   * `registerOTel({ metricReader: "auto" })` used to install.
+   */
+  _internalAdditionalMetricReaders?: MetricReader[];
+  /**
+   * @internal
+   *
+   * Extra span processors fanned into the NodeTracerProvider's processor
+   * list. See `_internalAdditionalLogRecordProcessors`.
+   */
+  _internalAdditionalSpanProcessors?: SpanProcessor[];
+  /**
+   * `false` disables the `console.*` → OTel `LogRecord` bridge.
+   * Defaults to enabled. Customers running their own structured
+   * logger (Pino, Winston, etc.) that already emits OTel logs can
+   * opt out to avoid double-emit.
+   */
+  consoleBridge?: boolean;
+  /**
+   * URL patterns the undici fetch instrumentation skips (no spans
+   * created for these). The collector OTLP endpoint is always
+   * skipped automatically — without this the SDK would trace its
+   * own export requests in an infinite loop.
+   */
+  ignoreUrls?: (string | RegExp)[];
+  /**
+   * URL patterns the undici fetch instrumentation injects W3C
+   * `traceparent` + `baggage` headers on for cross-process trace
+   * correlation. Same-origin requests aren't a concept on the server
+   * the way they are in a browser, so the allowlist is the only
+   * propagation control.
+   */
+  propagateContextUrls?: (string | RegExp)[];
+  /**
+   * Override the OTel `service.name` resource attribute. Defaults to
+   * `"interfere-sdk-next-server"`.
+   */
+  serviceName?: string;
+}
+//#endregion
+export { ServerInstrumentationOptions };

package/dist/internal/server/instrumentation-options.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instrumentation-options.d.mts","names":[],"sources":["../../../src/internal/server/instrumentation-options.ts"],"mappings":";;;;;;;AAyBA;;;;;;;;;;;;;;;;;;;UAAiB,4BAAA;EAmDkB;;;;;;;;;EAzCjC,sCAAA,GAAyC,kBAAA;;;;;;;;;;;;EAYzC,gCAAA,GAAmC,YAAA;;;;;;;EAOnC,iCAAA,GAAoC,aAAA;;;;;;;EAOpC,aAAA;;;;;;;EAOA,UAAA,aAAuB,MAAA;;;;;;;;EAQvB,oBAAA,aAAiC,MAAA;;;;;EAKjC,WAAA;AAAA"}

package/dist/internal/server/instrumentation-options.mjs

@@ -0,0 +1 @@
+export {};

package/dist/internal/server/remote-config.mjs

@@ -1,9 +1,9 @@
-import { isEnabledInEnvironment, readInterfereEnv } from "../env.mjs";
+import { isEnabledOnServer, readInterfereEnv } from "../env.mjs";
 import { API_PATHS } from "@interfere/constants/api";
 //#region src/internal/server/remote-config.ts
 let cachedConfig = null;
 async function fetchAndCacheRemoteConfig() {
-	if (!isEnabledInEnvironment()) return;
+	if (!isEnabledOnServer()) return;
 	const env = readInterfereEnv();
 	if (env.apiKey === null) return;
 	try {

package/dist/internal/server/remote-config.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"remote-config.mjs","names":[],"sources":["../../../src/internal/server/remote-config.ts"],"sourcesContent":["import { API_PATHS } from \"@interfere/constants/api\";\nimport type {\n  RemoteConfig,\n  RemotePluginConfig,\n} from \"@interfere/types/sdk/remote-config\";\n\nimport { isEnabledInEnvironment, readInterfereEnv } from \"../env.js\";\n\nlet cachedConfig: RemotePluginConfig | null = null;\n\nexport async function fetchAndCacheRemoteConfig(): Promise<void> {\n  if (!isEnabledInEnvironment()) {\n    return;\n  }\n\n  const env = readInterfereEnv();\n  if (env.apiKey === null) {\n    return;\n  }\n\n  try {\n    const url = `${env.apiUrl}${API_PATHS.CONFIG}`;\n    const response = await fetch(url, {\n      method: \"GET\",\n      headers: {\n        \"content-type\": \"application/json\",\n        \"x-api-key\": env.apiKey,\n      },\n      signal: AbortSignal.timeout(10_000),\n    });\n\n    if (!response.ok) {\n      return;\n    }\n\n    const config = (await response.json()) as RemoteConfig;\n    if (config?.plugins) {\n      cachedConfig = config.plugins;\n    }\n  } catch {\n    // Fail silently — all plugins remain enabled\n  }\n}\n\nexport function isPluginEnabled(plugin: string): boolean {\n  if (!cachedConfig) {\n    return true;\n  }\n  return cachedConfig[plugin as keyof RemotePluginConfig] !== false;\n}\n"],"mappings":";;;AAQA,IAAI,eAA0C;AAE9C,eAAsB,4BAA2C;AAC/D,KAAI,CAAC,wBAAwB,CAC3B;CAGF,MAAM,MAAM,kBAAkB;AAC9B,KAAI,IAAI,WAAW,KACjB;AAGF,KAAI;EACF,MAAM,MAAM,GAAG,IAAI,SAAS,UAAU;EACtC,MAAM,WAAW,MAAM,MAAM,KAAK;GAChC,QAAQ;GACR,SAAS;IACP,gBAAgB;IAChB,aAAa,IAAI;IAClB;GACD,QAAQ,YAAY,QAAQ,IAAO;GACpC,CAAC;AAEF,MAAI,CAAC,SAAS,GACZ;EAGF,MAAM,SAAU,MAAM,SAAS,MAAM;AACrC,MAAI,QAAQ,QACV,gBAAe,OAAO;SAElB;;AAKV,SAAgB,gBAAgB,QAAyB;AACvD,KAAI,CAAC,aACH,QAAO;AAET,QAAO,aAAa,YAAwC"}
+{"version":3,"file":"remote-config.mjs","names":[],"sources":["../../../src/internal/server/remote-config.ts"],"sourcesContent":["import { API_PATHS } from \"@interfere/constants/api\";\nimport type {\n  RemoteConfig,\n  RemotePluginConfig,\n} from \"@interfere/types/sdk/remote-config\";\n\nimport { isEnabledOnServer, readInterfereEnv } from \"../env.js\";\n\nlet cachedConfig: RemotePluginConfig | null = null;\n\nexport async function fetchAndCacheRemoteConfig(): Promise<void> {\n  if (!isEnabledOnServer()) {\n    return;\n  }\n\n  const env = readInterfereEnv();\n  if (env.apiKey === null) {\n    return;\n  }\n\n  try {\n    const url = `${env.apiUrl}${API_PATHS.CONFIG}`;\n    const response = await fetch(url, {\n      method: \"GET\",\n      headers: {\n        \"content-type\": \"application/json\",\n        \"x-api-key\": env.apiKey,\n      },\n      signal: AbortSignal.timeout(10_000),\n    });\n\n    if (!response.ok) {\n      return;\n    }\n\n    const config = (await response.json()) as RemoteConfig;\n    if (config?.plugins) {\n      cachedConfig = config.plugins;\n    }\n  } catch {\n    // Fail silently — all plugins remain enabled\n  }\n}\n\nexport function isPluginEnabled(plugin: string): boolean {\n  if (!cachedConfig) {\n    return true;\n  }\n  return cachedConfig[plugin as keyof RemotePluginConfig] !== false;\n}\n"],"mappings":";;;AAQA,IAAI,eAA0C;AAE9C,eAAsB,4BAA2C;CAC/D,IAAI,CAAC,mBAAmB,EACtB;CAGF,MAAM,MAAM,kBAAkB;CAC9B,IAAI,IAAI,WAAW,MACjB;CAGF,IAAI;EACF,MAAM,MAAM,GAAG,IAAI,SAAS,UAAU;EACtC,MAAM,WAAW,MAAM,MAAM,KAAK;GAChC,QAAQ;GACR,SAAS;IACP,gBAAgB;IAChB,aAAa,IAAI;IAClB;GACD,QAAQ,YAAY,QAAQ,IAAO;GACpC,CAAC;EAEF,IAAI,CAAC,SAAS,IACZ;EAGF,MAAM,SAAU,MAAM,SAAS,MAAM;EACrC,IAAI,QAAQ,SACV,eAAe,OAAO;SAElB;;AAKV,SAAgB,gBAAgB,QAAyB;CACvD,IAAI,CAAC,cACH,OAAO;CAET,OAAO,aAAa,YAAwC"}

package/dist/internal/server/trace-meta.d.mts

@@ -0,0 +1,34 @@
+import * as _$react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/internal/server/trace-meta.d.ts
+/**
+ * Server Component that emits a `<meta name="traceparent">` tag so the
+ * client SDK can stitch every browser span onto the server-side trace.
+ *
+ * Customer usage — drop into the root layout's `<head>`:
+ *
+ * ```tsx
+ * import { TraceMeta } from "@interfere/next/server";
+ *
+ * export default function RootLayout({ children }) {
+ *   return (
+ *     <html>
+ *       <head>
+ *         <TraceMeta />
+ *       </head>
+ *       <body>{children}</body>
+ *     </html>
+ *   );
+ * }
+ * ```
+ *
+ * Renders nothing when no OTel span is active (dev without OTel
+ * registered, edge runtime where `@interfere/next/instrumentation`'s
+ * async `register()` hasn't completed before the layout renders, or
+ * unsampled traces). The client SDK's propagation reader handles a
+ * missing meta tag the same as no parent — every browser span starts a
+ * fresh root, which is at least internally consistent.
+ */
+declare function TraceMeta(): _$react_jsx_runtime0.JSX.Element | null;
+//#endregion
+export { TraceMeta };

package/dist/internal/server/trace-meta.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-meta.d.mts","names":[],"sources":["../../../src/internal/server/trace-meta.tsx"],"mappings":";;;;;;AA8BA;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,SAAA,CAAA,GAAS,oBAAA,CAAA,GAAA,CAAA,OAAA"}

package/dist/internal/server/trace-meta.mjs

@@ -0,0 +1,41 @@
+import { activeTraceparent } from "./traceparent.mjs";
+import { jsx } from "react/jsx-runtime";
+//#region src/internal/server/trace-meta.tsx
+/**
+* Server Component that emits a `<meta name="traceparent">` tag so the
+* client SDK can stitch every browser span onto the server-side trace.
+*
+* Customer usage — drop into the root layout's `<head>`:
+*
+* ```tsx
+* import { TraceMeta } from "@interfere/next/server";
+*
+* export default function RootLayout({ children }) {
+*   return (
+*     <html>
+*       <head>
+*         <TraceMeta />
+*       </head>
+*       <body>{children}</body>
+*     </html>
+*   );
+* }
+* ```
+*
+* Renders nothing when no OTel span is active (dev without OTel
+* registered, edge runtime where `@interfere/next/instrumentation`'s
+* async `register()` hasn't completed before the layout renders, or
+* unsampled traces). The client SDK's propagation reader handles a
+* missing meta tag the same as no parent — every browser span starts a
+* fresh root, which is at least internally consistent.
+*/
+function TraceMeta() {
+	const traceparent = activeTraceparent();
+	if (!traceparent) return null;
+	return /* @__PURE__ */ jsx("meta", {
+		content: traceparent,
+		name: "traceparent"
+	});
+}
+//#endregion
+export { TraceMeta };

package/dist/internal/server/trace-meta.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-meta.mjs","names":[],"sources":["../../../src/internal/server/trace-meta.tsx"],"sourcesContent":["import { activeTraceparent } from \"./traceparent.js\";\n\n/**\n * Server Component that emits a `<meta name=\"traceparent\">` tag so the\n * client SDK can stitch every browser span onto the server-side trace.\n *\n * Customer usage — drop into the root layout's `<head>`:\n *\n * ```tsx\n * import { TraceMeta } from \"@interfere/next/server\";\n *\n * export default function RootLayout({ children }) {\n *   return (\n *     <html>\n *       <head>\n *         <TraceMeta />\n *       </head>\n *       <body>{children}</body>\n *     </html>\n *   );\n * }\n * ```\n *\n * Renders nothing when no OTel span is active (dev without OTel\n * registered, edge runtime where `@interfere/next/instrumentation`'s\n * async `register()` hasn't completed before the layout renders, or\n * unsampled traces). The client SDK's propagation reader handles a\n * missing meta tag the same as no parent — every browser span starts a\n * fresh root, which is at least internally consistent.\n */\nexport function TraceMeta() {\n  const traceparent = activeTraceparent();\n  if (!traceparent) {\n    return null;\n  }\n  return <meta content={traceparent} name=\"traceparent\" />;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,SAAgB,YAAY;CAC1B,MAAM,cAAc,mBAAmB;CACvC,IAAI,CAAC,aACH,OAAO;CAET,OAAO,oBAAC,QAAD;EAAM,SAAS;EAAa,MAAK;EAAgB,CAAA"}

package/dist/internal/server/traceparent.d.mts

@@ -0,0 +1,16 @@
+//#region src/internal/server/traceparent.d.ts
+/**
+ * Build a W3C `traceparent` string from the currently-active OTel
+ * span, or `null` if no span is active or the trace is not sampled.
+ *
+ * Server-side counterpart to the client SDK's
+ * `internal/otel/propagation.ts`: both ends of the wire filter
+ * unsampled traces. The browser doesn't honor the `sampled` bit when
+ * creating child spans, so propagating an unsampled trace_id from the
+ * server would orphan every browser span under a trace with no
+ * recorded server segments. Returning null lets the browser fall back
+ * to its own root, which is at least internally consistent.
+ */
+declare function activeTraceparent(): string | null;
+//#endregion
+export { activeTraceparent };

package/dist/internal/server/traceparent.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceparent.d.mts","names":[],"sources":["../../../src/internal/server/traceparent.ts"],"mappings":";;AAiBA;;;;;;;;;;;iBAAgB,iBAAA,CAAA"}

package/dist/internal/server/traceparent.mjs

@@ -0,0 +1,26 @@
+import { TraceFlags, trace } from "@opentelemetry/api";
+//#region src/internal/server/traceparent.ts
+const SAMPLED_BIT = TraceFlags.SAMPLED;
+const W3C_TRACECONTEXT_VERSION = "00";
+/**
+* Build a W3C `traceparent` string from the currently-active OTel
+* span, or `null` if no span is active or the trace is not sampled.
+*
+* Server-side counterpart to the client SDK's
+* `internal/otel/propagation.ts`: both ends of the wire filter
+* unsampled traces. The browser doesn't honor the `sampled` bit when
+* creating child spans, so propagating an unsampled trace_id from the
+* server would orphan every browser span under a trace with no
+* recorded server segments. Returning null lets the browser fall back
+* to its own root, which is at least internally consistent.
+*/
+function activeTraceparent() {
+	const span = trace.getActiveSpan();
+	if (!span) return null;
+	const ctx = span.spanContext();
+	if ((ctx.traceFlags & SAMPLED_BIT) !== SAMPLED_BIT) return null;
+	const flags = ctx.traceFlags.toString(16).padStart(2, "0");
+	return `${W3C_TRACECONTEXT_VERSION}-${ctx.traceId}-${ctx.spanId}-${flags}`;
+}
+//#endregion
+export { activeTraceparent };

package/dist/internal/server/traceparent.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceparent.mjs","names":[],"sources":["../../../src/internal/server/traceparent.ts"],"sourcesContent":["import { TraceFlags, trace } from \"@opentelemetry/api\";\n\nconst SAMPLED_BIT = TraceFlags.SAMPLED;\nconst W3C_TRACECONTEXT_VERSION = \"00\";\n\n/**\n * Build a W3C `traceparent` string from the currently-active OTel\n * span, or `null` if no span is active or the trace is not sampled.\n *\n * Server-side counterpart to the client SDK's\n * `internal/otel/propagation.ts`: both ends of the wire filter\n * unsampled traces. The browser doesn't honor the `sampled` bit when\n * creating child spans, so propagating an unsampled trace_id from the\n * server would orphan every browser span under a trace with no\n * recorded server segments. Returning null lets the browser fall back\n * to its own root, which is at least internally consistent.\n */\nexport function activeTraceparent(): string | null {\n  const span = trace.getActiveSpan();\n  if (!span) {\n    return null;\n  }\n  const ctx = span.spanContext();\n  // biome-ignore lint/suspicious/noBitwiseOperators: W3C trace_flags is a bitmask; SAMPLED (0x01) must be tested independently of any future reserved flags.\n  if ((ctx.traceFlags & SAMPLED_BIT) !== SAMPLED_BIT) {\n    return null;\n  }\n  const flags = ctx.traceFlags.toString(16).padStart(2, \"0\");\n  return `${W3C_TRACECONTEXT_VERSION}-${ctx.traceId}-${ctx.spanId}-${flags}`;\n}\n"],"mappings":";;AAEA,MAAM,cAAc,WAAW;AAC/B,MAAM,2BAA2B;;;;;;;;;;;;;AAcjC,SAAgB,oBAAmC;CACjD,MAAM,OAAO,MAAM,eAAe;CAClC,IAAI,CAAC,MACH,OAAO;CAET,MAAM,MAAM,KAAK,aAAa;CAE9B,KAAK,IAAI,aAAa,iBAAiB,aACrC,OAAO;CAET,MAAM,QAAQ,IAAI,WAAW,SAAS,GAAG,CAAC,SAAS,GAAG,IAAI;CAC1D,OAAO,GAAG,yBAAyB,GAAG,IAAI,QAAQ,GAAG,IAAI,OAAO,GAAG"}

package/dist/internal/server/types.d.mts

@@ -6,12 +6,6 @@ type OnRequestErrorContext = Omit<NextjsContext, "errorDigest" | "requestMethod"
 interface CaptureErrorContext {
   readonly mechanism?: ErrorMechanism;
   readonly nextjs?: Omit<NextjsContext, "runtime">;
-  readonly traceparent?: string;
-}
-interface NormalizedRequest {
-  readonly headers: Headers;
-  readonly method: string;
-  readonly path: string;
 }
 //#endregion
-export { CaptureErrorContext, NormalizedRequest, OnRequestErrorContext };
+export { CaptureErrorContext, OnRequestErrorContext };

package/dist/internal/server/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../../src/internal/server/types.ts"],"mappings":";;;;KAGY,qBAAA,GAAwB,IAAA,CAClC,aAAA;AAAA,UAIe,mBAAA;EAAA,SACN,SAAA,GAAY,cAAA;EAAA,SACZ,MAAA,GAAS,IAAA,CAAK,aAAA;EAAA,SACd,WAAA;AAAA;AAAA,UAGM,iBAAA;EAAA,SACN,OAAA,EAAS,OAAA;EAAA,SACT,MAAA;EAAA,SACA,IAAA;AAAA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../src/internal/server/types.ts"],"mappings":";;;;KAGY,qBAAA,GAAwB,IAAA,CAClC,aAAA;AAAA,UAIe,mBAAA;EAAA,SACN,SAAA,GAAY,cAAA;EAAA,SACZ,MAAA,GAAS,IAAA,CAAK,aAAA;AAAA"}

package/dist/internal/setup-warnings.d.mts

@@ -0,0 +1,17 @@
+//#region src/internal/setup-warnings.d.ts
+/**
+ * Best-effort warning when the customer set `INTERFERE_API_KEY` but never
+ * created `instrumentation.ts`. Server-side tracing then silently does
+ * nothing — that's surprising and there's no other place we get to tell
+ * them. Never blocks the build: some customers genuinely don't want
+ * server-side tracing.
+ */
+declare function warnIfServerInstrumentationMissing(projectDir: string): void;
+/**
+ * Reads the customer's installed `next` package version. Returns `null` if
+ * Next isn't resolvable from `projectDir` (e.g. running outside a Next app),
+ * in which case callers should skip version-conditional behaviour.
+ */
+declare function readNextMajorVersion(projectDir: string): number | null;
+//#endregion
+export { readNextMajorVersion, warnIfServerInstrumentationMissing };

package/dist/internal/setup-warnings.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-warnings.d.mts","names":[],"sources":["../../src/internal/setup-warnings.ts"],"mappings":";;AA8BA;;;;;AAeA;iBAfgB,kCAAA,CAAmC,UAAA;;;;;;iBAenC,oBAAA,CAAqB,UAAA"}

package/dist/internal/setup-warnings.mjs

@@ -0,0 +1,45 @@
+import { log } from "./logger.mjs";
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+//#region src/internal/setup-warnings.ts
+const SERVER_INSTRUMENTATION_FILES = [
+	"instrumentation.ts",
+	"instrumentation.tsx",
+	"instrumentation.js",
+	"instrumentation.jsx",
+	"src/instrumentation.ts",
+	"src/instrumentation.tsx",
+	"src/instrumentation.js",
+	"src/instrumentation.jsx"
+];
+function hasServerInstrumentation(projectDir) {
+	return SERVER_INSTRUMENTATION_FILES.some((c) => existsSync(resolve(projectDir, c)));
+}
+/**
+* Best-effort warning when the customer set `INTERFERE_API_KEY` but never
+* created `instrumentation.ts`. Server-side tracing then silently does
+* nothing — that's surprising and there's no other place we get to tell
+* them. Never blocks the build: some customers genuinely don't want
+* server-side tracing.
+*/
+function warnIfServerInstrumentationMissing(projectDir) {
+	if (hasServerInstrumentation(projectDir)) return;
+	log.warn("No instrumentation.ts found", ["Server-side traces will be skipped. To enable, create instrumentation.ts at the project root with:", "  export { register } from '@interfere/next/instrumentation';"]);
+}
+/**
+* Reads the customer's installed `next` package version. Returns `null` if
+* Next isn't resolvable from `projectDir` (e.g. running outside a Next app),
+* in which case callers should skip version-conditional behaviour.
+*/
+function readNextMajorVersion(projectDir) {
+	try {
+		const pkg = createRequire(`${projectDir}/_`)("next/package.json");
+		const major = Number.parseInt(pkg.version?.split(".")[0] ?? "", 10);
+		return Number.isFinite(major) ? major : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { readNextMajorVersion, warnIfServerInstrumentationMissing };

package/dist/internal/setup-warnings.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup-warnings.mjs","names":[],"sources":["../../src/internal/setup-warnings.ts"],"sourcesContent":["import { existsSync } from \"node:fs\";\nimport { createRequire } from \"node:module\";\nimport { resolve } from \"node:path\";\n\nimport { log } from \"./logger.js\";\n\nconst SERVER_INSTRUMENTATION_FILES = [\n  \"instrumentation.ts\",\n  \"instrumentation.tsx\",\n  \"instrumentation.js\",\n  \"instrumentation.jsx\",\n  \"src/instrumentation.ts\",\n  \"src/instrumentation.tsx\",\n  \"src/instrumentation.js\",\n  \"src/instrumentation.jsx\",\n] as const;\n\nfunction hasServerInstrumentation(projectDir: string): boolean {\n  return SERVER_INSTRUMENTATION_FILES.some((c) =>\n    existsSync(resolve(projectDir, c))\n  );\n}\n\n/**\n * Best-effort warning when the customer set `INTERFERE_API_KEY` but never\n * created `instrumentation.ts`. Server-side tracing then silently does\n * nothing — that's surprising and there's no other place we get to tell\n * them. Never blocks the build: some customers genuinely don't want\n * server-side tracing.\n */\nexport function warnIfServerInstrumentationMissing(projectDir: string): void {\n  if (hasServerInstrumentation(projectDir)) {\n    return;\n  }\n  log.warn(\"No instrumentation.ts found\", [\n    \"Server-side traces will be skipped. To enable, create instrumentation.ts at the project root with:\",\n    \"  export { register } from '@interfere/next/instrumentation';\",\n  ]);\n}\n\n/**\n * Reads the customer's installed `next` package version. Returns `null` if\n * Next isn't resolvable from `projectDir` (e.g. running outside a Next app),\n * in which case callers should skip version-conditional behaviour.\n */\nexport function readNextMajorVersion(projectDir: string): number | null {\n  try {\n    const require = createRequire(`${projectDir}/_`);\n    const pkg = require(\"next/package.json\") as { version?: string };\n    const major = Number.parseInt(pkg.version?.split(\".\")[0] ?? \"\", 10);\n    return Number.isFinite(major) ? major : null;\n  } catch {\n    return null;\n  }\n}\n"],"mappings":";;;;;AAMA,MAAM,+BAA+B;CACnC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD;AAED,SAAS,yBAAyB,YAA6B;CAC7D,OAAO,6BAA6B,MAAM,MACxC,WAAW,QAAQ,YAAY,EAAE,CAAC,CACnC;;;;;;;;;AAUH,SAAgB,mCAAmC,YAA0B;CAC3E,IAAI,yBAAyB,WAAW,EACtC;CAEF,IAAI,KAAK,+BAA+B,CACtC,sGACA,gEACD,CAAC;;;;;;;AAQJ,SAAgB,qBAAqB,YAAmC;CACtE,IAAI;EAEF,MAAM,MADU,cAAc,GAAG,WAAW,IACzB,CAAC,oBAAoB;EACxC,MAAM,QAAQ,OAAO,SAAS,IAAI,SAAS,MAAM,IAAI,CAAC,MAAM,IAAI,GAAG;EACnE,OAAO,OAAO,SAAS,MAAM,GAAG,QAAQ;SAClC;EACN,OAAO"}

package/dist/package.mjs

@@ -1,5 +1,5 @@
 //#region package.json
 var name = "@interfere/next";
-var version = "9.0.1";
+var version = "10.0.0";
 //#endregion
 export { name, version };

package/dist/provider.d.mts

@@ -1,3 +1,24 @@
-import { InterfereProvider, useInterfere, useSession } from "@interfere/react/provider";
-import { ConsentCategory, ConsentState, GateableCategory } from "@interfere/types/sdk/plugins/manifest";
+import { useInterfere, useSession } from "@interfere/react/provider";
+import { PropsWithChildren, ReactNode } from "react";
+import { ConsentCategory, ConsentState, ConsentState as ConsentState$1, GateableCategory } from "@interfere/types/sdk/plugins/manifest";
+
+//#region src/provider.d.ts
+interface InterfereProviderProps extends PropsWithChildren {
+  consent?: ConsentState$1 | undefined;
+  errorBoundary?: boolean;
+}
+/**
+ * Next.js wrapper around `@interfere/react`'s provider that resolves the
+ * kernel from module scope (set by the matching `init()` call). Customer
+ * code never passes the kernel explicitly. Uses `getKernelOrNull()` so the
+ * provider is safe to render during SSR/SSG when `init()` hasn't run
+ * (`init()` is client-only); the core provider mounts with null-safe
+ * accessors and switches to the real kernel on client hydration.
+ */
+declare function InterfereProvider({
+  children,
+  consent,
+  errorBoundary
+}: InterfereProviderProps): ReactNode;
+//#endregion
 export { type ConsentCategory, type ConsentState, type GateableCategory, InterfereProvider, useInterfere, useSession };