@refraction-ui/react 0.5.0 → 0.6.0

package/dist/index.cjs

@@ -25,7 +25,104 @@ function _interopNamespace(e) {
 var React11__namespace = /*#__PURE__*/_interopNamespace(React11);
 var ReactDOM__namespace = /*#__PURE__*/_interopNamespace(ReactDOM);
 
-// ../react-accordion/dist/index.js
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../logger/dist/chunk-57LG5ZUS.js
+async function createFaroSink(opts) {
+  const transport = opts.transport ?? await loadFaroTransport(opts);
+  if (!transport) return null;
+  return {
+    name: "faro",
+    log(record) {
+      transport.push({ kind: "log", record });
+    },
+    span(record) {
+      transport.push({ kind: "span", record });
+    },
+    async flush() {
+    }
+  };
+}
+async function loadFaroTransport(opts) {
+  try {
+    const sdkName = "@grafana/faro-web-sdk";
+    const tracingName = "@grafana/faro-web-tracing";
+    const sdk = await import(
+      /* @vite-ignore */
+      sdkName
+    );
+    const tracing = await import(
+      /* @vite-ignore */
+      tracingName
+    );
+    const faro = sdk.initializeFaro({
+      url: opts.endpoint,
+      app: { name: opts.app },
+      instrumentations: [
+        ...sdk.getWebInstrumentations(),
+        new tracing.TracingInstrumentation()
+      ]
+    });
+    return {
+      push({ kind, record }) {
+        if (kind === "log") {
+          const r = record;
+          faro.api.pushLog([r.message], {
+            level: FARO_LEVEL[r.level],
+            context: flatten(r.context)
+          });
+        } else {
+          const r = record;
+          faro.api.pushEvent(`span:${r.name}`, {
+            durationMs: String(r.durationMs),
+            status: r.status,
+            ...flatten(r.context)
+          });
+        }
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+function flatten(ctx) {
+  const out = {};
+  for (const [k, v] of Object.entries(ctx)) {
+    out[k] = typeof v === "string" ? v : JSON.stringify(v);
+  }
+  return out;
+}
+var FARO_LEVEL;
+var init_chunk_57LG5ZUS = __esm({
+  "../logger/dist/chunk-57LG5ZUS.js"() {
+    FARO_LEVEL = {
+      debug: "debug",
+      info: "info",
+      warn: "warn",
+      error: "error",
+      fatal: "error"
+    };
+  }
+});
+
+// ../logger/dist/faro-engine-47HGRAQH.js
+var faro_engine_47HGRAQH_exports = {};
+__export(faro_engine_47HGRAQH_exports, {
+  createFaroSink: () => createFaroSink
+});
+var init_faro_engine_47HGRAQH = __esm({
+  "../logger/dist/faro-engine-47HGRAQH.js"() {
+    init_chunk_57LG5ZUS();
+  }
+});
 
 // ../shared/dist/index.js
 var idCounter = 0;
@@ -138,6 +235,23 @@ function cva(config) {
     return classes.filter(Boolean).join(" ");
   };
 }
+var seen = /* @__PURE__ */ new Set();
+function isDev() {
+  return typeof process === "undefined" || process.env?.NODE_ENV !== "production";
+}
+function emit(level, code, message, detail) {
+  if (!isDev()) return;
+  const key = `${level}:${code}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  const text = `[refraction-ui] ${code}: ${message}`;
+  {
+    console.warn(text, "");
+  }
+}
+function devWarn(code, message, detail) {
+  emit("warn", code, message);
+}
 var AccordionContext = React11__namespace.createContext(null);
 var Accordion = React11__namespace.forwardRef(
   ({ className, type = "single", collapsible, value: controlledValue, defaultValue, onValueChange, ...props }, ref) => {
@@ -168,7 +282,13 @@ var AccordionItemContext = React11__namespace.createContext(null);
 var AccordionItem = React11__namespace.forwardRef(
   ({ className, value, ...props }, ref) => {
     const context = React11__namespace.useContext(AccordionContext);
-    if (!context) throw new Error("AccordionItem must be within Accordion");
+    if (!context) {
+      devWarn(
+        "react-accordion/item-outside-accordion",
+        "<AccordionItem> must be rendered inside an <Accordion>. The missing AccordionContext makes this throw."
+      );
+      throw new Error("AccordionItem must be within Accordion");
+    }
     const isOpen = context.type === "single" ? context.value === value : Array.isArray(context.value) && context.value.includes(value);
     return /* @__PURE__ */ jsxRuntime.jsx(AccordionItemContext.Provider, { value: { value, isOpen }, children: /* @__PURE__ */ jsxRuntime.jsx("div", { ref, className: cn("border-b border-border", className), "data-state": isOpen ? "open" : "closed", ...props }) });
   }
@@ -178,7 +298,13 @@ var AccordionTrigger = React11__namespace.forwardRef(
   ({ className, children, ...props }, ref) => {
     const accordionContext = React11__namespace.useContext(AccordionContext);
     const itemContext = React11__namespace.useContext(AccordionItemContext);
-    if (!accordionContext || !itemContext) throw new Error("AccordionTrigger missing context");
+    if (!accordionContext || !itemContext) {
+      devWarn(
+        "react-accordion/trigger-missing-context",
+        "<AccordionTrigger> must be rendered inside an <AccordionItem> within an <Accordion>. The missing AccordionContext/AccordionItemContext makes this throw."
+      );
+      throw new Error("AccordionTrigger missing context");
+    }
     return /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "flex m-0 p-0", children: /* @__PURE__ */ jsxRuntime.jsxs(
       "button",
       {
@@ -219,7 +345,13 @@ AccordionTrigger.displayName = "AccordionTrigger";
 var AccordionContent = React11__namespace.forwardRef(
   ({ className, children, ...props }, ref) => {
     const itemContext = React11__namespace.useContext(AccordionItemContext);
-    if (!itemContext) throw new Error("AccordionContent missing context");
+    if (!itemContext) {
+      devWarn(
+        "react-accordion/content-missing-context",
+        "<AccordionContent> must be rendered inside an <AccordionItem>. The missing AccordionItemContext makes this throw."
+      );
+      throw new Error("AccordionContent missing context");
+    }
     return /* @__PURE__ */ jsxRuntime.jsx(
       "div",
       {
@@ -517,6 +649,10 @@ function AuthProvider({ children, ...config }) {
   const authRef = React11__namespace.useRef(null);
   if (!authRef.current) {
     if (!config.adapter && !config.testMode) {
+      devWarn(
+        "react-auth/missing-adapter",
+        "<AuthProvider> was rendered without a required `adapter` prop (and not in `testMode`). Pass an auth adapter so the provider can create an auth instance."
+      );
       throw new Error("[refraction-ui/react-auth] You must provide an `adapter` to AuthProvider.");
     }
     authRef.current = createAuth(config.adapter, config);
@@ -548,6 +684,10 @@ function AuthProvider({ children, ...config }) {
 function useAuth() {
   const ctx = React11__namespace.useContext(AuthContext);
   if (!ctx) {
+    devWarn(
+      "react-auth/use-auth-outside-provider",
+      "useAuth() was called outside an <AuthProvider>. Wrap your app (or the consuming subtree) in <AuthProvider> so the auth context is available."
+    );
     throw new Error("useAuth must be used within an <AuthProvider>");
   }
   return ctx;
@@ -1744,6 +1884,10 @@ var CollapsibleContext = React11__namespace.createContext(null);
 function useCollapsibleContext() {
   const ctx = React11__namespace.useContext(CollapsibleContext);
   if (!ctx) {
+    devWarn(
+      "react-collapsible/context-outside-provider",
+      "Collapsible compound components (CollapsibleTrigger/CollapsibleContent) must be rendered inside a <Collapsible>. The missing CollapsibleContext makes this throw."
+    );
     throw new Error(
       "Collapsible compound components must be used within <Collapsible>"
     );
@@ -1891,6 +2035,10 @@ var ComboboxContext = React11__namespace.createContext(null);
 function useComboboxContext() {
   const ctx = React11__namespace.useContext(ComboboxContext);
   if (!ctx) {
+    devWarn(
+      "react-combobox/context-outside-provider",
+      "Combobox compound components (ComboboxInput/ComboboxContent/ComboboxItem/etc.) must be rendered inside a <Combobox>. The missing ComboboxContext makes this throw."
+    );
     throw new Error("Combobox compound components must be used within <Combobox>");
   }
   return ctx;
@@ -2563,6 +2711,10 @@ var CommandContext = React11__namespace.createContext(null);
 function useCommandContext() {
   const ctx = React11__namespace.useContext(CommandContext);
   if (!ctx) {
+    devWarn(
+      "react-command/context-outside-provider",
+      "Command compound components (CommandInput/CommandList/CommandItem/CommandGroup/etc.) must be rendered inside a <Command>. The missing CommandContext makes this throw."
+    );
     throw new Error("Command compound components must be used within <Command>");
   }
   return ctx;
@@ -3400,6 +3552,10 @@ var DialogContext = React11__namespace.createContext(null);
 function useDialogContext() {
   const ctx = React11__namespace.useContext(DialogContext);
   if (!ctx) {
+    devWarn(
+      "react-dialog/context-outside-provider",
+      "Dialog compound components (DialogTrigger/DialogContent/DialogTitle/etc.) must be rendered inside a <Dialog>. The missing DialogContext makes this throw."
+    );
     throw new Error("Dialog compound components must be used within <Dialog>");
   }
   return ctx;
@@ -3687,6 +3843,10 @@ var DropdownMenuContext = React11__namespace.createContext(null);
 function useDropdownMenuContext() {
   const ctx = React11__namespace.useContext(DropdownMenuContext);
   if (!ctx) {
+    devWarn(
+      "react-dropdown-menu/context-outside-provider",
+      "DropdownMenu compound components (DropdownMenuTrigger/DropdownMenuContent/DropdownMenuItem/etc.) must be rendered inside a <DropdownMenu>. The missing DropdownMenuContext makes this throw."
+    );
     throw new Error("DropdownMenu compound components must be used within <DropdownMenu>");
   }
   return ctx;
@@ -4937,6 +5097,10 @@ var MobileNavContext = React11__namespace.createContext(null);
 function useMobileNavContext() {
   const ctx = React11__namespace.useContext(MobileNavContext);
   if (!ctx) {
+    devWarn(
+      "react-mobile-nav/compound-outside-provider",
+      "A MobileNav compound component was rendered outside of <MobileNav>. Wrap it in <MobileNav>."
+    );
     throw new Error("MobileNav compound components must be used within <MobileNav>");
   }
   return ctx;
@@ -5195,6 +5359,10 @@ var PopoverContext = React11__namespace.createContext(null);
 function usePopoverContext() {
   const ctx = React11__namespace.useContext(PopoverContext);
   if (!ctx) {
+    devWarn(
+      "react-popover/context-outside-provider",
+      "Popover compound components (PopoverTrigger/PopoverContent/etc.) must be rendered inside a <Popover>. The missing PopoverContext makes this throw."
+    );
     throw new Error("Popover compound components must be used within <Popover>");
   }
   return ctx;
@@ -5400,6 +5568,10 @@ var SearchBarContext = React11__namespace.createContext(null);
 function useSearchBarContext() {
   const ctx = React11__namespace.useContext(SearchBarContext);
   if (!ctx) {
+    devWarn(
+      "react-search-bar/compound-outside-provider",
+      "A SearchBar compound component was rendered outside of <SearchBar>. Wrap it in <SearchBar>."
+    );
     throw new Error("SearchBar compound components must be used within <SearchBar>");
   }
   return ctx;
@@ -5663,6 +5835,10 @@ var SheetContext = React11__namespace.createContext(null);
 function useSheetContext() {
   const ctx = React11__namespace.useContext(SheetContext);
   if (!ctx) {
+    devWarn(
+      "react-sheet/sheet-compound-outside-provider",
+      "A Sheet compound component was rendered outside of <Sheet>. Wrap it in <Sheet>."
+    );
     throw new Error("Sheet compound components must be used within <Sheet>");
   }
   return ctx;
@@ -6114,6 +6290,10 @@ var TabsContext = React11__namespace.createContext(null);
 function useTabsContext() {
   const ctx = React11__namespace.useContext(TabsContext);
   if (!ctx) {
+    devWarn(
+      "react-tabs/context-outside-provider",
+      "Tabs compound components (TabsList/TabsTrigger/TabsContent) must be rendered inside a <Tabs>. The missing TabsContext makes this throw."
+    );
     throw new Error("Tabs compound components must be used within <Tabs>");
   }
   return ctx;
@@ -6438,6 +6618,10 @@ var ToastContext = React11__namespace.createContext(null);
 function useToastContext() {
   const ctx = React11__namespace.useContext(ToastContext);
   if (!ctx) {
+    devWarn(
+      "react-toast/use-toast-outside-provider",
+      "useToast() was called outside a <ToastProvider>. Wrap your app (or the consuming subtree) in <ToastProvider> so the toast context is available."
+    );
     throw new Error("useToast must be used within a <ToastProvider>");
   }
   return ctx;
@@ -6617,6 +6801,10 @@ var TooltipContext = React11__namespace.createContext(null);
 function useTooltipContext() {
   const ctx = React11__namespace.useContext(TooltipContext);
   if (!ctx) {
+    devWarn(
+      "react-tooltip/context-outside-provider",
+      "Tooltip compound components (TooltipTrigger/TooltipContent/etc.) must be rendered inside a <Tooltip>. The missing TooltipContext makes this throw."
+    );
     throw new Error("Tooltip compound components must be used within <Tooltip>");
   }
   return ctx;
@@ -8818,6 +9006,10 @@ var ResizableLayoutContext = React11__namespace.createContext(null);
 function useResizableLayoutContext() {
   const ctx = React11__namespace.useContext(ResizableLayoutContext);
   if (!ctx) {
+    devWarn(
+      "react-resizable-layout/compound-outside-provider",
+      "A Resizable compound component was rendered outside of <ResizableLayout>. Wrap it in <ResizableLayout>."
+    );
     throw new Error("Resizable compound components must be used within <ResizableLayout>");
   }
   return ctx;
@@ -9199,6 +9391,10 @@ var AppShellContext = React11__namespace.createContext(null);
 function useAppShell() {
   const ctx = React11__namespace.useContext(AppShellContext);
   if (!ctx) {
+    devWarn(
+      "react-app-shell/use-app-shell-outside-provider",
+      "useAppShell() was called outside of <AppShell>. Wrap the consuming component tree in <AppShell>."
+    );
     throw new Error("useAppShell must be used within <AppShell>");
   }
   return ctx;
@@ -9405,6 +9601,10 @@ var PageShellContext = React11__namespace.createContext(null);
 function usePageShell() {
   const ctx = React11__namespace.useContext(PageShellContext);
   if (!ctx) {
+    devWarn(
+      "react-app-shell/page-shell-compound-outside-provider",
+      "A PageShell compound component was rendered outside of <PageShell>. Wrap it in <PageShell>."
+    );
     throw new Error("PageShell compound components must be used within <PageShell>");
   }
   return ctx;
@@ -9507,6 +9707,10 @@ var AuthShellContext = React11__namespace.createContext(null);
 function useAuthShell() {
   const ctx = React11__namespace.useContext(AuthShellContext);
   if (!ctx) {
+    devWarn(
+      "react-app-shell/auth-shell-compound-outside-provider",
+      "An AuthShell compound component was rendered outside of <AuthShell>. Wrap it in <AuthShell>."
+    );
     throw new Error("AuthShell compound components must be used within <AuthShell>");
   }
   return ctx;
@@ -11904,7 +12108,13 @@ function RadioGroup({
 }
 function RadioItem({ value, children, disabled = false, className }) {
   const ctx = React11__namespace.useContext(RadioContext);
-  if (!ctx) throw new Error("RadioItem must be used within RadioGroup");
+  if (!ctx) {
+    devWarn(
+      "react-radio/radio-item-outside-group",
+      "RadioItem was rendered outside of <RadioGroup>. Wrap it in <RadioGroup>."
+    );
+    throw new Error("RadioItem must be used within RadioGroup");
+  }
   const isChecked = ctx.value === value;
   const isDisabled = ctx.disabled || disabled;
   return React11__namespace.createElement(
@@ -12171,6 +12381,7 @@ var selectItemVariants = cva({
   }
 });
 var SelectContext = React11__namespace.createContext({
+  __isDefault: true,
   value: void 0,
   onValueChange: () => {
   },
@@ -12183,6 +12394,16 @@ var SelectContext = React11__namespace.createContext({
   triggerId: "",
   contentId: ""
 });
+function useSelectContext(part) {
+  const ctx = React11__namespace.useContext(SelectContext);
+  if (ctx.__isDefault) {
+    devWarn(
+      "react-select/no-select-provider",
+      `<${part}> was rendered without a <Select> ancestor. It is silently reading inert context defaults (clicks/keyboard do nothing, it never opens). Wrap it in <Select>\u2026</Select>.`
+    );
+  }
+  return ctx;
+}
 function Select({
   value,
   onValueChange,
@@ -12215,7 +12436,7 @@ function Select({
 }
 var SelectTrigger = React11__namespace.forwardRef(
   ({ className, children, size = "default", ...props }, ref) => {
-    const { open, setOpen, disabled, triggerId, contentId } = React11__namespace.useContext(SelectContext);
+    const { open, setOpen, disabled, triggerId, contentId } = useSelectContext("SelectTrigger");
     const api = createSelect({ disabled, open });
     const handleClick = () => {
       if (!disabled) {
@@ -12274,7 +12495,7 @@ var SelectTrigger = React11__namespace.forwardRef(
 SelectTrigger.displayName = "SelectTrigger";
 var SelectContent = React11__namespace.forwardRef(
   ({ className, children, ...props }, forwardedRef) => {
-    const { open, contentId, triggerId, setOpen } = React11__namespace.useContext(SelectContext);
+    const { open, contentId, triggerId, setOpen } = useSelectContext("SelectContent");
     const containerRef = React11__namespace.useRef(null);
     const ref = React11__namespace.useCallback(
       (node) => {
@@ -12335,7 +12556,7 @@ var SelectContent = React11__namespace.forwardRef(
 SelectContent.displayName = "SelectContent";
 var SelectItem = React11__namespace.forwardRef(
   ({ className, children, value: itemValue, disabled: itemDisabled = false, ...props }, ref) => {
-    const { value, onValueChange, setOpen, triggerId } = React11__namespace.useContext(SelectContext);
+    const { value, onValueChange, setOpen, triggerId } = useSelectContext("SelectItem");
     const isSelected = value === itemValue;
     const handleClick = () => {
       if (!itemDisabled) {
@@ -12902,7 +13123,13 @@ var CarouselItemContext = React11__namespace.createContext(null);
 var CarouselItem = React11__namespace.forwardRef(
   ({ className, value, ...props }, ref) => {
     const context = React11__namespace.useContext(CarouselContext);
-    if (!context) throw new Error("CarouselItem must be within Carousel");
+    if (!context) {
+      devWarn(
+        "react-carousel/carousel-item-outside-carousel",
+        "CarouselItem was rendered outside of <Carousel>. Wrap it in <Carousel>."
+      );
+      throw new Error("CarouselItem must be within Carousel");
+    }
     const isOpen = context.type === "single" ? context.value === value : Array.isArray(context.value) && context.value.includes(value);
     return /* @__PURE__ */ jsxRuntime.jsx(CarouselItemContext.Provider, { value: { value, isOpen }, children: /* @__PURE__ */ jsxRuntime.jsx("div", { ref, className: cn("border-b border-border", className), "data-state": isOpen ? "open" : "closed", ...props }) });
   }
@@ -12912,7 +13139,13 @@ var CarouselTrigger = React11__namespace.forwardRef(
   ({ className, children, ...props }, ref) => {
     const carouselContext = React11__namespace.useContext(CarouselContext);
     const itemContext = React11__namespace.useContext(CarouselItemContext);
-    if (!carouselContext || !itemContext) throw new Error("CarouselTrigger missing context");
+    if (!carouselContext || !itemContext) {
+      devWarn(
+        "react-carousel/carousel-trigger-outside-item",
+        "CarouselTrigger was rendered outside of a <CarouselItem> within <Carousel>. Nest it inside <CarouselItem>."
+      );
+      throw new Error("CarouselTrigger missing context");
+    }
     return /* @__PURE__ */ jsxRuntime.jsx("h3", { className: "flex m-0 p-0", children: /* @__PURE__ */ jsxRuntime.jsxs(
       "button",
       {
@@ -12953,7 +13186,13 @@ CarouselTrigger.displayName = "CarouselTrigger";
 var CarouselContent = React11__namespace.forwardRef(
   ({ className, children, ...props }, ref) => {
     const itemContext = React11__namespace.useContext(CarouselItemContext);
-    if (!itemContext) throw new Error("CarouselContent missing context");
+    if (!itemContext) {
+      devWarn(
+        "react-carousel/carousel-content-outside-item",
+        "CarouselContent was rendered outside of a <CarouselItem> within <Carousel>. Nest it inside <CarouselItem>."
+      );
+      throw new Error("CarouselContent missing context");
+    }
     return /* @__PURE__ */ jsxRuntime.jsx(
       "div",
       {
@@ -13458,11 +13697,1191 @@ var PaymentButton = React11__namespace.forwardRef(
 );
 PaymentButton.displayName = "PaymentButton";
 
+// ../logger/dist/index.js
+var LEVEL_ORDER = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40,
+  fatal: 50
+};
+var METHOD = {
+  debug: "debug",
+  info: "info",
+  warn: "warn",
+  error: "error",
+  fatal: "error"
+};
+function createConsoleSink(opts) {
+  const pretty = opts?.pretty ?? true;
+  const out = opts?.console ?? console;
+  function emit2(level, line, payload) {
+    out[METHOD[level]](line, payload);
+  }
+  return {
+    name: "console",
+    log(record) {
+      if (pretty) {
+        const ts = new Date(record.timestamp).toISOString();
+        emit2(
+          record.level,
+          `${ts} ${record.level.toUpperCase()} [${record.app}] ${record.message}`,
+          record.context
+        );
+      } else {
+        emit2(record.level, JSON.stringify({ type: "log", ...record }), record.context);
+      }
+    },
+    span(record) {
+      const level = record.status === "error" ? "error" : "debug";
+      if (pretty) {
+        emit2(
+          level,
+          `[span] ${record.name} ${record.durationMs.toFixed(2)}ms (${record.status})`,
+          record.context
+        );
+      } else {
+        emit2(level, JSON.stringify({ type: "span", ...record }), record.context);
+      }
+    },
+    async flush() {
+    }
+  };
+}
+var NOOP_SPAN = {
+  end() {
+  }
+};
+function createNoopTelemetry() {
+  const noop = {
+    debug() {
+    },
+    info() {
+    },
+    warn() {
+    },
+    error() {
+    },
+    fatal() {
+    },
+    child() {
+      return noop;
+    },
+    startSpan() {
+      return NOOP_SPAN;
+    },
+    async flush() {
+    },
+    get sinks() {
+      return [];
+    },
+    addSink() {
+    },
+    removeSink() {
+    }
+  };
+  return noop;
+}
+var PRESETS = {
+  development: {
+    minLevel: "debug",
+    batch: false,
+    batchSize: 1,
+    sampleRate: 1,
+    pretty: true,
+    beaconFlush: false
+  },
+  production: {
+    minLevel: "warn",
+    batch: true,
+    batchSize: 20,
+    sampleRate: 0.25,
+    pretty: false,
+    beaconFlush: true
+  }
+};
+function resolvePreset(env) {
+  return { ...PRESETS[env] };
+}
+function redact(value, keys) {
+  if (keys.length === 0) return value;
+  const lookup = new Set(keys.map((k) => k.toLowerCase()));
+  return walk(value, lookup, /* @__PURE__ */ new WeakSet());
+}
+function walk(value, keys, seen2) {
+  if (value === null || typeof value !== "object") return value;
+  if (seen2.has(value)) return "[Circular]";
+  seen2.add(value);
+  if (Array.isArray(value)) {
+    return value.map((item) => walk(item, keys, seen2));
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (keys.has(k.toLowerCase())) {
+      out[k] = "[REDACTED]";
+      continue;
+    }
+    out[k] = walk(v, keys, seen2);
+  }
+  return out;
+}
+function createTelemetry(config) {
+  if (config.enabled === false) {
+    return createNoopTelemetry();
+  }
+  const preset = resolvePreset(config.env);
+  const sampleRate = config.sampleRate ?? preset.sampleRate;
+  const redactKeys = config.redactKeys ?? [];
+  const sinks = /* @__PURE__ */ new Map();
+  const sinkOrder = [];
+  const buffer = [];
+  function addSinkInternal(sink) {
+    if (sinks.has(sink.name)) {
+      sinks.set(sink.name, sink);
+    } else {
+      sinks.set(sink.name, sink);
+      sinkOrder.push(sink.name);
+    }
+  }
+  addSinkInternal(createConsoleSink({ pretty: preset.pretty }));
+  if (config.endpoint) {
+    const endpoint = config.endpoint;
+    void Promise.resolve().then(() => (init_faro_engine_47HGRAQH(), faro_engine_47HGRAQH_exports)).then(({ createFaroSink: createFaroSink2 }) => createFaroSink2({ app: config.app, endpoint })).then((faro) => {
+      if (faro) addSinkInternal(faro);
+    }).catch(() => {
+    });
+  }
+  function shouldSample() {
+    if (sampleRate >= 1) return true;
+    if (sampleRate <= 0) return false;
+    return Math.random() < sampleRate;
+  }
+  function dispatch(entry) {
+    if (preset.batch) {
+      buffer.push(entry);
+      if (buffer.length >= preset.batchSize) {
+        void flushBuffer();
+      }
+      return;
+    }
+    deliver(entry);
+  }
+  function deliver(entry) {
+    for (const name of sinkOrder) {
+      const sink = sinks.get(name);
+      if (!sink) continue;
+      if (entry.kind === "log") sink.log(entry.record);
+      else sink.span(entry.record);
+    }
+  }
+  async function flushBuffer() {
+    if (buffer.length > 0) {
+      const pending = buffer.splice(0, buffer.length);
+      for (const entry of pending) deliver(entry);
+    }
+    await Promise.all(
+      sinkOrder.map((name) => sinks.get(name)?.flush() ?? Promise.resolve())
+    );
+  }
+  const root = globalThis;
+  if (preset.beaconFlush && typeof root.addEventListener === "function") {
+    const onExit = () => {
+      void flushBuffer();
+    };
+    root.addEventListener("pagehide", onExit);
+    root.addEventListener("visibilitychange", () => {
+      if (root.document?.visibilityState === "hidden") onExit();
+    });
+  }
+  function makeLogger(boundContext) {
+    function emit2(level, message, context) {
+      if (LEVEL_ORDER[level] < LEVEL_ORDER[preset.minLevel]) return;
+      if (!shouldSample()) return;
+      const merged = redact({ ...boundContext, ...context }, redactKeys);
+      const record = {
+        level,
+        message,
+        timestamp: Date.now(),
+        app: config.app,
+        env: config.env,
+        context: merged
+      };
+      dispatch({ kind: "log", record });
+    }
+    const logger = {
+      debug(message, context) {
+        emit2("debug", message, context);
+      },
+      info(message, context) {
+        emit2("info", message, context);
+      },
+      warn(message, context) {
+        emit2("warn", message, context);
+      },
+      error(message, context) {
+        emit2("error", message, context);
+      },
+      fatal(message, context) {
+        emit2("fatal", message, context);
+      },
+      child(context) {
+        return makeLogger({ ...boundContext, ...context });
+      },
+      startSpan(name, attributes) {
+        const startTime = Date.now();
+        let ended = false;
+        return {
+          end(opts) {
+            if (ended) return;
+            ended = true;
+            const endTime = Date.now();
+            const merged = redact(
+              { ...boundContext, ...attributes, ...opts?.attributes },
+              redactKeys
+            );
+            const err = opts?.error;
+            const record = {
+              name,
+              startTime,
+              endTime,
+              durationMs: endTime - startTime,
+              app: config.app,
+              env: config.env,
+              context: merged,
+              status: err ? "error" : "ok",
+              ...err ? {
+                error: {
+                  name: err instanceof Error ? err.name : "Error",
+                  message: err instanceof Error ? err.message : String(err)
+                }
+              } : {}
+            };
+            dispatch({ kind: "span", record });
+          }
+        };
+      },
+      flush() {
+        return flushBuffer();
+      },
+      get sinks() {
+        return [...sinkOrder];
+      },
+      addSink(sink) {
+        addSinkInternal(sink);
+      },
+      removeSink(name) {
+        if (sinks.has(name)) {
+          sinks.delete(name);
+          const idx = sinkOrder.indexOf(name);
+          if (idx !== -1) sinkOrder.splice(idx, 1);
+        }
+      }
+    };
+    return logger;
+  }
+  return makeLogger({});
+}
+
+// ../react-logger/dist/index.js
+var TelemetryContext = React11__namespace.createContext(null);
+function TelemetryProvider({ children, ...config }) {
+  const telemetryRef = React11__namespace.useRef(null);
+  if (!telemetryRef.current) {
+    telemetryRef.current = createTelemetry(config);
+  }
+  const value = React11__namespace.useMemo(
+    () => ({ telemetry: telemetryRef.current }),
+    []
+  );
+  return React11__namespace.createElement(TelemetryContext.Provider, { value }, children);
+}
+function useTelemetry() {
+  const ctx = React11__namespace.useContext(TelemetryContext);
+  if (!ctx) {
+    devWarn(
+      "react-logger/use-telemetry-outside-provider",
+      "useTelemetry() (or useSpan(), which depends on it) was called outside a <TelemetryProvider>. Wrap your app (or the consuming subtree) in <TelemetryProvider> so the telemetry context is available."
+    );
+    throw new Error("useTelemetry must be used within a <TelemetryProvider>");
+  }
+  return ctx.telemetry;
+}
+function useLogger(scope) {
+  const telemetry = useTelemetry();
+  const scopeKey = scope ? JSON.stringify(scope) : "";
+  return React11__namespace.useMemo(
+    () => scope ? telemetry.child(scope) : telemetry,
+    [telemetry, scope, scopeKey]
+  );
+}
+function useSpan() {
+  const telemetry = useTelemetry();
+  const spanRef = React11__namespace.useRef(null);
+  const [isActive, setIsActive] = React11__namespace.useState(false);
+  const end = React11__namespace.useCallback(
+    (opts) => {
+      if (!spanRef.current) return;
+      spanRef.current.end(opts);
+      spanRef.current = null;
+      setIsActive(false);
+    },
+    []
+  );
+  const start = React11__namespace.useCallback(
+    (name, attributes) => {
+      if (spanRef.current) {
+        spanRef.current.end();
+      }
+      const span = telemetry.startSpan(name, attributes);
+      spanRef.current = span;
+      setIsActive(true);
+      return span;
+    },
+    [telemetry]
+  );
+  React11__namespace.useEffect(() => {
+    return () => {
+      if (spanRef.current) {
+        spanRef.current.end();
+        spanRef.current = null;
+      }
+    };
+  }, []);
+  return React11__namespace.useMemo(
+    () => ({ start, end, isActive }),
+    [start, end, isActive]
+  );
+}
+var TelemetryErrorBoundary = class extends React11__namespace.Component {
+  static contextType = TelemetryContext;
+  state = { error: null };
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(error, info) {
+    const telemetry = this.context?.telemetry;
+    if (telemetry) {
+      telemetry.error(error.message, {
+        ...this.props.context,
+        name: error.name,
+        stack: error.stack,
+        componentStack: info.componentStack
+      });
+    }
+    this.props.onError?.(error, info);
+  }
+  reset = () => {
+    this.setState({ error: null });
+  };
+  render() {
+    const { error } = this.state;
+    if (error) {
+      const { fallback } = this.props;
+      if (typeof fallback === "function") {
+        return fallback(error, this.reset);
+      }
+      return fallback ?? null;
+    }
+    return this.props.children;
+  }
+};
+
+// ../analytics/dist/index.js
+var SCHEMA_VERSION = 1;
+function uuidv4() {
+  const c = typeof globalThis !== "undefined" ? globalThis.crypto : void 0;
+  if (c && typeof c.randomUUID === "function") {
+    return c.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  if (c && typeof c.getRandomValues === "function") {
+    c.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 16; i++) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = [];
+  for (let i = 0; i < 256; i++) hex.push((i + 256).toString(16).slice(1));
+  return hex[bytes[0]] + hex[bytes[1]] + hex[bytes[2]] + hex[bytes[3]] + "-" + hex[bytes[4]] + hex[bytes[5]] + "-" + hex[bytes[6]] + hex[bytes[7]] + "-" + hex[bytes[8]] + hex[bytes[9]] + "-" + hex[bytes[10]] + hex[bytes[11]] + hex[bytes[12]] + hex[bytes[13]] + hex[bytes[14]] + hex[bytes[15]];
+}
+var UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function isUuidV4(value) {
+  return typeof value === "string" && UUID_V4_RE.test(value);
+}
+function createMemoryStorage() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    get: (k) => map.has(k) ? map.get(k) : null,
+    set: (k, v) => {
+      map.set(k, v);
+    },
+    remove: (k) => {
+      map.delete(k);
+    }
+  };
+}
+function createLocalStorageAdapter(ls) {
+  return {
+    get: (k) => {
+      try {
+        return ls.getItem(k);
+      } catch {
+        return null;
+      }
+    },
+    set: (k, v) => {
+      try {
+        ls.setItem(k, v);
+      } catch {
+      }
+    },
+    remove: (k) => {
+      try {
+        ls.removeItem(k);
+      } catch {
+      }
+    }
+  };
+}
+function createCookieAdapter(doc, maxAgeSeconds = 60 * 60 * 24 * 365) {
+  const read = (k) => {
+    const target = encodeURIComponent(k) + "=";
+    const parts = doc.cookie ? doc.cookie.split(";") : [];
+    for (const part of parts) {
+      const c = part.trim();
+      if (c.startsWith(target)) {
+        return decodeURIComponent(c.slice(target.length));
+      }
+    }
+    return null;
+  };
+  return {
+    get: read,
+    set: (k, v) => {
+      doc.cookie = `${encodeURIComponent(k)}=${encodeURIComponent(
+        v
+      )}; path=/; max-age=${maxAgeSeconds}; SameSite=Lax`;
+    },
+    remove: (k) => {
+      doc.cookie = `${encodeURIComponent(k)}=; path=/; max-age=0; SameSite=Lax`;
+    }
+  };
+}
+function resolveStorage(override) {
+  if (override) return override;
+  const g = globalThis;
+  if (g.localStorage) {
+    try {
+      const probe = "__rfx_a_probe__";
+      g.localStorage.setItem(probe, "1");
+      g.localStorage.removeItem(probe);
+      return createLocalStorageAdapter(g.localStorage);
+    } catch {
+    }
+  }
+  if (g.document && typeof g.document.cookie === "string") {
+    return createCookieAdapter(g.document);
+  }
+  return createMemoryStorage();
+}
+var DEFAULT_SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
+var DEFAULT_KEY = "rfx:analytics:session";
+var CAMPAIGN_PARAMS = [
+  "utm_source",
+  "utm_medium",
+  "utm_campaign",
+  "utm_term",
+  "utm_content",
+  "gclid",
+  "fbclid",
+  "msclkid"
+];
+function campaignFingerprint(search) {
+  if (!search) return void 0;
+  let qs = search;
+  const q = qs.indexOf("?");
+  if (q !== -1) qs = qs.slice(q + 1);
+  let params;
+  try {
+    params = new URLSearchParams(qs);
+  } catch {
+    return void 0;
+  }
+  const pairs = [];
+  for (const p of CAMPAIGN_PARAMS) {
+    const v = params.get(p);
+    if (v) pairs.push(`${p}=${v}`);
+  }
+  return pairs.length ? pairs.join("&") : void 0;
+}
+function createSession(config, now = () => Date.now()) {
+  const storage = resolveStorage(config?.storage);
+  const key = config?.storageKey ?? DEFAULT_KEY;
+  const timeoutMs = config?.timeoutMs ?? DEFAULT_SESSION_TIMEOUT_MS;
+  const resetOnCampaign = config?.resetOnCampaign ?? true;
+  function read() {
+    const raw = storage.get(key);
+    if (!raw) return null;
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed.id === "string") return parsed;
+    } catch {
+    }
+    return null;
+  }
+  function write(s) {
+    storage.set(key, JSON.stringify(s));
+  }
+  function mint(campaign) {
+    const s = {
+      id: uuidv4(),
+      lastActivity: now(),
+      campaign
+    };
+    write(s);
+    return s;
+  }
+  function ensure(campaign) {
+    const existing = read();
+    const t = now();
+    if (!existing) return mint(campaign);
+    if (t - existing.lastActivity > timeoutMs) {
+      return mint(campaign);
+    }
+    if (resetOnCampaign && campaign !== void 0 && existing.campaign !== campaign) {
+      return mint(campaign);
+    }
+    return existing;
+  }
+  return {
+    /** Get the current session id, rotating if expired. */
+    id(campaign) {
+      return ensure(campaign).id;
+    },
+    /** Force a brand-new session. */
+    start(campaign) {
+      return mint(campaign).id;
+    },
+    /** End the current session (next id() mints a fresh one). */
+    end() {
+      storage.remove(key);
+    },
+    /** Touch activity so the inactivity window slides forward. */
+    touch(campaign) {
+      const s = ensure(campaign);
+      s.lastActivity = now();
+      write(s);
+      return s.id;
+    },
+    /** Attach/merge session-scoped properties. */
+    set(props) {
+      const s = ensure();
+      s.props = { ...s.props ?? {}, ...props };
+      write(s);
+    },
+    /** Read session-scoped properties (undefined when none). */
+    props() {
+      return read()?.props;
+    }
+  };
+}
+var DEFAULT_KEY2 = "rfx:analytics:anon";
+function createIdentity(config) {
+  const storage = resolveStorage(config?.storage);
+  const key = config?.storageKey ?? DEFAULT_KEY2;
+  let userId;
+  function loadOrMintAnon() {
+    const existing = storage.get(key);
+    if (isUuidV4(existing)) return existing;
+    const fresh = uuidv4();
+    storage.set(key, fresh);
+    return fresh;
+  }
+  let anonymousId = loadOrMintAnon();
+  return {
+    anonymousId() {
+      return anonymousId;
+    },
+    userId() {
+      return userId;
+    },
+    /** identify(): bind an opaque app user id (no validation, no persistence). */
+    setUserId(id) {
+      userId = id;
+    },
+    /**
+     * alias(): returns the stitch pair for the envelope. `previousId`
+     * defaults to the current user or anonymous id.
+     */
+    alias(nextUserId, previousId) {
+      const prev = previousId ?? userId ?? anonymousId;
+      userId = nextUserId;
+      return { userId: nextUserId, previousId: prev };
+    },
+    /**
+     * reset(): privacy-safe logout. Drops the user binding and mints a brand
+     * new anonymousId so the next visitor is not stitched to the old one.
+     */
+    reset() {
+      userId = void 0;
+      anonymousId = uuidv4();
+      storage.set(key, anonymousId);
+      return anonymousId;
+    }
+  };
+}
+function createConsent(config) {
+  const granted = new Set(config?.granted ?? []);
+  return {
+    strict: config?.strict ?? false,
+    grant(...categories) {
+      for (const c of categories) granted.add(c);
+    },
+    revoke(...categories) {
+      for (const c of categories) granted.delete(c);
+    },
+    granted() {
+      return [...granted];
+    },
+    isGranted(category) {
+      return granted.has(category);
+    },
+    allows(required) {
+      if (!required || required.length === 0) return true;
+      return required.every((c) => granted.has(c));
+    }
+  };
+}
+var PII_DENY_LIST = [
+  "email",
+  "phone",
+  "mobile",
+  "firstname",
+  "lastname",
+  "fullname",
+  "givenname",
+  "surname",
+  "password",
+  "passwd",
+  "ssn",
+  "creditcard",
+  "cardnumber",
+  "cvv",
+  "dob",
+  "dateofbirth",
+  "address"
+];
+var PII_EXACT_KEYS = ["name"];
+var REDACTED = "[REDACTED]";
+function normalize(key) {
+  return key.toLowerCase().replace(/[_\-\s]/g, "");
+}
+function createRedactor(extraKeys = []) {
+  const exact = /* @__PURE__ */ new Set([
+    ...extraKeys.map(normalize),
+    ...PII_EXACT_KEYS.map(normalize)
+  ]);
+  const deny = PII_DENY_LIST.map(normalize);
+  const shouldRedact = (key) => {
+    const n = normalize(key);
+    if (exact.has(n)) return true;
+    return deny.some((d) => n.includes(d));
+  };
+  const walk2 = (value) => {
+    if (Array.isArray(value)) return value.map(walk2);
+    if (value && typeof value === "object") {
+      const out = {};
+      for (const [k, v] of Object.entries(value)) {
+        out[k] = shouldRedact(k) ? REDACTED : walk2(v);
+      }
+      return out;
+    }
+    return value;
+  };
+  return {
+    shouldRedact,
+    /** Redact a properties/traits bag (returns a new object). */
+    redact(props) {
+      if (!props) return props;
+      return walk2(props);
+    }
+  };
+}
+var NO_RETRY = /* @__PURE__ */ new Set([400, 401, 413]);
+function base64(input) {
+  const g = globalThis;
+  if (typeof g.btoa === "function") {
+    return g.btoa(input);
+  }
+  if (g.Buffer) {
+    return g.Buffer.from(input, "utf-8").toString("base64");
+  }
+  throw new Error("No base64 implementation available (btoa/Buffer)");
+}
+function byteLength(s) {
+  const g = globalThis;
+  if (g.TextEncoder) return new g.TextEncoder().encode(s).length;
+  return unescape(encodeURIComponent(s)).length;
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function splitBatch(batch, maxBatchBytes, maxEventBytes) {
+  const batches = [];
+  const dropped = [];
+  let current = [];
+  let currentBytes = 2;
+  for (const ev of batch) {
+    const evBytes = byteLength(JSON.stringify(ev));
+    if (evBytes > maxEventBytes) {
+      dropped.push(ev);
+      continue;
+    }
+    if (current.length && currentBytes + evBytes + 1 > maxBatchBytes) {
+      batches.push(current);
+      current = [];
+      currentBytes = 2;
+    }
+    current.push(ev);
+    currentBytes += evBytes + 1;
+  }
+  if (current.length) batches.push(current);
+  return { batches, dropped };
+}
+function createHttpSink(options) {
+  const {
+    endpoint,
+    writeKey,
+    maxRetries = 3,
+    backoffBaseMs = 500,
+    consentCategories = ["analytics"],
+    maxBatchBytes = 5e5,
+    maxEventBytes = 32e3
+  } = options;
+  const base = endpoint.replace(/\/+$/, "");
+  const url = `${base}/v${SCHEMA_VERSION}/batch`;
+  const authHeader = `Basic ${base64(`${writeKey}:`)}`;
+  const resolveFetch = () => {
+    if (options.fetchImpl) return options.fetchImpl;
+    const f = globalThis.fetch;
+    if (!f) throw new Error("No fetch implementation available");
+    return f;
+  };
+  const resolveBeacon = () => {
+    if (options.beaconImpl) return options.beaconImpl;
+    const nav = globalThis.navigator;
+    if (nav && typeof nav.sendBeacon === "function") {
+      return (u, body) => nav.sendBeacon(u, body);
+    }
+    return void 0;
+  };
+  function envelope(batch) {
+    return {
+      batch,
+      sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+      batchId: uuidv4()
+    };
+  }
+  function sendViaBeacon(batch) {
+    const beacon = resolveBeacon();
+    if (!beacon) return false;
+    const beaconUrl = `${url}?writeKey=${encodeURIComponent(writeKey)}`;
+    return beacon(beaconUrl, JSON.stringify(envelope(batch)));
+  }
+  async function sendViaFetch(batch) {
+    const doFetch = resolveFetch();
+    const body = JSON.stringify(envelope(batch));
+    for (let attempt = 0; ; attempt++) {
+      let status;
+      try {
+        const res = await doFetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: authHeader
+          },
+          body,
+          keepalive: true
+        });
+        status = res.status;
+      } catch {
+        status = 0;
+      }
+      if (status >= 200 && status < 300) return;
+      if (NO_RETRY.has(status)) return;
+      if (attempt >= maxRetries) return;
+      const delay = backoffBaseMs * 2 ** attempt;
+      await sleep(delay);
+    }
+  }
+  return {
+    name: "http",
+    consentCategories,
+    async deliver(batch, ctx) {
+      if (batch.length === 0) return;
+      const { batches } = splitBatch(
+        batch,
+        maxBatchBytes,
+        maxEventBytes
+      );
+      for (const part of batches) {
+        if (ctx.unload) {
+          if (sendViaBeacon(part)) continue;
+          void sendViaFetch(part);
+        } else {
+          await sendViaFetch(part);
+        }
+      }
+    }
+  };
+}
+function createConsoleSink2(options = {}) {
+  const logger = options.logger ?? globalThis.console;
+  return {
+    name: "console",
+    consentCategories: options.consentCategories,
+    deliver(batch) {
+      for (const ev of batch) {
+        const label = `[analytics] ${ev.type}${ev.event ? ` ${ev.event}` : ""}`;
+        if (typeof logger.groupCollapsed === "function") {
+          logger.groupCollapsed(label);
+          logger.log(ev);
+          logger.groupEnd?.();
+        } else {
+          logger.log(label, ev);
+        }
+      }
+    }
+  };
+}
+function createNoopAnalytics() {
+  const sessionId = "00000000-0000-4000-8000-000000000000";
+  const noop = () => {
+  };
+  const api = {
+    track: noop,
+    identify: noop,
+    page: noop,
+    screen: noop,
+    group: noop,
+    alias: noop,
+    session: {
+      id: () => sessionId,
+      start: () => sessionId,
+      end: noop,
+      set: noop
+    },
+    consent: {
+      grant: noop,
+      revoke: noop,
+      granted: () => [],
+      isGranted: () => false
+    },
+    anonymousId: () => sessionId,
+    userId: () => void 0,
+    with: () => api,
+    addSink: noop,
+    removeSink: noop,
+    get sinks() {
+      return [];
+    },
+    flush: async () => {
+    },
+    reset: noop,
+    enabled: false
+  };
+  return api;
+}
+var LIBRARY = {
+  name: "@refraction-ui/analytics",
+  version: "0.1.0"
+};
+function readPage() {
+  const g = globalThis;
+  if (!g.location && !g.document) return void 0;
+  return {
+    path: g.location?.pathname,
+    url: g.location?.href,
+    search: g.location?.search,
+    title: g.document?.title,
+    referrer: g.document?.referrer
+  };
+}
+function createAnalytics(config) {
+  if (config.enabled === false) {
+    return createNoopAnalytics();
+  }
+  const { app, env } = config;
+  const preset = config.preset ?? (env === "production" ? "prod" : "dev");
+  const sampleRate = config.sampleRate ?? 1;
+  const batchSize = config.batchSize ?? 20;
+  const flushIntervalMs = config.flushIntervalMs ?? 1e4;
+  const session = createSession(config.session);
+  const identity = createIdentity(config.identity);
+  const consent = createConsent(config.consent);
+  const redactor = createRedactor(config.redactKeys);
+  const sinks = /* @__PURE__ */ new Map();
+  const sinkOrder = [];
+  const initialized = /* @__PURE__ */ new Set();
+  function registerSink(sink) {
+    if (!sinks.has(sink.name)) sinkOrder.push(sink.name);
+    sinks.set(sink.name, sink);
+  }
+  if (config.endpoint) {
+    registerSink(
+      createHttpSink({
+        endpoint: config.endpoint,
+        writeKey: config.writeKey ?? ""
+      })
+    );
+  }
+  if (preset === "dev") {
+    registerSink(createConsoleSink2());
+  }
+  for (const s of config.sinks ?? []) registerSink(s);
+  function ensureInit(sink) {
+    if (initialized.has(sink.name)) return;
+    initialized.add(sink.name);
+    if (sink.init) {
+      return sink.init({ app, env, endpoint: config.endpoint });
+    }
+  }
+  const buffer = [];
+  let timer;
+  function startTimer() {
+    if (preset !== "prod" || timer) return;
+    timer = setInterval(() => {
+      void flush(false);
+    }, flushIntervalMs);
+    timer.unref?.();
+  }
+  function deliverToSinks(batch, unload) {
+    if (batch.length === 0) return;
+    const ctx = { unload };
+    const pending = [];
+    for (const name of sinkOrder) {
+      const sink = sinks.get(name);
+      if (!sink) continue;
+      if (!consent.allows(sink.consentCategories)) continue;
+      const inited = ensureInit(sink);
+      if (inited && typeof inited.then === "function") {
+        pending.push(
+          inited.then(() => sink.deliver(batch, ctx))
+        );
+      } else {
+        const r = sink.deliver(batch, ctx);
+        if (r && typeof r.then === "function") {
+          pending.push(r);
+        }
+      }
+    }
+    if (pending.length) return Promise.all(pending).then(() => void 0);
+  }
+  async function flush(unload = false) {
+    const batch = buffer.splice(0, buffer.length);
+    await deliverToSinks(batch, unload);
+    for (const name of sinkOrder) {
+      const sink = sinks.get(name);
+      if (sink?.flush && consent.allows(sink.consentCategories)) {
+        await sink.flush();
+      }
+    }
+  }
+  function bindUnload() {
+    if (preset !== "prod") return;
+    const g = globalThis;
+    if (typeof g.addEventListener !== "function") return;
+    const onUnload = () => {
+      void deliverToSinks(buffer.splice(0, buffer.length), true);
+    };
+    g.addEventListener("pagehide", onUnload);
+    g.addEventListener("visibilitychange", () => {
+      if (g.document?.visibilityState === "hidden") onUnload();
+    });
+  }
+  startTimer();
+  bindUnload();
+  function buildContext(extra, childCtx) {
+    const page = readPage();
+    return {
+      app,
+      env,
+      ...page ? { page } : {},
+      ...childCtx,
+      ...extra,
+      library: LIBRARY
+    };
+  }
+  function sampled() {
+    if (sampleRate >= 1) return true;
+    if (sampleRate <= 0) return false;
+    return Math.random() < sampleRate;
+  }
+  function enqueue(ev) {
+    if (preset === "dev") {
+      void deliverToSinks([ev], false);
+      return;
+    }
+    buffer.push(ev);
+    if (buffer.length >= batchSize) {
+      void flush(false);
+    }
+  }
+  function emit2(type, fields, childCtx, opts) {
+    if (!sampled()) return;
+    const page = readPage();
+    const campaign = campaignFingerprint(page?.search);
+    const sessionId = session.touch(campaign);
+    const sessionProps = session.props();
+    const ev = {
+      type,
+      messageId: uuidv4(),
+      anonymousId: identity.anonymousId(),
+      userId: identity.userId(),
+      sessionId,
+      context: buildContext(opts?.context, childCtx),
+      timestamp: opts?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+      schemaVersion: SCHEMA_VERSION,
+      ...fields
+    };
+    if (sessionProps && (ev.properties || type === "track" || type === "page" || type === "screen")) {
+      ev.properties = { ...sessionProps, ...ev.properties ?? {} };
+    }
+    enqueue(ev);
+  }
+  function makeApi(childCtx) {
+    const api = {
+      track(event, properties, opts) {
+        emit2(
+          "track",
+          { event, properties: redactor.redact(properties) },
+          childCtx,
+          opts
+        );
+      },
+      identify(userId, traits, opts) {
+        identity.setUserId(userId);
+        emit2("identify", { traits: redactor.redact(traits) }, childCtx, opts);
+      },
+      page(name, properties, opts) {
+        emit2(
+          "page",
+          { event: name, properties: redactor.redact(properties) },
+          childCtx,
+          opts
+        );
+      },
+      screen(name, properties, opts) {
+        emit2(
+          "screen",
+          { event: name, properties: redactor.redact(properties) },
+          childCtx,
+          opts
+        );
+      },
+      group(groupId, traits, opts) {
+        emit2(
+          "group",
+          { groupId, traits: redactor.redact(traits) },
+          childCtx,
+          opts
+        );
+      },
+      alias(userId, previousId, opts) {
+        const stitch = identity.alias(userId, previousId);
+        emit2(
+          "alias",
+          { userId: stitch.userId, previousId: stitch.previousId },
+          childCtx,
+          opts
+        );
+      },
+      session: {
+        id: () => session.id(),
+        start: () => session.start(),
+        end: () => session.end(),
+        set: (props) => session.set(props)
+      },
+      consent: {
+        grant: (...c) => consent.grant(...c),
+        revoke: (...c) => consent.revoke(...c),
+        granted: () => consent.granted(),
+        isGranted: (c) => consent.isGranted(c)
+      },
+      anonymousId: () => identity.anonymousId(),
+      userId: () => identity.userId(),
+      with(extra) {
+        return makeApi({ ...childCtx, ...extra });
+      },
+      addSink(sink) {
+        registerSink(sink);
+      },
+      removeSink(name) {
+        if (sinks.has(name)) {
+          sinks.delete(name);
+          const i = sinkOrder.indexOf(name);
+          if (i !== -1) sinkOrder.splice(i, 1);
+          initialized.delete(name);
+        }
+      },
+      get sinks() {
+        return [...sinkOrder];
+      },
+      async flush() {
+        await flush(false);
+      },
+      reset() {
+        identity.reset();
+        session.end();
+      },
+      enabled: true
+    };
+    return api;
+  }
+  return makeApi();
+}
+
+// ../react-analytics/dist/index.js
+var AnalyticsContext = React11__namespace.createContext(null);
+function AnalyticsProvider({ children, value }) {
+  const analyticsRef = React11__namespace.useRef(null);
+  if (!analyticsRef.current) {
+    analyticsRef.current = value;
+  }
+  return React11__namespace.createElement(
+    AnalyticsContext.Provider,
+    { value: analyticsRef.current },
+    children
+  );
+}
+function useAnalytics(options) {
+  const ctx = React11__namespace.useContext(AnalyticsContext);
+  if (!ctx) {
+    devWarn(
+      "react-analytics/use-analytics-outside-provider",
+      "useAnalytics() was called outside an <AnalyticsProvider>. Wrap your app (or the consuming subtree) in <AnalyticsProvider> so the analytics context is available."
+    );
+    throw new Error("useAnalytics must be used within an <AnalyticsProvider>");
+  }
+  const scope = options?.scope;
+  return React11__namespace.useMemo(
+    () => scope ? ctx.with(scope) : ctx,
+    [ctx, scope]
+  );
+}
+function useTrackEvent(options) {
+  const analytics = useAnalytics(options);
+  return React11__namespace.useCallback(
+    (event, properties, opts) => analytics.track(event, properties, opts),
+    [analytics]
+  );
+}
+
 exports.Accordion = Accordion;
 exports.AccordionContent = AccordionContent;
 exports.AccordionItem = AccordionItem;
 exports.AccordionTrigger = AccordionTrigger;
 exports.AltHintState = AltHintState;
+exports.AnalyticsProvider = AnalyticsProvider;
 exports.AnimatedText = AnimatedText;
 exports.AppShell = AppShell;
 exports.AuthGuard = AuthGuard;
@@ -13628,6 +15047,8 @@ exports.Tabs = Tabs;
 exports.TabsContent = TabsContent;
 exports.TabsList = TabsList;
 exports.TabsTrigger = TabsTrigger;
+exports.TelemetryErrorBoundary = TelemetryErrorBoundary;
+exports.TelemetryProvider = TelemetryProvider;
 exports.Textarea = Textarea;
 exports.ThreadView = ThreadView;
 exports.Toast = Toast;
@@ -13687,6 +15108,7 @@ exports.commandItemVariants = commandItemVariants;
 exports.commandVariants = commandVariants;
 exports.contentProtectionVariants = contentProtectionVariants;
 exports.controlsVariants = controlsVariants;
+exports.createAnalytics = createAnalytics;
 exports.createIntensitySamples = createIntensitySamples;
 exports.createSilentSamples = createSilentSamples;
 exports.createVoicePill = createVoicePill;
@@ -13820,9 +15242,14 @@ exports.toastVariants = toastVariants;
 exports.toolbarVariants = toolbarVariants;
 exports.tooltipContentVariants = tooltipContentVariants;
 exports.typewriterVariants = typewriterVariants;
+exports.useAnalytics = useAnalytics;
 exports.useAuth = useAuth;
+exports.useLogger = useLogger;
 exports.useShortcut = useShortcut;
+exports.useSpan = useSpan;
+exports.useTelemetry = useTelemetry;
 exports.useToast = useToast;
+exports.useTrackEvent = useTrackEvent;
 exports.versionSelectorOptionVariants = versionSelectorOptionVariants;
 exports.versionSelectorVariants = versionSelectorVariants;
 exports.voicePillAvatarStyles = voicePillAvatarStyles;