@interfere/vite 11.2.1 → 12.0.0

package/dist/internal/build/transfer-source-maps.mjs

@@ -0,0 +1 @@
+import{readPublicationStatus}from"./read-publication-status.mjs";import{uploadSourceMapChunks}from"@interfere/build/upload-source-map-chunks";import{completeSourceMapsResponse}from"@interfere/types/data/source-maps";import{sourceMapPublicationStatus}from"@interfere/types/data/source-map-status";import{extractRichness}from"@interfere/types/sdk/source-map-richness";async function transferSourceMaps(input){let{client,bundler,releaseSlug}=input,{files,sourceFileCount}=input.discovery,start=performance.now(),signFiles=files.map(file=>({path:file.path,sizeBytes:new TextEncoder().encode(file.content).byteLength,...extractRichness(file.content)})),environment=input.environment??void 0,signed=await client.releases.signSourceMapUploads({releaseSlug,environment,files:signFiles},{abortSignal:AbortSignal.timeout(6e4)}),signedAt=performance.now(),session=null;if(input.readinessTimeoutMs===void 0?input.capturePublication&&(session=await readPublicationStatus(input)):session=sourceMapPublicationStatus.parse(await client.releases.getSourceMapPublicationStatus({releaseSlug,environment},{abortSignal:AbortSignal.timeout(6e4)})),input.readinessTimeoutMs!==void 0&&session&&(!session.sessionId||session.releaseSlug!==releaseSlug||session.environment!==input.environment))throw Error(`Source-map publication requires an identified upload session for this environment`);let sessionReadAt=performance.now(),totalBytes=await uploadSourceMapChunks({client,environment,releaseSlug,files,signed}),uploadedAt=performance.now(),completion={bundler,sourceFileCount,files:files.map(({path,hash,debugId,chunkUrl})=>({path,hash,debugId,chunkUrl}))},accepted=completeSourceMapsResponse.safeParse(await client.releases.finalizeSourceMaps({releaseSlug,environment,...completion},{abortSignal:AbortSignal.timeout(Math.max(0,signed.expiresAt*1e3-Date.now()))}));if(!accepted.success||!accepted.data.ok||accepted.data.fileCount!==files.length)throw Error(`Source-map server did not accept the complete batch`);let acceptedAt=performance.now();return{completion,session,acceptedAt,timing:{sign:Math.round(signedAt-start),session:Math.round(sessionReadAt-signedAt),upload:Math.round(uploadedAt-sessionReadAt),finalize:Math.round(acceptedAt-uploadedAt),totalBytes}}}export{transferSourceMaps};

package/dist/internal/build/wait-for-source-maps.d.mts

@@ -0,0 +1,48 @@
+import { InterfereClient } from "@interfere/javascript";
+//#region src/internal/build/wait-for-source-maps.d.ts
+export declare function waitForSourceMaps(input: {
+  client: InterfereClient;
+  releaseSlug: string;
+  environment: string | null;
+  sessionId: string;
+  batchDigest: string;
+  fileCount: number;
+  timeoutMs: number;
+  signal?: AbortSignal;
+}): Promise<{
+  releaseSlug: `rel_${string}` & import("zod").$brand<"ReleaseSlug">;
+  environment: string | null;
+  sessionId: string | null;
+  state: "absent" | "accepted" | "expired" | "expiring" | "ready" | "uploading";
+  fileCount: number;
+  publishedFileCount: number;
+  batchDigest: string | null;
+  manifestReady: boolean;
+  diagnostics?: {
+    attempt: number;
+    scheduledAtMs: number | null;
+    startedAtMs: number;
+    completedAtMs: number | null;
+    phase: "complete" | "completion" | "continuation" | "files" | "manifest" | "release";
+    publishedAtStart: number;
+    progressObservedAtMs: number | null;
+    nativeRetryCount: number;
+    interruptedAttempts: number;
+    longestAttempt: {
+      attempt: number;
+      durationMs: number;
+    } | null;
+    longestAlarmDelay: {
+      attempt: number;
+      durationMs: number;
+    } | null;
+    nextAlarmAtMs: number | null;
+    lastFailure: {
+      attempt: number;
+      atMs: number;
+      phase: "complete" | "completion" | "continuation" | "files" | "manifest" | "release";
+      kind: "aborted" | "error" | "non-error" | "timeout";
+    } | null;
+  } | undefined;
+}>;
+//#endregion

package/dist/internal/build/wait-for-source-maps.mjs

@@ -0,0 +1 @@
+import{sourceMapPublicationStatus}from"@interfere/types/data/source-map-status";import{setTimeout}from"node:timers/promises";async function waitForSourceMaps(input){let startedAt=performance.now(),deadline=AbortSignal.timeout(input.timeoutMs),signal=input.signal?AbortSignal.any([deadline,input.signal]):deadline,delayMs=250,phase=`request`,requestOutcome=`interrupted`,requestStartedAt=startedAt,requestFinishedAt,lastValidatedAt,lastStatus;try{for(;;){signal.throwIfAborted(),phase=`request`,requestStartedAt=performance.now(),requestFinishedAt=void 0,requestOutcome=`interrupted`;let response=await input.client.releases.getSourceMapPublicationStatus({releaseSlug:input.releaseSlug,environment:input.environment??void 0},{abortSignal:signal});requestFinishedAt=performance.now(),requestOutcome=`returned`;let status=sourceMapPublicationStatus.parse(response);if(signal.throwIfAborted(),status.releaseSlug!==input.releaseSlug||status.environment!==input.environment||status.sessionId!==input.sessionId)throw Error(`Source-map publication session changed`);if(status.state===`expired`||status.state===`expiring`||status.state===`absent`)throw Error(`Source-map publication session is ${status.state}`);if(status.batchDigest!==input.batchDigest||status.fileCount!==input.fileCount)throw Error(`Source-map publication batch does not match the accepted build`);if(lastStatus=status,lastValidatedAt=performance.now(),status.state===`ready`&&status.manifestReady&&status.publishedFileCount===input.fileCount)return status;phase=`backoff`,await setTimeout(delayMs,void 0,{signal}),delayMs=Math.min(delayMs*2,5e3)}}catch(error){if(!deadline.aborted||signal.reason!==deadline.reason)throw error;let now=performance.now(),elapsedMs=Math.round(now-startedAt),polling={phase,lastValidatedAfterMs:lastValidatedAt===void 0?null:Math.round(lastValidatedAt-startedAt),lastValidatedAgeMs:lastValidatedAt===void 0?null:Math.round(now-lastValidatedAt),requestDurationMs:Math.round((requestFinishedAt??now)-requestStartedAt),requestOutcome},progress=lastStatus?`last validated status: state=${lastStatus.state}, published=${lastStatus.publishedFileCount}/${input.fileCount}, manifestReady=${lastStatus.manifestReady}`:`no validated status received`,diagnostics=lastStatus?.diagnostics?`; diagnostics=${JSON.stringify(lastStatus.diagnostics)}`:``;throw Error(`Source-map publication timed out after ${elapsedMs}ms (deadline=${input.timeoutMs}ms, release=${input.releaseSlug}, environment=${input.environment??`unspecified`}, session=${input.sessionId}); ${progress}${diagnostics}; polling=${JSON.stringify(polling)}`,{cause:error})}}export{waitForSourceMaps};

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

@@ -1,10 +1,8 @@
-import { ReleaseSlug } from "@interfere/types/releases/slug";
 import { RunGitCommand } from "@interfere/types/sdk/github-source";
 //#region src/internal/release-slug.d.ts
-declare function resolveCommitSha(runGit?: RunGitCommand): string | null;
-declare function resolveReleaseSlug(runGit?: RunGitCommand): {
+export declare function resolveCommitSha(runGit?: RunGitCommand): string | null;
+export declare function resolveReleaseSlug(runGit?: RunGitCommand): {
   commitSha: string | null;
-  slug: ReleaseSlug | null;
+  slug: (`rel_${string}` & import("zod").$brand<"ReleaseSlug">) | null;
 };
-//#endregion
-export { resolveCommitSha, resolveReleaseSlug };
+//#endregion

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

@@ -1,5 +1,4 @@
 import { CaptureErrorContext } from "./types.mjs";
 //#region src/internal/server/capture.d.ts
-declare function captureError(error: unknown, ctx?: CaptureErrorContext): void;
-//#endregion
-export { captureError };
+export declare function captureError(error: unknown, ctx?: CaptureErrorContext): void;
+//#endregion

package/dist/internal/server/capture.mjs

@@ -1 +1 @@
-import{isEnabledOnServer}from"./env.mjs";import{isPluginEnabled}from"./remote-config.mjs";import{MECHANISM_TYPE,isNonErrorException,toException}from"@interfere/types/sdk/errors";import{SpanKind,SpanStatusCode,context,trace}from"@opentelemetry/api";const DEFAULT_CAPTURE_ERROR_MECHANISM={type:MECHANISM_TYPE.node.captureError,handled:!0},seen=new WeakSet;function buildAttrs(value,mechanism,ctx){let attrs={"interfere.exception.mechanism":mechanism.type,"interfere.exception.handled":String(mechanism.handled)};return ctx?.request?.method&&(attrs[`http.request.method`]=ctx.request.method),ctx?.request?.path&&(attrs[`url.path`]=ctx.request.path),isNonErrorException(value)?(attrs[`exception.type`]=value.type,attrs[`exception.message`]=value.value,attrs[`interfere.exception.kind`]=`non-error`,attrs):(attrs[`exception.type`]=value.name,attrs[`exception.message`]=value.message,value.stack&&(attrs[`exception.stacktrace`]=value.stack),attrs)}function recordException(error,mechanism,ctx){let value=toException(error),attrs=buildAttrs(value,mechanism,ctx),tracer=trace.getTracer(`@interfere/vite/server`),active=trace.getActiveSpan();if(active){active.addEvent(`exception`,attrs),mechanism.handled||active.setStatus({code:SpanStatusCode.ERROR,message:isNonErrorException(value)?value.value:value.message});return}let span=tracer.startSpan(`interfere.captureError`,{kind:SpanKind.INTERNAL},context.active());span.addEvent(`exception`,attrs),mechanism.handled||span.setStatus({code:SpanStatusCode.ERROR,message:isNonErrorException(value)?value.value:value.message}),span.end()}function captureError(error,ctx){if(isEnabledOnServer()&&isPluginEnabled(`errors`)){if(error instanceof Error){if(seen.has(error))return;seen.add(error)}recordException(error,ctx?.mechanism??DEFAULT_CAPTURE_ERROR_MECHANISM,ctx)}}export{captureError};
+import{isEnabledOnServer}from"./env.mjs";import{isPluginEnabled}from"./remote-config.mjs";import{MECHANISM_TYPE,isNonErrorException,toException}from"@interfere/types/sdk/errors";import{SpanKind,SpanStatusCode,context,trace}from"@opentelemetry/api";const DEFAULT_CAPTURE_ERROR_MECHANISM={handled:!0,type:MECHANISM_TYPE.node.captureError},seen=new WeakSet;function buildAttrs(value,mechanism,ctx){let attrs={"interfere.exception.handled":String(mechanism.handled),"interfere.exception.mechanism":mechanism.type};return ctx?.request?.method&&(attrs[`http.request.method`]=ctx.request.method),ctx?.request?.path&&(attrs[`url.path`]=ctx.request.path),isNonErrorException(value)?(attrs[`exception.type`]=value.type,attrs[`exception.message`]=value.value,attrs[`interfere.exception.kind`]=`non-error`,attrs):(attrs[`exception.type`]=value.name,attrs[`exception.message`]=value.message,value.stack&&(attrs[`exception.stacktrace`]=value.stack),attrs)}function recordException(error,mechanism,ctx){let value=toException(error),attrs=buildAttrs(value,mechanism,ctx),tracer=trace.getTracer(`@interfere/vite/server`),active=trace.getActiveSpan();if(active){active.addEvent(`exception`,attrs),mechanism.handled||active.setStatus({code:SpanStatusCode.ERROR,message:isNonErrorException(value)?value.value:value.message});return}let span=tracer.startSpan(`interfere.captureError`,{kind:SpanKind.INTERNAL},context.active());span.addEvent(`exception`,attrs),mechanism.handled||span.setStatus({code:SpanStatusCode.ERROR,message:isNonErrorException(value)?value.value:value.message}),span.end()}function captureError(error,ctx){if(isEnabledOnServer()&&isPluginEnabled(`errors`)){if(error instanceof Error){if(seen.has(error))return;seen.add(error)}recordException(error,ctx?.mechanism??DEFAULT_CAPTURE_ERROR_MECHANISM,ctx)}}export{captureError};

package/dist/internal/server/console-bridge.d.mts

@@ -23,6 +23,5 @@
  * bridge, same trade-offs, intentionally kept in the Vite adapter's
  * source tree so SDKs do not share build/runtime internals.
  */
-declare function bridgeConsoleToOtel(): () => void;
-//#endregion
-export { bridgeConsoleToOtel };
+export declare function bridgeConsoleToOtel(): () => void;
+//#endregion

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

@@ -1 +1 @@
-import{context,trace}from"@opentelemetry/api";import{logs}from"@opentelemetry/api-logs";const CONSOLE_METHODS=[`debug`,`log`,`info`,`warn`,`error`],SEVERITY={debug:5,log:9,info:9,warn:13,error:17},MAX_BODY_CHARS=8192;function buildBody(args){let body=args.map(stringify).join(` `);return body.length>MAX_BODY_CHARS?`${body.slice(0,MAX_BODY_CHARS)}…`:body}function stringify(value){if(typeof value==`string`)return value;if(value instanceof Error)return value.stack??`${value.name}: ${value.message}`;try{return JSON.stringify(value)}catch{return String(value)}}function extractException(args){for(let arg of args)if(arg instanceof Error)return arg}function buildExceptionAttributes(args){let exception=extractException(args);if(!exception)return;let attrs={"exception.type":exception.name,"exception.message":exception.message};return exception.stack&&(attrs[`exception.stacktrace`]=exception.stack),attrs}function bridgeConsoleToOtel(){let logger=logs.getLogger(`@interfere/vite/console`),emitting=!1,bridgeFailures=0,original={debug:console.debug,log:console.log,info:console.info,warn:console.warn,error:console.error};function emitLog(orig,severity,method,args,activeContext,activeSpan){if(!emitting){emitting=!0;try{let attributes=buildExceptionAttributes(args);logger.emit({severityNumber:severity,severityText:method.toUpperCase(),body:buildBody(args),...activeSpan?{context:activeContext}:{},...attributes?{attributes}:{}})}catch(error){bridgeFailures+=1,bridgeFailures%100==1&&orig.call(console,`[interfere] console→OTel bridge emission failed (${bridgeFailures} total):`,error)}finally{emitting=!1}}}for(let method of CONSOLE_METHODS){let orig=original[method],severity=SEVERITY[method];console[method]=(...args)=>{orig.apply(console,args);let activeContext=context.active(),activeSpan=trace.getSpan(activeContext);queueMicrotask(()=>{emitLog(orig,severity,method,args,activeContext,activeSpan)})}}return()=>{for(let method of CONSOLE_METHODS)console[method]=original[method]}}export{bridgeConsoleToOtel};
+import{omitUndefined}from"@interfere/helpers/omit-undefined";import{context,trace}from"@opentelemetry/api";import{logs}from"@opentelemetry/api-logs";const CONSOLE_METHODS=[`debug`,`log`,`info`,`warn`,`error`],SEVERITY={debug:5,error:17,info:9,log:9,warn:13},MAX_BODY_CHARS=8192;function buildBody(args){let body=args.map(element=>stringify(element)).join(` `);return body.length>MAX_BODY_CHARS?`${body.slice(0,MAX_BODY_CHARS)}…`:body}function stringify(value){if(typeof value==`string`)return value;if(value instanceof Error)return value.stack??`${value.name}: ${value.message}`;try{return JSON.stringify(value)}catch{return String(value)}}function extractException(args){for(let arg of args)if(arg instanceof Error)return arg}function buildExceptionAttributes(args){let exception=extractException(args);if(exception)return omitUndefined({"exception.type":exception.name,"exception.message":exception.message,"exception.stacktrace":exception.stack||void 0})}function bridgeConsoleToOtel(){let logger=logs.getLogger(`@interfere/vite/console`),emitting=!1,bridgeFailures=0,original={debug:console.debug,error:console.error,info:console.info,log:console.log,warn:console.warn};function emitLog(orig,severity,method,args,activeContext,activeSpan){if(!emitting){emitting=!0;try{let attributes=buildExceptionAttributes(args);logger.emit(omitUndefined({body:buildBody(args),severityNumber:severity,severityText:method.toUpperCase(),context:activeSpan?activeContext:void 0,attributes}))}catch(error){bridgeFailures+=1,bridgeFailures%100==1&&orig.call(console,`[interfere] console→OTel bridge emission failed (${bridgeFailures} total):`,error)}finally{emitting=!1}}}for(let method of CONSOLE_METHODS){let orig=original[method],severity=SEVERITY[method];console[method]=(...args)=>{orig.apply(console,args);let activeContext=context.active(),activeSpan=trace.getSpan(activeContext);queueMicrotask(()=>{emitLog(orig,severity,method,args,activeContext,activeSpan)})}}return(()=>{for(let method of CONSOLE_METHODS)console[method]=original[method]})}export{bridgeConsoleToOtel};

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

@@ -1,10 +1,4 @@
 //#region src/internal/server/env.d.ts
-interface InterfereServerEnv {
-  readonly apiUrl: string;
-  readonly forceEnable: boolean;
-  readonly nodeEnvironment: string;
-  readonly publicKey: string | null;
-}
 /**
  * Server-side gate for the proxy handler, the `captureError` /
  * `onRequestError` helpers, and the OTel register path. Reads the same
@@ -15,7 +9,11 @@ interface InterfereServerEnv {
  * ingress remains the authority on whether local / unknown / production
  * events are allowed.
  */
-declare function isEnabledOnServer(): boolean;
-declare function readInterfereServerEnv(): InterfereServerEnv;
-//#endregion
-export { InterfereServerEnv, isEnabledOnServer, readInterfereServerEnv };
+export declare function isEnabledOnServer(): boolean;
+export declare function readInterfereServerEnv(): {
+  apiUrl: string;
+  forceEnable: boolean;
+  nodeEnvironment: string;
+  publicKey: string | null;
+};
+//#endregion

package/dist/internal/server/env.mjs

@@ -1 +1 @@
-import{API_URL}from"@interfere/constants/api";import{parseEnvValue}from"@interfere/types/sdk/env";import{resolveEnvironment}from"@interfere/types/sdk/runtime";function isEnabledOnServer(){return process.env.NODE_ENV===`production`||!!process.env.VITE_INTERFERE_PUBLIC_KEY}function readInterfereServerEnv(){let nodeEnvironment=resolveEnvironment({env:process.env});return{apiUrl:parseEnvValue(process.env.INTERFERE_API_URL)??API_URL,forceEnable:!!process.env.INTERFERE_FORCE_ENABLE,nodeEnvironment,publicKey:parseEnvValue(process.env.VITE_INTERFERE_PUBLIC_KEY)}}export{isEnabledOnServer,readInterfereServerEnv};
+import{API_URL}from"@interfere/constants/api";import{parseEnvValue}from"@interfere/types/sdk/env";import{resolveEnvironment}from"@interfere/types/sdk/runtime";function isEnabledOnServer(){return process.env.NODE_ENV===`production`||!!process.env.VITE_INTERFERE_PUBLIC_KEY}function readInterfereServerEnv(){let nodeEnvironment=resolveEnvironment({env:process.env,explicit:import.meta.env.VITE_INTERFERE_ENVIRONMENT});return{apiUrl:parseEnvValue(process.env.INTERFERE_API_URL)??API_URL,forceEnable:!!process.env.INTERFERE_FORCE_ENABLE,nodeEnvironment,publicKey:parseEnvValue(process.env.VITE_INTERFERE_PUBLIC_KEY)}}export{isEnabledOnServer,readInterfereServerEnv};

package/dist/internal/server/freshness-propagator.d.mts

@@ -0,0 +1,18 @@
+import { Context, TextMapPropagator, TextMapSetter } from "@opentelemetry/api";
+//#region src/internal/server/freshness-propagator.d.ts
+/**
+ * Stamp-only propagator that writes a `tracestate` freshness entry
+ * (`interfere=<unix seconds>`) at inject time, never touching
+ * `traceparent`. The SSR trace-meta tags feed the browser SDK's
+ * propagation reader, which drops traceparents older than its freshness
+ * window — so HTML cached by a CDN can't stitch every visitor in the
+ * cache window onto one stale trace. Mirrors `@interfere/next`'s
+ * stamper; Vite SSR has no framework-level ISR, so no static-generation
+ * gating is needed here.
+ */
+export declare class FreshnessStampingPropagator implements TextMapPropagator {
+  inject<Carrier>(context: Context, carrier: Carrier, setter: TextMapSetter<Carrier>): void;
+  extract(context: Context): Context;
+  fields(): string[];
+}
+//#endregion

package/dist/internal/server/freshness-propagator.mjs

@@ -0,0 +1 @@
+import{isSpanContextValid,trace}from"@opentelemetry/api";import{TraceState,isTracingSuppressed}from"@opentelemetry/core";import{TRACESTATE_FRESHNESS_KEY,freshnessStamp}from"@interfere/types/sdk/trace-freshness";const TRACE_STATE_HEADER=`tracestate`;var FreshnessStampingPropagator=class{inject(context,carrier,setter){let spanContext=trace.getSpanContext(context);if(!spanContext||!isSpanContextValid(spanContext)||isTracingSuppressed(context))return;let traceState=(spanContext.traceState??new TraceState).set(TRACESTATE_FRESHNESS_KEY,freshnessStamp(Date.now()));setter.set(carrier,TRACE_STATE_HEADER,traceState.serialize())}extract(context){return context}fields(){return[TRACE_STATE_HEADER]}};export{FreshnessStampingPropagator};

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

@@ -11,7 +11,7 @@
  * in the Next adapter, which is internal-only per the parity
  * decisions).
  */
-interface ServerInstrumentationOptions {
+export interface ServerInstrumentationOptions {
   /**
    * `false` disables the `console.*` → OTel `LogRecord` bridge.
    * Defaults to enabled. Customers running their own structured
@@ -40,5 +40,4 @@ interface ServerInstrumentationOptions {
    */
   serviceName?: string;
 }
-//#endregion
-export { ServerInstrumentationOptions };
+//#endregion

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

@@ -24,6 +24,5 @@ import { ServerInstrumentationOptions } from "./instrumentation-options.mjs";
  * runtime. Cloudflare Workers / Deno presets need a separate edge
  * stub (Phase 5).
  */
-declare function register(opts?: ServerInstrumentationOptions): Promise<void>;
-//#endregion
-export { register };
+export declare function register(opts?: ServerInstrumentationOptions): Promise<void>;
+//#endregion

package/dist/internal/server/register.mjs

@@ -1 +1 @@
-import{PRODUCER_VERSION}from"../../version.mjs";import{resolveReleaseSlug}from"../release-slug.mjs";import{readInterfereServerEnv}from"./env.mjs";import{withPublicKey}from"./url.mjs";import{fetchAndCacheRemoteConfig}from"./remote-config.mjs";import{bridgeConsoleToOtel}from"./console-bridge.mjs";import{metrics,propagation}from"@opentelemetry/api";import{readLogSourcingMode}from"@interfere/types/sdk/log-sourcing";import{readServerTracingMode}from"@interfere/types/sdk/server-tracing";import{BaggageSpanProcessor}from"@opentelemetry/baggage-span-processor";import{AsyncLocalStorageContextManager}from"@opentelemetry/context-async-hooks";import{CompositePropagator,W3CBaggagePropagator,W3CTraceContextPropagator}from"@opentelemetry/core";import{OTLPLogExporter}from"@opentelemetry/exporter-logs-otlp-http";import{AggregationTemporalityPreference,OTLPMetricExporter}from"@opentelemetry/exporter-metrics-otlp-http";import{OTLPTraceExporter}from"@opentelemetry/exporter-trace-otlp-http";import{registerInstrumentations}from"@opentelemetry/instrumentation";import{UndiciInstrumentation}from"@opentelemetry/instrumentation-undici";import{resourceFromAttributes}from"@opentelemetry/resources";import{BatchLogRecordProcessor,LoggerProvider}from"@opentelemetry/sdk-logs";import{MeterProvider,PeriodicExportingMetricReader}from"@opentelemetry/sdk-metrics";import{BatchSpanProcessor}from"@opentelemetry/sdk-trace-base";import{NodeTracerProvider}from"@opentelemetry/sdk-trace-node";let registered=!1;function matchesAny(url,patterns){for(let pattern of patterns)if(pattern instanceof RegExp?pattern.test(url):url.includes(pattern))return!0;return!1}async function register(opts={}){if(registered)return;let env=readInterfereServerEnv();if(!env.publicKey)return;let{slug:releaseSlug}=resolveReleaseSlug();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.");let sinkUrl=withPublicKey(`${env.apiUrl}/v2/sink`,env.publicKey),ignoreUrls=[sinkUrl,...opts.ignoreUrls??[]],propagateContextUrls=opts.propagateContextUrls??[],serverTracingMode=readServerTracingMode(),isLogDrainMode=readLogSourcingMode()===`drain`,exporterHeaders={"x-interfere-producer-version":PRODUCER_VERSION},resourceAttributes={"service.name":opts.serviceName??`interfere-sdk-vite-server`,"service.namespace":`interfere`,"deployment.environment.name":env.nodeEnvironment,"telemetry.sdk.language":`nodejs`,"interfere.sdk.name":`@interfere/vite`,"interfere.sdk.version":PRODUCER_VERSION,...releaseSlug?{"release.slug":releaseSlug}:{}},resource=resourceFromAttributes(resourceAttributes),isDrainMode=serverTracingMode===`drain`,tracerProvider=new NodeTracerProvider({resource,spanProcessors:[new BaggageSpanProcessor(()=>!0),...isDrainMode?[]:[new BatchSpanProcessor(new OTLPTraceExporter({url:sinkUrl,headers:exporterHeaders}))]]});if(propagation.fields().length===0&&propagation.setGlobalPropagator(new CompositePropagator({propagators:[new W3CTraceContextPropagator,new W3CBaggagePropagator]})),tracerProvider.register({contextManager:new AsyncLocalStorageContextManager().enable()}),!isLogDrainMode){let loggerProvider=new LoggerProvider({resource,processors:[new BatchLogRecordProcessor({exporter:new OTLPLogExporter({url:sinkUrl,headers:exporterHeaders})})]}),{logs:logsApi}=await import(`@opentelemetry/api-logs`);logsApi.setGlobalLoggerProvider(loggerProvider)}let meterProvider=new MeterProvider({resource,readers:[new PeriodicExportingMetricReader({exporter:new OTLPMetricExporter({url:sinkUrl,headers:exporterHeaders,temporalityPreference:AggregationTemporalityPreference.DELTA}),exportIntervalMillis:3e4})]});metrics.setGlobalMeterProvider(meterProvider),isDrainMode?console.info(`[interfere] server tracing in drain mode; SDK trace exporter + outbound HTTP instrumentation disabled — server traces come from the platform trace drain.`):registerInstrumentations({tracerProvider,meterProvider,instrumentations:[new UndiciInstrumentation({ignoreRequestHook:req=>matchesAny(`${req.origin}${req.path}`,ignoreUrls),requestHook:(span,req)=>{matchesAny(`${req.origin}${req.path}`,propagateContextUrls)&&span.setAttribute(`interfere.propagated`,!0)}})]}),!isLogDrainMode&&opts.consoleBridge!==!1&&bridgeConsoleToOtel(),registered=!0,await fetchAndCacheRemoteConfig()}export{register};
+import{PRODUCER_VERSION}from"../../version.mjs";import{resolveReleaseSlug}from"../release-slug.mjs";import{readInterfereServerEnv}from"./env.mjs";import{fetchAndCacheRemoteConfig}from"./remote-config.mjs";import{bridgeConsoleToOtel}from"./console-bridge.mjs";import{FreshnessStampingPropagator}from"./freshness-propagator.mjs";import{drainUrl}from"@interfere/constants/api";import{omitUndefined}from"@interfere/helpers/omit-undefined";import{metrics,propagation}from"@opentelemetry/api";import{logSourcingModeSchema,readLogSourcingMode}from"@interfere/types/sdk/log-sourcing";import{readServerTracingMode,serverTracingModeSchema}from"@interfere/types/sdk/server-tracing";import{BaggageSpanProcessor}from"@opentelemetry/baggage-span-processor";import{AsyncLocalStorageContextManager}from"@opentelemetry/context-async-hooks";import{CompositePropagator,W3CBaggagePropagator,W3CTraceContextPropagator}from"@opentelemetry/core";import{OTLPLogExporter}from"@opentelemetry/exporter-logs-otlp-http";import{AggregationTemporalityPreference,OTLPMetricExporter}from"@opentelemetry/exporter-metrics-otlp-http";import{OTLPTraceExporter}from"@opentelemetry/exporter-trace-otlp-http";import{registerInstrumentations}from"@opentelemetry/instrumentation";import{UndiciInstrumentation}from"@opentelemetry/instrumentation-undici";import{resourceFromAttributes}from"@opentelemetry/resources";import{BatchLogRecordProcessor,LoggerProvider}from"@opentelemetry/sdk-logs";import{MeterProvider,PeriodicExportingMetricReader}from"@opentelemetry/sdk-metrics";import{BatchSpanProcessor}from"@opentelemetry/sdk-trace-base";import{NodeTracerProvider}from"@opentelemetry/sdk-trace-node";let registered=!1;function matchesAny(url,patterns){for(let pattern of patterns)if(pattern instanceof RegExp?pattern.test(url):url.includes(pattern))return!0;return!1}async function register(opts={}){if(registered)return;let env=readInterfereServerEnv();if(!env.publicKey)return;let{slug:releaseSlug}=resolveReleaseSlug();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.");let{publicKey}=env,tracesUrl=drainUrl(env.apiUrl,`traces`,publicKey),logsUrl=drainUrl(env.apiUrl,`logs`,publicKey),metricsUrl=drainUrl(env.apiUrl,`metrics`,publicKey),ignoreUrls=[tracesUrl,logsUrl,metricsUrl,...opts.ignoreUrls??[]],propagateContextUrls=opts.propagateContextUrls??[],bakedTracing=serverTracingModeSchema.safeParse(import.meta.env?.VITE_INTERFERE_SERVER_TRACING),bakedLogs=logSourcingModeSchema.safeParse(import.meta.env?.VITE_INTERFERE_LOG_SOURCING),serverTracingMode=bakedTracing.success?bakedTracing.data:readServerTracingMode(),isLogDrainMode=(bakedLogs.success?bakedLogs.data:readLogSourcingMode())===`drain`,exporterHeaders={"x-interfere-producer-version":PRODUCER_VERSION},resourceAttributes=omitUndefined({"deployment.environment.name":env.nodeEnvironment,"interfere.sdk.name":`@interfere/vite`,"interfere.sdk.version":PRODUCER_VERSION,"service.name":opts.serviceName??`interfere-sdk-vite-server`,"service.namespace":`interfere`,"telemetry.sdk.language":`nodejs`,"release.slug":releaseSlug||void 0}),resource=resourceFromAttributes(resourceAttributes),isDrainMode=serverTracingMode===`drain`,tracerProvider=new NodeTracerProvider({resource,spanProcessors:[new BaggageSpanProcessor(()=>!0),...isDrainMode?[]:[new BatchSpanProcessor(new OTLPTraceExporter({headers:exporterHeaders,url:tracesUrl}))]]});if(propagation.fields().length===0&&propagation.setGlobalPropagator(new CompositePropagator({propagators:[new W3CTraceContextPropagator,new FreshnessStampingPropagator,new W3CBaggagePropagator]})),tracerProvider.register({contextManager:new AsyncLocalStorageContextManager().enable()}),!isLogDrainMode){let loggerProvider=new LoggerProvider({processors:[new BatchLogRecordProcessor({exporter:new OTLPLogExporter({url:logsUrl,headers:exporterHeaders})})],resource}),{logs:logsApi}=await import(`@opentelemetry/api-logs`);logsApi.setGlobalLoggerProvider(loggerProvider)}let meterProvider=new MeterProvider({readers:[new PeriodicExportingMetricReader({exporter:new OTLPMetricExporter({url:metricsUrl,headers:exporterHeaders,temporalityPreference:AggregationTemporalityPreference.DELTA}),exportIntervalMillis:3e4})],resource});metrics.setGlobalMeterProvider(meterProvider),isDrainMode?console.info(`[interfere] server tracing in drain mode; SDK trace exporter + outbound HTTP instrumentation disabled — server traces come from the platform trace drain.`):registerInstrumentations({instrumentations:[new UndiciInstrumentation({ignoreRequestHook:req=>matchesAny(`${req.origin}${req.path}`,ignoreUrls),requestHook:(span,req)=>{matchesAny(`${req.origin}${req.path}`,propagateContextUrls)&&span.setAttribute(`interfere.propagated`,!0)}})],meterProvider,tracerProvider}),!isLogDrainMode&&opts.consoleBridge!==!1&&bridgeConsoleToOtel(),registered=!0,await fetchAndCacheRemoteConfig()}export{register};

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

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

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

@@ -1 +1 @@
-import{isEnabledOnServer,readInterfereServerEnv}from"./env.mjs";import{withPublicKey}from"./url.mjs";import{readBakedPlugins}from"@interfere/types/sdk/remote-config";import{API_PATHS}from"@interfere/constants/api";let cachedConfig=null;async function fetchAndCacheRemoteConfig(){if(readBakedPlugins()||!isEnabledOnServer())return;let env=readInterfereServerEnv();if(env.publicKey===null)return;let config;try{let url=withPublicKey(`${env.apiUrl}${API_PATHS.CONFIG}`,env.publicKey),response=await fetch(url,{method:`GET`,headers:{"content-type":`application/json`},signal:AbortSignal.timeout(1e4)});if(!response.ok)return;config=await response.json()}catch{return}config?.plugins&&(cachedConfig=config.plugins)}function isPluginEnabled(plugin){let config=readBakedPlugins()??cachedConfig;return!config||config[plugin]!==!1}export{fetchAndCacheRemoteConfig,isPluginEnabled};
+import{isEnabledOnServer,readInterfereServerEnv}from"./env.mjs";import{readBakedPlugins,remoteConfigInputSchema}from"@interfere/types/sdk/remote-config";import{InterfereClient}from"@interfere/javascript";let cachedConfig=null;async function fetchAndCacheRemoteConfig(){if(readBakedPlugins()||!isEnabledOnServer())return;let env=readInterfereServerEnv();if(env.publicKey!==null)try{let client=new InterfereClient({baseUrl:env.apiUrl,publicKeyHeader:{apiKey:env.publicKey},timeoutInSeconds:10,maxRetries:0}),config=remoteConfigInputSchema.parse(await client.config.getSdkConfig());config.plugins&&(cachedConfig=config.plugins)}catch{return}}function isPluginEnabled(plugin){let config=readBakedPlugins()??cachedConfig;return!config||config[plugin]!==!1}export{fetchAndCacheRemoteConfig,isPluginEnabled};

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

@@ -1,9 +1,8 @@
 //#region src/internal/server/request-trace.d.ts
-interface TraceMetaDescriptor {
+export interface TraceMetaDescriptor {
   content: string;
   name: string;
 }
-declare function traceMeta(): TraceMetaDescriptor[];
-declare function withRequestSpan<T>(request: Request, next: () => Promise<T>): Promise<T>;
-//#endregion
-export { TraceMetaDescriptor, traceMeta, withRequestSpan };
+export declare function traceMeta(): TraceMetaDescriptor[];
+export declare function withRequestSpan<T>(request: Request, next: () => Promise<T>): Promise<T>;
+//#endregion

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

@@ -1 +1 @@
-import{isEnabledOnServer}from"./env.mjs";import{SpanKind,SpanStatusCode,TraceFlags,context,propagation,trace}from"@opentelemetry/api";const SAMPLED_BIT=TraceFlags.SAMPLED,PROPAGATED_FIELDS=[`traceparent`,`tracestate`,`baggage`];function traceMeta(){let span=trace.getActiveSpan();if(!span||(span.spanContext().traceFlags&SAMPLED_BIT)!==SAMPLED_BIT)return[];let carrier={};propagation.inject(context.active(),carrier);let meta=[];for(let name of PROPAGATED_FIELDS){let content=carrier[name];content&&meta.push({content,name})}return meta}function withRequestSpan(request,next){if(!isEnabledOnServer())return next();let parent=propagation.extract(context.active(),headersToCarrier(request.headers));return context.with(parent,()=>trace.getTracer(`@interfere/vite/tanstack-start`).startActiveSpan(spanName(request),{attributes:requestAttributes(request),kind:SpanKind.SERVER},async span=>{try{return await next()}catch(error){throw span.recordException(error),span.setStatus({code:SpanStatusCode.ERROR}),error}finally{span.end()}}))}function headersToCarrier(headers){let carrier={};for(let[key,value]of headers)carrier[key]=value;return carrier}function spanName(request){return`${request.method} ${new URL(request.url).pathname}`}function requestAttributes(request){let url=new URL(request.url);return{"http.request.method":request.method,"server.address":url.host,"url.full":url.href,"url.path":url.pathname}}export{traceMeta,withRequestSpan};
+import{isEnabledOnServer}from"./env.mjs";import{toError}from"@interfere/types/sdk/errors";import{SpanKind,SpanStatusCode,TraceFlags,context,propagation,trace}from"@opentelemetry/api";const SAMPLED_BIT=TraceFlags.SAMPLED,PROPAGATED_FIELDS=[`traceparent`,`tracestate`,`baggage`];function traceMeta(){let span=trace.getActiveSpan();if(!span||(span.spanContext().traceFlags&SAMPLED_BIT)===0)return[];let carrier={};propagation.inject(context.active(),carrier);let meta=[];for(let name of PROPAGATED_FIELDS){let content=carrier[name];content&&meta.push({content,name})}return meta}async function withRequestSpan(request,next){if(!isEnabledOnServer())return next();let parent=propagation.extract(context.active(),headersToCarrier(request.headers));return context.with(parent,async()=>trace.getTracer(`@interfere/vite/tanstack-start`).startActiveSpan(spanName(request),{attributes:requestAttributes(request),kind:SpanKind.SERVER},async span=>{try{return await next()}catch(error){throw span.recordException(toError(error)),span.setStatus({code:SpanStatusCode.ERROR}),error}finally{span.end()}}))}function headersToCarrier(headers){let carrier={};for(let[key,value]of headers)carrier[key]=value;return carrier}function spanName(request){return`${request.method} ${new URL(request.url).pathname}`}function requestAttributes(request){let url=new URL(request.url);return{"http.request.method":request.method,"server.address":url.host,"url.full":url.href,"url.path":url.pathname}}export{traceMeta,withRequestSpan};

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

@@ -1,11 +1,13 @@
 //#region src/internal/server/trace-meta.d.ts
 /**
- * Server Component that emits a `<meta name="traceparent">` tag so
- * the client SDK can stitch every browser span onto the server-side
- * trace.
+ * Server Component that emits the W3C trace-context meta tags
+ * (`traceparent`, plus `tracestate` and `baggage` when present) so the
+ * client SDK can stitch every browser span onto the server-side trace.
+ * The `tracestate` tag carries the freshness stamp that lets the browser
+ * reject trace context served from cached HTML.
  *
  * Customer usage — drop into the root layout's `<head>` (TanStack
- * Start uses the `head()` route option, but the meta tag also works
+ * Start uses the `head()` route option, but the meta tags also work
  * if rendered into the React tree):
  *
  * ```tsx
@@ -25,10 +27,9 @@
  *
  * Renders nothing when no OTel span is active (dev without OTel
  * registered, or unsampled traces). The client SDK's propagation
- * reader handles a missing meta tag the same as no parent — every
+ * reader handles missing meta tags the same as no parent — every
  * browser span starts a fresh root, which is at least internally
  * consistent.
  */
-declare function TraceMeta(): import("react").JSX.Element | null;
-//#endregion
-export { TraceMeta };
+export declare function TraceMeta(): import("react").JSX.Element | null;
+//#endregion

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

@@ -1 +1 @@
-import{activeTraceparent}from"./traceparent.mjs";import{jsx}from"react/jsx-runtime";function TraceMeta(){let traceparent=activeTraceparent();return traceparent?jsx(`meta`,{content:traceparent,name:`traceparent`}):null}export{TraceMeta};
+import{traceMeta}from"./request-trace.mjs";import{Fragment,jsx}from"react/jsx-runtime";function TraceMeta(){let meta=traceMeta();return meta.length===0?null:jsx(Fragment,{children:meta.map(({name,content})=>jsx(`meta`,{content,name},name))})}export{TraceMeta};

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

@@ -1,6 +1,6 @@
 import { ErrorMechanism } from "@interfere/types/sdk/plugins/payload/errors";
 //#region src/internal/server/types.d.ts
-interface CaptureErrorContext {
+export interface CaptureErrorContext {
   readonly mechanism?: ErrorMechanism;
   /**
    * Optional request method / path for the captured error. Stamped
@@ -12,5 +12,4 @@ interface CaptureErrorContext {
     path?: string;
   };
 }
-//#endregion
-export { CaptureErrorContext };
+//#endregion

package/dist/package.mjs

@@ -1 +1 @@
-var name=`@interfere/vite`,version=`11.2.1`;export{name,version};
+var name=`@interfere/vite`,version=`12.0.0`;export{name,version};

package/dist/plugin.d.mts

@@ -1,6 +1,8 @@
 import { Plugin } from "vite";
 //#region src/plugin.d.ts
-interface InterfereViteOptions {
+export interface InterfereViteOptions {
+  /** Writes private build evidence outside public and build output directories. */
+  buildReceipt?: string;
   /**
    * The endpoint the browser SDK posts telemetry to. Defaults to
    * Interfere's endpoint. Set it to a subdomain of your own site that
@@ -16,6 +18,8 @@ interface InterfereViteOptions {
    * Docker layer-cached image build).
    */
   commitSha?: string;
+  /** Separates source maps for distinct bundles built from the same commit. */
+  buildVariant?: string;
   /**
    * Directory (relative to the project root) where the SSR/server build
    * writes its `.js.map` files, when that isn't `<build.outDir>/server`.
@@ -27,11 +31,12 @@ interface InterfereViteOptions {
    * `false` skips the post-build release metadata pipeline. Defaults
    * to enabled when an `INTERFERE_API_KEY` is set; defaults to
    * disabled when one isn't (so dev runs without creds don't fail).
-   * Useful when source maps are uploaded out-of-band via the
-   * `@interfere/cli`.
+   * Useful when source maps are uploaded separately through the release API.
+   * `"required"` fails the build unless source-map publication succeeds.
    */
-  sourceMaps?: boolean;
+  sourceMaps?: boolean | "required";
+  /** Wait for the exact source-map batch to be published, with a separate deadline in milliseconds. Requires sourceMaps: "required". */
+  sourceMapReadinessTimeoutMs?: number;
 }
-declare function interfere(options?: InterfereViteOptions): Plugin;
-//#endregion
-export { InterfereViteOptions, interfere };
+export declare function interfere(options?: InterfereViteOptions): Plugin<any>;
+//#endregion

package/dist/plugin.mjs

@@ -1,3 +1,3 @@
-import{PRODUCER_VERSION}from"./version.mjs";import{resolveBakedConfig}from"./internal/build/baked-config.mjs";import{runGitCommand}from"./internal/build/git.mjs";import{discoverByPairing}from"./internal/build/source-maps.mjs";import{createSdkClient,runReleasePipeline}from"./internal/build/pipeline.mjs";import{resolveCommitSha}from"./internal/release-slug.mjs";import{API_URL}from"@interfere/constants/api";import{deriveReleaseSlug}from"@interfere/types/releases/slug";import{classifyReleasePipelineError,diagnoseRelease,isInterfereApiKey}from"@interfere/types/sdk/build-diagnostics";import{resolveDeployEnvironment}from"@interfere/types/sdk/deploy-environment";import{existsSync,readdirSync,statSync}from"node:fs";import path from"node:path";import{loadEnv}from"vite";const SERVER_RUNTIME_PLUGIN_HINTS=[`tanstack-start`,`nitro`,`@tanstack/react-start`],DIAGNOSTIC_CONTEXT={publicKeyEnvVar:`VITE_INTERFERE_PUBLIC_KEY`};function reportReleaseDiagnostic(logger,code,input){let diagnostic=diagnoseRelease(code,DIAGNOSTIC_CONTEXT,input);logger.warn(`[interfere] ${diagnostic.title}`);for(let line of diagnostic.details)logger.warn(`[interfere] ${line}`)}function isTestEnv(){return!!(process.env.VITEST||process.env.VITEST_WORKER_ID)}function pickEnvValue(env,key){let value=env[key];return value&&value.length>0?value:void 0}function failMissingPublicKey(){let lines=[`interfere() requires VITE_INTERFERE_PUBLIC_KEY to identify your project at runtime.`,`Set the VITE_INTERFERE_PUBLIC_KEY environment variable, or remove interfere() from your Vite config.`,`See: https://interfere.com/docs/sdk/vite`];if(isTestEnv())throw Error(`Interfere: Public key not set\n${lines.join(`
+import{PRODUCER_VERSION}from"./version.mjs";import{runGitCommand}from"./internal/build/git.mjs";import{createBuildReceipt}from"./internal/build/build-receipt.mjs";import{runReleasePipeline}from"./internal/build/pipeline.mjs";import{renderDebugId}from"./internal/build/render-debug-id.mjs";import{discoverByPairing}from"./internal/build/source-maps.mjs";import{resolveCommitSha}from"./internal/release-slug.mjs";import{InterfereClient}from"@interfere/javascript";import{createBuildConfigResolver}from"@interfere/build/config";import{API_URL}from"@interfere/constants/api";import{omitUndefined}from"@interfere/helpers/omit-undefined";import{deriveReleaseSlug}from"@interfere/types/releases/slug";import{classifyReleasePipelineError,diagnoseRelease,isInterfereApiKey}from"@interfere/types/sdk/build-diagnostics";import{resolveDeployEnvironment}from"@interfere/types/sdk/deploy-environment";import{createHash}from"node:crypto";import{existsSync,readdirSync,statSync}from"node:fs";import path from"node:path";import{loadEnv}from"vite";const SERVER_RUNTIME_PLUGIN_HINTS=[`tanstack-start`,`nitro`,`@tanstack/react-start`],DIAGNOSTIC_CONTEXT={publicKeyEnvVar:`VITE_INTERFERE_PUBLIC_KEY`};function reportReleaseDiagnostic(logger,code,input){let diagnostic=diagnoseRelease(code,DIAGNOSTIC_CONTEXT,input);logger.warn(`[interfere] ${diagnostic.title}`);for(let line of diagnostic.details)logger.warn(`[interfere] ${line}`)}function isTestEnv(){return!!(process.env.VITEST||process.env.VITEST_WORKER_ID)}function pickEnvValue(env,key){let value=env[key];return value&&value.length>0?value:void 0}function failMissingPublicKey(){let lines=[`interfere() requires VITE_INTERFERE_PUBLIC_KEY to identify your project at runtime.`,`Set the VITE_INTERFERE_PUBLIC_KEY environment variable, or remove interfere() from your Vite config.`,`See: https://interfere.com/docs/sdk/vite`];if(isTestEnv())throw Error(`Interfere: Public key not set\n${lines.join(`
 `)}`);console.error(`
-⨯ Interfere → Public key not set`);for(let i=0;i<lines.length;i+=1){let line=lines[i];if(!line)continue;let connector=i===lines.length-1?`└`:`├`;console.error(` ${connector} ${line}`)}process.exit(1)}function hasServerRuntimePlugin(pluginNames){return pluginNames.some(name=>SERVER_RUNTIME_PLUGIN_HINTS.some(hint=>name.includes(hint)))}function normalizeOrigin(host){try{return new URL(host).origin}catch{return null}}function resolveApiHost(options,env){let host=options.apiHost??env.VITE_INTERFERE_API_URL;if(!host)return;let origin=normalizeOrigin(host);if(!origin)throw Error(`interfere({ apiHost }) requires a full URL, e.g. apiHost: "https://in.yourapp.com"`);return origin}function resolveBrowserConfig(options,env,command){let commitSha=options.commitSha??env.VITE_INTERFERE_COMMIT_SHA??resolveCommitSha(runGitCommand);return{apiHost:resolveApiHost(options,env),commitSha,environment:command===`build`?resolveDeployEnvironment({...env,...process.env}):null,publicKey:env.VITE_INTERFERE_PUBLIC_KEY,releaseSlug:commitSha?deriveReleaseSlug(commitSha):null}}function browserDefine(browser){return{"import.meta.env.VITE_INTERFERE_API_HOST":JSON.stringify(browser.apiHost??null),"import.meta.env.VITE_INTERFERE_ENVIRONMENT":JSON.stringify(browser.environment),"import.meta.env.VITE_INTERFERE_RELEASE_SLUG":JSON.stringify(browser.releaseSlug)}}function hasFreshServerSourceMaps(root,sinceMs){if(!existsSync(root))return!1;let entries=readdirSync(root,{withFileTypes:!0});for(let entry of entries){let absolute=path.join(root,entry.name);if(entry.isDirectory()){if(hasFreshServerSourceMaps(absolute,sinceMs))return!0;continue}if(entry.name.endsWith(`.map`)&&statSync(absolute).mtimeMs>=sinceMs)return!0}return!1}function isUploadReady(state){return!!(state.isProductionBuild&&state.enableUpload&&state.apiKey&&state.releaseSlug&&state.commitSha&&!state.uploadStarted)}function shouldWaitForServerOutput(state){return state.serverBuild&&!hasFreshServerSourceMaps(state.serverSourcemapsDir,state.buildStartedAt)}function logSkippedRelease(logger,failure){if(failure.kind===`missing_source_provider`){logger.warn(`[interfere] release skipped: this surface has no version control provider configured. Configure one at https://interfere.com/~/${failure.config.org.slug}/surfaces/${failure.config.surface.slug}.`);return}logger.warn(`[interfere] release skipped: this surface has no deployment target configured. Configure one at https://interfere.com/~/${failure.config.org.slug}/surfaces/${failure.config.surface.slug}.`)}function logCleanupFailures(logger,failures){for(let failure of failures)logger.warn(`[interfere] cleanup left ${failure.absolute} on disk: ${failure.code??failure.message}`)}async function uploadSourceMaps(state){let{apiKey,apiUrl,releaseSlug,commitSha,logger,projectDir,uploadOutDir}=state;if(!isInterfereApiKey(apiKey)){reportReleaseDiagnostic(logger,`API_KEY_WRONG_PREFIX`,{apiKey});return}logger.info(`[interfere] uploading source maps for release ${releaseSlug}…`);try{let{sdk,security}=createSdkClient({apiKey,apiUrl}),[discovered,releasesConfig]=await Promise.all([discoverByPairing({projectDir,distDir:uploadOutDir,subtrees:[`.`],publicPathRewrites:[{from:`public`,to:``}]}),sdk.releases.getConfig(security)]);if(discovered.files.length===0){logger.info(`[interfere] no source maps found, skipping upload.`);return}let result=await runReleasePipeline({apiKey,apiUrl,bundler:`rollup`,buildId:commitSha,discovery:discovered,environment:state.environment,producerVersion:PRODUCER_VERSION,releasesConfig,releaseSlug});if(!result.ok){logSkippedRelease(logger,result.failure);return}logCleanupFailures(logger,result.data.cleanupFailures),logger.info(`[interfere] release ${result.data.releaseSlug} confirmed — ${result.data.fileCount} maps, ${result.data.timing.total}ms.`)}catch(error){let message=error instanceof Error?error.message:String(error);reportReleaseDiagnostic(logger,classifyReleasePipelineError(error),{errorMessage:message})}}async function uploadSourceMapsWhenReady(state){if(isUploadReady(state)){if(shouldWaitForServerOutput(state)){state.logger.info(`[interfere] waiting for Nitro server output before uploading source maps.`);return}state.uploadStarted=!0,await uploadSourceMaps(state)}}function emitSetupWarnings(state){let{logger,apiKey,releaseSlug,sourceMapsExplicit,isProductionBuild}=state;sourceMapsExplicit!==!1&&apiKey&&!releaseSlug&&logger.warn(`[interfere] No commit SHA available. Release metadata publishing is disabled. Set INTERFERE_SOURCE_ID, expose VERCEL_GIT_COMMIT_SHA / GITHUB_SHA, or run inside a git checkout.`),isProductionBuild&&sourceMapsExplicit!==!1&&!apiKey&&logger.warn("[interfere] INTERFERE_API_KEY is not set. Release metadata will not be published. Create an Interfere secret key in the dashboard and set it in your build environment, or pass `interfere({ sourceMaps: false })` to suppress this warning if release metadata is intentionally handled out-of-band.")}function resolveReleaseEnv(config){return{...loadEnv(config.mode,config.envDir,``),...process.env}}function shouldEnableUpload({apiKey,isProductionBuild,releaseSlug,sourceMaps}){return isProductionBuild?sourceMaps??!!(apiKey&&releaseSlug):!1}function buildPluginState(options,config,browser,announce){let{logger}=config,isProductionBuild=config.command===`build`;isProductionBuild&&!browser.publicKey&&failMissingPublicKey();let releaseEnv=resolveReleaseEnv(config),apiKey=pickEnvValue(releaseEnv,`INTERFERE_API_KEY`),apiUrl=pickEnvValue(releaseEnv,`INTERFERE_API_URL`)??API_URL,uploadOutDir=path.resolve(config.root,config.build.outDir),serverSourcemapsDir=options.serverSourcemapsDir?path.resolve(config.root,options.serverSourcemapsDir):path.join(uploadOutDir,`server`),serverBuild=hasServerRuntimePlugin(config.plugins.map(p=>p.name))||!!config.build?.ssr;return announce&&(logger.info(`[interfere] ingest → ${browser.apiHost??`Interfere (default)`}`),!browser.apiHost&&serverBuild&&logger.warn(`[interfere] Telemetry posts directly to Interfere. On a server-rendered app, set interfere({ apiHost }) to a subdomain of your own site to survive ad-blockers.`),emitSetupWarnings({apiKey,isProductionBuild,logger,releaseSlug:browser.releaseSlug,sourceMapsExplicit:options.sourceMaps})),{apiKey,apiUrl,commitSha:browser.commitSha,enableUpload:shouldEnableUpload({apiKey,isProductionBuild,releaseSlug:browser.releaseSlug,sourceMaps:options.sourceMaps}),environment:browser.environment,isProductionBuild,logger,serverBuild,projectDir:config.root,publicKey:browser.publicKey,releaseSlug:browser.releaseSlug,serverSourcemapsDir,uploadOutDir,uploadStarted:!1,buildStartedAt:Math.floor(Date.now()/1e3)*1e3}}function mirrorPublicKeyForDevServer(command,env){if(command!==`serve`)return;let publicKey=env.VITE_INTERFERE_PUBLIC_KEY;publicKey&&!process.env.VITE_INTERFERE_PUBLIC_KEY&&(process.env.VITE_INTERFERE_PUBLIC_KEY=publicKey)}function resolveEnvDir(userConfig){let root=userConfig.root?path.resolve(process.cwd(),userConfig.root):process.cwd();return userConfig.envDir?path.resolve(root,userConfig.envDir):root}function forceSourcemapForUpload(userConfig,options,command,env){if(!(command===`build`&&options.sourceMaps!==!1&&pickEnvValue(env,`INTERFERE_API_KEY`)))return;let previous=userConfig.build?.sourcemap;return userConfig.build={...userConfig.build,sourcemap:!0},previous===void 0||previous===!0?void 0:previous}function carryOverUploadProgress(previous,next){previous?.serverBuild&&next.serverBuild&&(next.uploadOutDir=previous.uploadOutDir,next.uploadStarted=previous.uploadStarted,next.buildStartedAt=previous.buildStartedAt)}function warnForcedSourcemap(logger,overridden){overridden!==void 0&&logger.warn(`[interfere] Forced build.sourcemap to true (was ${JSON.stringify(overridden)}). Source maps are required to symbolicate errors; they are uploaded then deleted from the build output, so they are never served. Pass interfere({ sourceMaps: false }) to opt out.`)}function interfere(options={}){let state=null,overriddenSourcemap,announced=!1;return{name:`interfere`,enforce:`pre`,async config(userConfig,{command,mode}){let env=loadEnv(mode,resolveEnvDir(userConfig),``);mirrorPublicKeyForDevServer(command,env),overriddenSourcemap=forceSourcemapForUpload(userConfig,options,command,env);let browser=resolveBrowserConfig(options,env,command),define=browserDefine(browser);if(command===`build`&&browser.publicKey&&!isTestEnv()){let baked=await resolveBakedConfig(browser.apiHost??API_URL,browser.publicKey);baked?.ingestUrl&&(define[`import.meta.env.VITE_INTERFERE_INGEST_URL`]=JSON.stringify(baked.ingestUrl)),baked?.plugins&&(define[`import.meta.env.VITE_INTERFERE_PLUGINS`]=JSON.stringify(JSON.stringify(baked.plugins)))}return{define}},configResolved(config){let next=buildPluginState(options,config,resolveBrowserConfig(options,config.env,config.command),!announced);announced=!0,carryOverUploadProgress(state,next),warnForcedSourcemap(next.logger,overriddenSourcemap),overriddenSourcemap=void 0,state=next},async closeBundle(){state&&await uploadSourceMapsWhenReady(state)}}}export{interfere};
+⨯ Interfere → Public key not set`);for(let i=0;i<lines.length;i+=1){let line=lines[i];if(!line)continue;let connector=i===lines.length-1?`└`:`├`;console.error(` ${connector} ${line}`)}process.exit(1)}function hasServerRuntimePlugin(pluginNames){return pluginNames.some(name=>SERVER_RUNTIME_PLUGIN_HINTS.some(hint=>name.includes(hint)))}function normalizeOrigin(host){try{return new URL(host).origin}catch{return null}}function resolveApiHost(options,env){let host=options.apiHost??env.VITE_INTERFERE_API_URL;if(!host)return;let origin=normalizeOrigin(host);if(!origin)throw Error(`interfere({ apiHost }) requires a full URL, e.g. apiHost: "https://in.yourapp.com"`);return origin}function resolveBrowserConfig(options,env,command){let commitSha=options.commitSha??env.VITE_INTERFERE_COMMIT_SHA??resolveCommitSha(runGitCommand);return{apiHost:resolveApiHost(options,env),commitSha,environment:command===`build`?resolveDeployEnvironment({...env,...process.env}):null,publicKey:env.VITE_INTERFERE_PUBLIC_KEY,releaseSlug:commitSha?deriveReleaseSlug(options.buildVariant?createHash(`sha256`).update(JSON.stringify([commitSha,options.buildVariant])).digest(`hex`):commitSha):null}}function browserDefine(browser){return{"import.meta.env.VITE_INTERFERE_API_HOST":JSON.stringify(browser.apiHost??null),"import.meta.env.VITE_INTERFERE_ENVIRONMENT":JSON.stringify(browser.environment),"import.meta.env.VITE_INTERFERE_RELEASE_SLUG":JSON.stringify(browser.releaseSlug)}}function hasFreshServerSourceMaps(root,sinceMs){if(!existsSync(root))return!1;let entries=readdirSync(root,{withFileTypes:!0});for(let entry of entries){let absolute=path.join(root,entry.name);if(entry.isDirectory()){if(hasFreshServerSourceMaps(absolute,sinceMs))return!0;continue}if(entry.name.endsWith(`.map`)&&statSync(absolute).mtimeMs>=sinceMs)return!0}return!1}function isUploadReady(state){return!!(state.isProductionBuild&&state.enableUpload&&state.apiKey&&state.releaseSlug&&state.commitSha&&!state.uploadStarted)}function shouldWaitForServerOutput(state){return state.serverBuild&&!hasFreshServerSourceMaps(state.serverSourcemapsDir,state.buildStartedAt)}function logSkippedRelease(logger,failure){if(failure.kind===`missing_source_provider`){logger.warn(`[interfere] release skipped: this surface has no version control provider configured. Configure one at https://interfere.com/~/${failure.config.org.slug}/surfaces/${failure.config.surface.slug}.`);return}logger.warn(`[interfere] release skipped: this surface has no deployment target configured. Configure one at https://interfere.com/~/${failure.config.org.slug}/surfaces/${failure.config.surface.slug}.`)}function logCleanupFailures(logger,failures){for(let failure of failures)logger.warn(`[interfere] cleanup left ${failure.absolute} on disk: ${failure.code??failure.message}`)}async function uploadSourceMaps(state){let{apiKey,apiUrl,releaseSlug,commitSha,logger,projectDir,uploadOutDir}=state;if(!isInterfereApiKey(apiKey)){if(reportReleaseDiagnostic(logger,`API_KEY_WRONG_PREFIX`,{apiKey}),state.requireUpload)throw Error(`Required source-map publication needs a valid INTERFERE_API_KEY`);return}logger.info(`[interfere] uploading source maps for release ${releaseSlug}…`);try{let client=new InterfereClient({baseUrl:apiUrl,apiKey:{token:apiKey},headers:{"user-agent":PRODUCER_VERSION},maxRetries:4,timeoutInSeconds:10}),[discovered,releasesConfig]=await Promise.all([discoverByPairing({distDir:uploadOutDir,projectDir,publicPathRewrites:[{from:`public`,to:``}],subtrees:[`.`]}),client.releases.getReleasesConfig({abortSignal:AbortSignal.timeout(6e4)})]);if(discovered.files.length===0){if(state.requireUpload)throw Error(`No source maps found for required publication`);logger.warn(`[interfere] No source maps found; the release remains unready. Enable source-map generation and upload them during the build.`);return}if(state.requireUpload&&discovered.files.length!==discovered.sourceFileCount)throw Error(`Required source-map publication is incomplete: loaded ${discovered.files.length} of ${discovered.sourceFileCount} referenced maps`);let result=await runReleasePipeline({client,buildId:commitSha,bundler:`rollup`,discovery:discovered,environment:state.environment,producerVersion:PRODUCER_VERSION,releaseSlug,releasesConfig,readinessTimeoutMs:state.readinessTimeoutMs,capturePublication:state.receipt!==void 0});if(!result.ok){if(logSkippedRelease(logger,result.failure),state.requireUpload)throw Error(`Required source-map publication failed: ${result.failure.kind}`);return}logCleanupFailures(logger,result.data.cleanupFailures),result.data.publication&&state.receipt?.recordPublication(result.data.publication),logger.info(`[interfere] source-map stages (ms): create=${result.data.timing.createRelease}, sign=${result.data.timing.sign}, session=${result.data.timing.session}, upload=${result.data.timing.upload}, finalize=${result.data.timing.finalize}, readiness=${result.data.timing.readiness}, receipt=${result.data.timing.receipt}, cleanup=${result.data.timing.cleanup}; bytes=${result.data.timing.totalBytes}.`),state.uploadComplete=!0,logger.info(`[interfere] release ${result.data.releaseSlug} confirmed — ${result.data.fileCount} maps, ${result.data.timing.total}ms.`)}catch(error){let message=error instanceof Error?error.message:String(error);if(reportReleaseDiagnostic(logger,classifyReleasePipelineError(error),{errorMessage:message}),state.requireUpload)throw error}}async function uploadSourceMapsWhenReady(state){return isUploadReady(state)?shouldWaitForServerOutput(state)?(state.logger.info(`[interfere] waiting for server build output in ${path.relative(state.projectDir,state.serverSourcemapsDir)} before uploading source maps.`),!1):(state.uploadStarted=!0,await uploadSourceMaps(state),state.uploadComplete):state.uploadComplete}function emitSetupWarnings(state){let{logger,apiKey,releaseSlug,sourceMapsExplicit,isProductionBuild}=state;sourceMapsExplicit!==!1&&apiKey&&!releaseSlug&&logger.warn(`[interfere] No commit SHA available. Release metadata publishing is disabled. Set INTERFERE_SOURCE_ID, expose VERCEL_GIT_COMMIT_SHA / GITHUB_SHA, or run inside a git checkout.`),isProductionBuild&&sourceMapsExplicit!==!1&&!apiKey&&logger.warn("[interfere] INTERFERE_API_KEY is not set. Release metadata will not be published. Create an Interfere secret key in the dashboard and set it in your build environment, or pass `interfere({ sourceMaps: false })` to suppress this warning if release metadata is intentionally handled out-of-band.")}function resolveReleaseEnv(config){return{...loadEnv(config.mode,config.envDir,``),...process.env}}function shouldEnableUpload({apiKey,isProductionBuild,releaseSlug,sourceMaps}){return isProductionBuild?sourceMaps===`required`||(sourceMaps??!!(apiKey&&releaseSlug)):!1}function buildPluginState(options,config,browser){let{logger}=config,isProductionBuild=config.command===`build`;isProductionBuild&&!browser.publicKey&&failMissingPublicKey();let releaseEnv=resolveReleaseEnv(config),apiKey=pickEnvValue(releaseEnv,`INTERFERE_API_KEY`),apiUrl=pickEnvValue(releaseEnv,`INTERFERE_API_URL`)??API_URL,requireUpload=isProductionBuild&&options.sourceMaps===`required`,readinessTimeoutMs=options.sourceMapReadinessTimeoutMs;if(readinessTimeoutMs!==void 0&&(options.sourceMaps!==`required`||!Number.isSafeInteger(readinessTimeoutMs)||readinessTimeoutMs<1||readinessTimeoutMs>6e5))throw Error(`sourceMapReadinessTimeoutMs requires sourceMaps: required and an integer between 1 and 600000 milliseconds`);if(requireUpload&&!apiKey)throw Error(`Required source-map publication needs INTERFERE_API_KEY`);if(requireUpload&&!browser.commitSha)throw Error(`Required source-map publication needs a commit SHA`);let uploadOutDir=path.resolve(config.root,config.build.outDir),serverSourcemapsDir=options.serverSourcemapsDir?path.resolve(config.root,options.serverSourcemapsDir):path.join(uploadOutDir,`server`),serverBuild=hasServerRuntimePlugin(config.plugins.map(p=>p.name))||!!config.build.ssr;return{apiHost:browser.apiHost,readinessTimeoutMs,apiKey,apiUrl,buildStartedAt:Math.floor(Date.now()/1e3)*1e3,commitSha:browser.commitSha,enableUpload:shouldEnableUpload({apiKey,isProductionBuild,releaseSlug:browser.releaseSlug,sourceMaps:options.sourceMaps}),environment:browser.environment,isProductionBuild,logger,projectDir:config.root,publicKey:browser.publicKey,requireUpload,releaseSlug:browser.releaseSlug,serverBuild,serverSourcemapsDir,uploadOutDir,uploadStarted:!1,uploadComplete:!1}}function announceSetup(state,options){state.logger.info(`[interfere] ingest → ${state.apiHost??`Interfere (default)`}`),!state.apiHost&&state.serverBuild&&state.logger.warn(`[interfere] Telemetry posts directly to Interfere. On a server-rendered app, set interfere({ apiHost }) to a subdomain of your own site to survive ad-blockers.`),emitSetupWarnings({apiKey:state.apiKey,isProductionBuild:state.isProductionBuild,logger:state.logger,releaseSlug:state.releaseSlug,sourceMapsExplicit:options.sourceMaps})}function mirrorPublicKeyForDevServer(command,env){if(command!==`serve`)return;let publicKey=env.VITE_INTERFERE_PUBLIC_KEY;publicKey&&!process.env.VITE_INTERFERE_PUBLIC_KEY&&(process.env.VITE_INTERFERE_PUBLIC_KEY=publicKey)}function resolveEnvDir(userConfig){let root=userConfig.root?path.resolve(process.cwd(),userConfig.root):process.cwd();return userConfig.envDir===!1||userConfig.envDir===void 0||userConfig.envDir===``?root:path.resolve(root,userConfig.envDir)}function forceSourcemapForUpload(userConfig,options,command,env){if(!(command===`build`&&options.sourceMaps!==!1&&pickEnvValue(env,`INTERFERE_API_KEY`)))return;let previous=userConfig.build?.sourcemap;return userConfig.build={...userConfig.build,sourcemap:!0},previous===void 0||previous===!0?void 0:previous}function carryOverUploadProgress(previous,next){previous?.serverBuild&&next.serverBuild&&(next.uploadOutDir=previous.uploadOutDir,next.serverSourcemapsDir=previous.serverSourcemapsDir,next.uploadStarted=previous.uploadStarted,next.uploadComplete=previous.uploadComplete,next.buildStartedAt=previous.buildStartedAt)}function warnForcedSourcemap(logger,overridden){overridden!==void 0&&logger.warn(`[interfere] Forced build.sourcemap to true (was ${JSON.stringify(overridden)}). Source maps are required to symbolicate errors; they are uploaded then deleted from the build output, so they are never served. Pass interfere({ sourceMaps: false }) to opt out.`)}function interfere(options={}){let receipt=options.buildReceipt?createBuildReceipt(options.buildReceipt):void 0,resolveBuildConfig=createBuildConfigResolver(receipt?.observeConfig),state=null,overriddenSourcemap,announced=!1,writeReceipt=async()=>{try{await receipt?.write()}catch{state?.logger.warn(`[interfere] Private build receipt could not be written.`)}};return{buildApp:{order:`post`,async handler(builder){if(!state?.requireUpload)return;let environments=Object.values(builder.environments);if(environments.every(environment=>!environment.isBuilt))for(let environment of environments)await builder.build(environment);if(!await uploadSourceMapsWhenReady(state))throw Error(`Required publication is waiting for fresh server source maps`);await writeReceipt()}},buildStart(){state&&!announced&&(announceSetup(state,options),warnForcedSourcemap(state.logger,overriddenSourcemap),announced=!0)},async closeBundle(){state&&await uploadSourceMapsWhenReady(state),await writeReceipt()},async writeBundle(output,bundle){output.dir&&await receipt?.recordOutput(output.dir,Object.keys(bundle))},outputOptions(output){return state?.enableUpload?{...output,sourcemapDebugIds:!1}:null},renderChunk:{order:`post`,handler(code){return state?.enableUpload?renderDebugId(code):null}},async config(userConfig,{command,mode}){let env=loadEnv(mode,resolveEnvDir(userConfig),``);mirrorPublicKeyForDevServer(command,env),overriddenSourcemap=forceSourcemapForUpload(userConfig,options,command,env);let browser=resolveBrowserConfig(options,env,command),baked=command===`build`&&browser.publicKey&&!isTestEnv()?await resolveBuildConfig(browser.apiHost??API_URL,browser.publicKey):null;return{define:omitUndefined({...browserDefine(browser),"import.meta.env.VITE_INTERFERE_INGEST_URL":baked?.ingestUrl?JSON.stringify(baked.ingestUrl):void 0,"import.meta.env.VITE_INTERFERE_SERVER_TRACING":baked?.serverTracing?JSON.stringify(baked.serverTracing):void 0,"import.meta.env.VITE_INTERFERE_LOG_SOURCING":baked?.logSourcing?JSON.stringify(baked.logSourcing):void 0,"import.meta.env.VITE_INTERFERE_PLUGINS":baked?.plugins?JSON.stringify(JSON.stringify(baked.plugins)):void 0}),ssr:{noExternal:[`@interfere/vite`]}}},async configResolved(config){let browser=resolveBrowserConfig(options,config.env,config.command),next=buildPluginState(options,config,browser);carryOverUploadProgress(state,next),state={...next,receipt},config.command===`build`&&await receipt?.configure(config,{commitSha:browser.commitSha,releaseSlug:browser.releaseSlug,environment:browser.environment,publicKey:browser.publicKey,apiOrigin:browser.apiHost??API_URL,producerVersion:PRODUCER_VERSION})},enforce:`pre`,name:`interfere`,sharedDuringBuild:!0}}export{interfere};

package/dist/provider.d.mts

@@ -1,5 +1,5 @@
 import { PluginOverrides, useInterfere, useSession } from "@interfere/react/provider";
-import { PropsWithChildren, ReactNode } from "react";
+import { PropsWithChildren } from "react";
 import { ConsentCategory, ConsentState, ConsentState as ConsentState$1, GateableCategory } from "@interfere/types/sdk/plugins/manifest";
 //#region src/provider.d.ts
 interface InterfereProviderProps extends PropsWithChildren {
@@ -11,6 +11,6 @@ interface InterfereProviderProps extends PropsWithChildren {
  * Vite wrapper around `@interfere/react`'s provider that reads the
  * kernel created by `@interfere/vite/init`.
  */
-declare function InterfereProvider({ children, consent, plugins, errorBoundary }: InterfereProviderProps): ReactNode;
+export declare function InterfereProvider({ children, consent, plugins, errorBoundary }: InterfereProviderProps): import("react").JSX.Element;
 //#endregion
-export { type ConsentCategory, type ConsentState, type GateableCategory, InterfereProvider, useInterfere, useSession };
+export { type ConsentCategory, type ConsentState, type GateableCategory, useInterfere, useSession };

package/dist/provider.mjs

@@ -1 +1 @@
-import{getKernelOrNull,subscribeToKernel}from"./init.mjs";import{omitUndefined}from"@interfere/helpers/omit-undefined";import{InterfereProvider as InterfereProvider$1,useInterfere,useSession}from"@interfere/react/provider";import{useSyncExternalStore}from"react";import{jsx}from"react/jsx-runtime";const nullSnapshot=()=>null;function InterfereProvider({children,consent,plugins,errorBoundary}){let kernel=useSyncExternalStore(subscribeToKernel,getKernelOrNull,nullSnapshot);return jsx(InterfereProvider$1,{kernel,...omitUndefined({consent,plugins,errorBoundary}),children})}export{InterfereProvider,useInterfere,useSession};
+import{getKernelOrNull,subscribeToKernel}from"./init.mjs";import{omitUndefined}from"@interfere/helpers/omit-undefined";import{InterfereProvider as InterfereProvider$1,useInterfere,useSession}from"@interfere/react/provider";import{useSyncExternalStore}from"react";import{jsx}from"react/jsx-runtime";const nullSnapshot=()=>null;function InterfereProvider({children,consent,plugins,errorBoundary}){let kernel=useSyncExternalStore(subscribeToKernel,getKernelOrNull,nullSnapshot);return jsx(InterfereProvider$1,{kernel,...omitUndefined({consent,errorBoundary,plugins}),children})}export{InterfereProvider,useInterfere,useSession};

package/dist/tanstack-start.d.mts

@@ -1,5 +1,5 @@
 import { TraceMetaDescriptor, traceMeta } from "./internal/server/request-trace.mjs";
 //#region src/tanstack-start.d.ts
-declare const interfereRequestMiddleware: import("@tanstack/react-start").RequestMiddlewareAfterServer<{}, undefined, undefined>;
+export declare const interfereRequestMiddleware: import("@tanstack/react-start").RequestMiddlewareAfterServer<{}, undefined, undefined>;
 //#endregion
-export { type TraceMetaDescriptor, interfereRequestMiddleware, traceMeta };
+export { type TraceMetaDescriptor, traceMeta };

package/dist/tanstack-start.mjs

@@ -1 +1 @@
-import{traceMeta,withRequestSpan}from"./internal/server/request-trace.mjs";import{createMiddleware}from"@tanstack/react-start";const interfereRequestMiddleware=createMiddleware().server(({next,request})=>withRequestSpan(request,()=>Promise.resolve(next())));export{interfereRequestMiddleware,traceMeta};
+import{traceMeta,withRequestSpan}from"./internal/server/request-trace.mjs";import{createMiddleware}from"@tanstack/react-start";const interfereRequestMiddleware=createMiddleware().server(async({next,request})=>withRequestSpan(request,async()=>next()));export{interfereRequestMiddleware,traceMeta};

package/dist/version.d.mts

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

package/package.json

@@ -1,21 +1,21 @@
 {
   "name": "@interfere/vite",
-  "version": "11.2.1",
-  "license": "MIT",
+  "version": "12.0.0",
   "description": "Vite build plugin and client + server initialization for Interfere.",
   "keywords": [
+    "error-tracking",
+    "nitro",
     "observability",
-    "typescript",
-    "vite",
+    "session-replay",
     "tanstack-start",
-    "nitro",
-    "error-tracking",
-    "session-replay"
+    "typescript",
+    "vite"
   ],
   "homepage": "https://interfere.com",
   "bugs": {
     "url": "mailto:support@interfere.com"
   },
+  "license": "MIT",
   "author": "Interfere <support@interfere.com> (https://interfere.com)",
   "repository": {
     "type": "git",
@@ -62,32 +62,49 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@interfere/constants": "^9.0.6",
-    "@interfere/helpers": "^9.1.2",
-    "@interfere/react": "^11.2.1",
-    "@interfere/sdk": "^11.2.1",
-    "@interfere/types": "^10.1.2",
+    "@interfere/build": "^0.2.0",
+    "@interfere/constants": "^9.1.0",
+    "@interfere/helpers": "^9.2.0",
+    "@interfere/javascript": "^0.2.0",
+    "@interfere/react": "^12.0.0",
+    "@interfere/types": "^10.2.0",
     "@opentelemetry/api": "^1.9.1",
-    "@opentelemetry/api-logs": "^0.221.0",
+    "@opentelemetry/api-logs": "^0.222.0",
     "@opentelemetry/baggage-span-processor": "^0.5.0",
-    "@opentelemetry/context-async-hooks": "^2.7.1",
-    "@opentelemetry/core": "^2.7.0",
-    "@opentelemetry/exporter-logs-otlp-http": "^0.221.0",
-    "@opentelemetry/exporter-metrics-otlp-http": "^0.221.0",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.221.0",
-    "@opentelemetry/instrumentation": "^0.221.0",
-    "@opentelemetry/instrumentation-undici": "^0.31.0",
-    "@opentelemetry/resources": "^2.7.0",
-    "@opentelemetry/sdk-logs": "^0.221.0",
-    "@opentelemetry/sdk-metrics": "^2.7.0",
-    "@opentelemetry/sdk-trace-base": "^2.7.0",
-    "@opentelemetry/sdk-trace-node": "^2.7.1"
+    "@opentelemetry/context-async-hooks": "^2.11.0",
+    "@opentelemetry/core": "^2.11.0",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.222.0",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.222.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.222.0",
+    "@opentelemetry/instrumentation": "^0.222.0",
+    "@opentelemetry/instrumentation-undici": "^0.32.0",
+    "@opentelemetry/resources": "^2.11.0",
+    "@opentelemetry/sdk-logs": "^0.222.0",
+    "@opentelemetry/sdk-metrics": "^2.11.0",
+    "@opentelemetry/sdk-trace-base": "^2.11.0",
+    "@opentelemetry/sdk-trace-node": "^2.11.0"
+  },
+  "devDependencies": {
+    "@interfere/typescript-config": "^9.0.2",
+    "@interfere/vitest-config": "0.0.0",
+    "@tanstack/react-start": "1.168.49",
+    "@types/node": "^26.4.1",
+    "@types/react": "19.2.18",
+    "@types/react-dom": "19.2.7",
+    "@vitest/coverage-v8": "5.0.1",
+    "msw": "^2.14.6",
+    "react": "19.3.0",
+    "react-dom": "19.3.0",
+    "tsdown": "^0.23.0",
+    "typescript": "^7.0.2",
+    "vite": "^8.2.2",
+    "vitest": "5.0.1"
   },
   "peerDependencies": {
-    "@tanstack/react-start": "1.168.42",
-    "react": "^19.2.6",
+    "@tanstack/react-start": "1.168.49",
+    "react": "^19.0.0",
     "react-dom": "^19.0.0",
-    "vite": "^8.2.1"
+    "vite": "^8.2.2"
   },
   "peerDependenciesMeta": {
     "@tanstack/react-start": {
@@ -102,20 +119,5 @@
     "vite": {
       "optional": true
     }
-  },
-  "devDependencies": {
-    "@interfere/test-utils": "^9.1.2",
-    "@interfere/typescript-config": "^9.0.2",
-    "@tanstack/react-start": "1.168.42",
-    "@types/node": "^26.2.0",
-    "@types/react": "19.2.18",
-    "@types/react-dom": "19.2.4",
-    "@vitest/coverage-v8": "4.1.10",
-    "react": "^19.2.6",
-    "react-dom": "19.2.8",
-    "tsdown": "^0.22.2",
-    "typescript": "^7.0.2",
-    "vite": "^8.2.1",
-    "vitest": "4.1.10"
   }
 }