@od-oneapp/observability 2026.1.1301

package/dist/hooks-useObservability.mjs

@@ -0,0 +1,174 @@
+'use client';
+
+import { logDebug, logError } from "@od-oneapp/shared/logs";
+import { use, useEffect, useSyncExternalStore } from "react";
+
+//#region src/hooks/useObservability.ts
+/**
+* @fileoverview React hooks for observability integration
+* React hooks for observability integration
+* Optimized for React 19 features including use() hook and automatic error boundaries
+*/
+/**
+* Global observability instance promise for React 19's use() hook
+* This allows components to suspend while waiting for initialization
+*/
+let observabilityPromise = null;
+/**
+* Set the observability promise for React 19 Suspense integration
+* @param promise - Promise that resolves to ObservabilityManager
+*/
+function setObservabilityPromise(promise) {
+	observabilityPromise = promise;
+}
+/**
+* React 19+ hook that suspends until observability is ready
+* Uses the new use() hook for automatic Suspense integration
+*
+* @example
+* ```tsx
+* 'use client';
+*
+* import { Suspense } from 'react';
+* import { useObservability } from '@od-oneapp/observability/hooks/useObservability';
+* import { logInfo } from '@od-oneapp/shared/logs';
+*
+* function MyComponent() {
+*   const observability = useObservability();
+*
+*   useEffect(() => {
+*     logInfo('Component mounted');
+*   }, [observability]);
+*
+*   return <div>Hello</div>;
+* }
+*
+* export default function Page() {
+*   return (
+*     <Suspense fallback={<div>Loading...</div>}>
+*       <MyComponent />
+*     </Suspense>
+*   );
+* }
+* ```
+*/
+function useObservability() {
+	if (!observabilityPromise) throw new Error("Observability promise not set. Call setObservabilityPromise() during module initialization.");
+	return use(observabilityPromise);
+}
+let legacyCurrentInstance = void 0;
+const legacyListeners = /* @__PURE__ */ new Set();
+let legacyInitialized = false;
+/**
+* Legacy hook for React 18 compatibility
+* Returns observability instance once available, undefined during initialization
+* Does not use Suspense
+*
+* @deprecated Use useObservability() with Suspense for React 19+
+*/
+function useObservabilityLegacy() {
+	const subscribe = (callback) => {
+		legacyListeners.add(callback);
+		if (observabilityPromise && !legacyInitialized) {
+			legacyInitialized = true;
+			(async () => {
+				try {
+					legacyCurrentInstance = await observabilityPromise;
+					legacyListeners.forEach((listener) => {
+						listener();
+					});
+				} catch {
+					legacyInitialized = false;
+				}
+			})();
+		}
+		return () => {
+			legacyListeners.delete(callback);
+		};
+	};
+	const getSnapshot = () => {
+		return legacyCurrentInstance;
+	};
+	return useSyncExternalStore(subscribe, getSnapshot);
+}
+/**
+* Hook to track component lifecycle events
+* Automatically logs mount, update, and unmount events
+*
+* @param componentName - Name of the component for logging
+* @param deps - Dependencies to track for updates
+*
+* @example
+* ```tsx
+* 'use client';
+*
+* import { useObservabilityLifecycle } from '@od-oneapp/observability/hooks/useObservability';
+*
+* function UserProfile({ userId }: { userId: string }) {
+*   useObservabilityLifecycle('UserProfile', [userId]);
+*
+*   return <div>User {userId}</div>;
+* }
+* ```
+*/
+function useObservabilityLifecycle(componentName, deps = []) {
+	useEffect(() => {
+		logDebug(`Component mounted: ${componentName}`, {
+			component: componentName,
+			event: "mount"
+		});
+		return () => {
+			logDebug(`Component unmounted: ${componentName}`, {
+				component: componentName,
+				event: "unmount"
+			});
+		};
+	}, deps);
+}
+/**
+* Hook to automatically report errors to observability
+* Compatible with React 19 error boundaries
+*
+* @param error - Error to report
+* @param errorInfo - Additional error information
+*
+* @example
+* ```tsx
+* 'use client';
+*
+* import { useObservabilityError } from '@od-oneapp/observability/hooks/useObservability';
+*
+* function MyComponent() {
+*   const [error, setError] = useState<Error | null>(null);
+*
+*   useObservabilityError(error, { component: 'MyComponent' });
+*
+*   if (error) {
+*     return <div>Error occurred</div>;
+*   }
+*
+*   return <div>Hello</div>;
+* }
+* ```
+*/
+function useObservabilityError(error, errorInfo) {
+	useEffect(() => {
+		if (error && observabilityPromise) (async () => {
+			try {
+				(await observabilityPromise).captureException(error, {
+					extra: errorInfo,
+					tags: { source: "react-component" }
+				});
+			} catch (reportError) {
+				logError("Failed to report error to observability", {
+					error: reportError,
+					originalError: error
+				});
+			}
+		})();
+	}, [error, errorInfo]);
+}
+
+//#endregion
+export { setObservabilityPromise, useObservability, useObservabilityError, useObservabilityLegacy, useObservabilityLifecycle };
+//# sourceMappingURL=hooks-useObservability.mjs.map

package/dist/hooks-useObservability.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks-useObservability.mjs","names":[],"sources":["../src/hooks/useObservability.ts"],"sourcesContent":["/**\n * @fileoverview React hooks for observability integration\n * React hooks for observability integration\n * Optimized for React 19 features including use() hook and automatic error boundaries\n */\n\n'use client';\n\nimport { use, useEffect, useSyncExternalStore } from 'react';\n\nimport { logDebug, logError } from '@repo/shared/logs';\n\nimport type { ObservabilityManager } from '../core/manager';\n\n/**\n * Global observability instance promise for React 19's use() hook\n * This allows components to suspend while waiting for initialization\n */\nlet observabilityPromise: Promise<ObservabilityManager> | null = null;\n\n/**\n * Set the observability promise for React 19 Suspense integration\n * @param promise - Promise that resolves to ObservabilityManager\n */\nexport function setObservabilityPromise(promise: Promise<ObservabilityManager>): void {\n  observabilityPromise = promise;\n}\n\n/**\n * React 19+ hook that suspends until observability is ready\n * Uses the new use() hook for automatic Suspense integration\n *\n * @example\n * ```tsx\n * 'use client';\n *\n * import { Suspense } from 'react';\n * import { useObservability } from '@repo/observability/hooks/useObservability';\n * import { logInfo } from '@repo/shared/logs';\n *\n * function MyComponent() {\n *   const observability = useObservability();\n *\n *   useEffect(() => {\n *     logInfo('Component mounted');\n *   }, [observability]);\n *\n *   return <div>Hello</div>;\n * }\n *\n * export default function Page() {\n *   return (\n *     <Suspense fallback={<div>Loading...</div>}>\n *       <MyComponent />\n *     </Suspense>\n *   );\n * }\n * ```\n */\nexport function useObservability(): ObservabilityManager {\n  if (!observabilityPromise) {\n    throw new Error(\n      'Observability promise not set. Call setObservabilityPromise() during module initialization.',\n    );\n  }\n\n  // React 19's use() hook automatically suspends until promise resolves\n  return use(observabilityPromise);\n}\n\n// Module-level state for legacy hook (fixes state recreation bug)\nlet legacyCurrentInstance: ObservabilityManager | undefined = undefined;\nconst legacyListeners = new Set<() => void>();\nlet legacyInitialized = false;\n\n/**\n * Legacy hook for React 18 compatibility\n * Returns observability instance once available, undefined during initialization\n * Does not use Suspense\n *\n * @deprecated Use useObservability() with Suspense for React 19+\n */\nexport function useObservabilityLegacy(): ObservabilityManager | undefined {\n  const subscribe = (callback: () => void) => {\n    legacyListeners.add(callback);\n\n    // If promise exists and instance not yet resolved, wait for it\n    if (observabilityPromise && !legacyInitialized) {\n      legacyInitialized = true;\n      void (async () => {\n        try {\n          const instance = await observabilityPromise;\n          legacyCurrentInstance = instance;\n          legacyListeners.forEach(listener => {\n            listener();\n          });\n        } catch {\n          legacyInitialized = false; // Allow retry on failure\n        }\n      })();\n    }\n\n    return () => {\n      legacyListeners.delete(callback);\n    };\n  };\n\n  const getSnapshot = (): ObservabilityManager | undefined => {\n    return legacyCurrentInstance;\n  };\n\n  return useSyncExternalStore(subscribe, getSnapshot);\n}\n\n/**\n * Hook to track component lifecycle events\n * Automatically logs mount, update, and unmount events\n *\n * @param componentName - Name of the component for logging\n * @param deps - Dependencies to track for updates\n *\n * @example\n * ```tsx\n * 'use client';\n *\n * import { useObservabilityLifecycle } from '@repo/observability/hooks/useObservability';\n *\n * function UserProfile({ userId }: { userId: string }) {\n *   useObservabilityLifecycle('UserProfile', [userId]);\n *\n *   return <div>User {userId}</div>;\n * }\n * ```\n */\nexport function useObservabilityLifecycle(\n  componentName: string,\n  deps: readonly unknown[] = [],\n): void {\n  useEffect(() => {\n    // Log mount\n    logDebug(`Component mounted: ${componentName}`, {\n      component: componentName,\n      event: 'mount',\n    });\n\n    // Log unmount\n    return () => {\n      logDebug(`Component unmounted: ${componentName}`, {\n        component: componentName,\n        event: 'unmount',\n      });\n    };\n  }, deps);\n}\n\n/**\n * Hook to automatically report errors to observability\n * Compatible with React 19 error boundaries\n *\n * @param error - Error to report\n * @param errorInfo - Additional error information\n *\n * @example\n * ```tsx\n * 'use client';\n *\n * import { useObservabilityError } from '@repo/observability/hooks/useObservability';\n *\n * function MyComponent() {\n *   const [error, setError] = useState<Error | null>(null);\n *\n *   useObservabilityError(error, { component: 'MyComponent' });\n *\n *   if (error) {\n *     return <div>Error occurred</div>;\n *   }\n *\n *   return <div>Hello</div>;\n * }\n * ```\n */\nexport function useObservabilityError(\n  error: Error | null | undefined,\n  errorInfo?: Record<string, unknown>,\n): void {\n  useEffect(() => {\n    if (error && observabilityPromise) {\n      void (async () => {\n        try {\n          const obs = await observabilityPromise;\n          obs.captureException(error, {\n            extra: errorInfo,\n            tags: {\n              source: 'react-component',\n            },\n          });\n        } catch (reportError) {\n          logError('Failed to report error to observability', {\n            error: reportError,\n            originalError: error,\n          });\n        }\n      })();\n    }\n  }, [error, errorInfo]);\n}\n"],"mappings":";;;;;;;;;;;;;;;AAkBA,IAAI,uBAA6D;;;;;AAMjE,SAAgB,wBAAwB,SAA8C;AACpF,wBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCzB,SAAgB,mBAAyC;AACvD,KAAI,CAAC,qBACH,OAAM,IAAI,MACR,8FACD;AAIH,QAAO,IAAI,qBAAqB;;AAIlC,IAAI,wBAA0D;AAC9D,MAAM,kCAAkB,IAAI,KAAiB;AAC7C,IAAI,oBAAoB;;;;;;;;AASxB,SAAgB,yBAA2D;CACzE,MAAM,aAAa,aAAyB;AAC1C,kBAAgB,IAAI,SAAS;AAG7B,MAAI,wBAAwB,CAAC,mBAAmB;AAC9C,uBAAoB;AACpB,IAAM,YAAY;AAChB,QAAI;AAEF,6BADiB,MAAM;AAEvB,qBAAgB,SAAQ,aAAY;AAClC,gBAAU;OACV;YACI;AACN,yBAAoB;;OAEpB;;AAGN,eAAa;AACX,mBAAgB,OAAO,SAAS;;;CAIpC,MAAM,oBAAsD;AAC1D,SAAO;;AAGT,QAAO,qBAAqB,WAAW,YAAY;;;;;;;;;;;;;;;;;;;;;;AAuBrD,SAAgB,0BACd,eACA,OAA2B,EAAE,EACvB;AACN,iBAAgB;AAEd,WAAS,sBAAsB,iBAAiB;GAC9C,WAAW;GACX,OAAO;GACR,CAAC;AAGF,eAAa;AACX,YAAS,wBAAwB,iBAAiB;IAChD,WAAW;IACX,OAAO;IACR,CAAC;;IAEH,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BV,SAAgB,sBACd,OACA,WACM;AACN,iBAAgB;AACd,MAAI,SAAS,qBACX,EAAM,YAAY;AAChB,OAAI;AAEF,KADY,MAAM,sBACd,iBAAiB,OAAO;KAC1B,OAAO;KACP,MAAM,EACJ,QAAQ,mBACT;KACF,CAAC;YACK,aAAa;AACpB,aAAS,2CAA2C;KAClD,OAAO;KACP,eAAe;KAChB,CAAC;;MAEF;IAEL,CAAC,OAAO,UAAU,CAAC"}

package/dist/index-CpcdzWrF.d.mts

@@ -0,0 +1,24 @@
+import { i as PluginLifecycle, n as ObservabilityServerPlugin, t as ObservabilityPlugin } from "./plugin-Bfq-o3nr.mjs";
+import { t as ObservabilityManager } from "./manager-BxQqOPEg.mjs";
+
+//#region src/factory/builder.d.ts
+declare class ObservabilityBuilder {
+  private plugins;
+  private lifecycle;
+  private autoInitialize;
+  withPlugin(plugin: ObservabilityPlugin | ObservabilityServerPlugin): this;
+  withPlugins(plugins: (ObservabilityPlugin | ObservabilityServerPlugin)[]): this;
+  withLifecycle(lifecycle: PluginLifecycle): this;
+  withAutoInitialize(autoInitialize: boolean): this;
+  build(): ObservabilityManager;
+  buildWithAutoInit(): Promise<ObservabilityManager>;
+  static create(): ObservabilityBuilder;
+}
+//#endregion
+//#region src/factory/index.d.ts
+declare function createObservability(plugins: (ObservabilityPlugin | ObservabilityServerPlugin)[], options?: {
+  autoInitialize?: boolean;
+}): ObservabilityManager;
+//#endregion
+export { ObservabilityBuilder as n, createObservability as t };
+//# sourceMappingURL=index-CpcdzWrF.d.mts.map

package/dist/index-CpcdzWrF.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CpcdzWrF.d.mts","names":[],"sources":["../src/factory/builder.ts","../src/factory/index.ts"],"mappings":";;;;cAkBa,oBAAA;EAAA,QACH,OAAA;EAAA,QACA,SAAA;EAAA,QACA,cAAA;EAOR,UAAA,CAAW,MAAA,EAAQ,mBAAA,GAAsB,yBAAA;EAYzC,WAAA,CAAY,OAAA,GAAU,mBAAA,GAAsB,yBAAA;EAa5C,aAAA,CAAc,SAAA,EAAW,eAAA;EAQzB,kBAAA,CAAmB,cAAA;EASnB,KAAA,CAAA,GAAS,oBAAA;EAqCH,iBAAA,CAAA,GAAqB,OAAA,CAAQ,oBAAA;EAAA,OAqB5B,MAAA,CAAA,GAAU,oBAAA;AAAA;;;iBC/FH,mBAAA,CACd,OAAA,GAAU,mBAAA,GAAsB,yBAAA,KAChC,OAAA;EACE,cAAA;AAAA,IAED,oBAAA"}

package/dist/index.d.mts

@@ -0,0 +1,88 @@
+//#region src/shared.d.ts
+declare const getRuntimeInfo: () => {
+  type: string;
+  variant: string;
+  version?: undefined;
+  isNextJs?: undefined;
+  major?: undefined;
+  minor?: undefined;
+  isNode22Plus?: undefined;
+} | {
+  type: string;
+  version: string;
+  variant?: undefined;
+  isNextJs?: undefined;
+  major?: undefined;
+  minor?: undefined;
+  isNode22Plus?: undefined;
+} | {
+  type: string;
+  isNextJs: boolean;
+  variant?: undefined;
+  version?: undefined;
+  major?: undefined;
+  minor?: undefined;
+  isNode22Plus?: undefined;
+} | {
+  type: string;
+  version: string;
+  major: number;
+  minor: number;
+  isNode22Plus: boolean;
+  isNextJs: boolean;
+  variant?: undefined;
+} | {
+  type: string;
+  variant?: undefined;
+  version?: undefined;
+  isNextJs?: undefined;
+  major?: undefined;
+  minor?: undefined;
+  isNode22Plus?: undefined;
+};
+declare const getRuntimeEnvironment: () => {
+  type: string;
+  variant: string;
+  version?: undefined;
+  isNextJs?: undefined;
+  major?: undefined;
+  minor?: undefined;
+  isNode22Plus?: undefined;
+} | {
+  type: string;
+  version: string;
+  variant?: undefined;
+  isNextJs?: undefined;
+  major?: undefined;
+  minor?: undefined;
+  isNode22Plus?: undefined;
+} | {
+  type: string;
+  isNextJs: boolean;
+  variant?: undefined;
+  version?: undefined;
+  major?: undefined;
+  minor?: undefined;
+  isNode22Plus?: undefined;
+} | {
+  type: string;
+  version: string;
+  major: number;
+  minor: number;
+  isNode22Plus: boolean;
+  isNextJs: boolean;
+  variant?: undefined;
+} | {
+  type: string;
+  variant?: undefined;
+  version?: undefined;
+  isNextJs?: undefined;
+  major?: undefined;
+  minor?: undefined;
+  isNode22Plus?: undefined;
+};
+declare function isBrowser(): boolean;
+declare function shouldEnableConsole(envNodeEnv?: string, consoleEnabled?: boolean, debugEnabled?: boolean): boolean;
+//#endregion
+export { getRuntimeEnvironment, getRuntimeInfo, isBrowser, shouldEnableConsole };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/shared.ts"],"mappings":";cAuBa,cAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2EA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOG,SAAA,CAAA;AAAA,iBAkBA,mBAAA,CACd,UAAA,WACA,cAAA,YACA,YAAA"}

package/dist/index.mjs

@@ -0,0 +1,97 @@
+import { logWarn } from "@od-oneapp/shared/logger";
+
+//#region src/shared.ts
+/**
+* @fileoverview Shared observability utilities and types
+* Shared observability utilities and types
+*/
+/**
+* Get runtime environment information.
+*
+* Detects the current runtime environment (browser, Node.js, edge, Bun) and returns
+* detailed information about the environment type, version, and capabilities.
+*
+* @returns Runtime information object with type, version, and environment-specific details
+*
+* @example
+* ```typescript
+* const runtime = getRuntimeInfo();
+* // Returns: { type: 'node', version: '22.0.0', major: 22, minor: 0, isNode22Plus: true, isNextJs: true }
+* // or: { type: 'browser', isNextJs: true }
+* // or: { type: 'edge', variant: 'vercel' }
+* ```
+*/
+const getRuntimeInfo = () => {
+	if (typeof globalThis !== "undefined" && globalThis.EdgeRuntime) return {
+		type: "edge",
+		variant: "vercel"
+	};
+	if (typeof globalThis !== "undefined" && globalThis.caches && typeof globalThis.caches !== "undefined") return {
+		type: "edge",
+		variant: "cloudflare"
+	};
+	if (typeof process !== "undefined" && process.versions?.bun) return {
+		type: "bun",
+		version: process.versions.bun
+	};
+	if (typeof globalThis !== "undefined" && "window" in globalThis && typeof globalThis.window !== "undefined" && typeof globalThis.window.document !== "undefined" && typeof globalThis.window.navigator !== "undefined") return {
+		type: "browser",
+		isNextJs: Boolean(globalThis.window.__NEXT_DATA__)
+	};
+	if (typeof process !== "undefined" && process.versions?.node) {
+		const nodeVersion = parseInt(process.versions.node.split(".")[0] ?? "0");
+		const nodeVersionMinor = parseInt(process.versions.node.split(".")[1] ?? "0");
+		if (nodeVersion < 22) logWarn(`[Observability] Node ${process.versions.node} detected. Node 22+ is required for optimal performance and latest features.`);
+		return {
+			type: "node",
+			version: process.versions.node,
+			major: nodeVersion,
+			minor: nodeVersionMinor,
+			isNode22Plus: nodeVersion >= 22,
+			isNextJs: Boolean(process.env.NEXT_RUNTIME) || Boolean(process.env.__NEXT_RUNTIME) || Boolean(process.env.NEXT_PUBLIC_VERCEL_ENV)
+		};
+	}
+	return { type: "unknown" };
+};
+const runtimeInfo = getRuntimeInfo();
+/**
+* Get cached runtime environment information.
+*
+* Returns the runtime information that was detected at module load time.
+* This is cached to avoid repeated detection checks.
+*
+* @returns Cached runtime information object
+*
+* @example
+* ```typescript
+* const runtime = getRuntimeEnvironment();
+* console.log(runtime.type); // 'node', 'browser', 'edge', etc.
+* ```
+*/
+const getRuntimeEnvironment = () => runtimeInfo;
+/**
+* Detect if code is running in a browser environment
+* Extracted to shared utility to avoid duplication
+* @returns true if running in browser, false otherwise
+*/
+function isBrowser() {
+	return typeof globalThis !== "undefined" && "window" in globalThis && typeof globalThis.window !== "undefined" && typeof globalThis.window.document !== "undefined" && typeof globalThis.window.navigator !== "undefined";
+}
+/**
+* Determine if console logging should be enabled based on environment
+* Centralized logic to avoid duplication across entry points
+* @param envNodeEnv - The NEXT_PUBLIC_NODE_ENV value
+* @param consoleEnabled - The NEXT_PUBLIC_OBSERVABILITY_CONSOLE_ENABLED value (explicit control)
+* @param debugEnabled - The NEXT_PUBLIC_OBSERVABILITY_DEBUG value
+* @returns boolean indicating if console should be enabled
+*/
+function shouldEnableConsole(envNodeEnv, consoleEnabled, debugEnabled) {
+	const isDevelopment = envNodeEnv === "development" || true;
+	if (consoleEnabled !== void 0) return consoleEnabled;
+	if (isDevelopment) return true;
+	return debugEnabled ?? false;
+}
+
+//#endregion
+export { getRuntimeEnvironment, getRuntimeInfo, isBrowser, shouldEnableConsole };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/shared.ts"],"sourcesContent":["/**\n * @fileoverview Shared observability utilities and types\n * Shared observability utilities and types\n */\n\nimport { logWarn } from '@repo/shared/logger';\n\n/**\n * Get runtime environment information.\n *\n * Detects the current runtime environment (browser, Node.js, edge, Bun) and returns\n * detailed information about the environment type, version, and capabilities.\n *\n * @returns Runtime information object with type, version, and environment-specific details\n *\n * @example\n * ```typescript\n * const runtime = getRuntimeInfo();\n * // Returns: { type: 'node', version: '22.0.0', major: 22, minor: 0, isNode22Plus: true, isNextJs: true }\n * // or: { type: 'browser', isNextJs: true }\n * // or: { type: 'edge', variant: 'vercel' }\n * ```\n */\nexport const getRuntimeInfo = () => {\n  // Edge runtime detection (Vercel Edge, Cloudflare Workers)\n  if (typeof globalThis !== 'undefined' && (globalThis as any).EdgeRuntime) {\n    return { type: 'edge', variant: 'vercel' };\n  }\n  if (\n    typeof globalThis !== 'undefined' &&\n    (globalThis as any).caches &&\n    typeof (globalThis as any).caches !== 'undefined'\n  ) {\n    return { type: 'edge', variant: 'cloudflare' };\n  }\n\n  // Bun detection\n  if (typeof process !== 'undefined' && process.versions?.bun) {\n    return { type: 'bun', version: process.versions.bun };\n  }\n\n  // Browser detection (more robust)\n  if (\n    typeof globalThis !== 'undefined' &&\n    'window' in globalThis &&\n    typeof (globalThis as any).window !== 'undefined' &&\n    typeof (globalThis as any).window.document !== 'undefined' &&\n    typeof (globalThis as any).window.navigator !== 'undefined'\n  ) {\n    return { type: 'browser', isNextJs: Boolean((globalThis as any).window.__NEXT_DATA__) };\n  }\n\n  // Node.js detection with version check\n  if (typeof process !== 'undefined' && process.versions?.node) {\n    const nodeVersion = parseInt(process.versions.node.split('.')[0] ?? '0');\n    const nodeVersionMinor = parseInt(process.versions.node.split('.')[1] ?? '0');\n\n    if (nodeVersion < 22) {\n      // Note: Using logWarn here - observability system may not be initialized yet, but shared logger is always available\n      logWarn(\n        `[Observability] Node ${process.versions.node} detected. Node 22+ is required for optimal performance and latest features.`,\n      );\n    }\n\n    return {\n      type: 'node',\n      version: process.versions.node,\n      major: nodeVersion,\n      minor: nodeVersionMinor,\n      isNode22Plus: nodeVersion >= 22,\n      isNextJs:\n        Boolean(process.env.NEXT_RUNTIME) ||\n        Boolean(process.env.__NEXT_RUNTIME) ||\n        Boolean(process.env.NEXT_PUBLIC_VERCEL_ENV),\n    };\n  }\n\n  // Fallback\n  return { type: 'unknown' };\n};\n\n// Cache the runtime info\nconst runtimeInfo = getRuntimeInfo();\n\n/**\n * Get cached runtime environment information.\n *\n * Returns the runtime information that was detected at module load time.\n * This is cached to avoid repeated detection checks.\n *\n * @returns Cached runtime information object\n *\n * @example\n * ```typescript\n * const runtime = getRuntimeEnvironment();\n * console.log(runtime.type); // 'node', 'browser', 'edge', etc.\n * ```\n */\nexport const getRuntimeEnvironment = () => runtimeInfo;\n\n/**\n * Detect if code is running in a browser environment\n * Extracted to shared utility to avoid duplication\n * @returns true if running in browser, false otherwise\n */\nexport function isBrowser(): boolean {\n  return (\n    typeof globalThis !== 'undefined' &&\n    'window' in globalThis &&\n    typeof (globalThis as any).window !== 'undefined' &&\n    typeof (globalThis as any).window.document !== 'undefined' &&\n    typeof (globalThis as any).window.navigator !== 'undefined'\n  );\n}\n\n/**\n * Determine if console logging should be enabled based on environment\n * Centralized logic to avoid duplication across entry points\n * @param envNodeEnv - The NEXT_PUBLIC_NODE_ENV value\n * @param consoleEnabled - The NEXT_PUBLIC_OBSERVABILITY_CONSOLE_ENABLED value (explicit control)\n * @param debugEnabled - The NEXT_PUBLIC_OBSERVABILITY_DEBUG value\n * @returns boolean indicating if console should be enabled\n */\nexport function shouldEnableConsole(\n  envNodeEnv?: string,\n  consoleEnabled?: boolean,\n  debugEnabled?: boolean,\n): boolean {\n  const isDevelopment = envNodeEnv === 'development' || process.env.NODE_ENV === 'development';\n\n  // Priority: explicit control > development mode > debug mode\n  if (consoleEnabled !== undefined) {\n    return consoleEnabled;\n  }\n  if (isDevelopment) {\n    return true;\n  }\n  return debugEnabled ?? false;\n}\n\n// Export types for convenience - removed for Rollup compatibility\n\n// Note: For direct access to observability instances, import from environment-specific modules:\n// - @repo/observability/client-next\n// - @repo/observability/server-next\n// - @repo/observability/server-edge\n// - @repo/observability/client\n// - @repo/observability/server\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,uBAAuB;AAElC,KAAI,OAAO,eAAe,eAAgB,WAAmB,YAC3D,QAAO;EAAE,MAAM;EAAQ,SAAS;EAAU;AAE5C,KACE,OAAO,eAAe,eACrB,WAAmB,UACpB,OAAQ,WAAmB,WAAW,YAEtC,QAAO;EAAE,MAAM;EAAQ,SAAS;EAAc;AAIhD,KAAI,OAAO,YAAY,eAAe,QAAQ,UAAU,IACtD,QAAO;EAAE,MAAM;EAAO,SAAS,QAAQ,SAAS;EAAK;AAIvD,KACE,OAAO,eAAe,eACtB,YAAY,cACZ,OAAQ,WAAmB,WAAW,eACtC,OAAQ,WAAmB,OAAO,aAAa,eAC/C,OAAQ,WAAmB,OAAO,cAAc,YAEhD,QAAO;EAAE,MAAM;EAAW,UAAU,QAAS,WAAmB,OAAO,cAAc;EAAE;AAIzF,KAAI,OAAO,YAAY,eAAe,QAAQ,UAAU,MAAM;EAC5D,MAAM,cAAc,SAAS,QAAQ,SAAS,KAAK,MAAM,IAAI,CAAC,MAAM,IAAI;EACxE,MAAM,mBAAmB,SAAS,QAAQ,SAAS,KAAK,MAAM,IAAI,CAAC,MAAM,IAAI;AAE7E,MAAI,cAAc,GAEhB,SACE,wBAAwB,QAAQ,SAAS,KAAK,8EAC/C;AAGH,SAAO;GACL,MAAM;GACN,SAAS,QAAQ,SAAS;GAC1B,OAAO;GACP,OAAO;GACP,cAAc,eAAe;GAC7B,UACE,QAAQ,QAAQ,IAAI,aAAa,IACjC,QAAQ,QAAQ,IAAI,eAAe,IACnC,QAAQ,QAAQ,IAAI,uBAAuB;GAC9C;;AAIH,QAAO,EAAE,MAAM,WAAW;;AAI5B,MAAM,cAAc,gBAAgB;;;;;;;;;;;;;;;AAgBpC,MAAa,8BAA8B;;;;;;AAO3C,SAAgB,YAAqB;AACnC,QACE,OAAO,eAAe,eACtB,YAAY,cACZ,OAAQ,WAAmB,WAAW,eACtC,OAAQ,WAAmB,OAAO,aAAa,eAC/C,OAAQ,WAAmB,OAAO,cAAc;;;;;;;;;;AAYpD,SAAgB,oBACd,YACA,gBACA,cACS;CACT,MAAM,gBAAgB,eAAe,iBAAiB;AAGtD,KAAI,mBAAmB,OACrB,QAAO;AAET,KAAI,cACF,QAAO;AAET,QAAO,gBAAgB"}

package/dist/manager-BxQqOPEg.d.mts

@@ -0,0 +1,33 @@
+import { a as Breadcrumb, d as ObservabilityServer, f as ObservabilityUser, i as PluginLifecycle, l as ObservabilityContext, n as ObservabilityServerPlugin, o as LogLevel, t as ObservabilityPlugin, u as ObservabilityScope } from "./plugin-Bfq-o3nr.mjs";
+
+//#region src/core/manager.d.ts
+declare class ObservabilityManager implements ObservabilityServer {
+  private plugins;
+  private initialized;
+  private initializationPromise;
+  private lifecycle;
+  private initializationError;
+  constructor(lifecycle?: PluginLifecycle);
+  addPlugin(plugin: ObservabilityPlugin | ObservabilityServerPlugin): this;
+  getPlugin<T extends ObservabilityPlugin>(name: string): T | undefined;
+  getPlugins(): ObservabilityPlugin[];
+  listPlugins(): ObservabilityPlugin[];
+  initialize(): Promise<void>;
+  private doInitialize;
+  hasInitializationError(): boolean;
+  getInitializationError(): Error | null;
+  shutdown(): Promise<void>;
+  captureException(error: Error | unknown, context?: ObservabilityContext): void;
+  captureMessage(message: string, level?: LogLevel, context?: ObservabilityContext): void;
+  private validateUser;
+  setUser(user: ObservabilityUser | null): void;
+  addBreadcrumb(breadcrumb: Breadcrumb): void;
+  withScope(callback: (scope: ObservabilityScope) => void): void;
+  flush(timeout?: number): Promise<boolean>;
+  private broadcast;
+  hasEnabledPlugins(): boolean;
+  getEnabledPluginNames(): string[];
+}
+//#endregion
+export { ObservabilityManager as t };
+//# sourceMappingURL=manager-BxQqOPEg.d.mts.map

package/dist/manager-BxQqOPEg.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager-BxQqOPEg.d.mts","names":[],"sources":["../src/core/manager.ts"],"mappings":";;;cAqBa,oBAAA,YAAgC,mBAAA;EAAA,QACnC,OAAA;EAAA,QACA,WAAA;EAAA,QACA,qBAAA;EAAA,QACA,SAAA;EAAA,QACA,mBAAA;cAOI,SAAA,GAAY,eAAA;EASxB,SAAA,CAAU,MAAA,EAAQ,mBAAA,GAAsB,yBAAA;EAWxC,SAAA,WAAoB,mBAAA,CAAA,CAAqB,IAAA,WAAe,CAAA;EASxD,UAAA,CAAA,GAAc,mBAAA;EASd,WAAA,CAAA,GAAe,mBAAA;EAST,UAAA,CAAA,GAAc,OAAA;EAAA,QA8BN,YAAA;EAiCd,sBAAA,CAAA;EAQA,sBAAA,CAAA,GAA0B,KAAA;EAOpB,QAAA,CAAA,GAAY,OAAA;EAyBlB,gBAAA,CAAiB,KAAA,EAAO,KAAA,YAAiB,OAAA,GAAU,oBAAA;EAWnD,cAAA,CAAe,OAAA,UAAiB,KAAA,GAAO,QAAA,EAAmB,OAAA,GAAU,oBAAA;EAAA,QAS5D,YAAA;EAiER,OAAA,CAAQ,IAAA,EAAM,iBAAA;EAUd,aAAA,CAAc,UAAA,EAAY,UAAA;EAS1B,SAAA,CAAU,QAAA,GAAW,KAAA,EAAO,kBAAA;EAYtB,KAAA,CAAM,OAAA,YAAmB,OAAA;EAAA,QAmBvB,SAAA;EA4BR,iBAAA,CAAA;EASA,qBAAA,CAAA;AAAA"}

package/dist/plugin-Bfq-o3nr.d.mts

@@ -0,0 +1,60 @@
+//#region src/core/types.d.ts
+interface ObservabilityUser {
+  id: string;
+  email?: string;
+  username?: string;
+  ip_address?: string;
+  [key: string]: unknown;
+}
+interface ObservabilityContext {
+  [key: string]: unknown;
+}
+interface ObservabilityScope {
+  setTag(key: string, value: string): void;
+  setExtra(key: string, value: unknown): void;
+  setUser(user: ObservabilityUser | null): void;
+  setLevel(level: LogLevel): void;
+  [key: string]: unknown;
+}
+type LogLevel = 'debug' | 'info' | 'warning' | 'error';
+interface Breadcrumb {
+  message: string;
+  category?: string;
+  level?: LogLevel | 'critical';
+  data?: Record<string, unknown>;
+  timestamp?: number;
+}
+interface ObservabilityClient {
+  captureException(error: Error | unknown, context?: ObservabilityContext): void;
+  captureMessage(message: string, level?: LogLevel, context?: ObservabilityContext): void;
+  setUser(user: ObservabilityUser | null): void;
+  addBreadcrumb(breadcrumb: Breadcrumb): void;
+  withScope(callback: (scope: ObservabilityScope) => void): void;
+}
+interface ObservabilityServer extends ObservabilityClient {
+  flush(timeout?: number): Promise<boolean>;
+}
+interface ObservabilityConfig {
+  enabled?: boolean;
+  environment?: 'development' | 'preview' | 'production';
+  debug?: boolean;
+}
+//#endregion
+//#region src/core/plugin.d.ts
+interface ObservabilityPlugin<TClient = any> extends ObservabilityClient {
+  name: string;
+  enabled: boolean;
+  getClient(): TClient | undefined;
+  initialize?(config?: any): Promise<void>;
+  shutdown?(): Promise<void>;
+}
+interface ObservabilityServerPlugin<TClient = any> extends ObservabilityPlugin<TClient>, ObservabilityServer {}
+type PluginFactory<TConfig = any, TPlugin = ObservabilityPlugin> = (config?: TConfig) => TPlugin;
+interface PluginLifecycle {
+  onError?: (error: Error, plugin: ObservabilityPlugin) => void;
+  onInitialized?: (plugin: ObservabilityPlugin) => void;
+  onShutdown?: (plugin: ObservabilityPlugin) => void;
+}
+//#endregion
+export { Breadcrumb as a, ObservabilityConfig as c, ObservabilityServer as d, ObservabilityUser as f, PluginLifecycle as i, ObservabilityContext as l, ObservabilityServerPlugin as n, LogLevel as o, PluginFactory as r, ObservabilityClient as s, ObservabilityPlugin as t, ObservabilityScope as u };
+//# sourceMappingURL=plugin-Bfq-o3nr.d.mts.map

package/dist/plugin-Bfq-o3nr.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-Bfq-o3nr.d.mts","names":[],"sources":["../src/core/types.ts","../src/core/plugin.ts"],"mappings":";UAYiB,iBAAA;EAEf,EAAA;EAEA,KAAA;EAEA,QAAA;EAEA,UAAA;EAAA,CAMC,GAAA;AAAA;AAAA,UASc,oBAAA;EAAA,CACd,GAAA;AAAA;AAAA,UASc,kBAAA;EACf,MAAA,CAAO,GAAA,UAAa,KAAA;EACpB,QAAA,CAAS,GAAA,UAAa,KAAA;EACtB,OAAA,CAAQ,IAAA,EAAM,iBAAA;EACd,QAAA,CAAS,KAAA,EAAO,QAAA;EAAA,CACf,GAAA;AAAA;AAAA,KAQS,QAAA;AAAA,UAQK,UAAA;EAEf,OAAA;EAEA,QAAA;EAEA,KAAA,GAAQ,QAAA;EAER,IAAA,GAAO,MAAA;EAEP,SAAA;AAAA;AAAA,UASe,mBAAA;EAOf,gBAAA,CAAiB,KAAA,EAAO,KAAA,YAAiB,OAAA,GAAU,oBAAA;EAQnD,cAAA,CAAe,OAAA,UAAiB,KAAA,GAAQ,QAAA,EAAU,OAAA,GAAU,oBAAA;EAM5D,OAAA,CAAQ,IAAA,EAAM,iBAAA;EAMd,aAAA,CAAc,UAAA,EAAY,UAAA;EAM1B,SAAA,CAAU,QAAA,GAAW,KAAA,EAAO,kBAAA;AAAA;AAAA,UASb,mBAAA,SAA4B,mBAAA;EAU3C,KAAA,CAAM,OAAA,YAAmB,OAAA;AAAA;AAAA,UAMV,mBAAA;EAEf,OAAA;EAEA,WAAA;EAEA,KAAA;AAAA;;;UC3Ie,mBAAA,wBAA2C,mBAAA;EAI1D,IAAA;EAKA,OAAA;EAMA,SAAA,IAAa,OAAA;EAKb,UAAA,EAAY,MAAA,SAAe,OAAA;EAK3B,QAAA,KAAa,OAAA;AAAA;AAAA,UAME,yBAAA,wBACP,mBAAA,CAAoB,OAAA,GAAU,mBAAA;AAAA,KAO5B,aAAA,0BAAuC,mBAAA,KACjD,MAAA,GAAS,OAAA,KACN,OAAA;AAAA,UAKY,eAAA;EACf,OAAA,IAAW,KAAA,EAAO,KAAA,EAAO,MAAA,EAAQ,mBAAA;EACjC,aAAA,IAAiB,MAAA,EAAQ,mBAAA;EACzB,UAAA,IAAc,MAAA,EAAQ,mBAAA;AAAA"}