@interfere/next 0.1.0-alpha.9 → 0.2.0-alpha.3

package/dist/build/with-interfere.mjs

@@ -1,154 +0,0 @@
-import { nextBuildLogger } from "./logger.mjs";
-import { ReleaseIdentityService, ReleaseIdentityServiceLive } from "./services/release-identity.service.mjs";
-import { createReleaseLayers, releaseProgram } from "./release-program.mjs";
-import { detectInstrumentationFilesSync } from "./services/instrumentation-detection.service.mjs";
-import { PreflightService, PreflightServiceLive } from "./services/preflight.service.mjs";
-import { withInterfereLogger } from "@interfere/effect-utils/observability";
-import { Effect, Layer, LogLevel, Logger, Option } from "effect";
-import * as path$1 from "node:path";
-import { fileURLToPath } from "node:url";
-
-//#region src/build/with-interfere.ts
-/**
-* Next.js configuration wrapper that automatically uploads source maps in production builds
-*
-* SECURITY: Secret key must be set via INTERFERE_SECRET_KEY env var (without NEXT_PUBLIC_ prefix)
-*
-* @example
-* ```js
-* // next.config.js
-* import { withInterfere } from '@interfere/next/config';
-*
-* export default withInterfere({
-*   environment: 'staging',
-*   debug: true,
-*   cleanupSourceMaps: true
-* })({
-*   // Your Next.js config
-* });
-* ```
-*/
-function withInterfere({ interfere = {}, ...nextConfig } = {}) {
-	const interfereConfig = Effect.gen(function* () {
-		return yield* (yield* PreflightService).buildConfig(interfere);
-	}).pipe(Effect.provide(PreflightServiceLive), Effect.runSync);
-	const identityProgram = Effect.gen(function* () {
-		return yield* (yield* ReleaseIdentityService).pipe(Effect.option);
-	}).pipe(Effect.provide(ReleaseIdentityServiceLive), Effect.runSync);
-	const identity = Option.getOrUndefined(identityProgram);
-	let instrumentationFiles;
-	try {
-		instrumentationFiles = detectInstrumentationFilesSync();
-	} catch {
-		instrumentationFiles = {
-			server: null,
-			client: null
-		};
-	}
-	return function buildConfig() {
-		const env = {
-			...nextConfig.env,
-			NEXT_PUBLIC_INTERFERE_ENVIRONMENT: interfereConfig.environment,
-			...identity?.buildId ? { NEXT_PUBLIC_INTERFERE_BUILD_ID: identity.buildId } : {},
-			...identity?.releaseId ? { NEXT_PUBLIC_INTERFERE_RELEASE_ID: identity.releaseId } : {}
-		};
-		const compiler = !interfereConfig.enabled ? nextConfig.compiler : {
-			...nextConfig.compiler,
-			runAfterProductionCompile: async (ctx) => {
-				const debugEnabled = process.env.INTERFERE_PLUGIN_DEBUG === "1";
-				const startTime = Date.now();
-				if (debugEnabled) console.log("[Interfere Plugin] Starting runAfterProductionCompile");
-				const existingHook = nextConfig.compiler?.runAfterProductionCompile;
-				if (existingHook) {
-					const hookStart = Date.now();
-					await existingHook(ctx);
-					if (debugEnabled) console.log(`[Interfere Plugin] Existing hook completed in ${Date.now() - hookStart}ms`);
-				}
-				const scopedProgram = releaseProgram.pipe(Effect.provide(createReleaseLayers(interfereConfig)), Effect.scoped, debugEnabled ? Logger.withMinimumLogLevel(LogLevel.Debug) : (x) => x);
-				const programStart = Date.now();
-				await Effect.runPromise(withInterfereLogger("next", scopedProgram, { logger: nextBuildLogger }));
-				if (debugEnabled) {
-					console.log(`[Interfere Plugin] Release program completed in ${Date.now() - programStart}ms`);
-					console.log(`[Interfere Plugin] Total runAfterProductionCompile time: ${Date.now() - startTime}ms`);
-				}
-			}
-		};
-		const injectionValues = {
-			__INTERFERE_BUILD_ID__: identity?.buildId ?? null,
-			__INTERFERE_RELEASE_ID__: identity?.releaseId ?? null,
-			__INTERFERE_ENVIRONMENT__: interfereConfig.environment,
-			__INTERFERE_ENABLED__: interfereConfig.enabled,
-			...interfere.features && { __INTERFERE_FEATURES__: interfere.features }
-		};
-		const webpack = createWebpackConfig(nextConfig.webpack, instrumentationFiles.client, injectionValues);
-		const turbopack = createTurbopackConfig(nextConfig.turbopack, instrumentationFiles.client, injectionValues);
-		return {
-			...nextConfig,
-			compiler,
-			env,
-			webpack,
-			turbopack,
-			productionBrowserSourceMaps: interfereConfig.enabled ? true : nextConfig.productionBrowserSourceMaps
-		};
-	};
-}
-/**
-* Creates webpack configuration that applies value injection loader to instrumentation-client files.
-*/
-function createWebpackConfig(existingWebpack, clientFilePath, injectionValues) {
-	if (!clientFilePath) return existingWebpack ?? ((config) => config);
-	const webpackConfigFn = (config, options) => {
-		const instrumentationRule = {
-			test: (resource) => {
-				if (!resource) return false;
-				return path$1.normalize(resource) === path$1.normalize(clientFilePath);
-			},
-			use: {
-				loader: path$1.resolve(path$1.dirname(fileURLToPath(import.meta.url)), "loaders", "value-injection-loader.js"),
-				options: { values: injectionValues }
-			}
-		};
-		let resultConfig = config;
-		if (existingWebpack) resultConfig = existingWebpack(config, options);
-		const webpackConfig = resultConfig;
-		webpackConfig.module = webpackConfig.module ?? {};
-		webpackConfig.module.rules = webpackConfig.module.rules ?? [];
-		webpackConfig.module.rules.push(instrumentationRule);
-		return resultConfig;
-	};
-	return webpackConfigFn;
-}
-/**
-* Converts values to a JSON string representation that preserves null semantics.
-* This avoids the issue of losing null values when they're converted to empty strings.
-* The loader will parse this string back to the original values.
-* @internal
-*/
-function serializeForTurbopack(value) {
-	return JSON.stringify(value);
-}
-/**
-* Creates turbopack configuration that applies value injection loader to instrumentation-client files.
-* 
-* Note: Turbopack loader options must be JSON-serializable, so we serialize the injection values.
-*/
-function createTurbopackConfig(existingTurbopack, clientFilePath, injectionValues) {
-	const loaderPath = path$1.resolve(path$1.dirname(fileURLToPath(import.meta.url)), "loaders", "value-injection-loader.js");
-	const baseTurbopack = existingTurbopack ?? {};
-	if (!clientFilePath) return baseTurbopack;
-	const clientFileName = path$1.basename(clientFilePath);
-	const serializedValues = serializeForTurbopack(injectionValues);
-	return {
-		...baseTurbopack,
-		rules: {
-			...baseTurbopack.rules,
-			[`**/${clientFileName}`]: { loaders: [{
-				loader: loaderPath,
-				options: { serializedValues }
-			}] }
-		}
-	};
-}
-
-//#endregion
-export { withInterfere };

package/dist/build/with-interfere.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"with-interfere.mjs","names":["instrumentationFiles: InstrumentationFiles","injectionValues: Record<string, unknown>","webpackConfigFn: NonNullable<NextConfig[\"webpack\"]>","instrumentationRule: RuleSetRule","path"],"sources":["../../src/build/with-interfere.ts"],"sourcesContent":["import { withInterfereLogger } from \"@interfere/effect-utils/observability\";\nimport { Effect, Layer, Logger, LogLevel, Option } from \"effect\";\nimport type { NextConfig } from \"next\";\nimport * as path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport type { Configuration as WebpackConfiguration, RuleSetRule } from \"webpack\";\nimport { nextBuildLogger } from \"./logger.js\";\nimport type { ValueInjectionLoaderOptions } from \"./loaders/value-injection-loader.js\";\nimport { createReleaseLayers, releaseProgram } from \"./release-program.js\";\nimport {\n  detectInstrumentationFilesSync,\n  type InstrumentationFiles,\n} from \"./services/instrumentation-detection.service.js\";\nimport { PreflightService, PreflightServiceLive } from \"./services/preflight.service.js\";\nimport { ReleaseIdentityService, ReleaseIdentityServiceLive } from \"./services/release-identity.service.js\";\n\nexport type InterfereFeatures = {\n  /**\n   * Enable error tracking\n   * @default true\n   */\n  errorTracking?: boolean;\n\n  /**\n   * Enable session replay\n   * @default true in production, false in development\n   */\n  replay?: boolean;\n\n  /**\n   * Enable performance monitoring\n   * @default true\n   */\n  performanceMonitoring?: boolean;\n};\n\nexport type InterfereOptions = {\n  /**\n   * Environment name\n   * @default \"production\"\n   */\n  environment?: string;\n\n  /**\n   * Enable debug logging\n   * @default false\n   */\n  debug?: boolean;\n\n  /**\n   * Whether to delete source maps after upload to prevent leakage\n   * @default true\n   */\n  cleanupSourceMaps?: boolean;\n\n  /**\n   * Feature flags for the SDK.\n   * These are injected at build time and available to the client SDK.\n   */\n  features?: InterfereFeatures;\n};\n\ntype NextConfigWithInterfere = NextConfig & {\n  interfere?: InterfereOptions;\n};\n\n/**\n * Next.js configuration wrapper that automatically uploads source maps in production builds\n *\n * SECURITY: Secret key must be set via INTERFERE_SECRET_KEY env var (without NEXT_PUBLIC_ prefix)\n *\n * @example\n * ```js\n * // next.config.js\n * import { withInterfere } from '@interfere/next/config';\n *\n * export default withInterfere({\n *   environment: 'staging',\n *   debug: true,\n *   cleanupSourceMaps: true\n * })({\n *   // Your Next.js config\n * });\n * ```\n */\nexport function withInterfere({\n  interfere = {},\n  ...nextConfig\n}: NextConfigWithInterfere = {}): () => NextConfig {\n  // Build the preflight config using the service\n  const configProgram = Effect.gen(function* () {\n    const preflight = yield* PreflightService;\n    return yield* preflight.buildConfig(interfere);\n  }).pipe(\n    Effect.provide(PreflightServiceLive),\n    Effect.runSync\n  );\n\n  const interfereConfig = configProgram;\n  \n  // Use the ReleaseIdentityService to infer build/release IDs\n  // This runs the same logic that the release program uses\n  const identityProgram = Effect.gen(function* () {\n    const identityEffect = yield* ReleaseIdentityService;\n    return yield* identityEffect.pipe(Effect.option);\n  }).pipe(\n    Effect.provide(ReleaseIdentityServiceLive),\n    Effect.runSync\n  );\n  \n  const identity = Option.getOrUndefined(identityProgram);\n\n  // Detect instrumentation files for automatic client initialization\n  let instrumentationFiles: InstrumentationFiles;\n  try {\n    instrumentationFiles = detectInstrumentationFilesSync();\n  } catch {\n    // If detection fails, assume no instrumentation files\n    instrumentationFiles = { server: null, client: null };\n  }\n\n  return function buildConfig() {\n    // Use the same release identity logic that the release program uses\n    // This ensures consistency between what gets uploaded and what the client SDK sends\n    const env = {\n      ...nextConfig.env,\n      // Pass the deduced/configured environment to the client SDK\n      // (it defaults to NODE_ENV in preflight service)\n      NEXT_PUBLIC_INTERFERE_ENVIRONMENT: interfereConfig.environment,\n      // Pass the inferred build/release IDs to the client SDK\n      // These come from the same ReleaseIdentityService that the release program uses\n      ...(identity?.buildId\n        ? { NEXT_PUBLIC_INTERFERE_BUILD_ID: identity.buildId }\n        : {}),\n      ...(identity?.releaseId\n        ? { NEXT_PUBLIC_INTERFERE_RELEASE_ID: identity.releaseId }\n        : {}),\n    };\n\n    // Set up compiler hook if enabled\n    const compiler = !interfereConfig.enabled\n      ? nextConfig.compiler\n      : {\n          ...nextConfig.compiler,\n          runAfterProductionCompile: async (ctx: {\n            projectDir: string;\n            distDir: string;\n          }) => {\n            const debugEnabled = process.env.INTERFERE_PLUGIN_DEBUG === \"1\";\n            const startTime = Date.now();\n\n            if (debugEnabled) {\n              console.log(\"[Interfere Plugin] Starting runAfterProductionCompile\");\n            }\n\n            // Run existing hook first\n            const existingHook = nextConfig.compiler?.runAfterProductionCompile;\n            if (existingHook) {\n              const hookStart = Date.now();\n              await existingHook(ctx);\n              if (debugEnabled) {\n                console.log(`[Interfere Plugin] Existing hook completed in ${Date.now() - hookStart}ms`);\n              }\n            }\n\n            // Run the unified release program with all layers\n            const scopedProgram = releaseProgram.pipe(\n              Effect.provide(createReleaseLayers(interfereConfig)),\n              Effect.scoped,\n              debugEnabled\n                ? Logger.withMinimumLogLevel(LogLevel.Debug)\n                : (x) => x\n            ) as Effect.Effect<unknown, unknown, never>;\n\n            const programStart = Date.now();\n            await Effect.runPromise(\n              withInterfereLogger(\"next\", scopedProgram, { logger: nextBuildLogger })\n            );\n            if (debugEnabled) {\n              console.log(`[Interfere Plugin] Release program completed in ${Date.now() - programStart}ms`);\n              console.log(`[Interfere Plugin] Total runAfterProductionCompile time: ${Date.now() - startTime}ms`);\n            }\n          },\n        };\n\n    // Build-time values to inject into instrumentation-client.ts\n    // These are read by @interfere/next/auto-init at runtime\n    const injectionValues: Record<string, unknown> = {\n      __INTERFERE_BUILD_ID__: identity?.buildId ?? null,\n      __INTERFERE_RELEASE_ID__: identity?.releaseId ?? null,\n      __INTERFERE_ENVIRONMENT__: interfereConfig.environment,\n      __INTERFERE_ENABLED__: interfereConfig.enabled,\n      // Feature flags - only include if explicitly set\n      ...(interfere.features && {\n        __INTERFERE_FEATURES__: interfere.features,\n      }),\n    };\n\n    // Configure webpack to apply value injection loader to instrumentation-client files\n    const webpack = createWebpackConfig(\n      nextConfig.webpack,\n      instrumentationFiles.client,\n      injectionValues\n    );\n\n    // Configure turbopack to apply value injection loader to instrumentation-client files\n    const turbopack = createTurbopackConfig(\n      nextConfig.turbopack,\n      instrumentationFiles.client,\n      injectionValues\n    );\n\n    return {\n      ...nextConfig,\n      compiler,\n      env,\n      webpack,\n      turbopack,\n      // Automatically enable browser source maps when Interfere is enabled\n      productionBrowserSourceMaps: interfereConfig.enabled\n        ? true\n        : nextConfig.productionBrowserSourceMaps,\n    };\n  };\n}\n\n/**\n * Creates webpack configuration that applies value injection loader to instrumentation-client files.\n */\nfunction createWebpackConfig(\n  existingWebpack: NextConfig[\"webpack\"],\n  clientFilePath: string | null,\n  injectionValues: Record<string, unknown>\n): NextConfig[\"webpack\"] {\n  // If no instrumentation-client file, return existing webpack config or identity function\n  // This ensures webpack is never undefined, matching the turbopack pattern\n  if (!clientFilePath) {\n    return existingWebpack ?? ((config) => config);\n  }\n\n  const webpackConfigFn: NonNullable<NextConfig[\"webpack\"]> = (config, options) => {\n    // Resolve the loader path relative to this file\n    // Use fileURLToPath for cross-platform compatibility (Windows support)\n    const loaderPath = path.resolve(\n      path.dirname(fileURLToPath(import.meta.url)),\n      \"loaders\",\n      \"value-injection-loader.js\"\n    );\n\n    // Create a rule that matches only the instrumentation-client file\n    const instrumentationRule: RuleSetRule = {\n      test: (resource: string) => {\n        if (!resource) return false;\n        // Match the exact instrumentation-client file path\n        const normalizedResource = path.normalize(resource);\n        const normalizedClientPath = path.normalize(clientFilePath);\n        return normalizedResource === normalizedClientPath;\n      },\n      use: {\n        loader: loaderPath,\n        options: { values: injectionValues } satisfies ValueInjectionLoaderOptions,\n      },\n    };\n\n    // Call existing webpack config first, if provided\n    // This ensures we add our rule to whatever config object is returned\n    let resultConfig = config;\n    if (existingWebpack) {\n      resultConfig = existingWebpack(config, options);\n    }\n\n    // Add the rule to the result config\n    // This ensures the rule is added regardless of whether the webpack function\n    // returned the original config or created a new object\n    const webpackConfig = resultConfig as WebpackConfiguration;\n    webpackConfig.module = webpackConfig.module ?? {};\n    webpackConfig.module.rules = webpackConfig.module.rules ?? [];\n    webpackConfig.module.rules.push(instrumentationRule);\n\n    return resultConfig;\n  };\n\n  return webpackConfigFn;\n}\n\n// JSONValue type from Next.js - doesn't allow null\ntype JSONValue = string | number | boolean | JSONValue[] | { [k: string]: JSONValue };\n\n/**\n * Converts values to a JSON string representation that preserves null semantics.\n * This avoids the issue of losing null values when they're converted to empty strings.\n * The loader will parse this string back to the original values.\n * @internal\n */\nfunction serializeForTurbopack(value: unknown): string {\n  // Use JSON.stringify which correctly handles null, arrays, and objects\n  return JSON.stringify(value);\n}\n\n/**\n * Creates turbopack configuration that applies value injection loader to instrumentation-client files.\n * \n * Note: Turbopack loader options must be JSON-serializable, so we serialize the injection values.\n */\nfunction createTurbopackConfig(\n  existingTurbopack: NextConfig[\"turbopack\"],\n  clientFilePath: string | null,\n  injectionValues: Record<string, unknown>\n): NextConfig[\"turbopack\"] {\n  // Resolve the loader path relative to this file\n  // Use fileURLToPath for cross-platform compatibility (Windows support)\n  const loaderPath = path.resolve(\n    path.dirname(fileURLToPath(import.meta.url)),\n    \"loaders\",\n    \"value-injection-loader.js\"\n  );\n\n  // Base turbopack config (preserve existing or empty object)\n  const baseTurbopack = existingTurbopack ?? {};\n\n  // If no instrumentation-client file, return base config\n  if (!clientFilePath) {\n    return baseTurbopack;\n  }\n\n  // Create glob pattern for the instrumentation-client file\n  // Turbopack rules use glob patterns\n  const clientFileName = path.basename(clientFilePath);\n\n  // Serialize injection values to preserve null semantics.\n  // Turbopack options must be JSON-serializable, but the loader can receive\n  // a serialized JSON string that it will parse to recover the original values.\n  const serializedValues = serializeForTurbopack(injectionValues);\n\n  return {\n    ...baseTurbopack,\n    rules: {\n      ...baseTurbopack.rules,\n      // Match instrumentation-client files in any location\n      [`**/${clientFileName}`]: {\n        loaders: [\n          {\n            loader: loaderPath,\n            options: {\n              // Pass as serialized JSON string to preserve null values\n              serializedValues,\n            } as Record<string, JSONValue>,\n          },\n        ],\n      },\n    },\n  };\n}"],"mappings":"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"}

package/dist/client/auto-init.d.mts

@@ -1,92 +0,0 @@
-import { Config } from "@interfere/types/sdk/config";
-
-//#region src/client/auto-init.d.ts
-
-/**
- * Feature flags that can be injected at build time.
- */
-interface InjectedFeatures {
-  errorTracking?: boolean;
-  replay?: boolean;
-  performanceMonitoring?: boolean;
-}
-/**
- * Build-time injected values set by the value-injection-loader.
- * These are populated when instrumentation-client.ts is processed during build.
- */
-declare global {
-  var __INTERFERE_BUILD_ID__: string | null | undefined;
-  var __INTERFERE_RELEASE_ID__: string | null | undefined;
-  var __INTERFERE_ENVIRONMENT__: string | undefined;
-  var __INTERFERE_ENABLED__: boolean | undefined;
-  var __INTERFERE_FEATURES__: InjectedFeatures | undefined;
-  var __INTERFERE_INITIALIZED__: boolean | undefined;
-}
-/**
- * The injected config keys that the value-injection-loader sets.
- * This is the canonical list of keys - keep in sync with withInterfere.
- */
-declare const INJECTED_CONFIG_KEYS: readonly ["__INTERFERE_BUILD_ID__", "__INTERFERE_RELEASE_ID__", "__INTERFERE_ENVIRONMENT__", "__INTERFERE_ENABLED__", "__INTERFERE_FEATURES__"];
-type InjectedConfigKey = (typeof INJECTED_CONFIG_KEYS)[number];
-/**
- * Partial config that can be provided by users to override injected values.
- */
-interface AutoInitConfigOverrides {
-  features?: Config["features"];
-  batch?: Config["batch"];
-  offline?: Config["offline"];
-  proxyUrl?: string;
-  metadata?: Partial<Config["metadata"]>;
-}
-/**
- * Reads configuration from build-time injected values.
- *
- * The value-injection-loader prepends code to instrumentation-client.ts
- * that sets these globalThis values during the build process.
- *
- * @returns Partial config from injected values, or null if SDK is disabled
- */
-declare function getInjectedConfig(): Partial<Config> | null;
-/**
- * Initialize Interfere client automatically from build-time injected config.
- *
- * Call this from instrumentation-client.ts for zero-config initialization.
- * User-provided overrides take precedence over injected values.
- *
- * @param userConfig - Optional configuration overrides
- * @returns Parsed config if initialization succeeded, null if SDK is disabled or already initialized
- *
- * @example
- * ```ts
- * // instrumentation-client.ts
- * import { autoInitClient } from "@interfere/next/auto-init";
- *
- * const config = autoInitClient();
- * if (config) {
- *   console.log("[Interfere] Client initialized", config.metadata);
- * }
- * ```
- *
- * @example
- * ```ts
- * // With overrides
- * import { autoInitClient } from "@interfere/next/auto-init";
- *
- * const config = autoInitClient({
- *   features: { replay: false },
- *   batch: { size: 25, ms: 500 }
- * });
- * ```
- */
-declare function autoInitClient(userConfig?: AutoInitConfigOverrides): Config | null;
-/**
- * Check if Interfere has already been initialized.
- */
-declare function isInitialized(): boolean;
-/**
- * Reset initialization state. Only use for testing.
- * @internal
- */
-declare function resetInitializationState(): void;
-//#endregion
-export { AutoInitConfigOverrides, INJECTED_CONFIG_KEYS, InjectedConfigKey, autoInitClient, getInjectedConfig, isInitialized, resetInitializationState };

package/dist/client/auto-init.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auto-init.d.mts","names":[],"sources":["../../src/client/auto-init.ts"],"sourcesContent":[],"mappings":";;;;;;AAEwE;AAM9C,UAAhB,gBAAA,CAAgB;EAAA,aAAA,CAAA,EAAA,OAAA;QAoBI,CAAA,EAAA,OAAA;EAAgB,qBAAA,CAAA,EAAA,OAAA;;AAS9C;AAQA;AAKA;;QAEU,MAAA,CAAA;EACE,IAAA,sBAAA,EAAA,MAAA,GAAA,IAAA,GAAA,SAAA;EAES,IAAA,wBAAA,EAAA,MAAA,GAAA,IAAA,GAAA,SAAA;EAAR,IAAA,yBAAA,EAAA,MAAA,GAAA,SAAA;EAAO,IAAA,qBAAA,EAAA,OAAA,GAAA,SAAA;EAWJ,IAAA,sBAAiB,EAtCH,gBAsCO,GAAA,SAAO;EAmE5B,IAAA,yBACD,EAAA,OAAA,GAAA,SAAA;AAiDf;AAQA;;;;cA1Ja;KAQD,iBAAA,WAA4B;;;;UAKvB,uBAAA;aACJ;UACH;YACE;;aAEC,QAAQ;;;;;;;;;;iBAWL,iBAAA,CAAA,GAAqB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmE7B,cAAA,cACD,0BACZ;;;;iBAgDa,aAAA,CAAA;;;;;iBAQA,wBAAA,CAAA"}

package/dist/client/auto-init.mjs

@@ -1,121 +0,0 @@
-"use client";
-
-import { configSchema } from "@interfere/types/sdk/config";
-import { envSchema } from "@interfere/types/sdk/runtime";
-
-//#region src/client/auto-init.ts
-/**
-* The injected config keys that the value-injection-loader sets.
-* This is the canonical list of keys - keep in sync with withInterfere.
-*/
-const INJECTED_CONFIG_KEYS = [
-	"__INTERFERE_BUILD_ID__",
-	"__INTERFERE_RELEASE_ID__",
-	"__INTERFERE_ENVIRONMENT__",
-	"__INTERFERE_ENABLED__",
-	"__INTERFERE_FEATURES__"
-];
-/**
-* Reads configuration from build-time injected values.
-*
-* The value-injection-loader prepends code to instrumentation-client.ts
-* that sets these globalThis values during the build process.
-*
-* @returns Partial config from injected values, or null if SDK is disabled
-*/
-function getInjectedConfig() {
-	if (typeof globalThis === "undefined") return null;
-	const buildId = globalThis.__INTERFERE_BUILD_ID__;
-	const releaseId = globalThis.__INTERFERE_RELEASE_ID__;
-	const environmentRaw = globalThis.__INTERFERE_ENVIRONMENT__;
-	const enabled = globalThis.__INTERFERE_ENABLED__;
-	const features = globalThis.__INTERFERE_FEATURES__;
-	if (!enabled) return null;
-	const environment = environmentRaw ? envSchema.safeParse(environmentRaw).data ?? "production" : "production";
-	return {
-		metadata: {
-			buildId: buildId ?? null,
-			releaseId: releaseId ?? null,
-			environment,
-			runtime: "browser"
-		},
-		proxyUrl: "/api/interfere",
-		...features && { features }
-	};
-}
-/**
-* Initialize Interfere client automatically from build-time injected config.
-*
-* Call this from instrumentation-client.ts for zero-config initialization.
-* User-provided overrides take precedence over injected values.
-*
-* @param userConfig - Optional configuration overrides
-* @returns Parsed config if initialization succeeded, null if SDK is disabled or already initialized
-*
-* @example
-* ```ts
-* // instrumentation-client.ts
-* import { autoInitClient } from "@interfere/next/auto-init";
-*
-* const config = autoInitClient();
-* if (config) {
-*   console.log("[Interfere] Client initialized", config.metadata);
-* }
-* ```
-*
-* @example
-* ```ts
-* // With overrides
-* import { autoInitClient } from "@interfere/next/auto-init";
-*
-* const config = autoInitClient({
-*   features: { replay: false },
-*   batch: { size: 25, ms: 500 }
-* });
-* ```
-*/
-function autoInitClient(userConfig) {
-	if (globalThis.__INTERFERE_INITIALIZED__) {
-		if (process.env.NODE_ENV === "development") console.warn("[Interfere] Already initialized, skipping duplicate init");
-		return null;
-	}
-	const injectedConfig = getInjectedConfig();
-	if (!injectedConfig) {
-		if (process.env.NODE_ENV === "development") console.info("[Interfere] No injected config found. SDK disabled. Ensure INTERFERE_SECRET_KEY is set and withInterfere() is configured.");
-		return null;
-	}
-	const mergedConfig = {
-		...injectedConfig,
-		...userConfig?.features && { features: userConfig.features },
-		...userConfig?.batch && { batch: userConfig.batch },
-		...userConfig?.offline && { offline: userConfig.offline },
-		...userConfig?.proxyUrl && { proxyUrl: userConfig.proxyUrl },
-		metadata: {
-			...injectedConfig.metadata,
-			...userConfig?.metadata
-		}
-	};
-	const parseResult = configSchema.safeParse(mergedConfig);
-	if (!parseResult.success) {
-		console.error("[Interfere] Failed to parse config:", parseResult.error);
-		return null;
-	}
-	globalThis.__INTERFERE_INITIALIZED__ = true;
-	return parseResult.data;
-}
-/**
-* Check if Interfere has already been initialized.
-*/
-function isInitialized() {
-	return globalThis.__INTERFERE_INITIALIZED__ === true;
-}
-/**
-* Reset initialization state. Only use for testing.
-* @internal
-*/
-function resetInitializationState() {
-	globalThis.__INTERFERE_INITIALIZED__ = void 0;
-}
-
-//#endregion
-export { INJECTED_CONFIG_KEYS, autoInitClient, getInjectedConfig, isInitialized, resetInitializationState };

package/dist/client/auto-init.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"auto-init.mjs","names":[],"sources":["../../src/client/auto-init.ts"],"sourcesContent":["\"use client\";\n\nimport { type Config, configSchema } from \"@interfere/types/sdk/config\";\nimport { envSchema } from \"@interfere/types/sdk/runtime\";\n\n/**\n * Feature flags that can be injected at build time.\n */\ninterface InjectedFeatures {\n  errorTracking?: boolean;\n  replay?: boolean;\n  performanceMonitoring?: boolean;\n}\n\n/**\n * Build-time injected values set by the value-injection-loader.\n * These are populated when instrumentation-client.ts is processed during build.\n */\ndeclare global {\n  // eslint-disable-next-line no-var\n  var __INTERFERE_BUILD_ID__: string | null | undefined;\n  // eslint-disable-next-line no-var\n  var __INTERFERE_RELEASE_ID__: string | null | undefined;\n  // eslint-disable-next-line no-var\n  var __INTERFERE_ENVIRONMENT__: string | undefined;\n  // eslint-disable-next-line no-var\n  var __INTERFERE_ENABLED__: boolean | undefined;\n  // eslint-disable-next-line no-var\n  var __INTERFERE_FEATURES__: InjectedFeatures | undefined;\n  // eslint-disable-next-line no-var\n  var __INTERFERE_INITIALIZED__: boolean | undefined;\n}\n\n/**\n * The injected config keys that the value-injection-loader sets.\n * This is the canonical list of keys - keep in sync with withInterfere.\n */\nexport const INJECTED_CONFIG_KEYS = [\n  \"__INTERFERE_BUILD_ID__\",\n  \"__INTERFERE_RELEASE_ID__\",\n  \"__INTERFERE_ENVIRONMENT__\",\n  \"__INTERFERE_ENABLED__\",\n  \"__INTERFERE_FEATURES__\",\n] as const;\n\nexport type InjectedConfigKey = (typeof INJECTED_CONFIG_KEYS)[number];\n\n/**\n * Partial config that can be provided by users to override injected values.\n */\nexport interface AutoInitConfigOverrides {\n  features?: Config[\"features\"];\n  batch?: Config[\"batch\"];\n  offline?: Config[\"offline\"];\n  proxyUrl?: string;\n  metadata?: Partial<Config[\"metadata\"]>;\n}\n\n/**\n * Reads configuration from build-time injected values.\n *\n * The value-injection-loader prepends code to instrumentation-client.ts\n * that sets these globalThis values during the build process.\n *\n * @returns Partial config from injected values, or null if SDK is disabled\n */\nexport function getInjectedConfig(): Partial<Config> | null {\n  if (typeof globalThis === \"undefined\") {\n    return null;\n  }\n\n  const buildId = globalThis.__INTERFERE_BUILD_ID__;\n  const releaseId = globalThis.__INTERFERE_RELEASE_ID__;\n  const environmentRaw = globalThis.__INTERFERE_ENVIRONMENT__;\n  const enabled = globalThis.__INTERFERE_ENABLED__;\n  const features = globalThis.__INTERFERE_FEATURES__;\n\n  // If not enabled, SDK was disabled (no valid INTERFERE_SECRET_KEY was set)\n  if (!enabled) {\n    return null;\n  }\n\n  // Parse environment with fallback\n  const environment = environmentRaw\n    ? (envSchema.safeParse(environmentRaw).data ?? \"production\")\n    : \"production\";\n\n  // For Next.js, we always use proxy mode - the proxy handles authentication\n  // This means the client doesn't need the surface token at all\n  return {\n    metadata: {\n      buildId: buildId ?? null,\n      releaseId: releaseId ?? null,\n      environment,\n      runtime: \"browser\",\n    },\n    proxyUrl: \"/api/interfere\",\n    // Include features if they were injected\n    ...(features && { features }),\n  };\n}\n\n/**\n * Initialize Interfere client automatically from build-time injected config.\n *\n * Call this from instrumentation-client.ts for zero-config initialization.\n * User-provided overrides take precedence over injected values.\n *\n * @param userConfig - Optional configuration overrides\n * @returns Parsed config if initialization succeeded, null if SDK is disabled or already initialized\n *\n * @example\n * ```ts\n * // instrumentation-client.ts\n * import { autoInitClient } from \"@interfere/next/auto-init\";\n *\n * const config = autoInitClient();\n * if (config) {\n *   console.log(\"[Interfere] Client initialized\", config.metadata);\n * }\n * ```\n *\n * @example\n * ```ts\n * // With overrides\n * import { autoInitClient } from \"@interfere/next/auto-init\";\n *\n * const config = autoInitClient({\n *   features: { replay: false },\n *   batch: { size: 25, ms: 500 }\n * });\n * ```\n */\nexport function autoInitClient(\n  userConfig?: AutoInitConfigOverrides\n): Config | null {\n  // Prevent double initialization\n  if (globalThis.__INTERFERE_INITIALIZED__) {\n    if (process.env.NODE_ENV === \"development\") {\n      console.warn(\"[Interfere] Already initialized, skipping duplicate init\");\n    }\n    return null;\n  }\n\n  const injectedConfig = getInjectedConfig();\n  if (!injectedConfig) {\n    if (process.env.NODE_ENV === \"development\") {\n      console.info(\n        \"[Interfere] No injected config found. SDK disabled. \" +\n          \"Ensure INTERFERE_SECRET_KEY is set and withInterfere() is configured.\"\n      );\n    }\n    return null;\n  }\n\n  // Merge injected config with user overrides\n  // User overrides take precedence\n  const mergedConfig = {\n    ...injectedConfig,\n    ...(userConfig?.features && { features: userConfig.features }),\n    ...(userConfig?.batch && { batch: userConfig.batch }),\n    ...(userConfig?.offline && { offline: userConfig.offline }),\n    ...(userConfig?.proxyUrl && { proxyUrl: userConfig.proxyUrl }),\n    metadata: {\n      ...injectedConfig.metadata,\n      ...userConfig?.metadata,\n    },\n  };\n\n  // Validate and parse the merged config\n  const parseResult = configSchema.safeParse(mergedConfig);\n  if (!parseResult.success) {\n    console.error(\"[Interfere] Failed to parse config:\", parseResult.error);\n    return null;\n  }\n\n  globalThis.__INTERFERE_INITIALIZED__ = true;\n  return parseResult.data;\n}\n\n/**\n * Check if Interfere has already been initialized.\n */\nexport function isInitialized(): boolean {\n  return globalThis.__INTERFERE_INITIALIZED__ === true;\n}\n\n/**\n * Reset initialization state. Only use for testing.\n * @internal\n */\nexport function resetInitializationState(): void {\n  globalThis.__INTERFERE_INITIALIZED__ = undefined;\n}\n"],"mappings":";;;;;;;;;;AAqCA,MAAa,uBAAuB;CAClC;CACA;CACA;CACA;CACA;CACD;;;;;;;;;AAuBD,SAAgB,oBAA4C;AAC1D,KAAI,OAAO,eAAe,YACxB,QAAO;CAGT,MAAM,UAAU,WAAW;CAC3B,MAAM,YAAY,WAAW;CAC7B,MAAM,iBAAiB,WAAW;CAClC,MAAM,UAAU,WAAW;CAC3B,MAAM,WAAW,WAAW;AAG5B,KAAI,CAAC,QACH,QAAO;CAIT,MAAM,cAAc,iBACf,UAAU,UAAU,eAAe,CAAC,QAAQ,eAC7C;AAIJ,QAAO;EACL,UAAU;GACR,SAAS,WAAW;GACpB,WAAW,aAAa;GACxB;GACA,SAAS;GACV;EACD,UAAU;EAEV,GAAI,YAAY,EAAE,UAAU;EAC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCH,SAAgB,eACd,YACe;AAEf,KAAI,WAAW,2BAA2B;AACxC,MAAI,QAAQ,IAAI,aAAa,cAC3B,SAAQ,KAAK,2DAA2D;AAE1E,SAAO;;CAGT,MAAM,iBAAiB,mBAAmB;AAC1C,KAAI,CAAC,gBAAgB;AACnB,MAAI,QAAQ,IAAI,aAAa,cAC3B,SAAQ,KACN,4HAED;AAEH,SAAO;;CAKT,MAAM,eAAe;EACnB,GAAG;EACH,GAAI,YAAY,YAAY,EAAE,UAAU,WAAW,UAAU;EAC7D,GAAI,YAAY,SAAS,EAAE,OAAO,WAAW,OAAO;EACpD,GAAI,YAAY,WAAW,EAAE,SAAS,WAAW,SAAS;EAC1D,GAAI,YAAY,YAAY,EAAE,UAAU,WAAW,UAAU;EAC7D,UAAU;GACR,GAAG,eAAe;GAClB,GAAG,YAAY;GAChB;EACF;CAGD,MAAM,cAAc,aAAa,UAAU,aAAa;AACxD,KAAI,CAAC,YAAY,SAAS;AACxB,UAAQ,MAAM,uCAAuC,YAAY,MAAM;AACvE,SAAO;;AAGT,YAAW,4BAA4B;AACvC,QAAO,YAAY;;;;;AAMrB,SAAgB,gBAAyB;AACvC,QAAO,WAAW,8BAA8B;;;;;;AAOlD,SAAgB,2BAAiC;AAC/C,YAAW,4BAA4B"}

package/dist/client/client.d.mts

@@ -1,3 +0,0 @@
-import { useInterfere } from "@interfere/react/provider";
-export * from "@interfere/react/client";
-export { useInterfere };

package/dist/client/client.mjs

@@ -1,5 +0,0 @@
-import { useInterfere } from "@interfere/react/provider";
-
-export * from "@interfere/react/client"
-
-export { useInterfere };

package/dist/client/provider.d.mts

@@ -1,22 +0,0 @@
-import { ConfigInput } from "@interfere/types/sdk/config";
-import { InterfereProviderProps } from "@interfere/react/provider";
-import * as react_jsx_runtime0 from "react/jsx-runtime";
-
-//#region src/client/provider.d.ts
-interface NextConfigInput {
-  features?: ConfigInput["features"];
-  metadata?: ConfigInput["metadata"];
-  batch?: ConfigInput["batch"];
-  proxyUrl?: string;
-  ingestUrl?: string;
-  surfaceToken?: string;
-}
-declare function InterfereProvider({
-  children,
-  config,
-  ...rest
-}: Omit<InterfereProviderProps, "config"> & {
-  config?: NextConfigInput;
-}): react_jsx_runtime0.JSX.Element;
-//#endregion
-export { InterfereProvider };

package/dist/client/provider.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"provider.d.mts","names":[],"sources":["../../src/client/provider.tsx"],"sourcesContent":[],"mappings":";;;;;UA2CU,eAAA;aACG;aACA;EAFH,KAAA,CAAA,EAGA,WAHe,CAAA,OAAA,CAAA;EACZ,QAAA,CAAA,EAAA,MAAA;EACA,SAAA,CAAA,EAAA,MAAA;EACH,YAAA,CAAA,EAAA,MAAA;;AAiCM,iBAAA,iBAAA,CAAiB;EAAA,QAAA;EAAA,MAAA;EAAA,GAAA;CAAA,EAI9B,IAJ8B,CAIzB,sBAJyB,EAAA,QAAA,CAAA,GAAA;EAC/B,MAAA,CAAA,EAGqD,eAHrD;CACA,CAAA,EAEsE,kBAAA,CAAA,GAAA,CAAA,OAFtE"}

package/dist/client/provider.mjs

@@ -1,50 +0,0 @@
-"use client";
-
-import { getInjectedConfig } from "./auto-init.mjs";
-import { configSchema } from "@interfere/types/sdk/config";
-import { envSchema } from "@interfere/types/sdk/runtime";
-import { InterfereProvider as InterfereProvider$1 } from "@interfere/react/provider";
-import { getRuntime } from "@interfere/react/core/runtime/config";
-import { jsx } from "react/jsx-runtime";
-
-//#region src/client/provider.tsx
-/**
-* Get default metadata from environment variables (legacy approach)
-* or from injected config (instrumentation approach).
-*/
-function getDefaultMetadata() {
-	const injectedConfig = getInjectedConfig();
-	if (injectedConfig?.metadata) return {
-		...injectedConfig.metadata,
-		runtime: getRuntime()
-	};
-	return {
-		buildId: process.env.NEXT_PUBLIC_INTERFERE_BUILD_ID ?? null,
-		releaseId: process.env.NEXT_PUBLIC_INTERFERE_RELEASE_ID ?? null,
-		environment: process.env.NEXT_PUBLIC_INTERFERE_ENVIRONMENT ? envSchema.parse(process.env.NEXT_PUBLIC_INTERFERE_ENVIRONMENT) : "production",
-		runtime: getRuntime()
-	};
-}
-function mergeConfig(config) {
-	const defaults = getDefaultMetadata();
-	const incomingMeta = config.metadata ?? {};
-	const transportConfig = typeof config.proxyUrl !== "undefined" || typeof config.ingestUrl !== "undefined" || typeof config.surfaceToken !== "undefined" ? config : { proxyUrl: "/api/interfere" };
-	return configSchema.parse({
-		...transportConfig,
-		...config,
-		metadata: {
-			...defaults,
-			...incomingMeta
-		}
-	});
-}
-function InterfereProvider({ children, config = {}, ...rest }) {
-	return /* @__PURE__ */ jsx(InterfereProvider$1, {
-		config: mergeConfig(config),
-		...rest,
-		children
-	});
-}
-
-//#endregion
-export { InterfereProvider };

package/dist/client/provider.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"provider.mjs","names":["InterfereProviderReact"],"sources":["../../src/client/provider.tsx"],"sourcesContent":["\"use client\";\n\nimport { getRuntime } from \"@interfere/react/core/runtime/config\";\nimport {\n  type InterfereProviderProps,\n  InterfereProvider as InterfereProviderReact,\n} from \"@interfere/react/provider\";\nimport {\n  type Config,\n  type ConfigInput,\n  configSchema,\n} from \"@interfere/types/sdk/config\";\nimport { envSchema } from \"@interfere/types/sdk/runtime\";\n\nimport { getInjectedConfig } from \"./auto-init.js\";\n\n/**\n * Get default metadata from environment variables (legacy approach)\n * or from injected config (instrumentation approach).\n */\nfunction getDefaultMetadata(): ConfigInput[\"metadata\"] {\n  // First, try to get injected config from instrumentation-client.ts\n  const injectedConfig = getInjectedConfig();\n  if (injectedConfig?.metadata) {\n    return {\n      ...injectedConfig.metadata,\n      runtime: getRuntime(),\n    };\n  }\n\n  // Fallback to environment variables (legacy approach)\n  return {\n    buildId: process.env.NEXT_PUBLIC_INTERFERE_BUILD_ID ?? null,\n    releaseId: process.env.NEXT_PUBLIC_INTERFERE_RELEASE_ID ?? null,\n    environment: process.env.NEXT_PUBLIC_INTERFERE_ENVIRONMENT\n      ? envSchema.parse(process.env.NEXT_PUBLIC_INTERFERE_ENVIRONMENT)\n      : \"production\",\n    runtime: getRuntime(),\n  };\n}\n\n// Next.js-specific config type that allows omitting transport\n// because Next.js can provide its own proxy endpoint\ninterface NextConfigInput {\n  features?: ConfigInput[\"features\"];\n  metadata?: ConfigInput[\"metadata\"];\n  batch?: ConfigInput[\"batch\"];\n  proxyUrl?: string;\n  ingestUrl?: string;\n  surfaceToken?: string;\n}\n\nfunction mergeConfig(config: NextConfigInput): Config {\n  const defaults = getDefaultMetadata();\n  const incomingMeta = config.metadata ?? {};\n\n  // Determine transport config:\n  // - If they explicitly set proxyUrl, use proxy mode\n  // - If they set ingestUrl or surfaceToken, use direct mode (let schema validate)\n  // - Otherwise, default to Next.js proxy\n  const hasTransportConfig =\n    typeof config.proxyUrl !== \"undefined\" ||\n    typeof config.ingestUrl !== \"undefined\" ||\n    typeof config.surfaceToken !== \"undefined\";\n\n  const transportConfig = hasTransportConfig\n    ? config\n    : { proxyUrl: \"/api/interfere\" }; // Default Next.js proxy endpoint\n\n  return configSchema.parse({\n    ...transportConfig,\n    ...config,\n    metadata: {\n      ...defaults,\n      ...incomingMeta,\n    },\n  });\n}\n\nexport function InterfereProvider({\n  children,\n  config = {},\n  ...rest\n}: Omit<InterfereProviderProps, \"config\"> & { config?: NextConfigInput }) {\n  const mergedConfig = mergeConfig(config);\n\n  return (\n    <InterfereProviderReact config={mergedConfig} {...rest}>\n      {children}\n    </InterfereProviderReact>\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;AAoBA,SAAS,qBAA8C;CAErD,MAAM,iBAAiB,mBAAmB;AAC1C,KAAI,gBAAgB,SAClB,QAAO;EACL,GAAG,eAAe;EAClB,SAAS,YAAY;EACtB;AAIH,QAAO;EACL,SAAS,QAAQ,IAAI,kCAAkC;EACvD,WAAW,QAAQ,IAAI,oCAAoC;EAC3D,aAAa,QAAQ,IAAI,oCACrB,UAAU,MAAM,QAAQ,IAAI,kCAAkC,GAC9D;EACJ,SAAS,YAAY;EACtB;;AAcH,SAAS,YAAY,QAAiC;CACpD,MAAM,WAAW,oBAAoB;CACrC,MAAM,eAAe,OAAO,YAAY,EAAE;CAW1C,MAAM,kBAJJ,OAAO,OAAO,aAAa,eAC3B,OAAO,OAAO,cAAc,eAC5B,OAAO,OAAO,iBAAiB,cAG7B,SACA,EAAE,UAAU,kBAAkB;AAElC,QAAO,aAAa,MAAM;EACxB,GAAG;EACH,GAAG;EACH,UAAU;GACR,GAAG;GACH,GAAG;GACJ;EACF,CAAC;;AAGJ,SAAgB,kBAAkB,EAChC,UACA,SAAS,EAAE,EACX,GAAG,QACqE;AAGxE,QACE,oBAACA;EAAuB,QAHL,YAAY,OAAO;EAGQ,GAAI;EAC/C;GACsB"}

package/dist/lib/env.d.mts

@@ -1,12 +0,0 @@
-//#region src/lib/env.d.ts
-/**
- * Shared helpers for Interfere-specific environment values that can be used
- * safely at both build time and runtime.
- *
- * Provider-specific environment variables (Vercel, Netlify, etc.) should live
- * in their respective provider modules instead of this file.
- */
-declare function getEnvBuildId(): string | null;
-declare function getEnvReleaseId(): string | null;
-//#endregion
-export { getEnvBuildId, getEnvReleaseId };

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

@@ -1 +0,0 @@
-{"version":3,"file":"env.d.mts","names":[],"sources":["../../src/lib/env.ts"],"sourcesContent":[],"mappings":";;AAQA;AAQA;;;;;iBARgB,aAAA,CAAA;iBAQA,eAAA,CAAA"}

package/dist/lib/env.mjs

@@ -1,17 +0,0 @@
-//#region src/lib/env.ts
-/**
-* Shared helpers for Interfere-specific environment values that can be used
-* safely at both build time and runtime.
-*
-* Provider-specific environment variables (Vercel, Netlify, etc.) should live
-* in their respective provider modules instead of this file.
-*/
-function getEnvBuildId() {
-	return process.env.NEXT_PUBLIC_INTERFERE_BUILD_ID || process.env.NEXT_BUILD_ID || null;
-}
-function getEnvReleaseId() {
-	return process.env.NEXT_PUBLIC_INTERFERE_RELEASE_ID || null;
-}
-
-//#endregion
-export { getEnvBuildId, getEnvReleaseId };

package/dist/lib/env.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"env.mjs","names":[],"sources":["../../src/lib/env.ts"],"sourcesContent":["/**\n * Shared helpers for Interfere-specific environment values that can be used\n * safely at both build time and runtime.\n *\n * Provider-specific environment variables (Vercel, Netlify, etc.) should live\n * in their respective provider modules instead of this file.\n */\n\nexport function getEnvBuildId(): string | null {\n  return (\n    process.env.NEXT_PUBLIC_INTERFERE_BUILD_ID ||\n    process.env.NEXT_BUILD_ID ||\n    null\n  );\n}\n\nexport function getEnvReleaseId(): string | null {\n  return process.env.NEXT_PUBLIC_INTERFERE_RELEASE_ID || null;\n}\n"],"mappings":";;;;;;;;AAQA,SAAgB,gBAA+B;AAC7C,QACE,QAAQ,IAAI,kCACZ,QAAQ,IAAI,iBACZ;;AAIJ,SAAgB,kBAAiC;AAC/C,QAAO,QAAQ,IAAI,oCAAoC"}

package/dist/lib/test-utils/make-next-request.d.mts

@@ -1,6 +0,0 @@
-import { NextRequest } from "next/server";
-
-//#region src/lib/test-utils/make-next-request.d.ts
-declare function makeNextRequest(url: string | URL, init?: RequestInit): NextRequest;
-//#endregion
-export { makeNextRequest };

package/dist/lib/test-utils/make-next-request.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"make-next-request.d.mts","names":[],"sources":["../../../src/lib/test-utils/make-next-request.ts"],"sourcesContent":[],"mappings":";;;iBAGgB,eAAA,eACA,YACP,cACN"}

package/dist/lib/test-utils/make-next-request.mjs

@@ -1,12 +0,0 @@
-import { NextRequest } from "next/server";
-
-//#region src/lib/test-utils/make-next-request.ts
-function makeNextRequest(url, init) {
-	return new NextRequest(url, {
-		...init,
-		signal: init?.signal ?? void 0
-	});
-}
-
-//#endregion
-export { makeNextRequest };

package/dist/lib/test-utils/make-next-request.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"make-next-request.mjs","names":["NextRequestCtor"],"sources":["../../../src/lib/test-utils/make-next-request.ts"],"sourcesContent":["import type { NextRequest } from \"next/server\";\nimport { NextRequest as NextRequestCtor } from \"next/server\";\n\nexport function makeNextRequest(\n  url: string | URL,\n  init?: RequestInit\n): NextRequest {\n  // The NextRequest constructor mirrors the standard Request but augments with nextUrl, cookies, etc.\n  // Using the real constructor keeps types intact and avoids casts in tests.\n  return new NextRequestCtor(url, {\n    ...init,\n    signal: init?.signal ?? undefined,\n  });\n}\n"],"mappings":";;;AAGA,SAAgB,gBACd,KACA,MACa;AAGb,QAAO,IAAIA,YAAgB,KAAK;EAC9B,GAAG;EACH,QAAQ,MAAM,UAAU;EACzB,CAAC"}

package/dist/lib/types.d.mts

@@ -1,22 +0,0 @@
-//#region src/lib/types.d.ts
-type NonEmptyString = string & {
-  readonly __brand: unique symbol;
-};
-declare function toNonEmptyString(value: string): NonEmptyString | null;
-interface PreflightEnabled {
-  enabled: true;
-  surface: NonEmptyString;
-  secretKey: NonEmptyString;
-  environment: string;
-  debug: boolean;
-  cleanupSourceMaps: boolean;
-}
-interface PreflightDisabled {
-  enabled: false;
-  environment: string | undefined;
-  debug: boolean;
-  cleanupSourceMaps: boolean;
-}
-type PreflightConfig = PreflightEnabled | PreflightDisabled;
-//#endregion
-export { NonEmptyString, PreflightConfig, PreflightDisabled, PreflightEnabled, toNonEmptyString };

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/lib/types.ts"],"sourcesContent":[],"mappings":";KACY,cAAA;EAAA,SAAA,OAAA,EAAc,OAAA,MAAA;AAE1B,CAAA;AAIiB,iBAJD,gBAAA,CAML,KAAA,EAAA,MACE,CAAA,EAPoC,cAOtB,GAAA,IAAA;AAMV,UATA,gBAAA,CASiB;EAOtB,OAAA,EAAA,IAAA;WAdD;aACE;;;;;UAMI,iBAAA;;;;;;KAOL,eAAA,GAAkB,mBAAmB"}

package/dist/lib/types.mjs

@@ -1,7 +0,0 @@
-//#region src/lib/types.ts
-function toNonEmptyString(value) {
-	return value.length > 0 ? value : null;
-}
-
-//#endregion
-export { toNonEmptyString };

package/dist/lib/types.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.mjs","names":[],"sources":["../../src/lib/types.ts"],"sourcesContent":["// Branded non-empty string type to prevent passing empty strings accidentally\nexport type NonEmptyString = string & { readonly __brand: unique symbol };\n\nexport function toNonEmptyString(value: string): NonEmptyString | null {\n  return value.length > 0 ? (value as NonEmptyString) : null;\n}\n\nexport interface PreflightEnabled {\n  enabled: true;\n  surface: NonEmptyString;\n  secretKey: NonEmptyString;\n  environment: string;\n  debug: boolean;\n  cleanupSourceMaps: boolean;\n}\n\nexport interface PreflightDisabled {\n  enabled: false;\n  environment: string | undefined;\n  debug: boolean;\n  cleanupSourceMaps: boolean;\n}\n\nexport type PreflightConfig = PreflightEnabled | PreflightDisabled;\n"],"mappings":";AAGA,SAAgB,iBAAiB,OAAsC;AACrE,QAAO,MAAM,SAAS,IAAK,QAA2B"}

package/dist/server/middleware.d.mts

@@ -1,11 +0,0 @@
-import { NextRequest, NextResponse } from "next/server";
-
-//#region src/server/middleware.d.ts
-declare function withInterfereMiddleware(middleware: (request: NextRequest) => Promise<NextResponse> | NextResponse): (request: NextRequest) => Promise<NextResponse<unknown>>;
-declare function withInterfereApiRoute(handler: (req: NextRequest) => Promise<Response>): (req: NextRequest) => Promise<Response>;
-declare function withInterfereServerComponent<T extends (...args: unknown[]) => Promise<unknown>>(component: T, componentName?: string): T;
-declare function createInterfereErrorHandler(): (error: Error, errorInfo: {
-  digest?: string;
-}) => Promise<void>;
-//#endregion
-export { createInterfereErrorHandler, withInterfereApiRoute, withInterfereMiddleware, withInterfereServerComponent };