@nexushub/client 0.9.0 → 1.1.1

package/dist/react.js

@@ -1,16 +1,426 @@
 import {
+  SDK_VERSION,
+  buildQueryString,
   getFullConfig,
-  validateConfig
-} from "./chunk-VQ6IEN4I.js";
+  measurePerformance,
+  normalizeQuery,
+  validateConfig,
+  validateSlug
+} from "./chunk-PB3YCBFH.js";
+
+// src/components/NexusRenderer.tsx
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import { createPortal } from "react-dom";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function cn(...classes) {
+  return classes.filter(Boolean).join(" ");
+}
+var DEFAULT_CHART = {
+  chartType: "bar",
+  title: "Untitled Chart",
+  categories: ["Category A", "Category B", "Category C", "Category D"],
+  series: [
+    {
+      label: "Series 1",
+      color: "#6366f1",
+      data: [40, 65, 30, 80]
+    }
+  ],
+  showLegend: true,
+  showGrid: true,
+  width: 560,
+  height: 320,
+  sourceNote: null
+};
+var FALLBACK_CHART_COLORS = [
+  "#6366f1",
+  "#f97316",
+  "#10b981",
+  "#ec4899",
+  "#0ea5e9",
+  "#eab308",
+  "#a855f7",
+  "#ef4444",
+  "#14b8a6",
+  "#84cc16"
+];
+function decodeChartSpec(raw) {
+  if (!raw) return null;
+  try {
+    const decoded = JSON.parse(
+      decodeURIComponent(atob(raw))
+    );
+    if (!decoded || typeof decoded !== "object") return null;
+    const categories = Array.isArray(decoded.categories) ? decoded.categories.map(String) : DEFAULT_CHART.categories;
+    const series = Array.isArray(decoded.series) ? decoded.series.filter(Boolean).map((s, index) => ({
+      label: typeof s.label === "string" ? s.label : `Series ${index + 1}`,
+      color: typeof s.color === "string" ? s.color : FALLBACK_CHART_COLORS[index % FALLBACK_CHART_COLORS.length],
+      data: Array.isArray(s.data) ? s.data.map((v) => {
+        const n = Number(v);
+        return Number.isFinite(n) ? n : 0;
+      }) : []
+    })) : DEFAULT_CHART.series;
+    return {
+      ...DEFAULT_CHART,
+      ...decoded,
+      categories,
+      series: series.length ? series : DEFAULT_CHART.series,
+      chartType: ["bar", "line", "pie", "donut", "area"].includes(decoded.chartType) ? decoded.chartType : DEFAULT_CHART.chartType,
+      title: typeof decoded.title === "string" ? decoded.title : DEFAULT_CHART.title,
+      showLegend: typeof decoded.showLegend === "boolean" ? decoded.showLegend : DEFAULT_CHART.showLegend,
+      showGrid: typeof decoded.showGrid === "boolean" ? decoded.showGrid : DEFAULT_CHART.showGrid,
+      width: typeof decoded.width === "number" && decoded.width > 0 ? decoded.width : DEFAULT_CHART.width,
+      height: typeof decoded.height === "number" && decoded.height > 0 ? decoded.height : DEFAULT_CHART.height,
+      sourceNote: typeof decoded.sourceNote === "string" ? decoded.sourceNote : null
+    };
+  } catch {
+    return null;
+  }
+}
+function recoverChartFromElement(element) {
+  const spec = decodeChartSpec(element.getAttribute("data-chart-spec"));
+  if (spec) return spec;
+  const title = element.getAttribute("data-chart-title") || DEFAULT_CHART.title;
+  const chartType = element.getAttribute("data-chart-type");
+  return {
+    ...DEFAULT_CHART,
+    title,
+    chartType: ["bar", "line", "pie", "donut", "area"].includes(chartType) ? chartType : "bar"
+  };
+}
+function prepareDocumentHTML(html) {
+  if (typeof window === "undefined") return html;
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, "text/html");
+  doc.querySelectorAll("script, noscript").forEach((node) => node.remove());
+  doc.querySelectorAll("*").forEach((element) => {
+    [...element.attributes].forEach((attr) => {
+      if (attr.name.toLowerCase().startsWith("on")) {
+        element.removeAttribute(attr.name);
+      }
+    });
+    const href = element.getAttribute("href");
+    const src = element.getAttribute("src");
+    if (href && /^\s*javascript:/i.test(href)) element.removeAttribute("href");
+    if (src && /^\s*javascript:/i.test(src)) element.removeAttribute("src");
+  });
+  return doc.body.innerHTML;
+}
+function NativeNexusChart({ chart }) {
+  const [hoveredValue, setHoveredValue] = useState(null);
+  const categories = chart.categories;
+  const series = chart.series;
+  const allNumbers = series.flatMap((s) => s.data);
+  const maxVal = Math.max(...allNumbers, 10);
+  const minVal = Math.min(0, ...allNumbers);
+  const width = 560;
+  const height = Math.max(220, Math.min(chart.height || 300, 450));
+  const padLeft = 45;
+  const padRight = 20;
+  const padTop = 20;
+  const padBottom = 35;
+  const plotW = width - padLeft - padRight;
+  const plotH = height - padTop - padBottom;
+  const getY = (val) => {
+    const range = maxVal - minVal;
+    return padTop + plotH - (val - minVal) / range * plotH;
+  };
+  const getX = (catIndex) => {
+    return padLeft + catIndex / Math.max(categories.length - 1, 1) * plotW;
+  };
+  const renderGridAndAxes = () => /* @__PURE__ */ jsxs(Fragment, { children: [
+    chart.showGrid && /* @__PURE__ */ jsx(Fragment, { children: [0, 0.25, 0.5, 0.75, 1].map((pct, i) => {
+      const y = padTop + plotH * (1 - pct);
+      const val = Math.round(minVal + (maxVal - minVal) * pct);
+      return /* @__PURE__ */ jsxs("g", { children: [
+        /* @__PURE__ */ jsx(
+          "line",
+          {
+            x1: padLeft,
+            y1: y,
+            x2: width - padRight,
+            y2: y,
+            stroke: "currentColor",
+            strokeOpacity: 0.08,
+            strokeDasharray: "3 3"
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "text",
+          {
+            x: padLeft - 8,
+            y: y + 3,
+            textAnchor: "end",
+            fontSize: 10,
+            fill: "currentColor",
+            opacity: 0.5,
+            className: "font-mono",
+            children: val
+          }
+        )
+      ] }, `grid-${i}`);
+    }) }),
+    categories.map((cat, i) => {
+      const x = categories.length === 1 ? padLeft + plotW / 2 : getX(i);
+      return /* @__PURE__ */ jsx(
+        "text",
+        {
+          x,
+          y: height - 10,
+          textAnchor: "middle",
+          fontSize: 11,
+          fill: "currentColor",
+          opacity: 0.6,
+          className: "font-mono",
+          children: cat
+        },
+        `cat-${i}`
+      );
+    })
+  ] });
+  const renderBars = () => {
+    const groupW = plotW / categories.length;
+    const barWidth = Math.max(6, Math.min(28, groupW * 0.7 / series.length));
+    return categories.map((cat, catIdx) => {
+      const groupCenterX = padLeft + catIdx * groupW + groupW / 2;
+      const startX = groupCenterX - series.length * barWidth / 2;
+      return series.map((s, sIdx) => {
+        const val = s.data[catIdx] || 0;
+        const barH = (val - minVal) / (maxVal - minVal) * plotH;
+        const x = startX + sIdx * barWidth;
+        const y = padTop + plotH - barH;
+        return /* @__PURE__ */ jsx(
+          "rect",
+          {
+            x,
+            y,
+            width: barWidth - 2,
+            height: Math.max(barH, 2),
+            rx: 3,
+            fill: s.color,
+            opacity: 0.9,
+            className: "transition-all duration-300 hover:opacity-100 cursor-pointer",
+            onMouseEnter: () => setHoveredValue(`${cat} \u2022 ${s.label}: ${val.toLocaleString()}`),
+            onMouseLeave: () => setHoveredValue(null)
+          },
+          `bar-${catIdx}-${sIdx}`
+        );
+      });
+    });
+  };
+  const renderLinesOrArea = (isArea) => {
+    return series.map((s, sIdx) => {
+      const points = s.data.map((val, catIdx) => `${getX(catIdx)},${getY(val)}`).join(" ");
+      const areaPoints = `${getX(0)},${padTop + plotH} ${points} ${getX(s.data.length - 1)},${padTop + plotH}`;
+      return /* @__PURE__ */ jsxs("g", { children: [
+        isArea && /* @__PURE__ */ jsx("polygon", { points: areaPoints, fill: s.color, fillOpacity: 0.15 }),
+        /* @__PURE__ */ jsx(
+          "polyline",
+          {
+            points,
+            fill: "none",
+            stroke: s.color,
+            strokeWidth: 2.5,
+            strokeLinecap: "round",
+            strokeLinejoin: "round"
+          }
+        ),
+        s.data.map((val, catIdx) => /* @__PURE__ */ jsx(
+          "circle",
+          {
+            cx: getX(catIdx),
+            cy: getY(val),
+            r: 4,
+            fill: s.color,
+            className: "cursor-pointer transition-transform hover:scale-150",
+            onMouseEnter: () => setHoveredValue(
+              `${categories[catIdx]} \u2022 ${s.label}: ${val.toLocaleString()}`
+            ),
+            onMouseLeave: () => setHoveredValue(null)
+          },
+          `dot-${catIdx}`
+        ))
+      ] }, `series-${sIdx}`);
+    });
+  };
+  const renderPieOrDonut = () => {
+    const s = series[0] || { data: [] };
+    const total = s.data.reduce((a, b) => a + (Number(b) || 0), 0) || 1;
+    let accumulated = 0;
+    const cx = width / 2;
+    const cy = height / 2;
+    const r = Math.min(cx, cy) - 30;
+    const isDonut = chart.chartType === "donut";
+    return /* @__PURE__ */ jsxs("g", { transform: `translate(${cx}, ${cy})`, children: [
+      categories.map((cat, idx) => {
+        const val = s.data[idx] || 0;
+        const sliceAngle = val / total * 2 * Math.PI;
+        const startAngle = accumulated;
+        const endAngle = accumulated + sliceAngle;
+        accumulated += sliceAngle;
+        const x1 = Math.cos(startAngle) * r;
+        const y1 = Math.sin(startAngle) * r;
+        const x2 = Math.cos(endAngle) * r;
+        const y2 = Math.sin(endAngle) * r;
+        const largeArc = sliceAngle > Math.PI ? 1 : 0;
+        const color = FALLBACK_CHART_COLORS[idx % FALLBACK_CHART_COLORS.length];
+        return /* @__PURE__ */ jsx(
+          "path",
+          {
+            d: `M 0 0 L ${x1} ${y1} A ${r} ${r} 0 ${largeArc} 1 ${x2} ${y2} Z`,
+            fill: color,
+            className: "cursor-pointer transition-transform duration-200 hover:scale-105",
+            onMouseEnter: () => setHoveredValue(
+              `${cat}: ${val.toLocaleString()} (${Math.round(val / total * 100)}%)`
+            ),
+            onMouseLeave: () => setHoveredValue(null)
+          },
+          `pie-${idx}`
+        );
+      }),
+      isDonut && /* @__PURE__ */ jsx(
+        "circle",
+        {
+          cx: 0,
+          cy: 0,
+          r: r * 0.55,
+          className: "fill-white dark:fill-zinc-900"
+        }
+      )
+    ] });
+  };
+  return /* @__PURE__ */ jsxs("figure", { className: "nexus-chart-rendered my-6 w-full rounded-2xl border border-zinc-200 bg-white/70 p-4 backdrop-blur-md dark:border-zinc-800 dark:bg-zinc-900/60", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between mb-2", children: [
+      chart.title && /* @__PURE__ */ jsx("figcaption", { className: "text-sm font-semibold text-zinc-900 dark:text-zinc-100", children: chart.title }),
+      hoveredValue && /* @__PURE__ */ jsx("span", { className: "font-mono text-xs font-medium text-indigo-600 dark:text-indigo-400 bg-indigo-50 dark:bg-indigo-950/50 px-2 py-0.5 rounded-md", children: hoveredValue })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "w-full overflow-hidden text-zinc-700 dark:text-zinc-300", children: /* @__PURE__ */ jsx(
+      "svg",
+      {
+        viewBox: `0 0 ${width} ${height}`,
+        className: "w-full h-auto max-h-[360px] overflow-visible",
+        children: chart.chartType === "pie" || chart.chartType === "donut" ? renderPieOrDonut() : /* @__PURE__ */ jsxs(Fragment, { children: [
+          renderGridAndAxes(),
+          chart.chartType === "bar" && renderBars(),
+          chart.chartType === "line" && renderLinesOrArea(false),
+          chart.chartType === "area" && renderLinesOrArea(true)
+        ] })
+      }
+    ) }),
+    chart.showLegend && /* @__PURE__ */ jsx("div", { className: "flex flex-wrap items-center justify-center gap-3 mt-3 text-xs font-medium text-zinc-600 dark:text-zinc-400", children: (chart.chartType === "pie" || chart.chartType === "donut" ? categories : series).map((item, idx) => /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5", children: [
+      /* @__PURE__ */ jsx(
+        "span",
+        {
+          className: "h-2.5 w-2.5 rounded-full",
+          style: {
+            backgroundColor: item.color || FALLBACK_CHART_COLORS[idx % FALLBACK_CHART_COLORS.length]
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx("span", { children: item.label || item })
+    ] }, `legend-${idx}`)) }),
+    chart.sourceNote && /* @__PURE__ */ jsx("figcaption", { className: "mt-2 text-center text-xs text-zinc-400", children: chart.sourceNote })
+  ] });
+}
+function NexusRenderer({
+  content,
+  className,
+  onCommentClick,
+  onImageClick,
+  hydrateCharts = true,
+  enableImageInteraction = true,
+  documentClassName
+}) {
+  const containerRef = useRef(null);
+  const mounted = typeof window !== "undefined";
+  const preparedHTML = useMemo(
+    () => prepareDocumentHTML(content || ""),
+    [content]
+  );
+  const isEmpty = !content || content.trim() === "" || content.trim() === "<p></p>" || content.trim() === "<p><br></p>";
+  const handleDocumentClick = useCallback(
+    (event) => {
+      const target = event.target;
+      if (!(target instanceof Element)) return;
+      const commentElement = target.closest("[data-comment-id]");
+      if (commentElement && onCommentClick) {
+        const commentId = commentElement.getAttribute("data-comment-id");
+        if (commentId) {
+          event.preventDefault();
+          onCommentClick(commentId);
+          return;
+        }
+      }
+      if (enableImageInteraction && onImageClick && target instanceof HTMLImageElement) {
+        const src = target.currentSrc || target.src;
+        if (src) {
+          event.preventDefault();
+          onImageClick(src, target.alt || void 0);
+        }
+      }
+    },
+    [enableImageInteraction, onCommentClick, onImageClick]
+  );
+  const [chartTargets, setChartTargets] = useState([]);
+  const updateChartTargets = useCallback(() => {
+    if (!hydrateCharts) {
+      setChartTargets([]);
+      return;
+    }
+    const container = containerRef.current;
+    if (!container) return;
+    setChartTargets(
+      Array.from(
+        container.querySelectorAll("[data-nexus-chart]")
+      ).map((element) => ({
+        element,
+        chart: recoverChartFromElement(element)
+      }))
+    );
+  }, [hydrateCharts]);
+  useEffect(() => {
+    updateChartTargets();
+  }, [preparedHTML, updateChartTargets]);
+  if (isEmpty) {
+    return /* @__PURE__ */ jsx("p", { className: cn("text-sm italic text-zinc-500", className), children: "No descriptive data provisioned for this node." });
+  }
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "article",
+      {
+        ref: containerRef,
+        onClick: handleDocumentClick,
+        className: cn(
+          "nexus-renderer max-w-none w-full min-w-0 text-[15px] leading-7 md:text-base text-zinc-700 dark:text-zinc-300",
+          documentClassName,
+          className
+        ),
+        dangerouslySetInnerHTML: { __html: preparedHTML }
+      }
+    ),
+    mounted && hydrateCharts && chartTargets.map(
+      ({ element, chart }, index) => createPortal(
+        /* @__PURE__ */ jsx(NativeNexusChart, { chart }, `nexus-chart-${index}`),
+        element
+      )
+    )
+  ] });
+}
 
 // src/components/NexusProvider.tsx
-import React2, {
+import React3, {
   createContext as createContext2,
-  useEffect as useEffect2,
-  useRef,
-  useMemo,
-  useState as useState2,
-  useCallback as useCallback2,
+  useEffect as useEffect3,
+  useRef as useRef2,
+  useMemo as useMemo2,
+  useState as useState3,
+  useCallback as useCallback3,
   Suspense
 } from "react";
 import { usePathname, useSearchParams } from "next/navigation";
@@ -282,7 +692,7 @@ var LocalCacheProxy = class {
   async getInstance() {
     if (this.instance) return this.instance;
     if (typeof window === "undefined") {
-      const mod = await import("./local-cache-server-RM7T456Z.js");
+      const mod = await import("./local-cache-server-POO2S6OU.js");
       this.instance = new mod.LocalCache(this.cachePath);
     } else {
       const mod = await import("./local-cache-client-I6UYVJJV.js");
@@ -314,90 +724,69 @@ var LocalCacheProxy = class {
 // src/content/strategies.ts
 var RateLimiter = class {
   constructor(config) {
-    this.requests = [];
     this.config = config;
+    this.requests = [];
   }
   async checkLimit() {
     while (true) {
       const now = Date.now();
-      const windowStart = now - this.config.timeWindow;
-      this.requests = this.requests.filter((time) => time > windowStart);
+      const cutoff = now - this.config.timeWindow;
+      this.requests = this.requests.filter((t) => t > cutoff);
       if (this.requests.length < this.config.maxRequests) {
         this.requests.push(now);
         return;
       }
-      const oldestRequest = this.requests[0];
-      const waitTime = oldestRequest + this.config.timeWindow - now;
-      if (waitTime > 0) {
-        await new Promise((resolve) => setTimeout(resolve, waitTime));
-      } else {
-      }
+      await new Promise((r) => setTimeout(r, Math.max(1, this.requests[0] + this.config.timeWindow - now)));
     }
   }
   getStats() {
     const now = Date.now();
-    const windowStart = now - this.config.timeWindow;
-    const currentRequests = this.requests.filter(
-      (time) => time > windowStart
-    ).length;
-    return { currentRequests, limit: this.config.maxRequests };
+    return { currentRequests: this.requests.filter((t) => t > now - this.config.timeWindow).length, limit: this.config.maxRequests };
   }
 };
 var ExponentialBackoff = class {
   constructor(config) {
+    this.config = config;
     this.config = { jitter: true, ...config };
   }
   async execute(fn, onRetry) {
-    let lastError = new Error("Unknown error");
-    for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
+    let last;
+    for (let a = 0; a <= this.config.maxRetries; a++) {
       try {
         return await fn();
-      } catch (error) {
-        lastError = error;
-        if (this.isClientError(error) && !this.isRateLimitError(error)) {
-          throw error;
-        }
-        if (attempt === this.config.maxRetries) break;
-        const delay = this.calculateDelay(attempt);
-        if (onRetry) onRetry(attempt + 1, delay, error);
-        await new Promise((resolve) => setTimeout(resolve, delay));
+      } catch (e) {
+        last = e;
+        if (e?.code === "ABORTED" || e?.code === "VALIDATION_ERROR" || e?.status >= 400 && e?.status < 500 && e?.status !== 429) throw e;
+        if (a === this.config.maxRetries) break;
+        let delay = Math.min(this.config.maxDelay, this.config.baseDelay * 2 ** a);
+        if (this.config.jitter) delay *= 0.5 + Math.random();
+        onRetry?.(a + 1, delay, e);
+        await new Promise((r) => setTimeout(r, delay));
       }
     }
-    throw lastError;
-  }
-  calculateDelay(attempt) {
-    let delay = this.config.baseDelay * Math.pow(2, attempt);
-    delay = Math.min(delay, this.config.maxDelay);
-    if (this.config.jitter) {
-      delay = delay * (0.5 + Math.random());
-    }
-    return delay;
-  }
-  isClientError(error) {
-    return error?.status >= 400 && error?.status < 500;
-  }
-  isRateLimitError(error) {
-    return error?.status === 429;
+    throw last;
   }
 };
+var CircuitState = /* @__PURE__ */ ((CircuitState2) => {
+  CircuitState2[CircuitState2["CLOSED"] = 0] = "CLOSED";
+  CircuitState2[CircuitState2["OPEN"] = 1] = "OPEN";
+  CircuitState2[CircuitState2["HALF_OPEN"] = 2] = "HALF_OPEN";
+  return CircuitState2;
+})(CircuitState || {});
 var CircuitBreaker = class {
-  constructor() {
+  constructor(threshold = 5, reset = 3e4) {
+    this.threshold = threshold;
+    this.reset = reset;
     this.state = 0 /* CLOSED */;
     this.failures = 0;
-    this.lastFailureTime = 0;
-    this.failureThreshold = 5;
-    this.resetTimeout = 3e4;
+    this.lastFailure = 0;
   }
-  // 30 seconds
   isOpen() {
-    if (this.state === 1 /* OPEN */) {
-      if (Date.now() - this.lastFailureTime > this.resetTimeout) {
-        this.state = 2 /* HALF_OPEN */;
-        return false;
-      }
-      return true;
+    if (this.state === 1 /* OPEN */ && Date.now() - this.lastFailure >= this.reset) {
+      this.state = 2 /* HALF_OPEN */;
+      return false;
     }
-    return false;
+    return this.state === 1 /* OPEN */;
   }
   recordSuccess() {
     this.failures = 0;
@@ -405,110 +794,33 @@ var CircuitBreaker = class {
   }
   recordFailure() {
     this.failures++;
-    this.lastFailureTime = Date.now();
-    if (this.failures >= this.failureThreshold) {
-      this.state = 1 /* OPEN */;
-      if (process.env.NODE_ENV === "development") {
-        console.warn(
-          "[NexusHub] \u{1F50C} Circuit Breaker OPEN. Pausing network requests."
-        );
-      }
-    }
+    this.lastFailure = Date.now();
+    if (this.failures >= this.threshold) this.state = 1 /* OPEN */;
+  }
+  getState() {
+    return CircuitState[this.state];
   }
 };
 var RequestBatcher = class {
-  constructor(batchWindow = 10, maxBatchSize = 20) {
-    this.batchWindow = batchWindow;
+  constructor(windowMs = 10, maxBatchSize = 50) {
+    this.windowMs = windowMs;
     this.maxBatchSize = maxBatchSize;
-    this.batch = [];
-    this.processing = false;
-  }
-  async schedule(key, request) {
-    return new Promise((resolve, reject) => {
-      this.batch.push({ key, resolve, reject });
-      if (this.batch.length >= this.maxBatchSize) {
-        this.processBatch(request);
-      } else if (!this.batchTimeout) {
-        this.batchTimeout = setTimeout(
-          () => this.processBatch(request),
-          this.batchWindow
-        );
-      }
+    this.pending = /* @__PURE__ */ new Map();
+  }
+  schedule(key, request) {
+    const existing = this.pending.get(key);
+    if (existing) return existing;
+    const promise = new Promise((resolve, reject) => setTimeout(() => request().then(resolve, reject), this.windowMs));
+    this.pending.set(key, promise);
+    promise.finally(() => this.pending.delete(key)).catch(() => {
     });
+    return promise;
   }
-  async processBatch(request) {
-    if (this.processing || this.batch.length === 0) return;
-    this.processing = true;
-    if (this.batchTimeout) {
-      clearTimeout(this.batchTimeout);
-      this.batchTimeout = void 0;
-    }
-    const currentBatch = [...this.batch];
-    this.batch = [];
-    try {
-      const result = await request();
-      currentBatch.forEach((item) => item.resolve(result));
-    } catch (error) {
-      currentBatch.forEach((item) => item.reject(error));
-    } finally {
-      this.processing = false;
-      if (this.batch.length > 0) {
-        setTimeout(() => this.processBatch(request), 0);
-      }
-    }
+  clear() {
+    this.pending.clear();
   }
 };
 
-// src/content/utils.ts
-function validateSlug(slug) {
-  if (!slug || typeof slug !== "string") {
-    throw new Error("Slug must be a non-empty string");
-  }
-  if (!/^[a-z0-9-_]+$/.test(slug)) {
-    throw new Error("Slug can only contain lowercase letters, numbers, hyphens, and underscores");
-  }
-}
-function normalizeQuery(query) {
-  const normalized = { ...query };
-  normalized.page = Math.max(1, normalized.page || 1);
-  normalized.limit = Math.min(100, Math.max(1, normalized.limit || 10));
-  normalized.order = normalized.order || "desc";
-  if (normalized.page < 1) {
-    throw new Error("Page must be greater than 0");
-  }
-  if (normalized.limit < 1 || normalized.limit > 100) {
-    throw new Error("Limit must be between 1 and 100");
-  }
-  return normalized;
-}
-function buildQueryString(query) {
-  const params = new URLSearchParams();
-  if (query.page) params.append("page", query.page.toString());
-  if (query.limit) params.append("limit", query.limit.toString());
-  if (query.sort) params.append("sort", query.sort);
-  if (query.order) params.append("order", query.order);
-  if (query.search) params.append("search", query.search);
-  if (query.include?.length) {
-    params.append("include", query.include.join(","));
-  }
-  if (query.fields?.length) {
-    params.append("fields", query.fields.join(","));
-  }
-  if (query.filter) {
-    params.append("filter", JSON.stringify(query.filter));
-  }
-  return params.toString();
-}
-function measurePerformance(name, fn) {
-  const start = performance.now();
-  const result = fn();
-  const end = performance.now();
-  if (process.env.NODE_ENV === "development") {
-    console.log(`\u23F1\uFE0F ${name}: ${(end - start).toFixed(2)}ms`);
-  }
-  return { result, duration: end - start };
-}
-
 // src/content/index.ts
 var ContentEngine = class {
   constructor(config) {
@@ -541,6 +853,12 @@ var ContentEngine = class {
       window.addEventListener("beforeunload", this.cleanup.bind(this));
     }
   }
+  /** Update runtime configuration without exposing internal mutation. */
+  updateConfig(config) {
+    this.config = config;
+    this.defaultRevalidate = config.revalidateTime ?? false;
+    this.cacheStrategy = config.cacheStrategy || "memory";
+  }
   /**
    * Fetch a Single Page with full strategy pipeline
    */
@@ -699,7 +1017,7 @@ var ContentEngine = class {
     }
   }
   /**
-   * Fetch Global Settings with nested includes support
+   * Fetch Global Settings
    */
   async getGlobals(options = {}) {
     const {
@@ -751,6 +1069,9 @@ var ContentEngine = class {
         revalidate
       });
       if (!res.ok) {
+        if (res.status === 408) {
+          throw new Error("Request timeout");
+        }
         throw new Error(`API Error ${res.status}: ${res.statusText}`);
       }
       const json = await res.json();
@@ -799,12 +1120,12 @@ var ContentEngine = class {
         method: "GET",
         headers: this.getHeaders(),
         tags: fetchTags,
-        // ?? not || — see the constructor comment on defaultRevalidate for
-        // why: an explicit `revalidate: 0` on this call must not be
-        // discarded in favor of the engine's default.
         revalidate: options.revalidate ?? this.defaultRevalidate
       });
       if (!res.ok) {
+        if (res.status === 408) {
+          throw new Error("Request timeout");
+        }
         throw new Error(`API Error ${res.status}: ${res.statusText}`);
       }
       const json = await res.json();
@@ -836,12 +1157,15 @@ var ContentEngine = class {
       headers: this.getHeaders()
     });
     if (!res.ok) {
+      if (res.status === 408) {
+        throw new Error("Request timeout");
+      }
       throw new Error(`API Error ${res.status}: ${res.statusText}`);
     }
     return await res.json();
   }
   /**
-   * Prefetch content for better performance
+   * Prefetch content
    */
   async prefetch(urls) {
     if (typeof window !== "undefined" && "requestIdleCallback" in window) {
@@ -854,41 +1178,19 @@ var ContentEngine = class {
   }
   /**
    * Robust Real-time Subscriptions (SSE) with Auto-Reconnect
-   *
-   * ⚠️ SCOPE — READ BEFORE RELYING ON THIS FOR "instant" UPDATES:
-   * This connects from the BROWSER TAB it's called in, and on message it
-   * only clears THIS SDK INSTANCE's in-memory `memoryCache` (via
-   * invalidateCache below) in THAT browser tab's JS heap. In a typical
-   * Next.js deployment — and Cloudflare specifically, which is stateless
-   * per-request at the edge — that is a different process/isolate than the
-   * one that will render the NEXT server request for this content. So:
-   *   - ✅ Useful for: a client component that reads from `nexus.content`
-   *     directly in the browser and re-renders in place without a page
-   *     navigation (e.g. a live-updating dashboard widget).
-   *   - ❌ NOT sufficient for: "user A edits content in the CMS, user B's
-   *     already-loaded page updates" via a server-rendered page. That
-   *     requires the backend's /api/revalidate webhook (see
-   *     content.service.ts `pingNextRevalidateWebhook`) to have actually
-   *     cleared the *server's* Data Cache, so the NEXT navigation or
-   *     server request picks up fresh data. This SSE channel does not
-   *     replace that — it's a complementary, browser-local optimization.
-   * If your symptom was "stale content after editing," fix the webhook
-   * wiring first; treat this method as an enhancement layered on top.
    */
   subscribeToUpdates(callback) {
     if (this.isServer || typeof EventSource === "undefined") {
       if (this.config.debug) {
         console.warn(
-          "[NexusHub] subscribeToUpdates() called in a non-browser environment (server render or SSR pass) \u2014 this is expected and safely skipped; EventSource only makes sense client-side."
+          "[NexusHub] subscribeToUpdates() called in a non-browser environment."
         );
       }
       return () => {
       };
     }
     if (!this.config.apiKey) {
-      console.warn(
-        "[NexusHub] subscribeToUpdates(): no apiKey configured, the SSE connection will likely be rejected by the backend. Set NEXT_PUBLIC_NEXUS_KEY."
-      );
+      console.warn("[NexusHub] subscribeToUpdates(): no apiKey configured.");
     }
     let eventSource = null;
     let retryCount = 0;
@@ -1052,6 +1354,9 @@ var ContentEngine = class {
           `Page '${slug}' not found. Check your Dashboard or Seed data.`
         );
       }
+      if (res.status === 408) {
+        throw new Error("Request timeout");
+      }
       throw new Error(`API Error ${res.status}: ${res.statusText}`);
     }
     const json = await res.json();
@@ -1086,6 +1391,9 @@ var ContentEngine = class {
       revalidate
     });
     if (!res.ok) {
+      if (res.status === 408) {
+        throw new Error("Request timeout");
+      }
       throw new Error(`API Error ${res.status}: ${res.statusText}`);
     }
     const json = await res.json();
@@ -1172,7 +1480,6 @@ var ContentEngine = class {
       const response = await fetch(url, {
         ...fetchOptions,
         ...nextConfig,
-        // Inject Next.js tags
         signal: controller.signal
       });
       clearTimeout(id);
@@ -1185,7 +1492,8 @@ var ContentEngine = class {
   getHeaders() {
     const headers = {
       "Content-Type": "application/json",
-      "X-Nexus-Client": "client-sdk/1.0.0",
+      "X-Nexus-Client": `client-sdk/${this.config.sdkVersion ?? "1.1.0"}`,
+      "X-Nexus-Request-ID": typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : `nx_${Date.now()}_${Math.random().toString(36).slice(2)}`,
       "X-Nexus-Project": this.config.projectId
     };
     if (this.config.apiKey) {
@@ -1196,13 +1504,22 @@ var ContentEngine = class {
   isCacheValid(metadata) {
     return Date.now() < metadata.expiresAt;
   }
+  /**
+   * 🛡️ FIX: Normalizes timeout errors (AbortError, 408, or Timeout messages)
+   * into clean, standardized "Request timeout" errors.
+   */
   normalizeError(error, context) {
     if (error instanceof Error) {
-      if (error.name === "AbortError") {
+      const msg = error.message.toLowerCase();
+      if (error.name === "AbortError" || error.message.includes("408") || msg.includes("timeout") || msg.includes("aborted")) {
         return new Error(`${context}: Request timeout`);
       }
       return error;
     }
+    const str = String(error).toLowerCase();
+    if (str.includes("408") || str.includes("timeout") || str.includes("aborted")) {
+      return new Error(`${context}: Request timeout`);
+    }
     return new Error(`${context}: ${String(error)}`);
   }
   cancelRequests() {
@@ -1221,7 +1538,7 @@ var ContentEngine = class {
 
 // src/analytics/fingerprint.ts
 var cachedEntropy = null;
-var getDeviceEntropy = async () => {
+var getDeviceEntropy = async (allowFingerprinting = true) => {
   if (cachedEntropy) return cachedEntropy;
   if (typeof window === "undefined") return {};
   const nav = window.navigator;
@@ -1236,7 +1553,7 @@ var getDeviceEntropy = async () => {
     platform: nav.platform,
     language: nav.language,
     touch_support: "ontouchstart" in window || nav.maxTouchPoints > 0,
-    canvas_hash: await generateCanvasHash()
+    canvas_hash: allowFingerprinting ? await generateCanvasHash() : void 0
   };
   return cachedEntropy;
 };
@@ -1249,7 +1566,6 @@ var generateCanvasHash = async () => {
     canvas.height = 50;
     ctx.textBaseline = "top";
     ctx.font = '16px "Arial"';
-    ctx.textBaseline = "alphabetic";
     ctx.fillStyle = "#f60";
     ctx.fillRect(125, 1, 62, 20);
     ctx.fillStyle = "#069";
@@ -1268,12 +1584,12 @@ var generateCanvasHash = async () => {
     return "";
   }
 };
-var getVisitorId = async () => {
+var getVisitorId = async (allowFingerprinting = true) => {
   if (typeof window === "undefined") return "server_visitor";
   const STORAGE_KEY = "nexus_vid";
   let vid = localStorage.getItem(STORAGE_KEY);
   if (!vid) {
-    const entropy = await getDeviceEntropy();
+    const entropy = await getDeviceEntropy(allowFingerprinting);
     const random = Math.random().toString(36).substring(2, 15);
     const timestamp = Date.now().toString(36);
     const fingerprint = [
@@ -1281,7 +1597,7 @@ var getVisitorId = async () => {
       entropy.hardware_concurrency,
       entropy.timezone_offset,
       entropy.platform,
-      entropy.canvas_hash
+      entropy.canvas_hash || "standard_entropy"
     ].join("|");
     let hash = 0;
     for (let i = 0; i < fingerprint.length; i++) {
@@ -1492,7 +1808,6 @@ var EventStorage = class {
 var eventStorage = new EventStorage();
 
 // src/analytics/tracker.ts
-var SDK_VERSION = "0.1.0";
 var safeGetItem = (key) => {
   try {
     return localStorage.getItem(key);
@@ -1528,6 +1843,8 @@ var Tracker = class {
     this.visitorId = "";
     this.anonymousId = "";
     this.isFlushing = false;
+    this.flushPromise = null;
+    this.batchSize = 25;
     this.config = config;
     this.endpoint = `${this.config.analyticsUrl}/api/collect`;
     this.circuitBreaker = new CircuitBreaker();
@@ -1538,7 +1855,9 @@ var Tracker = class {
     }
   }
   async initSession() {
-    this.visitorId = await getVisitorId();
+    this.visitorId = await getVisitorId(
+      this.config.privacy?.fingerprinting ?? false
+    );
     let anonId = safeGetItem("nexus_anon_id");
     if (!anonId) {
       anonId = `anon_${generateUUID().replace(/-/g, "")}`;
@@ -1551,8 +1870,8 @@ var Tracker = class {
     const SESSION_TIMEOUT = 30 * 60 * 1e3;
     const isExpired = !sid || !lastActivity || now - parseInt(lastActivity, 10) > SESSION_TIMEOUT;
     if (isExpired) {
-      const uuid = generateUUID().replace(/-/g, "").substring(0, 16);
-      sid = `sess_${uuid}_${now}`;
+      const uuid2 = generateUUID().replace(/-/g, "").substring(0, 16);
+      sid = `sess_${uuid2}_${now}`;
       safeSetItem("nexus_sid", sid);
       this.sessionStart = now;
     }
@@ -1562,7 +1881,9 @@ var Tracker = class {
   async send(eventType, data = {}, eventName, ecommerce) {
     if (typeof window === "undefined") return;
     safeSetItem("nexus_last_active", Date.now().toString());
-    const entropy = await getDeviceEntropy();
+    const entropy = await getDeviceEntropy(
+      this.config.privacy?.fingerprinting ?? false
+    );
     const perfMetrics = vitalsCollector.getMetricsSnapshot();
     const utmParams = extractUtmParams(window.location.href);
     const payload = {
@@ -1573,6 +1894,7 @@ var Tracker = class {
       messageId: generateUUID(),
       sentAt: (/* @__PURE__ */ new Date()).toISOString(),
       version: SDK_VERSION,
+      // Dynamically synced to SDK 1.1.0
       url: window.location.href,
       referrer: document.referrer,
       userAgent: window.navigator.userAgent,
@@ -1590,8 +1912,8 @@ var Tracker = class {
           hardwareConcurrency: entropy.hardware_concurrency,
           deviceMemory: entropy.device_memory,
           pixelRatio: entropy.pixel_ratio,
-          canvasFingerprint: entropy.canvas_hash,
-          platform: entropy.platform
+          platform: entropy.platform,
+          ...this.config.privacy?.fingerprinting ? { canvasFingerprint: entropy.canvas_hash } : {}
         },
         visitorIdLocal: this.visitorId,
         utm: utmParams
@@ -1611,53 +1933,69 @@ var Tracker = class {
     });
   }
   async flushQueue(useBeacon = false) {
-    if (this.isFlushing) return;
-    if (this.circuitBreaker.isOpen()) return;
-    this.isFlushing = true;
-    try {
-      const storedEvents = await eventStorage.peek(20);
-      if (storedEvents.length === 0) {
-        this.isFlushing = false;
-        return;
-      }
-      const payloads = storedEvents.map((e) => e.payload);
-      const promises = payloads.map(
-        (event) => fetch(this.endpoint, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${this.config.apiKey}`
-          },
-          body: JSON.stringify(event),
-          keepalive: useBeacon
-        })
-      );
-      const results = await Promise.allSettled(promises);
-      const successIds = [];
-      let failureCount = 0;
-      results.forEach((res, index) => {
-        if (res.status === "fulfilled" && res.value.ok) {
-          successIds.push(storedEvents[index].id);
+    if (this.flushPromise) return this.flushPromise;
+    this.flushPromise = (async () => {
+      if (this.circuitBreaker.isOpen()) return;
+      try {
+        const storedEvents = await eventStorage.peek(this.batchSize);
+        if (!storedEvents.length) return;
+        const payloads = storedEvents.map((e) => e.payload);
+        const headers = {
+          "Content-Type": "application/json",
+          Authorization: this.config.apiKey ? `Bearer ${this.config.apiKey}` : "",
+          "X-Nexus-Client": `analytics/${SDK_VERSION}`,
+          "X-Nexus-Project": this.config.projectId
+        };
+        let response;
+        try {
+          response = await fetch(
+            `${this.config.analyticsUrl}/api/collect/batch`,
+            {
+              method: "POST",
+              headers,
+              body: JSON.stringify({ events: payloads }),
+              keepalive: useBeacon
+            }
+          );
+        } catch {
+          response = void 0;
+        }
+        if (!response || response.status === 404 || response.status === 405) {
+          const results = await Promise.allSettled(
+            payloads.map(
+              (event) => fetch(this.endpoint, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(event),
+                keepalive: useBeacon
+              })
+            )
+          );
+          const successIds = results.flatMap(
+            (r, i) => r.status === "fulfilled" && r.value.ok ? [storedEvents[i].id] : []
+          );
+          if (successIds.length) await eventStorage.remove(successIds);
+          if (successIds.length === storedEvents.length) {
+            this.circuitBreaker.recordSuccess();
+          } else {
+            this.circuitBreaker.recordFailure();
+          }
+        } else if (response.ok) {
+          await eventStorage.remove(storedEvents.map((e) => e.id));
+          this.circuitBreaker.recordSuccess();
         } else {
-          failureCount++;
+          this.circuitBreaker.recordFailure();
         }
-      });
-      if (successIds.length > 0) {
-        await eventStorage.remove(successIds);
-        this.circuitBreaker.recordSuccess();
-      }
-      if (failureCount > 0) {
+      } catch (err) {
         this.circuitBreaker.recordFailure();
+        if (this.config.debug) {
+          console.warn("[GN-Apex] Analytics flush deferred:", err);
+        }
+      } finally {
+        this.flushPromise = null;
       }
-    } catch (err) {
-      console.error("[NexusHub] Network Error:", err);
-      this.circuitBreaker.recordFailure();
-    } finally {
-      this.isFlushing = false;
-      if (!this.circuitBreaker.isOpen() && await eventStorage.count() > 0) {
-        setTimeout(() => this.flushQueue(), 100);
-      }
-    }
+    })();
+    return this.flushPromise;
   }
   getSession() {
     return this.sessionId;
@@ -1936,70 +2274,35 @@ var AnalyticsEngine = class {
   }
   setupVideoTracking() {
     if (typeof document === "undefined") return;
-    const attachVideoListeners = (video) => {
-      if (video.__nexus_tracked) return;
-      video.__nexus_tracked = true;
-      const src = video.src || video.currentSrc || "unknown";
-      let milestone50Fired = false;
-      video.addEventListener("play", () => {
-        this.tracker.send(
-          "custom_event",
-          { event_name: "video_play", src },
-          "video_play"
-        );
-      });
-      video.addEventListener("pause", () => {
-        this.tracker.send(
-          "custom_event",
-          {
-            event_name: "video_pause",
-            src,
-            position_seconds: Math.round(video.currentTime)
-          },
-          "video_pause"
-        );
-      });
+    const attach = (video) => {
+      const v = video;
+      if (v.__gnexusTracked) return;
+      v.__gnexusTracked = true;
+      v.__gnexusMilestones = /* @__PURE__ */ new Set();
+      const src = () => video.currentSrc || video.src || "unknown";
+      const emit = (name, data = {}) => this.tracker.send("media", { media_type: "video", event_name: name, src: src(), ...data }, name);
+      video.addEventListener("loadedmetadata", () => emit("video_loaded", { duration_seconds: Number.isFinite(video.duration) ? Math.round(video.duration) : void 0 }));
+      video.addEventListener("play", () => emit("video_play", { position_seconds: Math.round(video.currentTime) }));
+      video.addEventListener("pause", () => emit("video_pause", { position_seconds: Math.round(video.currentTime) }));
+      video.addEventListener("seeking", () => emit("video_seek", { position_seconds: Math.round(video.currentTime) }));
+      video.addEventListener("ended", () => emit("video_complete", { duration_seconds: Math.round(video.duration) }));
+      video.addEventListener("error", () => emit("video_error"));
       video.addEventListener("timeupdate", () => {
-        if (!video.duration || video.duration === Infinity) return;
-        const pct = video.currentTime / video.duration;
-        if (pct >= 0.5 && !milestone50Fired) {
-          milestone50Fired = true;
-          this.tracker.send(
-            "custom_event",
-            {
-              event_name: "video_50_percent",
-              src
-            },
-            "video_50_percent"
-          );
+        if (!Number.isFinite(video.duration) || video.duration <= 0) return;
+        for (const milestone of [25, 50, 75, 90, 100]) {
+          if (video.currentTime / video.duration * 100 >= milestone && !v.__gnexusMilestones.has(milestone)) {
+            v.__gnexusMilestones.add(milestone);
+            emit(`video_${milestone}_percent`, { progress: milestone / 100 });
+          }
         }
       });
-      video.addEventListener("ended", () => {
-        this.tracker.send(
-          "custom_event",
-          {
-            event_name: "video_complete",
-            src,
-            duration_seconds: Math.round(video.duration)
-          },
-          "video_complete"
-        );
-      });
     };
-    document.querySelectorAll("video").forEach((v) => attachVideoListeners(v));
-    const observer = new MutationObserver((mutations) => {
-      mutations.forEach((m) => {
-        m.addedNodes.forEach((node) => {
-          if (node instanceof HTMLVideoElement) {
-            attachVideoListeners(node);
-          }
-          if (node instanceof Element) {
-            node.querySelectorAll("video").forEach((v) => attachVideoListeners(v));
-          }
-        });
-      });
-    });
-    observer.observe(document.body, { childList: true, subtree: true });
+    document.querySelectorAll("video").forEach((v) => attach(v));
+    const observer = new MutationObserver((ms) => ms.forEach((m) => m.addedNodes.forEach((n) => {
+      if (n instanceof HTMLVideoElement) attach(n);
+      if (n instanceof Element) n.querySelectorAll("video").forEach((v) => attach(v));
+    })));
+    if (document.body) observer.observe(document.body, { childList: true, subtree: true });
     this.cleanupFns.push(() => observer.disconnect());
   }
   setupErrorTracking() {
@@ -2188,57 +2491,303 @@ function getSelector(el, depth = 0) {
   return `${parent}${self}`;
 }
 
+// src/errors.ts
+var NexusError = class extends Error {
+  constructor(message, code = "UNKNOWN", status, requestId, details, retryable = false, cause) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.requestId = requestId;
+    this.details = details;
+    this.retryable = retryable;
+    this.cause = cause;
+    this.name = "NexusError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/events.ts
+var NexusEventBus = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  on(event, listener) {
+    const set = this.listeners.get(event) ?? /* @__PURE__ */ new Set();
+    set.add(listener);
+    this.listeners.set(event, set);
+    return () => set.delete(listener);
+  }
+  emit(event, payload) {
+    this.listeners.get(event)?.forEach((l) => {
+      try {
+        l(payload);
+      } catch {
+      }
+    });
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+// src/http.ts
+var uuid = () => typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : `nx_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+var NexusHttpClient = class {
+  constructor(config, events = new NexusEventBus()) {
+    this.config = config;
+    this.events = events;
+    this.breaker = new CircuitBreaker();
+    this.limiter = new RateLimiter({
+      maxRequests: config.debug ? 200 : 100,
+      timeWindow: 6e4
+    });
+    this.backoff = new ExponentialBackoff({
+      maxRetries: config.retries ?? 3,
+      baseDelay: 150,
+      maxDelay: 8e3,
+      jitter: true
+    });
+  }
+  updateConfig(config) {
+    this.config = config;
+  }
+  async request(input, options = {}) {
+    if (this.breaker.isOpen()) {
+      throw new NexusError(
+        "GN-Apex service circuit is open",
+        "CIRCUIT_OPEN",
+        void 0,
+        void 0,
+        void 0,
+        true
+      );
+    }
+    const requestId = uuid();
+    const url = input;
+    const started = Date.now();
+    const headers = new Headers(options.headers);
+    headers.set("X-Nexus-Request-ID", requestId);
+    headers.set(
+      "X-Nexus-Client",
+      `gnexus-sdk/${this.config.sdkVersion ?? "1.1.0"}`
+    );
+    headers.set("X-Nexus-Project", this.config.projectId);
+    if (this.config.apiKey)
+      headers.set("Authorization", `Bearer ${this.config.apiKey}`);
+    this.events.emit("request:start", {
+      requestId,
+      url,
+      method: options.method ?? "GET"
+    });
+    try {
+      await this.limiter.checkLimit();
+      const response = await this.backoff.execute(async () => {
+        const controller = new AbortController();
+        const timeout = options.timeout ?? this.config.timeout ?? 1e4;
+        const timer = setTimeout(() => controller.abort(), timeout);
+        try {
+          return await fetch(url, {
+            ...options,
+            headers,
+            signal: options.signal ?? controller.signal
+          });
+        } catch (e) {
+          if (e?.name === "AbortError") {
+            throw new NexusError(
+              `Request timed out after ${timeout}ms`,
+              "TIMEOUT",
+              void 0,
+              requestId,
+              void 0,
+              true,
+              e
+            );
+          }
+          throw new NexusError(
+            "Network request failed",
+            "NETWORK_ERROR",
+            void 0,
+            requestId,
+            void 0,
+            true,
+            e
+          );
+        } finally {
+          clearTimeout(timer);
+        }
+      });
+      if (!response.ok) {
+        const retryable = response.status === 408 || response.status === 429 || response.status >= 500;
+        let details;
+        try {
+          details = await response.clone().json();
+        } catch {
+        }
+        const code = response.status === 404 ? "NOT_FOUND" : response.status === 429 ? "RATE_LIMITED" : "HTTP_ERROR";
+        const err = new NexusError(
+          `API request failed (${response.status})`,
+          code,
+          response.status,
+          response.headers.get("x-nexus-request-id") ?? requestId,
+          details,
+          retryable
+        );
+        throw err;
+      }
+      this.breaker.recordSuccess();
+      this.events.emit("request:end", {
+        requestId,
+        url,
+        status: response.status,
+        duration: Date.now() - started
+      });
+      return response;
+    } catch (e) {
+      if (e instanceof NexusError) {
+        if (e.retryable || e.status && (e.status >= 500 || e.status === 429)) {
+          this.breaker.recordFailure();
+        } else {
+          this.breaker.recordSuccess();
+        }
+      } else {
+        this.breaker.recordFailure();
+      }
+      this.events.emit("error", { error: e });
+      throw e;
+    }
+  }
+  getStats() {
+    return {
+      rateLimit: this.limiter.getStats(),
+      circuit: this.breaker.getState()
+    };
+  }
+};
+
+// src/flags.ts
+var FeatureFlags = class {
+  constructor(initial) {
+    this.values = {};
+    this.values = { ...initial };
+  }
+  set(values) {
+    this.values = { ...this.values, ...values };
+  }
+  isEnabled(key, fallback = false) {
+    const v = this.values[key];
+    return typeof v === "boolean" ? v : fallback;
+  }
+  get(key, fallback) {
+    return this.values[key] ?? fallback;
+  }
+  all() {
+    return { ...this.values };
+  }
+};
+var RemoteConfig = class {
+  constructor() {
+    this.values = {};
+  }
+  set(values) {
+    this.values = { ...this.values, ...values };
+  }
+  get(key, fallback) {
+    return this.values[key] ?? fallback;
+  }
+  all() {
+    return { ...this.values };
+  }
+};
+
+// src/diagnostics.ts
+var getDiagnostics = (version, environment) => ({ version, environment, online: typeof navigator === "undefined" ? true : navigator.onLine, userAgent: typeof navigator === "undefined" ? void 0 : navigator.userAgent, memory: typeof performance !== "undefined" && "memory" in performance ? performance.memory?.usedJSHeapSize : void 0 });
+
 // src/client.ts
-var DEFAULT_REVALIDATE_SECONDS = false;
 var NexusClient = class {
-  constructor(config) {
-    const fullConfig = getFullConfig(config);
+  constructor(config = {}) {
+    const full = getFullConfig(config);
     this.config = {
-      debug: config?.debug ?? false,
-      cacheStrategy: config?.cacheStrategy ?? "memory",
-      // Only fall through to the safe default when revalidateTime is
-      // genuinely *unset* (undefined). An explicit `false` from the caller
-      // is a deliberate "never revalidate" choice and must be respected,
-      // not silently upgraded — `??` (not `||`) is required here so that
-      // `0` (revalidate on every request) also passes through untouched
-      // instead of being treated as falsy.
-      revalidateTime: config?.revalidateTime ?? DEFAULT_REVALIDATE_SECONDS,
-      timeout: config?.timeout ?? 1e4,
-      retries: config?.retries ?? 3,
-      ...fullConfig
+      debug: false,
+      cacheStrategy: "memory",
+      revalidateTime: false,
+      timeout: 1e4,
+      retries: 3,
+      sdkVersion: SDK_VERSION,
+      cacheInvalidation: "platform",
+      environment: typeof process !== "undefined" && process.env?.NODE_ENV === "development" ? "development" : "production",
+      autoTracking: true,
+      publicKeyOnly: true,
+      // 🚀 Default: fingerprinting: true (Active by default for high-precision analytics)
+      privacy: { analytics: true, fingerprinting: true, redact: true },
+      ...full,
+      ...config
     };
     const errors = validateConfig(this.config);
-    if (errors.length > 0) {
-      console.warn("\u26A0\uFE0F NexusHub: Configuration issues:", errors.join(", "));
-      if (!this.config.projectId) {
-        console.warn("\u26A0\uFE0F NexusHub: No Project ID found. Tracking will fail.");
-      }
+    if (errors.length && this.config.debug) {
+      console.warn("[GN-Apex] Configuration warnings:", errors);
     }
+    this.events = new NexusEventBus();
+    this.http = new NexusHttpClient(this.config, this.events);
+    this.flags = new FeatureFlags();
+    this.remoteConfig = new RemoteConfig();
     this.content = new ContentEngine(this.config);
-    if (typeof window !== "undefined") {
+    if (typeof window !== "undefined" && this.config.autoTracking !== false && this.config.privacy?.analytics !== false) {
       this.analytics = new AnalyticsEngine(this.config);
       this.analytics.start();
     }
   }
   /**
-   * Helper alias for cleaner content fetching.
+   * Helper alias for cleaner page content fetching.
    */
   getPage(slug, options) {
     return this.content.getPage(slug, options);
   }
   /**
-   * Returns a readonly snapshot of the current config.
+   * Returns a readonly snapshot of the active configuration.
    */
   getConfig() {
-    return { ...this.config };
+    return Object.freeze({
+      ...this.config,
+      privacy: { ...this.config.privacy }
+    });
   }
   /**
-   * Updates specific config fields at runtime.
-   * Replaces the previous pattern of `(nexus as any).config.projectId = x`
-   * which bypassed TypeScript and mutated internal state unsafely.
+   * Updates runtime configuration dynamically without breaking active listeners.
    */
   updateConfig(updates) {
-    this.config = { ...this.config, ...updates };
+    this.config = {
+      ...this.config,
+      ...updates,
+      privacy: { ...this.config.privacy, ...updates.privacy }
+    };
+    this.http.updateConfig(this.config);
+    this.content.updateConfig?.(this.config);
+    if (typeof window !== "undefined" && this.config.autoTracking !== false && this.config.privacy?.analytics !== false && !this.analytics) {
+      this.analytics = new AnalyticsEngine(this.config);
+      this.analytics.start();
+    }
+    if (this.config.privacy?.analytics === false) {
+      this.analytics?.stop();
+    }
+  }
+  /**
+   * Returns deep system diagnostics including HTTP and cache performance.
+   */
+  diagnostics() {
+    return {
+      ...getDiagnostics(SDK_VERSION, this.config.environment ?? "production"),
+      cache: this.content.getCacheStats(),
+      http: this.http.getStats(),
+      analyticsQueue: this.analytics ? void 0 : 0
+    };
+  }
+  /**
+   * Gracefully terminates background tasks and cleans up listeners.
+   */
+  destroy() {
+    this.analytics?.stop(true);
+    this.content.cleanup?.();
+    this.events.clear();
   }
 };
 var nexus = new NexusClient();
@@ -2247,21 +2796,21 @@ var nexus = new NexusClient();
 import {
   createContext,
   useContext,
-  useEffect,
-  useState,
-  useCallback
+  useEffect as useEffect2,
+  useState as useState2,
+  useCallback as useCallback2
 } from "react";
-import { jsx } from "react/jsx-runtime";
+import { jsx as jsx2 } from "react/jsx-runtime";
 var AuthContext = createContext(null);
 var AuthProvider = ({
   children,
   config
 }) => {
-  const [user, setUser] = useState(null);
-  const [isLoading, setIsLoading] = useState(true);
-  const [error, setError] = useState(null);
+  const [user, setUser] = useState2(null);
+  const [isLoading, setIsLoading] = useState2(true);
+  const [error, setError] = useState2(null);
   const AUTH_BASE = `${config.apiUrl}/auth/project/${config.projectId}`;
-  const checkSession = useCallback(async () => {
+  const checkSession = useCallback2(async () => {
     try {
       const res = await fetch(`${AUTH_BASE}/me`, {
         headers: getHeaders(config)
@@ -2286,7 +2835,7 @@ var AuthProvider = ({
       setIsLoading(false);
     }
   }, [AUTH_BASE, config]);
-  useEffect(() => {
+  useEffect2(() => {
     checkSession();
   }, [checkSession]);
   const login = async (creds) => {
@@ -2386,7 +2935,7 @@ var AuthProvider = ({
     });
     if (!res.ok) throw await parseError(res);
   };
-  return /* @__PURE__ */ jsx(
+  return /* @__PURE__ */ jsx2(
     AuthContext.Provider,
     {
       value: {
@@ -2522,27 +3071,27 @@ var NexusPushClient = class {
 };
 
 // src/components/NexusProvider.tsx
-import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
 var NexusContext = createContext2(nexus);
 var NexusLiveFeedContext = createContext2({
   latestEvent: null,
   isConnected: false
 });
-var useNexusLiveFeed = () => React2.useContext(NexusLiveFeedContext);
+var useNexusLiveFeed = () => React3.useContext(NexusLiveFeedContext);
 function NexusAnalyticsTracker({
   disableAnalytics
 }) {
   const pathname = usePathname();
   const searchParams = useSearchParams();
-  const prevPathRef = useRef("");
+  const prevPathRef = useRef2("");
   const searchParamsString = searchParams.toString();
-  useEffect2(() => {
+  useEffect3(() => {
     if (nexus.analytics && !disableAnalytics) {
       nexus.analytics.pageView(prevPathRef.current || document.referrer);
       prevPathRef.current = pathname;
     }
   }, [pathname, searchParamsString, disableAnalytics]);
-  return /* @__PURE__ */ jsx2("div", { id: "__nexus_react_active", style: { display: "none" } });
+  return /* @__PURE__ */ jsx3("div", { id: "__nexus_react_active", style: { display: "none" } });
 }
 var NexusProvider = ({
   children,
@@ -2554,23 +3103,23 @@ var NexusProvider = ({
   autoPromptPush = true
   // 🚀 Default: true for zero-config automatic visitor subscription
 }) => {
-  const isInitialized = useRef(false);
-  const socketRef = useRef(null);
-  const [latestEvent, setLatestEvent] = useState2(
+  const isInitialized = useRef2(false);
+  const socketRef = useRef2(null);
+  const [latestEvent, setLatestEvent] = useState3(
     null
   );
-  const [isConnected, setIsConnected] = useState2(false);
-  const liveFeedValue = useMemo(
+  const [isConnected, setIsConnected] = useState3(false);
+  const liveFeedValue = useMemo2(
     () => ({ latestEvent, isConnected }),
     [latestEvent, isConnected]
   );
-  const config = useMemo(() => {
+  const config = useMemo2(() => {
     if (projectId && nexus.getConfig().projectId !== projectId) {
       nexus.updateConfig({ projectId });
     }
     return nexus.getConfig();
   }, [projectId]);
-  useEffect2(() => {
+  useEffect3(() => {
     if (typeof window === "undefined" || !("serviceWorker" in navigator))
       return;
     navigator.serviceWorker.register("/sw.js").then(async (registration) => {
@@ -2593,7 +3142,7 @@ var NexusProvider = ({
       console.warn("[NexusHub] Service Worker registration failed:", err);
     });
   }, [autoPromptPush]);
-  useEffect2(() => {
+  useEffect3(() => {
     if (typeof window === "undefined" || disableAnalytics || !hasConsent)
       return;
     if (!isInitialized.current) {
@@ -2613,7 +3162,7 @@ var NexusProvider = ({
       }
     };
   }, [disableAnalytics, hasConsent]);
-  const connectLiveFeed = useCallback2(async () => {
+  const connectLiveFeed = useCallback3(async () => {
     if (typeof window === "undefined" || !enableLiveFeed) return;
     try {
       const { io } = await import("socket.io-client");
@@ -2643,7 +3192,7 @@ var NexusProvider = ({
       console.error("[NexusHub] Live feed connection failed:", err);
     }
   }, [enableLiveFeed, onLiveEvent]);
-  useEffect2(() => {
+  useEffect3(() => {
     if (enableLiveFeed) {
       connectLiveFeed();
     }
@@ -2655,13 +3204,13 @@ var NexusProvider = ({
       }
     };
   }, [enableLiveFeed, connectLiveFeed]);
-  return /* @__PURE__ */ jsx2(NexusContext.Provider, { value: nexus, children: /* @__PURE__ */ jsx2(NexusLiveFeedContext.Provider, { value: liveFeedValue, children: /* @__PURE__ */ jsxs(AuthProvider, { config, children: [
-    /* @__PURE__ */ jsx2(Suspense, { fallback: null, children: /* @__PURE__ */ jsx2(NexusAnalyticsTracker, { disableAnalytics }) }),
+  return /* @__PURE__ */ jsx3(NexusContext.Provider, { value: nexus, children: /* @__PURE__ */ jsx3(NexusLiveFeedContext.Provider, { value: liveFeedValue, children: /* @__PURE__ */ jsxs2(AuthProvider, { config, children: [
+    /* @__PURE__ */ jsx3(Suspense, { fallback: null, children: /* @__PURE__ */ jsx3(NexusAnalyticsTracker, { disableAnalytics }) }),
     children
   ] }) }) });
 };
 var useNexus = () => {
-  const context = React2.useContext(NexusContext);
+  const context = React3.useContext(NexusContext);
   if (!context) {
     throw new Error("useNexus must be used within a NexusProvider");
   }
@@ -2696,26 +3245,56 @@ var useNexusAnalytics = () => {
 };
 
 // src/components/NexusRenders.tsx
-import { useState as useState3 } from "react";
+import { useState as useState4 } from "react";
 import * as LucideIcons from "lucide-react";
-import { Fragment, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
-function NexusRichText({ value, className = "" }) {
+import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function sanitizeHtml(html) {
+  if (!html) return "";
+  if (typeof window === "undefined") {
+    return html.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "").replace(/<noscript\b[^<]*(?:(?!<\/noscript>)<[^<]*)*<\/noscript>/gi, "").replace(/\bon\w+\s*=\s*(?:'[^']*'|"[^"]*"|[^\s>]+)/gi, "").replace(/href\s*=\s*['"]\s*javascript:[^'"]*['"]/gi, 'href="#"').replace(/src\s*=\s*['"]\s*javascript:[^'"]*['"]/gi, 'src=""');
+  }
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, "text/html");
+  doc.querySelectorAll("script, noscript").forEach((n) => n.remove());
+  doc.querySelectorAll("*").forEach((el) => {
+    [...el.attributes].forEach((attr) => {
+      if (attr.name.toLowerCase().startsWith("on")) {
+        el.removeAttribute(attr.name);
+      }
+    });
+    const href = el.getAttribute("href");
+    const src = el.getAttribute("src");
+    if (href && /^\s*javascript:/i.test(href)) el.removeAttribute("href");
+    if (src && /^\s*javascript:/i.test(src)) el.removeAttribute("src");
+  });
+  return doc.body.innerHTML;
+}
+function NexusRichText({
+  value,
+  className = "",
+  hydrateCharts = true,
+  onCommentClick,
+  onImageClick
+}) {
   if (!value) return null;
-  return /* @__PURE__ */ jsx3(
-    "div",
+  return /* @__PURE__ */ jsx4(
+    NexusRenderer,
     {
-      className: `prose dark:prose-invert max-w-none text-foreground leading-relaxed ${className}`,
-      dangerouslySetInnerHTML: { __html: value }
+      content: value,
+      className,
+      hydrateCharts,
+      onCommentClick,
+      onImageClick
     }
   );
 }
 function NexusLongText({ value, className = "" }) {
   if (!value) return null;
-  return /* @__PURE__ */ jsx3(
+  return /* @__PURE__ */ jsx4(
     "p",
     {
       className: `text-sm text-muted-foreground whitespace-pre-line leading-relaxed ${className}`,
-      dangerouslySetInnerHTML: { __html: value }
+      dangerouslySetInnerHTML: { __html: sanitizeHtml(value) }
     }
   );
 }
@@ -2729,9 +3308,9 @@ function NexusIcon({
   const IconComponent = LucideIcons[name];
   if (!IconComponent) {
     const Fallback = LucideIcons.HelpCircle;
-    return /* @__PURE__ */ jsx3(Fallback, { className, size, strokeWidth });
+    return /* @__PURE__ */ jsx4(Fallback, { className, size, strokeWidth });
   }
-  return /* @__PURE__ */ jsx3(
+  return /* @__PURE__ */ jsx4(
     IconComponent,
     {
       className,
@@ -2752,11 +3331,13 @@ function NexusImage({
   if (!imageUrl) return null;
   return (
     /* eslint-disable-next-line @next/next/no-img-element */
-    /* @__PURE__ */ jsx3(
+    /* @__PURE__ */ jsx4(
       "img",
       {
         src: imageUrl,
         alt: imageAlt,
+        loading: "lazy",
+        decoding: "async",
         className: `max-w-full h-auto object-cover rounded-xl ${className}`,
         ...props
       }
@@ -2769,15 +3350,15 @@ function NexusGallery({
   imageClassName = ""
 }) {
   if (!value || value.length === 0) return null;
-  return /* @__PURE__ */ jsx3(
+  return /* @__PURE__ */ jsx4(
     "div",
     {
       className: `grid grid-cols-2 md:grid-cols-3 lg:grid-cols-4 gap-4 ${className}`,
-      children: value.map((img, idx) => /* @__PURE__ */ jsx3(
+      children: value.map((img, idx) => /* @__PURE__ */ jsx4(
         "div",
         {
           className: "overflow-hidden rounded-xl aspect-square bg-muted/20 border border-border",
-          children: /* @__PURE__ */ jsx3(
+          children: /* @__PURE__ */ jsx4(
             NexusImage,
             {
               value: img,
@@ -2799,8 +3380,8 @@ function NexusVideo({
   const isYouTube = value.includes("youtube.com") || value.includes("youtu.be");
   const isVimeo = value.includes("vimeo.com");
   if (isYouTube) {
-    const videoId = value.includes("youtu.be") ? value.split("/").pop() : value.split("v=")[1]?.split("&")[0];
-    return /* @__PURE__ */ jsx3(
+    const videoId = value.includes("youtu.be") ? value.split("/").pop()?.split("?")[0] : value.split("v=")[1]?.split("&")[0];
+    return /* @__PURE__ */ jsx4(
       "iframe",
       {
         src: `https://www.youtube.com/embed/${videoId}?autoplay=${autoplay ? 1 : 0}`,
@@ -2812,8 +3393,8 @@ function NexusVideo({
     );
   }
   if (isVimeo) {
-    const videoId = value.split("/").pop();
-    return /* @__PURE__ */ jsx3(
+    const videoId = value.split("/").pop()?.split("?")[0];
+    return /* @__PURE__ */ jsx4(
       "iframe",
       {
         src: `https://player.vimeo.com/video/${videoId}?autoplay=${autoplay ? 1 : 0}`,
@@ -2824,7 +3405,7 @@ function NexusVideo({
       }
     );
   }
-  return /* @__PURE__ */ jsx3(
+  return /* @__PURE__ */ jsx4(
     "video",
     {
       src: value,
@@ -2842,11 +3423,11 @@ function NexusMap({ value, className = "" }) {
     value.address || `${value.lat},${value.lng}`
   );
   const embedUrl = `https://maps.google.com/maps?q=${query}&t=&z=13&ie=UTF8&iwloc=&output=embed`;
-  return /* @__PURE__ */ jsx3(
+  return /* @__PURE__ */ jsx4(
     "div",
     {
       className: `overflow-hidden rounded-xl border border-border aspect-video w-full ${className}`,
-      children: /* @__PURE__ */ jsx3(
+      children: /* @__PURE__ */ jsx4(
         "iframe",
         {
           title: "Embedded Map",
@@ -2867,15 +3448,15 @@ function NexusColor({
   showHexLabel = true
 }) {
   if (!value) return null;
-  return /* @__PURE__ */ jsxs2("div", { className: `flex items-center gap-2.5 ${className}`, children: [
-    /* @__PURE__ */ jsx3(
+  return /* @__PURE__ */ jsxs3("div", { className: `flex items-center gap-2.5 ${className}`, children: [
+    /* @__PURE__ */ jsx4(
       "div",
       {
         className: "h-6 w-6 rounded-full border border-border/80 shadow-xs shrink-0",
         style: { backgroundColor: value }
       }
     ),
-    showHexLabel && /* @__PURE__ */ jsx3("span", { className: "font-mono text-xs font-semibold text-foreground/80 uppercase", children: value })
+    showHexLabel && /* @__PURE__ */ jsx4("span", { className: "font-mono text-xs font-semibold text-foreground/80 uppercase", children: value })
   ] });
 }
 function NexusGradient({
@@ -2884,9 +3465,9 @@ function NexusGradient({
   className = "",
   asTextMask = false
 }) {
-  if (!value) return /* @__PURE__ */ jsx3(Fragment, { children });
+  if (!value) return /* @__PURE__ */ jsx4(Fragment2, { children });
   if (asTextMask) {
-    return /* @__PURE__ */ jsx3(
+    return /* @__PURE__ */ jsx4(
       "span",
       {
         className: `bg-clip-text text-transparent font-bold ${className}`,
@@ -2895,7 +3476,7 @@ function NexusGradient({
       }
     );
   }
-  return /* @__PURE__ */ jsx3(
+  return /* @__PURE__ */ jsx4(
     "div",
     {
       className: `rounded-xl ${className}`,
@@ -2912,26 +3493,26 @@ function NexusAddress({ value, className = "" }) {
     value.country
   ].filter(Boolean);
   if (lines.length === 0) return null;
-  return /* @__PURE__ */ jsxs2(
+  return /* @__PURE__ */ jsxs3(
     "div",
     {
       className: `flex items-start gap-2.5 p-3 rounded-xl border border-border bg-card/50 ${className}`,
       children: [
-        /* @__PURE__ */ jsx3(LucideIcons.MapPin, { className: "h-4 w-4 text-muted-foreground shrink-0 mt-0.5" }),
-        /* @__PURE__ */ jsx3("div", { className: "text-xs text-foreground/80 leading-relaxed font-medium", children: lines.map((line, i) => /* @__PURE__ */ jsx3("div", { children: line }, i)) })
+        /* @__PURE__ */ jsx4(LucideIcons.MapPin, { className: "h-4 w-4 text-muted-foreground shrink-0 mt-0.5" }),
+        /* @__PURE__ */ jsx4("div", { className: "text-xs text-foreground/80 leading-relaxed font-medium", children: lines.map((line, i) => /* @__PURE__ */ jsx4("div", { children: line }, i)) })
       ]
     }
   );
 }
 function NexusKeyValue({ value, className = "" }) {
   if (!value || Object.keys(value).length === 0) return null;
-  return /* @__PURE__ */ jsx3(
+  return /* @__PURE__ */ jsx4(
     "div",
     {
       className: `border border-border rounded-xl overflow-hidden bg-card/30 divide-y divide-border ${className}`,
-      children: Object.entries(value).map(([k, v]) => /* @__PURE__ */ jsxs2("div", { className: "flex text-xs px-4 py-3 gap-4", children: [
-        /* @__PURE__ */ jsx3("div", { className: "w-1/3 font-bold text-muted-foreground select-none uppercase tracking-wider text-[10px]", children: k }),
-        /* @__PURE__ */ jsx3("div", { className: "flex-1 font-medium text-foreground", children: v })
+      children: Object.entries(value).map(([k, v]) => /* @__PURE__ */ jsxs3("div", { className: "flex text-xs px-4 py-3 gap-4", children: [
+        /* @__PURE__ */ jsx4("div", { className: "w-1/3 font-bold text-muted-foreground select-none uppercase tracking-wider text-[10px]", children: k }),
+        /* @__PURE__ */ jsx4("div", { className: "flex-1 font-medium text-foreground", children: v })
       ] }, k))
     }
   );
@@ -2942,7 +3523,7 @@ function NexusTags({
   badgeClassName = ""
 }) {
   if (!value || value.length === 0) return null;
-  return /* @__PURE__ */ jsx3("div", { className: `flex flex-wrap gap-1.5 ${className}`, children: value.map((tag) => /* @__PURE__ */ jsx3(
+  return /* @__PURE__ */ jsx4("div", { className: `flex flex-wrap gap-1.5 ${className}`, children: value.map((tag) => /* @__PURE__ */ jsx4(
     "span",
     {
       className: `inline-flex items-center rounded-lg border border-border bg-muted/40 px-2.5 py-1 text-xs font-semibold text-foreground/80 ${badgeClassName}`,
@@ -2958,8 +3539,8 @@ function NexusProgress({
   color = "bg-primary"
 }) {
   if (value === null) return null;
-  const percent = Math.min(value / max * 100, 100);
-  return /* @__PURE__ */ jsx3("div", { className: `w-full ${className}`, children: /* @__PURE__ */ jsx3("div", { className: "h-2 w-full rounded-full bg-muted overflow-hidden border border-border/30", children: /* @__PURE__ */ jsx3(
+  const percent = Math.min(Math.max(value / max * 100, 0), 100);
+  return /* @__PURE__ */ jsx4("div", { className: `w-full ${className}`, children: /* @__PURE__ */ jsx4("div", { className: "h-2 w-full rounded-full bg-muted overflow-hidden border border-border/30", children: /* @__PURE__ */ jsx4(
     "div",
     {
       className: `h-full rounded-full transition-all duration-500 ${color}`,
@@ -2973,7 +3554,7 @@ function NexusBlendContainer({
   className = ""
 }) {
   const blendStyle = mode ? { mixBlendMode: mode } : {};
-  return /* @__PURE__ */ jsx3("div", { className, style: blendStyle, children });
+  return /* @__PURE__ */ jsx4("div", { className, style: blendStyle, children });
 }
 function NexusCode({
   value,
@@ -2981,39 +3562,54 @@ function NexusCode({
   className = "",
   showLineNumbers = false
 }) {
-  const [copied, setCopied] = useState3(false);
+  const [copied, setCopied] = useState4(false);
   if (!value) return null;
   const handleCopy = () => {
-    navigator.clipboard.writeText(value);
+    if (navigator.clipboard && window.isSecureContext) {
+      navigator.clipboard.writeText(value);
+    } else {
+      const textArea = document.createElement("textarea");
+      textArea.value = value;
+      textArea.style.position = "fixed";
+      textArea.style.left = "-999999px";
+      document.body.appendChild(textArea);
+      textArea.focus();
+      textArea.select();
+      try {
+        document.execCommand("copy");
+      } catch {
+      }
+      textArea.remove();
+    }
     setCopied(true);
     setTimeout(() => setCopied(false), 2e3);
   };
   const lines = value.split("\n");
-  return /* @__PURE__ */ jsxs2(
+  return /* @__PURE__ */ jsxs3(
     "div",
     {
       className: `relative rounded-xl border border-border bg-[#090A0F] overflow-hidden ${className}`,
       children: [
-        /* @__PURE__ */ jsxs2("div", { className: "flex items-center justify-between px-4 py-2 border-b border-border bg-white/2 select-none", children: [
-          /* @__PURE__ */ jsx3("span", { className: "text-[10px] font-black uppercase text-muted-foreground tracking-wider", children: language }),
-          /* @__PURE__ */ jsx3(
+        /* @__PURE__ */ jsxs3("div", { className: "flex items-center justify-between px-4 py-2 border-b border-border bg-white/2 select-none", children: [
+          /* @__PURE__ */ jsx4("span", { className: "text-[10px] font-black uppercase text-muted-foreground tracking-wider", children: language }),
+          /* @__PURE__ */ jsx4(
             "button",
             {
               onClick: handleCopy,
               className: "flex items-center gap-1.5 text-[10px] font-bold text-muted-foreground hover:text-primary transition-colors cursor-pointer",
-              children: copied ? /* @__PURE__ */ jsxs2(Fragment, { children: [
-                /* @__PURE__ */ jsx3(LucideIcons.Check, { className: "h-3 w-3 text-emerald-400" }),
-                /* @__PURE__ */ jsx3("span", { className: "text-emerald-400", children: "Copied!" })
-              ] }) : /* @__PURE__ */ jsxs2(Fragment, { children: [
-                /* @__PURE__ */ jsx3(LucideIcons.Copy, { className: "h-3 w-3" }),
-                /* @__PURE__ */ jsx3("span", { children: "Copy Code" })
+              children: copied ? /* @__PURE__ */ jsxs3(Fragment2, { children: [
+                /* @__PURE__ */ jsx4(LucideIcons.Check, { className: "h-3 w-3 text-emerald-400" }),
+                /* @__PURE__ */ jsx4("span", { className: "text-emerald-400", children: "Copied!" })
+              ] }) : /* @__PURE__ */ jsxs3(Fragment2, { children: [
+                /* @__PURE__ */ jsx4(LucideIcons.Copy, { className: "h-3 w-3" }),
+                /* @__PURE__ */ jsx4("span", { children: "Copy Code" })
               ] })
             }
           )
         ] }),
-        /* @__PURE__ */ jsxs2("div", { className: "flex overflow-x-auto p-4 font-mono text-[11px] leading-relaxed text-emerald-400 select-text", children: [
-          showLineNumbers && /* @__PURE__ */ jsx3("div", { className: "flex flex-col text-right text-gray-600 select-none pr-3.5 border-r border-border/30 mr-3.5", children: lines.map((_, i) => /* @__PURE__ */ jsx3("span", { children: i + 1 }, i)) }),
-          /* @__PURE__ */ jsx3("pre", { className: "flex-1 whitespace-pre", children: value })
+        /* @__PURE__ */ jsxs3("div", { className: "flex overflow-x-auto p-4 font-mono text-[11px] leading-relaxed text-emerald-400 select-text", children: [
+          showLineNumbers && /* @__PURE__ */ jsx4("div", { className: "flex flex-col text-right text-gray-600 select-none pr-3.5 border-r border-border/30 mr-3.5", children: lines.map((_, i) => /* @__PURE__ */ jsx4("span", { children: i + 1 }, i)) }),
+          /* @__PURE__ */ jsx4("pre", { className: "flex-1 whitespace-pre", children: value })
         ] })
       ]
     }
@@ -3026,12 +3622,12 @@ function NexusBoolean({
   falseLabel = "Inactive"
 }) {
   if (value === null) return null;
-  return /* @__PURE__ */ jsxs2(
+  return /* @__PURE__ */ jsxs3(
     "span",
     {
       className: `inline-flex items-center gap-1.5 rounded-full px-2.5 py-1 text-[10px] font-black uppercase tracking-wider border shadow-sm ${value ? "border-emerald-500/20 bg-emerald-500/10 text-emerald-400" : "border-muted-foreground/20 bg-muted-foreground/10 text-muted-foreground"} ${className}`,
       children: [
-        /* @__PURE__ */ jsx3(
+        /* @__PURE__ */ jsx4(
           "span",
           {
             className: `h-1.5 w-1.5 rounded-full ${value ? "bg-emerald-500 animate-pulse" : "bg-muted-foreground"}`
@@ -3058,6 +3654,7 @@ export {
   NexusMap,
   NexusProgress,
   NexusProvider,
+  NexusRenderer,
   NexusRichText,
   NexusTags,
   NexusVideo,