@interfere/node 0.0.1-canary.0

package/README.md

@@ -0,0 +1,30 @@
+# @interfere/node
+
+> **Status: canary.** Pre-1.0 API, expect breaking changes. Pin to a specific `10.0.0-canary.N` in CI.
+
+Node.js SDK for [Interfere](https://interfere.com).
+
+## Install
+
+```sh
+bun add @interfere/node
+```
+
+## Usage
+
+```ts
+import { init, captureError, withSpan } from "@interfere/node";
+
+await init({ serviceName: "checkout-worker" });
+
+await withSpan("checkout.fulfill", () => fulfill(order));
+
+try {
+  await doWork();
+} catch (err) {
+  captureError(err);
+  throw err;
+}
+```
+
+Set `INTERFERE_API_KEY` in the environment. Full docs at <https://interfere.com/docs>.

package/dist/capture.d.mts

@@ -0,0 +1,34 @@
+import { CaptureErrorContext } from "./internal/types.mjs";
+
+//#region src/capture.d.ts
+/**
+ * Reports an error to Interfere. Safe to call from anywhere — no-op when the
+ * SDK is not configured (`INTERFERE_API_KEY` unset) or when the `errors`
+ * plugin is disabled by remote config.
+ *
+ * Internally opens a short OTel span and records the error as an `exception`
+ * event on it. The span ships through the same `OTLPTraceExporter` wired up
+ * in `init()`, so error capture inherits the OTel transport (batch, retry,
+ * traceparent propagation) without a separate fetch path. The collector's
+ * `mapTracesToSpanEvents` lifts the OTel-semconv `exception.*` attrs plus
+ * our `interfere.exception.*` taxonomy into the `span_events` datasource.
+ *
+ * Pass the request (a `Request`, a Node `IncomingMessage`-like object, or
+ * any object with `headers`/`method`/`url`) so the span carries request
+ * context. If there's an active OTel context (e.g. an HTTP handler span),
+ * the exception attaches to it as a child; otherwise it becomes a
+ * root span.
+ */
+declare function captureError(error: unknown, request?: unknown, errorContext?: CaptureErrorContext): void;
+/**
+ * Reports a string message as an error event.
+ */
+declare function captureMessage(message: string, request?: unknown, errorContext?: CaptureErrorContext): void;
+/**
+ * Wraps a function in an OTel span. Thrown errors are recorded on the span
+ * and rethrown. Without an active provider (i.e. before `init()`), still
+ * runs `fn` but produces no telemetry.
+ */
+declare function withSpan<T>(name: string, fn: () => Promise<T> | T): Promise<T>;
+//#endregion
+export { type CaptureErrorContext, captureError, captureMessage, withSpan };

package/dist/capture.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture.d.mts","names":[],"sources":["../src/capture.ts"],"mappings":";;;;AAwCA;;;;;;;;;;AA8EA;;;;;;;iBA9EgB,YAAA,CACd,KAAA,WACA,OAAA,YACA,YAAA,GAAe,mBAAA;;;AAwFjB;iBAbgB,cAAA,CACd,OAAA,UACA,OAAA,YACA,YAAA,GAAe,mBAAA;;;;;;iBAUK,QAAA,GAAA,CACpB,IAAA,UACA,EAAA,QAAU,OAAA,CAAQ,CAAA,IAAK,CAAA,GACtB,OAAA,CAAQ,CAAA"}

package/dist/capture.mjs

@@ -0,0 +1,85 @@
+import { isErrorCaptured, markErrorCaptured } from "./internal/dedupe.mjs";
+import { isEnabledInEnvironment } from "./internal/env.mjs";
+import { normalizeRequest } from "./internal/normalize-request.mjs";
+import { isPluginEnabled } from "./internal/remote-config.mjs";
+import { MECHANISM_TYPE, toError } from "@interfere/types/sdk/errors";
+import { SpanKind, SpanStatusCode, context, trace } from "@opentelemetry/api";
+//#region src/capture.ts
+const TRACER_NAME = "@interfere/node";
+const ERROR_SPAN_NAME = "interfere.error.captured";
+const SESSION_HEADER = "x-interfere-session";
+const DEFAULT_ERROR_MECHANISM = {
+	type: MECHANISM_TYPE.node.captureError,
+	handled: true
+};
+/**
+* Reports an error to Interfere. Safe to call from anywhere — no-op when the
+* SDK is not configured (`INTERFERE_API_KEY` unset) or when the `errors`
+* plugin is disabled by remote config.
+*
+* Internally opens a short OTel span and records the error as an `exception`
+* event on it. The span ships through the same `OTLPTraceExporter` wired up
+* in `init()`, so error capture inherits the OTel transport (batch, retry,
+* traceparent propagation) without a separate fetch path. The collector's
+* `mapTracesToSpanEvents` lifts the OTel-semconv `exception.*` attrs plus
+* our `interfere.exception.*` taxonomy into the `span_events` datasource.
+*
+* Pass the request (a `Request`, a Node `IncomingMessage`-like object, or
+* any object with `headers`/`method`/`url`) so the span carries request
+* context. If there's an active OTel context (e.g. an HTTP handler span),
+* the exception attaches to it as a child; otherwise it becomes a
+* root span.
+*/
+function captureError(error, request, errorContext) {
+	if (!isEnabledInEnvironment()) return;
+	if (!isPluginEnabled("errors")) return;
+	if (isErrorCaptured(error)) return;
+	markErrorCaptured(error);
+	const err = toError(error);
+	const normalizedRequest = normalizeRequest(request);
+	const mechanism = errorContext?.mechanism ?? DEFAULT_ERROR_MECHANISM;
+	const span = trace.getTracer(TRACER_NAME).startSpan(ERROR_SPAN_NAME, { kind: SpanKind.INTERNAL }, context.active());
+	const requestMethod = errorContext?.node?.requestMethod ?? normalizedRequest?.method ?? null;
+	if (requestMethod) span.setAttribute("http.request.method", requestMethod);
+	const requestPath = errorContext?.node?.requestPath ?? normalizedRequest?.path ?? null;
+	if (requestPath) span.setAttribute("url.path", requestPath);
+	const sessionId = normalizedRequest?.headers.get(SESSION_HEADER);
+	if (sessionId) span.setAttribute("interfere.session.id", sessionId);
+	const eventAttrs = {
+		"exception.type": err.name,
+		"exception.message": err.message,
+		"interfere.exception.mechanism": mechanism.type,
+		"interfere.exception.handled": mechanism.handled
+	};
+	if (err.stack) eventAttrs["exception.stacktrace"] = err.stack;
+	const digest = errorContext?.node?.errorDigest;
+	if (digest) eventAttrs["interfere.error.digest"] = digest;
+	span.addEvent("exception", eventAttrs);
+	span.setStatus({ code: SpanStatusCode.ERROR });
+	span.end();
+}
+/**
+* Reports a string message as an error event.
+*/
+function captureMessage(message, request, errorContext) {
+	captureError(new Error(message), request, errorContext);
+}
+/**
+* Wraps a function in an OTel span. Thrown errors are recorded on the span
+* and rethrown. Without an active provider (i.e. before `init()`), still
+* runs `fn` but produces no telemetry.
+*/
+async function withSpan(name, fn) {
+	const span = trace.getTracer(TRACER_NAME).startSpan(name);
+	try {
+		return await context.with(trace.setSpan(context.active(), span), fn);
+	} catch (error) {
+		span.recordException(error);
+		span.setStatus({ code: SpanStatusCode.ERROR });
+		throw error;
+	} finally {
+		span.end();
+	}
+}
+//#endregion
+export { captureError, captureMessage, withSpan };

package/dist/capture.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"capture.mjs","names":[],"sources":["../src/capture.ts"],"sourcesContent":["import { MECHANISM_TYPE, toError } from \"@interfere/types/sdk/errors\";\nimport type { ErrorMechanism } from \"@interfere/types/sdk/plugins/payload/errors\";\n\nimport { context, SpanKind, SpanStatusCode, trace } from \"@opentelemetry/api\";\n\nimport { isErrorCaptured, markErrorCaptured } from \"./internal/dedupe.js\";\nimport { isEnabledInEnvironment } from \"./internal/env.js\";\nimport { normalizeRequest } from \"./internal/normalize-request.js\";\nimport { isPluginEnabled } from \"./internal/remote-config.js\";\nimport type { CaptureErrorContext } from \"./internal/types.js\";\n\nexport type { CaptureErrorContext } from \"./internal/types.js\";\n\nconst TRACER_NAME = \"@interfere/node\";\nconst ERROR_SPAN_NAME = \"interfere.error.captured\";\nconst SESSION_HEADER = \"x-interfere-session\";\n\nconst DEFAULT_ERROR_MECHANISM: ErrorMechanism = {\n  type: MECHANISM_TYPE.node.captureError,\n  handled: true,\n};\n\n/**\n * Reports an error to Interfere. Safe to call from anywhere — no-op when the\n * SDK is not configured (`INTERFERE_API_KEY` unset) or when the `errors`\n * plugin is disabled by remote config.\n *\n * Internally opens a short OTel span and records the error as an `exception`\n * event on it. The span ships through the same `OTLPTraceExporter` wired up\n * in `init()`, so error capture inherits the OTel transport (batch, retry,\n * traceparent propagation) without a separate fetch path. The collector's\n * `mapTracesToSpanEvents` lifts the OTel-semconv `exception.*` attrs plus\n * our `interfere.exception.*` taxonomy into the `span_events` datasource.\n *\n * Pass the request (a `Request`, a Node `IncomingMessage`-like object, or\n * any object with `headers`/`method`/`url`) so the span carries request\n * context. If there's an active OTel context (e.g. an HTTP handler span),\n * the exception attaches to it as a child; otherwise it becomes a\n * root span.\n */\nexport function captureError(\n  error: unknown,\n  request?: unknown,\n  errorContext?: CaptureErrorContext\n): void {\n  if (!isEnabledInEnvironment()) {\n    return;\n  }\n\n  if (!isPluginEnabled(\"errors\")) {\n    return;\n  }\n\n  if (isErrorCaptured(error)) {\n    return;\n  }\n  markErrorCaptured(error);\n\n  const err = toError(error);\n  const normalizedRequest = normalizeRequest(request);\n  const mechanism = errorContext?.mechanism ?? DEFAULT_ERROR_MECHANISM;\n\n  const tracer = trace.getTracer(TRACER_NAME);\n  const span = tracer.startSpan(\n    ERROR_SPAN_NAME,\n    { kind: SpanKind.INTERNAL },\n    context.active()\n  );\n\n  // Request context as span attributes (OTel HTTP semconv). Prefer an\n  // explicit `errorContext.node` payload over the normalized request when\n  // both are present — callers passing `node` are typically frameworks\n  // (Next.js error handlers) that already have the canonical values.\n  const requestMethod =\n    errorContext?.node?.requestMethod ?? normalizedRequest?.method ?? null;\n  if (requestMethod) {\n    span.setAttribute(\"http.request.method\", requestMethod);\n  }\n  const requestPath =\n    errorContext?.node?.requestPath ?? normalizedRequest?.path ?? null;\n  if (requestPath) {\n    span.setAttribute(\"url.path\", requestPath);\n  }\n\n  // Session header is the legacy bridge: browser/Next forwards\n  // `x-interfere-session` so the dashboard can stitch server errors to a\n  // user session. Lift it as a span attribute so the mapper can fold it in.\n  const sessionId = normalizedRequest?.headers.get(SESSION_HEADER);\n  if (sessionId) {\n    span.setAttribute(\"interfere.session.id\", sessionId);\n  }\n\n  // Exception event — OTel semconv naming (`exception.{type,message,\n  // stacktrace}`) plus our taxonomy (`interfere.exception.{mechanism,\n  // handled}`, `interfere.error.digest`). `mapTracesToSpanEvents` in the\n  // collector lifts both sets into typed columns on the `span_events` row.\n  const eventAttrs: Record<string, string | boolean> = {\n    \"exception.type\": err.name,\n    \"exception.message\": err.message,\n    \"interfere.exception.mechanism\": mechanism.type,\n    \"interfere.exception.handled\": mechanism.handled,\n  };\n  if (err.stack) {\n    eventAttrs[\"exception.stacktrace\"] = err.stack;\n  }\n  const digest = errorContext?.node?.errorDigest;\n  if (digest) {\n    eventAttrs[\"interfere.error.digest\"] = digest;\n  }\n\n  span.addEvent(\"exception\", eventAttrs);\n  span.setStatus({ code: SpanStatusCode.ERROR });\n  span.end();\n}\n\n/**\n * Reports a string message as an error event.\n */\nexport function captureMessage(\n  message: string,\n  request?: unknown,\n  errorContext?: CaptureErrorContext\n): void {\n  captureError(new Error(message), request, errorContext);\n}\n\n/**\n * Wraps a function in an OTel span. Thrown errors are recorded on the span\n * and rethrown. Without an active provider (i.e. before `init()`), still\n * runs `fn` but produces no telemetry.\n */\nexport async function withSpan<T>(\n  name: string,\n  fn: () => Promise<T> | T\n): Promise<T> {\n  const tracer = trace.getTracer(TRACER_NAME);\n  const span = tracer.startSpan(name);\n  try {\n    return await context.with(trace.setSpan(context.active(), span), fn);\n  } catch (error) {\n    span.recordException(error as Error);\n    span.setStatus({ code: SpanStatusCode.ERROR });\n    throw error;\n  } finally {\n    span.end();\n  }\n}\n"],"mappings":";;;;;;;AAaA,MAAM,cAAc;AACpB,MAAM,kBAAkB;AACxB,MAAM,iBAAiB;AAEvB,MAAM,0BAA0C;CAC9C,MAAM,eAAe,KAAK;CAC1B,SAAS;CACV;;;;;;;;;;;;;;;;;;;AAoBD,SAAgB,aACd,OACA,SACA,cACM;CACN,IAAI,CAAC,wBAAwB,EAC3B;CAGF,IAAI,CAAC,gBAAgB,SAAS,EAC5B;CAGF,IAAI,gBAAgB,MAAM,EACxB;CAEF,kBAAkB,MAAM;CAExB,MAAM,MAAM,QAAQ,MAAM;CAC1B,MAAM,oBAAoB,iBAAiB,QAAQ;CACnD,MAAM,YAAY,cAAc,aAAa;CAG7C,MAAM,OADS,MAAM,UAAU,YACZ,CAAC,UAClB,iBACA,EAAE,MAAM,SAAS,UAAU,EAC3B,QAAQ,QAAQ,CACjB;CAMD,MAAM,gBACJ,cAAc,MAAM,iBAAiB,mBAAmB,UAAU;CACpE,IAAI,eACF,KAAK,aAAa,uBAAuB,cAAc;CAEzD,MAAM,cACJ,cAAc,MAAM,eAAe,mBAAmB,QAAQ;CAChE,IAAI,aACF,KAAK,aAAa,YAAY,YAAY;CAM5C,MAAM,YAAY,mBAAmB,QAAQ,IAAI,eAAe;CAChE,IAAI,WACF,KAAK,aAAa,wBAAwB,UAAU;CAOtD,MAAM,aAA+C;EACnD,kBAAkB,IAAI;EACtB,qBAAqB,IAAI;EACzB,iCAAiC,UAAU;EAC3C,+BAA+B,UAAU;EAC1C;CACD,IAAI,IAAI,OACN,WAAW,0BAA0B,IAAI;CAE3C,MAAM,SAAS,cAAc,MAAM;CACnC,IAAI,QACF,WAAW,4BAA4B;CAGzC,KAAK,SAAS,aAAa,WAAW;CACtC,KAAK,UAAU,EAAE,MAAM,eAAe,OAAO,CAAC;CAC9C,KAAK,KAAK;;;;;AAMZ,SAAgB,eACd,SACA,SACA,cACM;CACN,aAAa,IAAI,MAAM,QAAQ,EAAE,SAAS,aAAa;;;;;;;AAQzD,eAAsB,SACpB,MACA,IACY;CAEZ,MAAM,OADS,MAAM,UAAU,YACZ,CAAC,UAAU,KAAK;CACnC,IAAI;EACF,OAAO,MAAM,QAAQ,KAAK,MAAM,QAAQ,QAAQ,QAAQ,EAAE,KAAK,EAAE,GAAG;UAC7D,OAAO;EACd,KAAK,gBAAgB,MAAe;EACpC,KAAK,UAAU,EAAE,MAAM,eAAe,OAAO,CAAC;EAC9C,MAAM;WACE;EACR,KAAK,KAAK"}

package/dist/index.d.mts

@@ -0,0 +1,4 @@
+import { CaptureErrorContext } from "./internal/types.mjs";
+import { captureError, captureMessage, withSpan } from "./capture.mjs";
+import { InitOptions, close, flush, init } from "./init.mjs";
+export { type CaptureErrorContext, type InitOptions, captureError, captureMessage, close, flush, init, withSpan };

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { captureError, captureMessage, withSpan } from "./capture.mjs";
+import { close, flush, init } from "./init.mjs";
+export { captureError, captureMessage, close, flush, init, withSpan };

package/dist/init.d.mts

@@ -0,0 +1,61 @@
+//#region src/init.d.ts
+interface InitOptions {
+  /**
+   * Install a `process.on("uncaughtException")` listener that captures the
+   * error, flushes spans, and exits the process. Default `true`. Disable to
+   * use your own handler.
+   */
+  readonly captureUncaughtException?: boolean;
+  /**
+   * Install a `process.on("unhandledRejection")` listener that captures the
+   * rejection and flushes spans. Default `true`. Disable to use your own
+   * handler. Whether the process exits is governed by Node's
+   * `--unhandled-rejections` flag, not the SDK.
+   */
+  readonly captureUnhandledRejection?: boolean;
+  /**
+   * Sets the OTel `service.name` resource attribute — the identity spans
+   * are grouped by in the dashboard. Defaults to `OTEL_SERVICE_NAME` env
+   * var, then `"node-app"`. Use this to distinguish workers, crons, and
+   * other processes that share an `INTERFERE_API_KEY`.
+   */
+  readonly serviceName?: string;
+  /**
+   * Sets the OTel `service.namespace` resource attribute. Optional; useful
+   * for grouping multiple services under one logical product surface
+   * (e.g. `"checkout"` across an API and worker fleet).
+   */
+  readonly serviceNamespace?: string;
+}
+/**
+ * Bootstraps the Interfere Node SDK: wires a private `NodeTracerProvider`
+ * whose spans export to the Interfere collector via OTLP/HTTP, registers an
+ * `AsyncLocalStorageContextManager` so user spans propagate across async
+ * boundaries, and fetches the remote-config gate.
+ *
+ * Idempotent — safe to call from multiple entry points; only the first call
+ * wires up.
+ *
+ * Bails silently when `INTERFERE_API_KEY` is unset so dev runs without the
+ * SDK configured don't crash.
+ *
+ * The `release.slug` resource attribute is derived deterministically from
+ * the commit SHA (auto-detected from `INTERFERE_SOURCE_ID`,
+ * `VERCEL_GIT_COMMIT_SHA`, `GITHUB_SHA`, or `git rev-parse HEAD`) plus the
+ * API key — same algorithm used by `@interfere/next` and the browser SDKs,
+ * so spans from cohabiting frontends agree on release identity.
+ */
+declare function init(options?: InitOptions): Promise<void>;
+/**
+ * Flushes any buffered spans and shuts down the tracer provider. Call from
+ * a server shutdown hook (`SIGTERM`, `process.on("beforeExit")`, framework
+ * lifecycle close) so in-flight error spans aren't lost on exit.
+ */
+declare function close(): Promise<void>;
+/**
+ * Forces buffered spans to be exported immediately. Useful in serverless
+ * runtimes where the process is suspended between requests.
+ */
+declare function flush(): Promise<void>;
+//#endregion
+export { InitOptions, close, flush, init };

package/dist/init.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.mts","names":[],"sources":["../src/init.ts"],"mappings":";UAqBiB,WAAA;EAAA;;;;;EAAA,SAMN,wBAAA;EAcA;;;;AA2BX;;EA3BW,SAPA,yBAAA;EAkCmD;;;;;;EAAA,SA3BnD,WAAA;EA4GgB;;;;AAa3B;EAb2B,SAtGhB,gBAAA;AAAA;;;;;;;;;;;;;;;;;;;iBAqBW,IAAA,CAAK,OAAA,GAAS,WAAA,GAAmB,OAAA;;;;;;iBAiFjC,KAAA,CAAA,GAAS,OAAA;;;;;iBAaT,KAAA,CAAA,GAAS,OAAA"}

package/dist/init.mjs

@@ -0,0 +1,87 @@
+import { readInterfereEnv } from "./internal/env.mjs";
+import { fetchAndCacheRemoteConfig } from "./internal/remote-config.mjs";
+import { installGlobalHandlers, uninstallGlobalHandlers } from "./internal/global-handlers.mjs";
+import { resolveReleaseSlug } from "./internal/release-slug.mjs";
+import { PRODUCER_VERSION } from "./internal/version.mjs";
+import { API_PATHS } from "@interfere/constants/api";
+import { AsyncLocalStorageContextManager } from "@opentelemetry/context-async-hooks";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+//#region src/init.ts
+const DEFAULT_SERVICE_NAME = "node-app";
+let provider = null;
+/**
+* Bootstraps the Interfere Node SDK: wires a private `NodeTracerProvider`
+* whose spans export to the Interfere collector via OTLP/HTTP, registers an
+* `AsyncLocalStorageContextManager` so user spans propagate across async
+* boundaries, and fetches the remote-config gate.
+*
+* Idempotent — safe to call from multiple entry points; only the first call
+* wires up.
+*
+* Bails silently when `INTERFERE_API_KEY` is unset so dev runs without the
+* SDK configured don't crash.
+*
+* The `release.slug` resource attribute is derived deterministically from
+* the commit SHA (auto-detected from `INTERFERE_SOURCE_ID`,
+* `VERCEL_GIT_COMMIT_SHA`, `GITHUB_SHA`, or `git rev-parse HEAD`) plus the
+* API key — same algorithm used by `@interfere/next` and the browser SDKs,
+* so spans from cohabiting frontends agree on release identity.
+*/
+async function init(options = {}) {
+	if (provider) return;
+	const env = readInterfereEnv();
+	if (!env.apiKey) return;
+	const releaseSlug = env.forceEnable ? "rel_0000000000000000" : resolveReleaseSlug().slug;
+	if (!releaseSlug) console.warn("[interfere] No commit SHA available; server spans will ship without `release.slug`. Set `INTERFERE_SOURCE_ID` (or any of `VERCEL_GIT_COMMIT_SHA`, `GITHUB_SHA`) on the runtime env.");
+	provider = new NodeTracerProvider({
+		resource: resourceFromAttributes({
+			"service.name": options.serviceName ?? process.env["OTEL_SERVICE_NAME"] ?? DEFAULT_SERVICE_NAME,
+			...options.serviceNamespace ? { "service.namespace": options.serviceNamespace } : {},
+			"deployment.environment.name": env.nodeEnvironment ?? "unknown",
+			"telemetry.sdk.language": "nodejs",
+			"interfere.sdk.name": "@interfere/node",
+			"interfere.sdk.version": PRODUCER_VERSION,
+			...releaseSlug ? { "release.slug": releaseSlug } : {}
+		}),
+		spanProcessors: [new BatchSpanProcessor(new OTLPTraceExporter({
+			url: `${env.apiUrl}${API_PATHS.SINK}`,
+			headers: {
+				"user-agent": PRODUCER_VERSION,
+				"x-api-key": env.apiKey,
+				"x-interfere-producer-version": PRODUCER_VERSION,
+				...env.forceEnable ? { "x-interfere-force-enable": "1" } : {}
+			}
+		}))]
+	});
+	provider.register({ contextManager: new AsyncLocalStorageContextManager().enable() });
+	installGlobalHandlers({
+		captureUncaughtException: options.captureUncaughtException ?? true,
+		captureUnhandledRejection: options.captureUnhandledRejection ?? true,
+		flush
+	});
+	await fetchAndCacheRemoteConfig();
+}
+/**
+* Flushes any buffered spans and shuts down the tracer provider. Call from
+* a server shutdown hook (`SIGTERM`, `process.on("beforeExit")`, framework
+* lifecycle close) so in-flight error spans aren't lost on exit.
+*/
+async function close() {
+	if (!provider) return;
+	uninstallGlobalHandlers();
+	await provider.shutdown();
+	provider = null;
+}
+/**
+* Forces buffered spans to be exported immediately. Useful in serverless
+* runtimes where the process is suspended between requests.
+*/
+async function flush() {
+	if (!provider) return;
+	await provider.forceFlush();
+}
+//#endregion
+export { close, flush, init };

package/dist/init.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.mjs","names":[],"sources":["../src/init.ts"],"sourcesContent":["import { API_PATHS } from \"@interfere/constants/api\";\n\nimport { AsyncLocalStorageContextManager } from \"@opentelemetry/context-async-hooks\";\nimport { OTLPTraceExporter } from \"@opentelemetry/exporter-trace-otlp-http\";\nimport { resourceFromAttributes } from \"@opentelemetry/resources\";\nimport { BatchSpanProcessor } from \"@opentelemetry/sdk-trace-base\";\nimport { NodeTracerProvider } from \"@opentelemetry/sdk-trace-node\";\n\nimport { readInterfereEnv } from \"./internal/env.js\";\nimport {\n  installGlobalHandlers,\n  uninstallGlobalHandlers,\n} from \"./internal/global-handlers.js\";\nimport { resolveReleaseSlug } from \"./internal/release-slug.js\";\nimport { fetchAndCacheRemoteConfig } from \"./internal/remote-config.js\";\nimport { PRODUCER_VERSION } from \"./internal/version.js\";\n\nconst DEFAULT_SERVICE_NAME = \"node-app\";\n\nlet provider: NodeTracerProvider | null = null;\n\nexport interface InitOptions {\n  /**\n   * Install a `process.on(\"uncaughtException\")` listener that captures the\n   * error, flushes spans, and exits the process. Default `true`. Disable to\n   * use your own handler.\n   */\n  readonly captureUncaughtException?: boolean;\n  /**\n   * Install a `process.on(\"unhandledRejection\")` listener that captures the\n   * rejection and flushes spans. Default `true`. Disable to use your own\n   * handler. Whether the process exits is governed by Node's\n   * `--unhandled-rejections` flag, not the SDK.\n   */\n  readonly captureUnhandledRejection?: boolean;\n  /**\n   * Sets the OTel `service.name` resource attribute — the identity spans\n   * are grouped by in the dashboard. Defaults to `OTEL_SERVICE_NAME` env\n   * var, then `\"node-app\"`. Use this to distinguish workers, crons, and\n   * other processes that share an `INTERFERE_API_KEY`.\n   */\n  readonly serviceName?: string;\n  /**\n   * Sets the OTel `service.namespace` resource attribute. Optional; useful\n   * for grouping multiple services under one logical product surface\n   * (e.g. `\"checkout\"` across an API and worker fleet).\n   */\n  readonly serviceNamespace?: string;\n}\n\n/**\n * Bootstraps the Interfere Node SDK: wires a private `NodeTracerProvider`\n * whose spans export to the Interfere collector via OTLP/HTTP, registers an\n * `AsyncLocalStorageContextManager` so user spans propagate across async\n * boundaries, and fetches the remote-config gate.\n *\n * Idempotent — safe to call from multiple entry points; only the first call\n * wires up.\n *\n * Bails silently when `INTERFERE_API_KEY` is unset so dev runs without the\n * SDK configured don't crash.\n *\n * The `release.slug` resource attribute is derived deterministically from\n * the commit SHA (auto-detected from `INTERFERE_SOURCE_ID`,\n * `VERCEL_GIT_COMMIT_SHA`, `GITHUB_SHA`, or `git rev-parse HEAD`) plus the\n * API key — same algorithm used by `@interfere/next` and the browser SDKs,\n * so spans from cohabiting frontends agree on release identity.\n */\nexport async function init(options: InitOptions = {}): Promise<void> {\n  if (provider) {\n    return;\n  }\n\n  const env = readInterfereEnv();\n  if (!env.apiKey) {\n    return;\n  }\n\n  // Force-enable swaps in the seeded `rel_local` slug so dev runs pass the\n  // collector's preflight gate without uploading source maps. Prod\n  // collectors drop force-enabled batches with a 2xx, so this header is\n  // safe to ship in dev images that escape to prod by mistake. Same\n  // pattern as `@interfere/next/config.ts` for `next dev`.\n  const releaseSlug = env.forceEnable\n    ? \"rel_0000000000000000\"\n    : resolveReleaseSlug().slug;\n\n  if (!releaseSlug) {\n    console.warn(\n      \"[interfere] No commit SHA available; server spans will ship without `release.slug`. Set `INTERFERE_SOURCE_ID` (or any of `VERCEL_GIT_COMMIT_SHA`, `GITHUB_SHA`) on the runtime env.\"\n    );\n  }\n\n  const serviceName =\n    options.serviceName ??\n    process.env[\"OTEL_SERVICE_NAME\"] ??\n    DEFAULT_SERVICE_NAME;\n\n  const resource = resourceFromAttributes({\n    \"service.name\": serviceName,\n    ...(options.serviceNamespace\n      ? { \"service.namespace\": options.serviceNamespace }\n      : {}),\n    \"deployment.environment.name\": env.nodeEnvironment ?? \"unknown\",\n    \"telemetry.sdk.language\": \"nodejs\",\n    \"interfere.sdk.name\": \"@interfere/node\",\n    \"interfere.sdk.version\": PRODUCER_VERSION,\n    ...(releaseSlug ? { \"release.slug\": releaseSlug } : {}),\n  });\n\n  const exporter = new OTLPTraceExporter({\n    // Single opaque sink endpoint shared with browser/Next exporters; see\n    // `@interfere/react/internal/otel/exporter` for the rationale.\n    url: `${env.apiUrl}${API_PATHS.SINK}`,\n    headers: {\n      // The collector's bot filter (`v2/index.ts`) silently 202-drops\n      // requests whose UA matches `isBot()`. Bun/Node's default UA gets\n      // flagged, so SDKs self-identify; the bypass regex\n      // `^@interfere/[a-z][a-z-]*@` lives in `collector/lib/bot-filter.ts`.\n      \"user-agent\": PRODUCER_VERSION,\n      \"x-api-key\": env.apiKey,\n      \"x-interfere-producer-version\": PRODUCER_VERSION,\n      ...(env.forceEnable ? { \"x-interfere-force-enable\": \"1\" } : {}),\n    },\n  });\n\n  provider = new NodeTracerProvider({\n    resource,\n    spanProcessors: [new BatchSpanProcessor(exporter)],\n  });\n\n  provider.register({\n    contextManager: new AsyncLocalStorageContextManager().enable(),\n  });\n\n  installGlobalHandlers({\n    captureUncaughtException: options.captureUncaughtException ?? true,\n    captureUnhandledRejection: options.captureUnhandledRejection ?? true,\n    flush,\n  });\n\n  await fetchAndCacheRemoteConfig();\n}\n\n/**\n * Flushes any buffered spans and shuts down the tracer provider. Call from\n * a server shutdown hook (`SIGTERM`, `process.on(\"beforeExit\")`, framework\n * lifecycle close) so in-flight error spans aren't lost on exit.\n */\nexport async function close(): Promise<void> {\n  if (!provider) {\n    return;\n  }\n  uninstallGlobalHandlers();\n  await provider.shutdown();\n  provider = null;\n}\n\n/**\n * Forces buffered spans to be exported immediately. Useful in serverless\n * runtimes where the process is suspended between requests.\n */\nexport async function flush(): Promise<void> {\n  if (!provider) {\n    return;\n  }\n  await provider.forceFlush();\n}\n"],"mappings":";;;;;;;;;;;;AAiBA,MAAM,uBAAuB;AAE7B,IAAI,WAAsC;;;;;;;;;;;;;;;;;;;AAiD1C,eAAsB,KAAK,UAAuB,EAAE,EAAiB;CACnE,IAAI,UACF;CAGF,MAAM,MAAM,kBAAkB;CAC9B,IAAI,CAAC,IAAI,QACP;CAQF,MAAM,cAAc,IAAI,cACpB,yBACA,oBAAoB,CAAC;CAEzB,IAAI,CAAC,aACH,QAAQ,KACN,sLACD;CAoCH,WAAW,IAAI,mBAAmB;EAChC,UA7Be,uBAAuB;GACtC,gBALA,QAAQ,eACR,QAAQ,IAAI,wBACZ;GAIA,GAAI,QAAQ,mBACR,EAAE,qBAAqB,QAAQ,kBAAkB,GACjD,EAAE;GACN,+BAA+B,IAAI,mBAAmB;GACtD,0BAA0B;GAC1B,sBAAsB;GACtB,yBAAyB;GACzB,GAAI,cAAc,EAAE,gBAAgB,aAAa,GAAG,EAAE;GACvD,CAmBS;EACR,gBAAgB,CAAC,IAAI,mBAAmB,IAlBrB,kBAAkB;GAGrC,KAAK,GAAG,IAAI,SAAS,UAAU;GAC/B,SAAS;IAKP,cAAc;IACd,aAAa,IAAI;IACjB,gCAAgC;IAChC,GAAI,IAAI,cAAc,EAAE,4BAA4B,KAAK,GAAG,EAAE;IAC/D;GACF,CAIiD,CAAC,CAAC;EACnD,CAAC;CAEF,SAAS,SAAS,EAChB,gBAAgB,IAAI,iCAAiC,CAAC,QAAQ,EAC/D,CAAC;CAEF,sBAAsB;EACpB,0BAA0B,QAAQ,4BAA4B;EAC9D,2BAA2B,QAAQ,6BAA6B;EAChE;EACD,CAAC;CAEF,MAAM,2BAA2B;;;;;;;AAQnC,eAAsB,QAAuB;CAC3C,IAAI,CAAC,UACH;CAEF,yBAAyB;CACzB,MAAM,SAAS,UAAU;CACzB,WAAW;;;;;;AAOb,eAAsB,QAAuB;CAC3C,IAAI,CAAC,UACH;CAEF,MAAM,SAAS,YAAY"}

package/dist/internal/dedupe.d.mts

@@ -0,0 +1,5 @@
+//#region src/internal/dedupe.d.ts
+declare function isErrorCaptured(error: unknown): boolean;
+declare function markErrorCaptured(error: unknown): void;
+//#endregion
+export { isErrorCaptured, markErrorCaptured };

package/dist/internal/dedupe.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedupe.d.mts","names":[],"sources":["../../src/internal/dedupe.ts"],"mappings":";iBAEgB,eAAA,CAAgB,KAAA;AAAA,iBAIhB,iBAAA,CAAkB,KAAA"}

package/dist/internal/dedupe.mjs

@@ -0,0 +1,11 @@
+//#region src/internal/dedupe.ts
+const seenErrors = /* @__PURE__ */ new WeakSet();
+function isErrorCaptured(error) {
+	return error instanceof Error && seenErrors.has(error);
+}
+function markErrorCaptured(error) {
+	if (!(error instanceof Error)) return;
+	seenErrors.add(error);
+}
+//#endregion
+export { isErrorCaptured, markErrorCaptured };

package/dist/internal/dedupe.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedupe.mjs","names":[],"sources":["../../src/internal/dedupe.ts"],"sourcesContent":["const seenErrors = new WeakSet<Error>();\n\nexport function isErrorCaptured(error: unknown): boolean {\n  return error instanceof Error && seenErrors.has(error);\n}\n\nexport function markErrorCaptured(error: unknown): void {\n  if (!(error instanceof Error)) {\n    return;\n  }\n\n  seenErrors.add(error);\n}\n"],"mappings":";AAAA,MAAM,6BAAa,IAAI,SAAgB;AAEvC,SAAgB,gBAAgB,OAAyB;CACvD,OAAO,iBAAiB,SAAS,WAAW,IAAI,MAAM;;AAGxD,SAAgB,kBAAkB,OAAsB;CACtD,IAAI,EAAE,iBAAiB,QACrB;CAGF,WAAW,IAAI,MAAM"}

package/dist/internal/env.d.mts

@@ -0,0 +1,20 @@
+import { Env } from "@interfere/types/sdk/runtime";
+
+//#region src/internal/env.d.ts
+interface InterfereEnv {
+  readonly apiKey: string | null;
+  readonly apiUrl: string;
+  readonly forceEnable: boolean;
+  readonly nodeEnvironment: Exclude<Env, null>;
+}
+/**
+ * Server SDKs always run end-to-end. There's no `NEXT_PUBLIC_*` force-enable
+ * escape hatch here — if `INTERFERE_API_KEY` is set, the SDK is on. The Next
+ * SDK guards on `NODE_ENV=production || NEXT_PUBLIC_INTERFERE_FORCE_ENABLE`
+ * because `next dev` runs the SDK during development without a real release
+ * slug; that asymmetry doesn't apply to plain Node servers.
+ */
+declare function isEnabledInEnvironment(): boolean;
+declare function readInterfereEnv(): InterfereEnv;
+//#endregion
+export { InterfereEnv, isEnabledInEnvironment, readInterfereEnv };

package/dist/internal/env.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.mts","names":[],"sources":["../../src/internal/env.ts"],"mappings":";;;UAKiB,YAAA;EAAA,SACN,MAAA;EAAA,SACA,MAAA;EAAA,SACA,WAAA;EAAA,SACA,eAAA,EAAiB,OAAA,CAAQ,GAAA;AAAA;;;;;;;;iBAUpB,sBAAA,CAAA;AAAA,iBAIA,gBAAA,CAAA,GAAoB,YAAA"}

package/dist/internal/env.mjs

@@ -0,0 +1,25 @@
+import { API_URL } from "@interfere/constants/api";
+import { parseEnvValue } from "@interfere/types/sdk/env";
+import { normalizeEnv } from "@interfere/types/sdk/runtime";
+//#region src/internal/env.ts
+/**
+* Server SDKs always run end-to-end. There's no `NEXT_PUBLIC_*` force-enable
+* escape hatch here — if `INTERFERE_API_KEY` is set, the SDK is on. The Next
+* SDK guards on `NODE_ENV=production || NEXT_PUBLIC_INTERFERE_FORCE_ENABLE`
+* because `next dev` runs the SDK during development without a real release
+* slug; that asymmetry doesn't apply to plain Node servers.
+*/
+function isEnabledInEnvironment() {
+	return true;
+}
+function readInterfereEnv() {
+	const nodeEnvironment = normalizeEnv(process.env["NODE_ENV"]) ?? "production";
+	return {
+		apiKey: parseEnvValue(process.env["INTERFERE_API_KEY"]),
+		apiUrl: parseEnvValue(process.env["INTERFERE_API_URL"]) ?? API_URL,
+		forceEnable: process.env["INTERFERE_FORCE_ENABLE"] === "1",
+		nodeEnvironment
+	};
+}
+//#endregion
+export { isEnabledInEnvironment, readInterfereEnv };

package/dist/internal/env.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.mjs","names":[],"sources":["../../src/internal/env.ts"],"sourcesContent":["import { API_URL } from \"@interfere/constants/api\";\nimport { parseEnvValue } from \"@interfere/types/sdk/env\";\nimport type { Env } from \"@interfere/types/sdk/runtime\";\nimport { normalizeEnv } from \"@interfere/types/sdk/runtime\";\n\nexport interface InterfereEnv {\n  readonly apiKey: string | null;\n  readonly apiUrl: string;\n  readonly forceEnable: boolean;\n  readonly nodeEnvironment: Exclude<Env, null>;\n}\n\n/**\n * Server SDKs always run end-to-end. There's no `NEXT_PUBLIC_*` force-enable\n * escape hatch here — if `INTERFERE_API_KEY` is set, the SDK is on. The Next\n * SDK guards on `NODE_ENV=production || NEXT_PUBLIC_INTERFERE_FORCE_ENABLE`\n * because `next dev` runs the SDK during development without a real release\n * slug; that asymmetry doesn't apply to plain Node servers.\n */\nexport function isEnabledInEnvironment(): boolean {\n  return true;\n}\n\nexport function readInterfereEnv(): InterfereEnv {\n  const nodeEnvironment = normalizeEnv(process.env[\"NODE_ENV\"]) ?? \"production\";\n\n  return {\n    apiKey: parseEnvValue(process.env[\"INTERFERE_API_KEY\"]),\n    apiUrl: parseEnvValue(process.env[\"INTERFERE_API_URL\"]) ?? API_URL,\n    forceEnable: process.env[\"INTERFERE_FORCE_ENABLE\"] === \"1\",\n    nodeEnvironment,\n  };\n}\n"],"mappings":";;;;;;;;;;;AAmBA,SAAgB,yBAAkC;CAChD,OAAO;;AAGT,SAAgB,mBAAiC;CAC/C,MAAM,kBAAkB,aAAa,QAAQ,IAAI,YAAY,IAAI;CAEjE,OAAO;EACL,QAAQ,cAAc,QAAQ,IAAI,qBAAqB;EACvD,QAAQ,cAAc,QAAQ,IAAI,qBAAqB,IAAI;EAC3D,aAAa,QAAQ,IAAI,8BAA8B;EACvD;EACD"}

package/dist/internal/global-handlers.d.mts

@@ -0,0 +1,25 @@
+//#region src/internal/global-handlers.d.ts
+/**
+ * Installs `process.on("uncaughtException")` and
+ * `process.on("unhandledRejection")` listeners that report to Interfere.
+ *
+ * Uncaught exceptions: captured, spans flushed (best-effort, 2s timeout),
+ * then `process.exit(1)`. Once an `uncaughtException` listener is
+ * registered, Node will not exit on its own — leaving the process alive
+ * after an uncaught error usually means a corrupted state, so we own the
+ * exit. Customers who need different exit semantics should opt out and
+ * register their own handler.
+ *
+ * Unhandled rejections: captured and flushed, but the SDK does not call
+ * `process.exit`. Whether unhandled rejections are fatal is governed by
+ * Node's `--unhandled-rejections` flag (default `throw` since v15) and we
+ * don't override that.
+ */
+declare function installGlobalHandlers(options: {
+  readonly captureUncaughtException: boolean;
+  readonly captureUnhandledRejection: boolean;
+  readonly flush: () => Promise<void>;
+}): void;
+declare function uninstallGlobalHandlers(): void;
+//#endregion
+export { installGlobalHandlers, uninstallGlobalHandlers };

package/dist/internal/global-handlers.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-handlers.d.mts","names":[],"sources":["../../src/internal/global-handlers.ts"],"mappings":";;AAyBA;;;;;;;;;;;AAoBA;;;;iBApBgB,qBAAA,CAAsB,OAAA;EAAA,SAC3B,wBAAA;EAAA,SACA,yBAAA;EAAA,SACA,KAAA,QAAa,OAAA;AAAA;AAAA,iBAiBR,uBAAA,CAAA"}

package/dist/internal/global-handlers.mjs

@@ -0,0 +1,68 @@
+import { captureError } from "../capture.mjs";
+import { MECHANISM_TYPE } from "@interfere/types/sdk/errors";
+//#region src/internal/global-handlers.ts
+const FLUSH_TIMEOUT_MS = 2e3;
+let uncaughtHandler = null;
+let unhandledHandler = null;
+/**
+* Installs `process.on("uncaughtException")` and
+* `process.on("unhandledRejection")` listeners that report to Interfere.
+*
+* Uncaught exceptions: captured, spans flushed (best-effort, 2s timeout),
+* then `process.exit(1)`. Once an `uncaughtException` listener is
+* registered, Node will not exit on its own — leaving the process alive
+* after an uncaught error usually means a corrupted state, so we own the
+* exit. Customers who need different exit semantics should opt out and
+* register their own handler.
+*
+* Unhandled rejections: captured and flushed, but the SDK does not call
+* `process.exit`. Whether unhandled rejections are fatal is governed by
+* Node's `--unhandled-rejections` flag (default `throw` since v15) and we
+* don't override that.
+*/
+function installGlobalHandlers(options) {
+	if (options.captureUncaughtException && uncaughtHandler === null) {
+		uncaughtHandler = (error) => {
+			handleUncaughtException(error, options.flush).catch(() => void 0);
+		};
+		process.on("uncaughtException", uncaughtHandler);
+	}
+	if (options.captureUnhandledRejection && unhandledHandler === null) {
+		unhandledHandler = (reason) => {
+			handleUnhandledRejection(reason, options.flush).catch(() => void 0);
+		};
+		process.on("unhandledRejection", unhandledHandler);
+	}
+}
+function uninstallGlobalHandlers() {
+	if (uncaughtHandler !== null) {
+		process.off("uncaughtException", uncaughtHandler);
+		uncaughtHandler = null;
+	}
+	if (unhandledHandler !== null) {
+		process.off("unhandledRejection", unhandledHandler);
+		unhandledHandler = null;
+	}
+}
+async function handleUncaughtException(error, flush) {
+	await captureError(error, void 0, { mechanism: {
+		type: MECHANISM_TYPE.node.uncaughtException,
+		handled: false
+	} });
+	await flushWithTimeout(flush);
+	process.exit(1);
+}
+async function handleUnhandledRejection(reason, flush) {
+	await captureError(reason, void 0, { mechanism: {
+		type: MECHANISM_TYPE.node.unhandledRejection,
+		handled: false
+	} });
+	await flushWithTimeout(flush);
+}
+function flushWithTimeout(flush) {
+	return Promise.race([flush(), new Promise((resolve) => {
+		setTimeout(resolve, FLUSH_TIMEOUT_MS);
+	})]);
+}
+//#endregion
+export { installGlobalHandlers, uninstallGlobalHandlers };

package/dist/internal/global-handlers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-handlers.mjs","names":[],"sources":["../../src/internal/global-handlers.ts"],"sourcesContent":["import { MECHANISM_TYPE } from \"@interfere/types/sdk/errors\";\n\nimport { captureError } from \"../capture.js\";\n\nconst FLUSH_TIMEOUT_MS = 2000;\n\nlet uncaughtHandler: NodeJS.UncaughtExceptionListener | null = null;\nlet unhandledHandler: NodeJS.UnhandledRejectionListener | null = null;\n\n/**\n * Installs `process.on(\"uncaughtException\")` and\n * `process.on(\"unhandledRejection\")` listeners that report to Interfere.\n *\n * Uncaught exceptions: captured, spans flushed (best-effort, 2s timeout),\n * then `process.exit(1)`. Once an `uncaughtException` listener is\n * registered, Node will not exit on its own — leaving the process alive\n * after an uncaught error usually means a corrupted state, so we own the\n * exit. Customers who need different exit semantics should opt out and\n * register their own handler.\n *\n * Unhandled rejections: captured and flushed, but the SDK does not call\n * `process.exit`. Whether unhandled rejections are fatal is governed by\n * Node's `--unhandled-rejections` flag (default `throw` since v15) and we\n * don't override that.\n */\nexport function installGlobalHandlers(options: {\n  readonly captureUncaughtException: boolean;\n  readonly captureUnhandledRejection: boolean;\n  readonly flush: () => Promise<void>;\n}): void {\n  if (options.captureUncaughtException && uncaughtHandler === null) {\n    uncaughtHandler = (error) => {\n      handleUncaughtException(error, options.flush).catch(() => undefined);\n    };\n    process.on(\"uncaughtException\", uncaughtHandler);\n  }\n\n  if (options.captureUnhandledRejection && unhandledHandler === null) {\n    unhandledHandler = (reason) => {\n      handleUnhandledRejection(reason, options.flush).catch(() => undefined);\n    };\n    process.on(\"unhandledRejection\", unhandledHandler);\n  }\n}\n\nexport function uninstallGlobalHandlers(): void {\n  if (uncaughtHandler !== null) {\n    process.off(\"uncaughtException\", uncaughtHandler);\n    uncaughtHandler = null;\n  }\n  if (unhandledHandler !== null) {\n    process.off(\"unhandledRejection\", unhandledHandler);\n    unhandledHandler = null;\n  }\n}\n\nasync function handleUncaughtException(\n  error: Error,\n  flush: () => Promise<void>\n): Promise<void> {\n  await captureError(error, undefined, {\n    mechanism: {\n      type: MECHANISM_TYPE.node.uncaughtException,\n      handled: false,\n    },\n  });\n  await flushWithTimeout(flush);\n  process.exit(1);\n}\n\nasync function handleUnhandledRejection(\n  reason: unknown,\n  flush: () => Promise<void>\n): Promise<void> {\n  await captureError(reason, undefined, {\n    mechanism: {\n      type: MECHANISM_TYPE.node.unhandledRejection,\n      handled: false,\n    },\n  });\n  await flushWithTimeout(flush);\n}\n\nfunction flushWithTimeout(flush: () => Promise<void>): Promise<void> {\n  return Promise.race([\n    flush(),\n    new Promise<void>((resolve) => {\n      setTimeout(resolve, FLUSH_TIMEOUT_MS);\n    }),\n  ]);\n}\n"],"mappings":";;;AAIA,MAAM,mBAAmB;AAEzB,IAAI,kBAA2D;AAC/D,IAAI,mBAA6D;;;;;;;;;;;;;;;;;AAkBjE,SAAgB,sBAAsB,SAI7B;CACP,IAAI,QAAQ,4BAA4B,oBAAoB,MAAM;EAChE,mBAAmB,UAAU;GAC3B,wBAAwB,OAAO,QAAQ,MAAM,CAAC,YAAY,KAAA,EAAU;;EAEtE,QAAQ,GAAG,qBAAqB,gBAAgB;;CAGlD,IAAI,QAAQ,6BAA6B,qBAAqB,MAAM;EAClE,oBAAoB,WAAW;GAC7B,yBAAyB,QAAQ,QAAQ,MAAM,CAAC,YAAY,KAAA,EAAU;;EAExE,QAAQ,GAAG,sBAAsB,iBAAiB;;;AAItD,SAAgB,0BAAgC;CAC9C,IAAI,oBAAoB,MAAM;EAC5B,QAAQ,IAAI,qBAAqB,gBAAgB;EACjD,kBAAkB;;CAEpB,IAAI,qBAAqB,MAAM;EAC7B,QAAQ,IAAI,sBAAsB,iBAAiB;EACnD,mBAAmB;;;AAIvB,eAAe,wBACb,OACA,OACe;CACf,MAAM,aAAa,OAAO,KAAA,GAAW,EACnC,WAAW;EACT,MAAM,eAAe,KAAK;EAC1B,SAAS;EACV,EACF,CAAC;CACF,MAAM,iBAAiB,MAAM;CAC7B,QAAQ,KAAK,EAAE;;AAGjB,eAAe,yBACb,QACA,OACe;CACf,MAAM,aAAa,QAAQ,KAAA,GAAW,EACpC,WAAW;EACT,MAAM,eAAe,KAAK;EAC1B,SAAS;EACV,EACF,CAAC;CACF,MAAM,iBAAiB,MAAM;;AAG/B,SAAS,iBAAiB,OAA2C;CACnE,OAAO,QAAQ,KAAK,CAClB,OAAO,EACP,IAAI,SAAe,YAAY;EAC7B,WAAW,SAAS,iBAAiB;GACrC,CACH,CAAC"}

package/dist/internal/normalize-request.d.mts

@@ -0,0 +1,15 @@
+import { NormalizedRequest } from "./types.mjs";
+
+//#region src/internal/normalize-request.d.ts
+declare const TRACEPARENT_HEADER = "traceparent";
+/**
+ * Coerces a request-shaped value into the headers/method/path triple used
+ * by envelope construction. Handles WHATWG `Request`, Node
+ * `IncomingMessage`-like objects, and plain object literals.
+ *
+ * Returns `null` only for non-objects; otherwise produces a best-effort
+ * `NormalizedRequest` with sensible defaults.
+ */
+declare function normalizeRequest(request: unknown): NormalizedRequest | null;
+//#endregion
+export { TRACEPARENT_HEADER, normalizeRequest };

package/dist/internal/normalize-request.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-request.d.mts","names":[],"sources":["../../src/internal/normalize-request.ts"],"mappings":";;;cAEa,kBAAA;;AAAb;;;;;AAUA;;iBAAgB,gBAAA,CAAiB,OAAA,YAAmB,iBAAA"}

package/dist/internal/normalize-request.mjs

@@ -0,0 +1,58 @@
+//#region src/internal/normalize-request.ts
+const TRACEPARENT_HEADER = "traceparent";
+/**
+* Coerces a request-shaped value into the headers/method/path triple used
+* by envelope construction. Handles WHATWG `Request`, Node
+* `IncomingMessage`-like objects, and plain object literals.
+*
+* Returns `null` only for non-objects; otherwise produces a best-effort
+* `NormalizedRequest` with sensible defaults.
+*/
+function normalizeRequest(request) {
+	if (request instanceof Request) return {
+		method: normalizeMethod(request.method),
+		path: normalizePath(request.url),
+		headers: request.headers
+	};
+	if (typeof request !== "object" || request === null) return null;
+	const value = request;
+	return {
+		method: normalizeMethod(value.method),
+		path: normalizePath(typeof value.path === "string" ? value.path : toStringOrDefault(value.url)),
+		headers: normalizeHeaders(value.headers)
+	};
+}
+function normalizeMethod(value) {
+	if (typeof value !== "string") return "GET";
+	const method = value.trim();
+	return method.length > 0 ? method.toUpperCase() : "GET";
+}
+function normalizePath(value) {
+	if (value.length === 0) return "/";
+	try {
+		return new URL(value, "http://localhost").pathname || "/";
+	} catch {
+		return value.startsWith("/") ? value : `/${value}`;
+	}
+}
+function toStringOrDefault(value, fallback = "/") {
+	if (typeof value !== "string") return fallback;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : fallback;
+}
+function normalizeHeaders(value) {
+	if (value instanceof Headers) return new Headers(value);
+	if (typeof value !== "object" || value === null) return new Headers();
+	const headers = new Headers();
+	for (const [key, headerValue] of Object.entries(value)) {
+		if (headerValue === void 0) continue;
+		if (Array.isArray(headerValue)) {
+			headers.set(key, headerValue.join(", "));
+			continue;
+		}
+		headers.set(key, String(headerValue));
+	}
+	return headers;
+}
+//#endregion
+export { TRACEPARENT_HEADER, normalizeRequest };

package/dist/internal/normalize-request.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-request.mjs","names":[],"sources":["../../src/internal/normalize-request.ts"],"sourcesContent":["import type { NormalizedRequest } from \"./types.js\";\n\nexport const TRACEPARENT_HEADER = \"traceparent\";\n\n/**\n * Coerces a request-shaped value into the headers/method/path triple used\n * by envelope construction. Handles WHATWG `Request`, Node\n * `IncomingMessage`-like objects, and plain object literals.\n *\n * Returns `null` only for non-objects; otherwise produces a best-effort\n * `NormalizedRequest` with sensible defaults.\n */\nexport function normalizeRequest(request: unknown): NormalizedRequest | null {\n  if (request instanceof Request) {\n    return {\n      method: normalizeMethod(request.method),\n      path: normalizePath(request.url),\n      headers: request.headers,\n    };\n  }\n\n  if (typeof request !== \"object\" || request === null) {\n    return null;\n  }\n\n  const value = request as {\n    headers?: unknown;\n    method?: unknown;\n    path?: unknown;\n    url?: unknown;\n  };\n\n  return {\n    method: normalizeMethod(value.method),\n    path: normalizePath(\n      typeof value.path === \"string\" ? value.path : toStringOrDefault(value.url)\n    ),\n    headers: normalizeHeaders(value.headers),\n  };\n}\n\nfunction normalizeMethod(value: unknown): string {\n  if (typeof value !== \"string\") {\n    return \"GET\";\n  }\n\n  const method = value.trim();\n  return method.length > 0 ? method.toUpperCase() : \"GET\";\n}\n\nfunction normalizePath(value: string): string {\n  if (value.length === 0) {\n    return \"/\";\n  }\n\n  try {\n    const parsed = new URL(value, \"http://localhost\");\n    return parsed.pathname || \"/\";\n  } catch {\n    return value.startsWith(\"/\") ? value : `/${value}`;\n  }\n}\n\nfunction toStringOrDefault(value: unknown, fallback = \"/\"): string {\n  if (typeof value !== \"string\") {\n    return fallback;\n  }\n\n  const trimmed = value.trim();\n  return trimmed.length > 0 ? trimmed : fallback;\n}\n\nfunction normalizeHeaders(value: unknown): Headers {\n  if (value instanceof Headers) {\n    return new Headers(value);\n  }\n\n  if (typeof value !== \"object\" || value === null) {\n    return new Headers();\n  }\n\n  const headers = new Headers();\n  for (const [key, headerValue] of Object.entries(value)) {\n    if (headerValue === undefined) {\n      continue;\n    }\n\n    if (Array.isArray(headerValue)) {\n      headers.set(key, headerValue.join(\", \"));\n      continue;\n    }\n\n    headers.set(key, String(headerValue));\n  }\n\n  return headers;\n}\n"],"mappings":";AAEA,MAAa,qBAAqB;;;;;;;;;AAUlC,SAAgB,iBAAiB,SAA4C;CAC3E,IAAI,mBAAmB,SACrB,OAAO;EACL,QAAQ,gBAAgB,QAAQ,OAAO;EACvC,MAAM,cAAc,QAAQ,IAAI;EAChC,SAAS,QAAQ;EAClB;CAGH,IAAI,OAAO,YAAY,YAAY,YAAY,MAC7C,OAAO;CAGT,MAAM,QAAQ;CAOd,OAAO;EACL,QAAQ,gBAAgB,MAAM,OAAO;EACrC,MAAM,cACJ,OAAO,MAAM,SAAS,WAAW,MAAM,OAAO,kBAAkB,MAAM,IAAI,CAC3E;EACD,SAAS,iBAAiB,MAAM,QAAQ;EACzC;;AAGH,SAAS,gBAAgB,OAAwB;CAC/C,IAAI,OAAO,UAAU,UACnB,OAAO;CAGT,MAAM,SAAS,MAAM,MAAM;CAC3B,OAAO,OAAO,SAAS,IAAI,OAAO,aAAa,GAAG;;AAGpD,SAAS,cAAc,OAAuB;CAC5C,IAAI,MAAM,WAAW,GACnB,OAAO;CAGT,IAAI;EAEF,OAAO,IADY,IAAI,OAAO,mBACjB,CAAC,YAAY;SACpB;EACN,OAAO,MAAM,WAAW,IAAI,GAAG,QAAQ,IAAI;;;AAI/C,SAAS,kBAAkB,OAAgB,WAAW,KAAa;CACjE,IAAI,OAAO,UAAU,UACnB,OAAO;CAGT,MAAM,UAAU,MAAM,MAAM;CAC5B,OAAO,QAAQ,SAAS,IAAI,UAAU;;AAGxC,SAAS,iBAAiB,OAAyB;CACjD,IAAI,iBAAiB,SACnB,OAAO,IAAI,QAAQ,MAAM;CAG3B,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC,OAAO,IAAI,SAAS;CAGtB,MAAM,UAAU,IAAI,SAAS;CAC7B,KAAK,MAAM,CAAC,KAAK,gBAAgB,OAAO,QAAQ,MAAM,EAAE;EACtD,IAAI,gBAAgB,KAAA,GAClB;EAGF,IAAI,MAAM,QAAQ,YAAY,EAAE;GAC9B,QAAQ,IAAI,KAAK,YAAY,KAAK,KAAK,CAAC;GACxC;;EAGF,QAAQ,IAAI,KAAK,OAAO,YAAY,CAAC;;CAGvC,OAAO"}

package/dist/internal/release-slug.d.mts

@@ -0,0 +1,8 @@
+//#region src/internal/release-slug.d.ts
+declare function resolveCommitSha(): string | null;
+declare function resolveReleaseSlug(): {
+  commitSha: string | null;
+  slug: string | null;
+};
+//#endregion
+export { resolveCommitSha, resolveReleaseSlug };

package/dist/internal/release-slug.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"release-slug.d.mts","names":[],"sources":["../../src/internal/release-slug.ts"],"mappings":";iBAkBgB,gBAAA,CAAA;AAAA,iBAOA,kBAAA,CAAA;EACd,SAAA;EACA,IAAA;AAAA"}

package/dist/internal/release-slug.mjs

@@ -0,0 +1,32 @@
+import { readFirstEnvValue } from "@interfere/types/sdk/env";
+import { releaseSourceIdEnvKeys } from "@interfere/types/integrations";
+import { deriveReleaseSlug } from "@interfere/types/releases/slug";
+import { execSync } from "node:child_process";
+//#region src/internal/release-slug.ts
+function runGitCommand(command) {
+	try {
+		const output = execSync(command, {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+		return output.length > 0 ? output : null;
+	} catch {
+		return null;
+	}
+}
+function resolveCommitSha() {
+	return readFirstEnvValue(process.env, releaseSourceIdEnvKeys) ?? runGitCommand("git rev-parse HEAD");
+}
+function resolveReleaseSlug() {
+	const commitSha = resolveCommitSha();
+	return {
+		commitSha,
+		slug: commitSha ? deriveReleaseSlug(commitSha) : null
+	};
+}
+//#endregion
+export { resolveCommitSha, resolveReleaseSlug };

package/dist/internal/release-slug.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"release-slug.mjs","names":[],"sources":["../../src/internal/release-slug.ts"],"sourcesContent":["import { releaseSourceIdEnvKeys } from \"@interfere/types/integrations\";\nimport { deriveReleaseSlug } from \"@interfere/types/releases/slug\";\nimport { readFirstEnvValue } from \"@interfere/types/sdk/env\";\n\nimport { execSync } from \"node:child_process\";\n\nfunction runGitCommand(command: string): string | null {\n  try {\n    const output = execSync(command, {\n      encoding: \"utf8\",\n      stdio: [\"ignore\", \"pipe\", \"ignore\"],\n    }).trim();\n    return output.length > 0 ? output : null;\n  } catch {\n    return null;\n  }\n}\n\nexport function resolveCommitSha(): string | null {\n  return (\n    readFirstEnvValue(process.env, releaseSourceIdEnvKeys) ??\n    runGitCommand(\"git rev-parse HEAD\")\n  );\n}\n\nexport function resolveReleaseSlug(): {\n  commitSha: string | null;\n  slug: string | null;\n} {\n  const commitSha = resolveCommitSha();\n  return {\n    commitSha,\n    slug: commitSha ? deriveReleaseSlug(commitSha) : null,\n  };\n}\n"],"mappings":";;;;;AAMA,SAAS,cAAc,SAAgC;CACrD,IAAI;EACF,MAAM,SAAS,SAAS,SAAS;GAC/B,UAAU;GACV,OAAO;IAAC;IAAU;IAAQ;IAAS;GACpC,CAAC,CAAC,MAAM;EACT,OAAO,OAAO,SAAS,IAAI,SAAS;SAC9B;EACN,OAAO;;;AAIX,SAAgB,mBAAkC;CAChD,OACE,kBAAkB,QAAQ,KAAK,uBAAuB,IACtD,cAAc,qBAAqB;;AAIvC,SAAgB,qBAGd;CACA,MAAM,YAAY,kBAAkB;CACpC,OAAO;EACL;EACA,MAAM,YAAY,kBAAkB,UAAU,GAAG;EAClD"}

package/dist/internal/remote-config.d.mts

@@ -0,0 +1,5 @@
+//#region src/internal/remote-config.d.ts
+declare function fetchAndCacheRemoteConfig(): Promise<void>;
+declare function isPluginEnabled(plugin: string): boolean;
+//#endregion
+export { fetchAndCacheRemoteConfig, isPluginEnabled };

package/dist/internal/remote-config.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-config.d.mts","names":[],"sources":["../../src/internal/remote-config.ts"],"mappings":";iBAUsB,yBAAA,CAAA,GAA6B,OAAA;AAAA,iBAkCnC,eAAA,CAAgB,MAAA"}

package/dist/internal/remote-config.mjs

@@ -0,0 +1,29 @@
+import { isEnabledInEnvironment, readInterfereEnv } from "./env.mjs";
+import { API_PATHS } from "@interfere/constants/api";
+//#region src/internal/remote-config.ts
+let cachedConfig = null;
+async function fetchAndCacheRemoteConfig() {
+	if (!isEnabledInEnvironment()) return;
+	const env = readInterfereEnv();
+	if (env.apiKey === null) return;
+	try {
+		const url = `${env.apiUrl}${API_PATHS.CONFIG}`;
+		const response = await fetch(url, {
+			method: "GET",
+			headers: {
+				"content-type": "application/json",
+				"x-api-key": env.apiKey
+			},
+			signal: AbortSignal.timeout(1e4)
+		});
+		if (!response.ok) return;
+		const config = await response.json();
+		if (config?.plugins) cachedConfig = config.plugins;
+	} catch {}
+}
+function isPluginEnabled(plugin) {
+	if (!cachedConfig) return true;
+	return cachedConfig[plugin] !== false;
+}
+//#endregion
+export { fetchAndCacheRemoteConfig, isPluginEnabled };

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

@@ -0,0 +1 @@
+{"version":3,"file":"remote-config.mjs","names":[],"sources":["../../src/internal/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;CAC/D,IAAI,CAAC,wBAAwB,EAC3B;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/types.d.mts

@@ -0,0 +1,16 @@
+import { NodeContext } from "@interfere/types/sdk/plugins/context/node";
+import { ErrorMechanism } from "@interfere/types/sdk/plugins/payload/errors";
+
+//#region src/internal/types.d.ts
+interface CaptureErrorContext {
+  readonly mechanism?: ErrorMechanism;
+  readonly node?: Omit<NodeContext, "runtime">;
+  readonly traceparent?: string;
+}
+interface NormalizedRequest {
+  readonly headers: Headers;
+  readonly method: string;
+  readonly path: string;
+}
+//#endregion
+export { CaptureErrorContext, NormalizedRequest };

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/internal/types.ts"],"mappings":";;;;UAGiB,mBAAA;EAAA,SACN,SAAA,GAAY,cAAA;EAAA,SACZ,IAAA,GAAO,IAAA,CAAK,WAAA;EAAA,SACZ,WAAA;AAAA;AAAA,UAGM,iBAAA;EAAA,SACN,OAAA,EAAS,OAAA;EAAA,SACT,MAAA;EAAA,SACA,IAAA;AAAA"}

package/dist/internal/types.mjs

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

package/dist/internal/version.d.mts

@@ -0,0 +1,4 @@
+//#region src/internal/version.d.ts
+declare const PRODUCER_VERSION: string;
+//#endregion
+export { PRODUCER_VERSION };

package/dist/internal/version.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.mts","names":[],"sources":["../../src/internal/version.ts"],"mappings":";cAEa,gBAAA"}

package/dist/internal/version.mjs

@@ -0,0 +1,5 @@
+import { name, version } from "../package.mjs";
+//#region src/internal/version.ts
+const PRODUCER_VERSION = `${name}@${version}`;
+//#endregion
+export { PRODUCER_VERSION };

package/dist/internal/version.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.mjs","names":["pkg.name","pkg.version"],"sources":["../../src/internal/version.ts"],"sourcesContent":["import pkg from \"../../package.json\" with { type: \"json\" };\n\nexport const PRODUCER_VERSION = `${pkg.name}@${pkg.version}`;\n"],"mappings":";;AAEA,MAAa,mBAAmB,GAAGA,KAAS,GAAGC"}

package/dist/package.mjs

@@ -0,0 +1,5 @@
+//#region package.json
+var name = "@interfere/node";
+var version = "0.0.1-canary.0";
+//#endregion
+export { name, version };

package/dist/package.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"package.mjs","names":[],"sources":["../package.json"],"sourcesContent":[""],"mappings":""}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@interfere/node",
+  "version": "0.0.1-canary.0",
+  "license": "MIT",
+  "description": "Node.js SDK for Interfere. Error tracking and OTel instrumentation for any Node server.",
+  "keywords": [
+    "observability",
+    "typescript",
+    "nodejs",
+    "error-tracking",
+    "opentelemetry"
+  ],
+  "homepage": "https://interfere.com",
+  "bugs": {
+    "url": "mailto:support@interfere.com"
+  },
+  "author": "Interfere <support@interfere.com> (https://interfere.com)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/interfere-inc/interfere.git",
+    "directory": "src/packages/public/node"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "@source": "./src/index.ts",
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./init": {
+      "@source": "./src/init.ts",
+      "types": "./dist/init.d.mts",
+      "default": "./dist/init.mjs"
+    },
+    "./capture": {
+      "@source": "./src/capture.ts",
+      "types": "./dist/capture.d.mts",
+      "default": "./dist/capture.mjs"
+    }
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public",
+    "tag": "canary"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit --incremental"
+  },
+  "dependencies": {
+    "@interfere/constants": "^9.0.1",
+    "@interfere/types": "^9.0.0",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/context-async-hooks": "^2.7.1",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.217.0",
+    "@opentelemetry/resources": "^2.7.0",
+    "@opentelemetry/sdk-trace-base": "^2.7.0",
+    "@opentelemetry/sdk-trace-node": "^2.7.1",
+    "uuid": "^14.0.0"
+  },
+  "devDependencies": {
+    "@interfere/test-utils": "^9.0.0",
+    "@interfere/typescript-config": "^9.0.0",
+    "@types/node": "^24.12.0",
+    "@vitest/coverage-v8": "^4.1.6",
+    "tsdown": "^0.22.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.6"
+  }
+}