@interfere/node 0.0.1-canary.0 → 0.0.1-canary.2

package/README.md

@@ -27,4 +27,4 @@ try {
 }
 ```
 
-Set `INTERFERE_API_KEY` in the environment. Full docs at <https://interfere.com/docs>.
+Set `INTERFERE_PUBLIC_KEY` to your surface's `interfere_pk_*` public key. Full docs at <https://interfere.com/docs>.

package/dist/capture.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const require_internal_dedupe=require("./internal/dedupe.cjs"),require_internal_env=require("./internal/env.cjs"),require_internal_normalize_request=require("./internal/normalize-request.cjs");let _interfere_types_sdk_errors=require("@interfere/types/sdk/errors"),_opentelemetry_api=require("@opentelemetry/api");const TRACER_NAME=`@interfere/node`,DEFAULT_ERROR_MECHANISM={type:_interfere_types_sdk_errors.MECHANISM_TYPE.node.captureError,handled:!0};function captureError(error,request,errorContext){if(!require_internal_env.isEnabledInEnvironment()||require_internal_dedupe.isErrorCaptured(error))return;require_internal_dedupe.markErrorCaptured(error);let err=(0,_interfere_types_sdk_errors.toError)(error),normalizedRequest=require_internal_normalize_request.normalizeRequest(request),mechanism=errorContext?.mechanism??DEFAULT_ERROR_MECHANISM,span=_opentelemetry_api.trace.getTracer(TRACER_NAME).startSpan(`interfere.error.captured`,{kind:_opentelemetry_api.SpanKind.INTERNAL},_opentelemetry_api.context.active()),requestMethod=errorContext?.node?.requestMethod??normalizedRequest?.method??null;requestMethod&&span.setAttribute(`http.request.method`,requestMethod);let requestPath=errorContext?.node?.requestPath??normalizedRequest?.path??null;requestPath&&span.setAttribute(`url.path`,requestPath);let sessionId=normalizedRequest?.headers.get(`x-interfere-session`);sessionId&&span.setAttribute(`interfere.session.id`,sessionId);let eventAttrs={"exception.type":err.name,"exception.message":err.message,"interfere.exception.mechanism":mechanism.type,"interfere.exception.handled":mechanism.handled};err.stack&&(eventAttrs[`exception.stacktrace`]=err.stack);let digest=errorContext?.node?.errorDigest;digest&&(eventAttrs[`interfere.error.digest`]=digest),span.addEvent(`exception`,eventAttrs),span.setStatus({code:_opentelemetry_api.SpanStatusCode.ERROR}),span.end()}function captureMessage(message,request,errorContext){captureError(Error(message),request,errorContext)}async function withSpan(name,fn){let span=_opentelemetry_api.trace.getTracer(TRACER_NAME).startSpan(name);try{return await _opentelemetry_api.context.with(_opentelemetry_api.trace.setSpan(_opentelemetry_api.context.active(),span),fn)}catch(error){throw span.recordException(error),span.setStatus({code:_opentelemetry_api.SpanStatusCode.ERROR}),error}finally{span.end()}}exports.captureError=captureError,exports.captureMessage=captureMessage,exports.withSpan=withSpan;

package/dist/capture.d.cts

@@ -0,0 +1,34 @@
+import { CaptureErrorContext } from "./internal/types.cjs";
+
+//#region src/capture.d.ts
+/**
+ * Reports an error to Interfere. Safe to call from anywhere — no-op when the
+ * SDK is not configured (`INTERFERE_PUBLIC_KEY` unset).
+ *
+ * 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 };
+//# sourceMappingURL=capture.d.cts.map

package/dist/capture.d.mts

@@ -3,8 +3,7 @@ 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.
+ * SDK is not configured (`INTERFERE_PUBLIC_KEY` unset).
  *
  * 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
@@ -31,4 +30,5 @@ declare function captureMessage(message: string, request?: unknown, errorContext
  */
 declare function withSpan<T>(name: string, fn: () => Promise<T> | T): Promise<T>;
 //#endregion
-export { type CaptureErrorContext, captureError, captureMessage, withSpan };
+export { type CaptureErrorContext, captureError, captureMessage, withSpan };
+//# sourceMappingURL=capture.d.mts.map

package/dist/capture.mjs

@@ -1,85 +1,2 @@
-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 };
+import{isErrorCaptured,markErrorCaptured}from"./internal/dedupe.mjs";import{isEnabledInEnvironment}from"./internal/env.mjs";import{normalizeRequest}from"./internal/normalize-request.mjs";import{MECHANISM_TYPE,toError}from"@interfere/types/sdk/errors";import{SpanKind,SpanStatusCode,context,trace}from"@opentelemetry/api";const TRACER_NAME=`@interfere/node`,DEFAULT_ERROR_MECHANISM={type:MECHANISM_TYPE.node.captureError,handled:!0};function captureError(error,request,errorContext){if(!isEnabledInEnvironment()||isErrorCaptured(error))return;markErrorCaptured(error);let err=toError(error),normalizedRequest=normalizeRequest(request),mechanism=errorContext?.mechanism??DEFAULT_ERROR_MECHANISM,span=trace.getTracer(TRACER_NAME).startSpan(`interfere.error.captured`,{kind:SpanKind.INTERNAL},context.active()),requestMethod=errorContext?.node?.requestMethod??normalizedRequest?.method??null;requestMethod&&span.setAttribute(`http.request.method`,requestMethod);let requestPath=errorContext?.node?.requestPath??normalizedRequest?.path??null;requestPath&&span.setAttribute(`url.path`,requestPath);let sessionId=normalizedRequest?.headers.get(`x-interfere-session`);sessionId&&span.setAttribute(`interfere.session.id`,sessionId);let eventAttrs={"exception.type":err.name,"exception.message":err.message,"interfere.exception.mechanism":mechanism.type,"interfere.exception.handled":mechanism.handled};err.stack&&(eventAttrs[`exception.stacktrace`]=err.stack);let digest=errorContext?.node?.errorDigest;digest&&(eventAttrs[`interfere.error.digest`]=digest),span.addEvent(`exception`,eventAttrs),span.setStatus({code:SpanStatusCode.ERROR}),span.end()}function captureMessage(message,request,errorContext){captureError(Error(message),request,errorContext)}async function withSpan(name,fn){let span=trace.getTracer(TRACER_NAME).startSpan(name);try{return await context.with(trace.setSpan(context.active(),span),fn)}catch(error){throw span.recordException(error),span.setStatus({code:SpanStatusCode.ERROR}),error}finally{span.end()}}export{captureError,captureMessage,withSpan};
+//# sourceMappingURL=capture.mjs.map

package/dist/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const require_capture=require("./capture.cjs"),require_init=require("./init.cjs");exports.captureError=require_capture.captureError,exports.captureMessage=require_capture.captureMessage,exports.close=require_init.close,exports.flush=require_init.flush,exports.init=require_init.init,exports.withSpan=require_capture.withSpan;

package/dist/index.d.cts

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

package/dist/index.mjs

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

package/dist/init.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const require_internal_env=require("./internal/env.cjs"),require_internal_global_handlers=require("./internal/global-handlers.cjs"),require_internal_release_slug=require("./internal/release-slug.cjs"),require_internal_url=require("./internal/url.cjs"),require_internal_version=require("./internal/version.cjs");let _interfere_constants_api=require("@interfere/constants/api"),_interfere_types_releases_slug=require("@interfere/types/releases/slug"),_opentelemetry_context_async_hooks=require("@opentelemetry/context-async-hooks"),_opentelemetry_exporter_trace_otlp_http=require("@opentelemetry/exporter-trace-otlp-http"),_opentelemetry_resources=require("@opentelemetry/resources"),_opentelemetry_sdk_trace_base=require("@opentelemetry/sdk-trace-base"),_opentelemetry_sdk_trace_node=require("@opentelemetry/sdk-trace-node"),provider=null;function init(options={}){if(provider)return;let env=require_internal_env.readInterfereEnv();if(!env.publicKey)return;let releaseSlug=env.forceEnable?_interfere_types_releases_slug.LOCAL_DEV_RELEASE_SLUG:require_internal_release_slug.resolveReleaseSlug().slug;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 _opentelemetry_sdk_trace_node.NodeTracerProvider({resource:(0,_opentelemetry_resources.resourceFromAttributes)({"service.name":options.serviceName??process.env.OTEL_SERVICE_NAME??`node-app`,...options.serviceNamespace?{"service.namespace":options.serviceNamespace}:{},"deployment.environment.name":env.nodeEnvironment??`unknown`,"telemetry.sdk.language":`nodejs`,"interfere.sdk.name":`@interfere/node`,"interfere.sdk.version":require_internal_version.PRODUCER_VERSION,...releaseSlug?{"release.slug":releaseSlug}:{}}),spanProcessors:[new _opentelemetry_sdk_trace_base.BatchSpanProcessor(new _opentelemetry_exporter_trace_otlp_http.OTLPTraceExporter({url:require_internal_url.withPublicKey(`${env.apiUrl}${_interfere_constants_api.API_PATHS.SINK}`,env.publicKey),headers:{"user-agent":require_internal_version.PRODUCER_VERSION,"x-interfere-producer-version":require_internal_version.PRODUCER_VERSION,...env.forceEnable?{"x-interfere-force-enable":`1`}:{}}}))]}),provider.register({contextManager:new _opentelemetry_context_async_hooks.AsyncLocalStorageContextManager().enable()}),require_internal_global_handlers.installGlobalHandlers({captureUncaughtException:options.captureUncaughtException??!0,captureUnhandledRejection:options.captureUnhandledRejection??!0,flush})}async function close(){provider&&=(require_internal_global_handlers.uninstallGlobalHandlers(),await provider.shutdown(),null)}async function flush(){provider&&await provider.forceFlush()}exports.close=close,exports.flush=flush,exports.init=init;

package/dist/init.d.cts

@@ -0,0 +1,62 @@
+//#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_PUBLIC_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.
+ *
+ * Idempotent — safe to call from multiple entry points; only the first call
+ * wires up.
+ *
+ * Bails silently when `INTERFERE_PUBLIC_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
+ * public 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): 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 };
+//# sourceMappingURL=init.d.cts.map

package/dist/init.d.mts

@@ -17,7 +17,7 @@ interface InitOptions {
    * 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`.
+   * other processes that share an `INTERFERE_PUBLIC_KEY`.
    */
   readonly serviceName?: string;
   /**
@@ -31,21 +31,21 @@ interface InitOptions {
  * 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.
+ * boundaries.
  *
  * 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
+ * Bails silently when `INTERFERE_PUBLIC_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,
+ * public 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>;
+declare function init(options?: InitOptions): void;
 /**
  * Flushes any buffered spans and shuts down the tracer provider. Call from
  * a server shutdown hook (`SIGTERM`, `process.on("beforeExit")`, framework
@@ -58,4 +58,5 @@ declare function close(): Promise<void>;
  */
 declare function flush(): Promise<void>;
 //#endregion
-export { InitOptions, close, flush, init };
+export { InitOptions, close, flush, init };
+//# sourceMappingURL=init.d.mts.map

package/dist/init.mjs

@@ -1,87 +1,2 @@
-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 };
+import{readInterfereEnv}from"./internal/env.mjs";import{installGlobalHandlers,uninstallGlobalHandlers}from"./internal/global-handlers.mjs";import{resolveReleaseSlug}from"./internal/release-slug.mjs";import{withPublicKey}from"./internal/url.mjs";import{PRODUCER_VERSION}from"./internal/version.mjs";import{API_PATHS}from"@interfere/constants/api";import{LOCAL_DEV_RELEASE_SLUG}from"@interfere/types/releases/slug";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";let provider=null;function init(options={}){if(provider)return;let env=readInterfereEnv();if(!env.publicKey)return;let releaseSlug=env.forceEnable?LOCAL_DEV_RELEASE_SLUG:resolveReleaseSlug().slug;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??`node-app`,...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:withPublicKey(`${env.apiUrl}${API_PATHS.SINK}`,env.publicKey),headers:{"user-agent":PRODUCER_VERSION,"x-interfere-producer-version":PRODUCER_VERSION,...env.forceEnable?{"x-interfere-force-enable":`1`}:{}}}))]}),provider.register({contextManager:new AsyncLocalStorageContextManager().enable()}),installGlobalHandlers({captureUncaughtException:options.captureUncaughtException??!0,captureUnhandledRejection:options.captureUnhandledRejection??!0,flush})}async function close(){provider&&=(uninstallGlobalHandlers(),await provider.shutdown(),null)}async function flush(){provider&&await provider.forceFlush()}export{close,flush,init};
+//# sourceMappingURL=init.mjs.map

package/dist/internal/dedupe.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const seenErrors=new WeakSet;function isErrorCaptured(error){return error instanceof Error&&seenErrors.has(error)}function markErrorCaptured(error){error instanceof Error&&seenErrors.add(error)}exports.isErrorCaptured=isErrorCaptured,exports.markErrorCaptured=markErrorCaptured;

package/dist/internal/dedupe.d.cts

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

package/dist/internal/dedupe.d.mts

@@ -2,4 +2,5 @@
 declare function isErrorCaptured(error: unknown): boolean;
 declare function markErrorCaptured(error: unknown): void;
 //#endregion
-export { isErrorCaptured, markErrorCaptured };
+export { isErrorCaptured, markErrorCaptured };
+//# sourceMappingURL=dedupe.d.mts.map

package/dist/internal/dedupe.mjs

@@ -1,11 +1,2 @@
-//#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 };
+const seenErrors=new WeakSet;function isErrorCaptured(error){return error instanceof Error&&seenErrors.has(error)}function markErrorCaptured(error){error instanceof Error&&seenErrors.add(error)}export{isErrorCaptured,markErrorCaptured};
+//# sourceMappingURL=dedupe.mjs.map

package/dist/internal/env.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});let _interfere_constants_api=require("@interfere/constants/api"),_interfere_types_sdk_env=require("@interfere/types/sdk/env"),_interfere_types_sdk_runtime=require("@interfere/types/sdk/runtime");function isEnabledInEnvironment(){return!0}function readInterfereEnv(){let nodeEnvironment=(0,_interfere_types_sdk_runtime.normalizeEnv)(process.env.NODE_ENV);return{apiUrl:(0,_interfere_types_sdk_env.parseEnvValue)(process.env.INTERFERE_API_URL)??_interfere_constants_api.API_URL,forceEnable:process.env.INTERFERE_FORCE_ENABLE===`1`,nodeEnvironment,publicKey:(0,_interfere_types_sdk_env.parseEnvValue)(process.env.INTERFERE_PUBLIC_KEY)}}exports.isEnabledInEnvironment=isEnabledInEnvironment,exports.readInterfereEnv=readInterfereEnv;

package/dist/internal/env.d.cts

@@ -0,0 +1,21 @@
+import { Env } from "@interfere/types/sdk/runtime";
+
+//#region src/internal/env.d.ts
+interface InterfereEnv {
+  readonly apiUrl: string;
+  readonly forceEnable: boolean;
+  readonly nodeEnvironment: Env;
+  readonly publicKey: string | null;
+}
+/**
+ * Server SDKs always run end-to-end. There's no `NEXT_PUBLIC_*` force-enable
+ * escape hatch here — if `INTERFERE_PUBLIC_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 };
+//# sourceMappingURL=env.d.cts.map

package/dist/internal/env.d.mts

@@ -2,14 +2,14 @@ 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>;
+  readonly nodeEnvironment: Env;
+  readonly publicKey: string | 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
+ * escape hatch here — if `INTERFERE_PUBLIC_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.
@@ -17,4 +17,5 @@ interface InterfereEnv {
 declare function isEnabledInEnvironment(): boolean;
 declare function readInterfereEnv(): InterfereEnv;
 //#endregion
-export { InterfereEnv, isEnabledInEnvironment, readInterfereEnv };
+export { InterfereEnv, isEnabledInEnvironment, readInterfereEnv };
+//# sourceMappingURL=env.d.mts.map

package/dist/internal/env.mjs

@@ -1,25 +1,2 @@
-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 };
+import{API_URL}from"@interfere/constants/api";import{parseEnvValue}from"@interfere/types/sdk/env";import{normalizeEnv}from"@interfere/types/sdk/runtime";function isEnabledInEnvironment(){return!0}function readInterfereEnv(){let nodeEnvironment=normalizeEnv(process.env.NODE_ENV);return{apiUrl:parseEnvValue(process.env.INTERFERE_API_URL)??API_URL,forceEnable:process.env.INTERFERE_FORCE_ENABLE===`1`,nodeEnvironment,publicKey:parseEnvValue(process.env.INTERFERE_PUBLIC_KEY)}}export{isEnabledInEnvironment,readInterfereEnv};
+//# sourceMappingURL=env.mjs.map

package/dist/internal/global-handlers.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const require_capture=require("../capture.cjs");let _interfere_types_sdk_errors=require("@interfere/types/sdk/errors"),uncaughtHandler=null,unhandledHandler=null;function installGlobalHandlers(options){options.captureUncaughtException&&uncaughtHandler===null&&(uncaughtHandler=error=>{handleUncaughtException(error,options.flush).catch(()=>void 0)},process.on(`uncaughtException`,uncaughtHandler)),options.captureUnhandledRejection&&unhandledHandler===null&&(unhandledHandler=reason=>{handleUnhandledRejection(reason,options.flush).catch(()=>void 0)},process.on(`unhandledRejection`,unhandledHandler))}function uninstallGlobalHandlers(){uncaughtHandler!==null&&(process.off(`uncaughtException`,uncaughtHandler),uncaughtHandler=null),unhandledHandler!==null&&(process.off(`unhandledRejection`,unhandledHandler),unhandledHandler=null)}async function handleUncaughtException(error,flush){await require_capture.captureError(error,void 0,{mechanism:{type:_interfere_types_sdk_errors.MECHANISM_TYPE.node.uncaughtException,handled:!1}}),await flushWithTimeout(flush),process.exit(1)}async function handleUnhandledRejection(reason,flush){await require_capture.captureError(reason,void 0,{mechanism:{type:_interfere_types_sdk_errors.MECHANISM_TYPE.node.unhandledRejection,handled:!1}}),await flushWithTimeout(flush)}function flushWithTimeout(flush){return Promise.race([flush(),new Promise(resolve=>{setTimeout(resolve,2e3)})])}exports.installGlobalHandlers=installGlobalHandlers,exports.uninstallGlobalHandlers=uninstallGlobalHandlers;

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

@@ -0,0 +1,26 @@
+//#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 };
+//# sourceMappingURL=global-handlers.d.cts.map

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

@@ -22,4 +22,5 @@ declare function installGlobalHandlers(options: {
 }): void;
 declare function uninstallGlobalHandlers(): void;
 //#endregion
-export { installGlobalHandlers, uninstallGlobalHandlers };
+export { installGlobalHandlers, uninstallGlobalHandlers };
+//# sourceMappingURL=global-handlers.d.mts.map

package/dist/internal/global-handlers.mjs

@@ -1,68 +1,2 @@
-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 };
+import{captureError}from"../capture.mjs";import{MECHANISM_TYPE}from"@interfere/types/sdk/errors";let uncaughtHandler=null,unhandledHandler=null;function installGlobalHandlers(options){options.captureUncaughtException&&uncaughtHandler===null&&(uncaughtHandler=error=>{handleUncaughtException(error,options.flush).catch(()=>void 0)},process.on(`uncaughtException`,uncaughtHandler)),options.captureUnhandledRejection&&unhandledHandler===null&&(unhandledHandler=reason=>{handleUnhandledRejection(reason,options.flush).catch(()=>void 0)},process.on(`unhandledRejection`,unhandledHandler))}function uninstallGlobalHandlers(){uncaughtHandler!==null&&(process.off(`uncaughtException`,uncaughtHandler),uncaughtHandler=null),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:!1}}),await flushWithTimeout(flush),process.exit(1)}async function handleUnhandledRejection(reason,flush){await captureError(reason,void 0,{mechanism:{type:MECHANISM_TYPE.node.unhandledRejection,handled:!1}}),await flushWithTimeout(flush)}function flushWithTimeout(flush){return Promise.race([flush(),new Promise(resolve=>{setTimeout(resolve,2e3)})])}export{installGlobalHandlers,uninstallGlobalHandlers};
+//# sourceMappingURL=global-handlers.mjs.map

package/dist/internal/normalize-request.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function normalizeRequest(request){if(request instanceof Request)return{method:normalizeMethod(request.method),path:normalizePath(request.url),headers:request.headers};if(typeof request!=`object`||!request)return null;let 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`;let 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;let 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)return new Headers;let headers=new Headers;for(let[key,headerValue]of Object.entries(value))if(headerValue!==void 0){if(Array.isArray(headerValue)){headers.set(key,headerValue.join(`, `));continue}headers.set(key,String(headerValue))}return headers}exports.TRACEPARENT_HEADER=`traceparent`,exports.normalizeRequest=normalizeRequest;

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

@@ -0,0 +1,16 @@
+import { NormalizedRequest } from "./types.cjs";
+
+//#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 };
+//# sourceMappingURL=normalize-request.d.cts.map

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

@@ -12,4 +12,5 @@ declare const TRACEPARENT_HEADER = "traceparent";
  */
 declare function normalizeRequest(request: unknown): NormalizedRequest | null;
 //#endregion
-export { TRACEPARENT_HEADER, normalizeRequest };
+export { TRACEPARENT_HEADER, normalizeRequest };
+//# sourceMappingURL=normalize-request.d.mts.map

package/dist/internal/normalize-request.mjs

@@ -1,58 +1,2 @@
-//#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 };
+const TRACEPARENT_HEADER=`traceparent`;function normalizeRequest(request){if(request instanceof Request)return{method:normalizeMethod(request.method),path:normalizePath(request.url),headers:request.headers};if(typeof request!=`object`||!request)return null;let 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`;let 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;let 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)return new Headers;let headers=new Headers;for(let[key,headerValue]of Object.entries(value))if(headerValue!==void 0){if(Array.isArray(headerValue)){headers.set(key,headerValue.join(`, `));continue}headers.set(key,String(headerValue))}return headers}export{TRACEPARENT_HEADER,normalizeRequest};
+//# sourceMappingURL=normalize-request.mjs.map

package/dist/internal/release-slug.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});let _interfere_types_sdk_env=require("@interfere/types/sdk/env"),_interfere_types_releases_slug=require("@interfere/types/releases/slug"),_interfere_types_integrations=require("@interfere/types/integrations"),node_child_process=require("node:child_process");function runGitCommand(command){try{let output=(0,node_child_process.execSync)(command,{encoding:`utf8`,stdio:[`ignore`,`pipe`,`ignore`]}).trim();return output.length>0?output:null}catch{return null}}function resolveCommitSha(){return(0,_interfere_types_sdk_env.readFirstEnvValue)(process.env,_interfere_types_integrations.releaseSourceIdEnvKeys)??runGitCommand(`git rev-parse HEAD`)}function resolveReleaseSlug(){let commitSha=resolveCommitSha();return{commitSha,slug:commitSha?(0,_interfere_types_releases_slug.deriveReleaseSlug)(commitSha):null}}exports.resolveCommitSha=resolveCommitSha,exports.resolveReleaseSlug=resolveReleaseSlug;

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

@@ -0,0 +1,9 @@
+//#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 };
+//# sourceMappingURL=release-slug.d.cts.map

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

@@ -5,4 +5,5 @@ declare function resolveReleaseSlug(): {
   slug: string | null;
 };
 //#endregion
-export { resolveCommitSha, resolveReleaseSlug };
+export { resolveCommitSha, resolveReleaseSlug };
+//# sourceMappingURL=release-slug.d.mts.map

package/dist/internal/release-slug.mjs

@@ -1,32 +1,2 @@
-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 };
+import{readFirstEnvValue}from"@interfere/types/sdk/env";import{deriveReleaseSlug}from"@interfere/types/releases/slug";import{releaseSourceIdEnvKeys}from"@interfere/types/integrations";import{execSync}from"node:child_process";function runGitCommand(command){try{let 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(){let commitSha=resolveCommitSha();return{commitSha,slug:commitSha?deriveReleaseSlug(commitSha):null}}export{resolveCommitSha,resolveReleaseSlug};
+//# sourceMappingURL=release-slug.mjs.map

package/dist/internal/types.d.cts

@@ -0,0 +1,17 @@
+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 };
+//# sourceMappingURL=types.d.cts.map

package/dist/internal/types.d.mts

@@ -13,4 +13,5 @@ interface NormalizedRequest {
   readonly path: string;
 }
 //#endregion
-export { CaptureErrorContext, NormalizedRequest };
+export { CaptureErrorContext, NormalizedRequest };
+//# sourceMappingURL=types.d.mts.map

package/dist/internal/types.mjs

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

package/dist/internal/url.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function withPublicKey(url,publicKey){let next=new URL(url);return next.searchParams.set(`pk`,publicKey),next.toString()}exports.withPublicKey=withPublicKey;

package/dist/internal/url.d.cts

@@ -0,0 +1,5 @@
+//#region src/internal/url.d.ts
+declare function withPublicKey(url: string, publicKey: string): string;
+//#endregion
+export { withPublicKey };
+//# sourceMappingURL=url.d.cts.map

package/dist/internal/url.d.mts

@@ -0,0 +1,5 @@
+//#region src/internal/url.d.ts
+declare function withPublicKey(url: string, publicKey: string): string;
+//#endregion
+export { withPublicKey };
+//# sourceMappingURL=url.d.mts.map

package/dist/internal/url.mjs

@@ -0,0 +1,2 @@
+function withPublicKey(url,publicKey){let next=new URL(url);return next.searchParams.set(`pk`,publicKey),next.toString()}export{withPublicKey};
+//# sourceMappingURL=url.mjs.map

package/dist/internal/version.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const require_package=require("../package.cjs"),PRODUCER_VERSION=`${require_package.name}@${require_package.version}`;exports.PRODUCER_VERSION=PRODUCER_VERSION;

package/dist/internal/version.d.cts

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

package/dist/internal/version.d.mts

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

package/dist/internal/version.mjs

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

package/dist/package.cjs

@@ -0,0 +1 @@
+var name=`@interfere/node`,version=`0.0.1-canary.2`;Object.defineProperty(exports,"name",{enumerable:!0,get:function(){return name}}),Object.defineProperty(exports,"version",{enumerable:!0,get:function(){return version}});

package/dist/package.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interfere/node",
-  "version": "0.0.1-canary.0",
+  "version": "0.0.1-canary.2",
   "license": "MIT",
   "description": "Node.js SDK for Interfere. Error tracking and OTel instrumentation for any Node server.",
   "keywords": [
@@ -21,30 +21,54 @@
     "directory": "src/packages/public/node"
   },
   "files": [
-    "dist"
+    "dist/**/*.cjs",
+    "dist/**/*.mjs",
+    "dist/**/*.d.cts",
+    "dist/**/*.d.mts",
+    "README.md"
   ],
   "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
   "exports": {
     ".": {
-      "@source": "./src/index.ts",
-      "types": "./dist/index.d.mts",
-      "default": "./dist/index.mjs"
+      "monorepo": "./src/index.ts",
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     },
     "./init": {
-      "@source": "./src/init.ts",
-      "types": "./dist/init.d.mts",
-      "default": "./dist/init.mjs"
+      "monorepo": "./src/init.ts",
+      "import": {
+        "types": "./dist/init.d.mts",
+        "default": "./dist/init.mjs"
+      },
+      "require": {
+        "types": "./dist/init.d.cts",
+        "default": "./dist/init.cjs"
+      }
     },
     "./capture": {
-      "@source": "./src/capture.ts",
-      "types": "./dist/capture.d.mts",
-      "default": "./dist/capture.mjs"
+      "monorepo": "./src/capture.ts",
+      "import": {
+        "types": "./dist/capture.d.mts",
+        "default": "./dist/capture.mjs"
+      },
+      "require": {
+        "types": "./dist/capture.d.cts",
+        "default": "./dist/capture.cjs"
+      }
     }
   },
   "sideEffects": false,
   "publishConfig": {
-    "access": "public",
-    "tag": "canary"
+    "access": "public"
   },
   "scripts": {
     "build": "tsdown",
@@ -52,11 +76,11 @@
     "typecheck": "tsc --noEmit --incremental"
   },
   "dependencies": {
-    "@interfere/constants": "^9.0.1",
-    "@interfere/types": "^9.0.0",
+    "@interfere/constants": "^9.0.2-canary.0",
+    "@interfere/types": "^9.0.3-canary.0",
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/context-async-hooks": "^2.7.1",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.217.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.218.0",
     "@opentelemetry/resources": "^2.7.0",
     "@opentelemetry/sdk-trace-base": "^2.7.0",
     "@opentelemetry/sdk-trace-node": "^2.7.1",

package/dist/capture.d.mts.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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/init.d.mts.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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

@@ -1,5 +0,0 @@
-//#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

@@ -1 +0,0 @@
-{"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

@@ -1,29 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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.map

@@ -1 +0,0 @@
-{"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/version.d.mts.map

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

package/dist/internal/version.mjs.map

@@ -1 +0,0 @@
-{"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.map

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