@nexushub/client 0.4.2 → 0.4.3

package/dist/react.js

@@ -1,12 +1,2619 @@
-"use client";
+// src/components/NexusProvider.tsx
+import React2, {
+  createContext as createContext2,
+  useEffect as useEffect2,
+  useRef,
+  useMemo,
+  useState as useState2,
+  useCallback as useCallback2,
+  Suspense
+} from "react";
+import { usePathname, useSearchParams } from "next/navigation";
+
+// src/config.ts
+var DEFAULT_API_URL = "https://endpoints.gnexus.co.tz";
+var DEFAULT_ANALYTICS_URL = "https://sentry.gnexus.co.tz";
+var LOCAL_NEST_URL = "https://endpoints.gnexus.co.tz";
+var LOCAL_RUST_URL = "https://sentry.gnexus.co.tz";
+var getEnvConfig = () => {
+  const NEXT_PUBLIC_ID = typeof process !== "undefined" ? process.env.NEXT_PUBLIC_NEXUS_ID : void 0;
+  const NEXT_PUBLIC_KEY = typeof process !== "undefined" ? process.env.NEXT_PUBLIC_NEXUS_KEY : void 0;
+  const NEXT_PUBLIC_URL = typeof process !== "undefined" ? process.env.NEXT_PUBLIC_NEXUS_API_URL : void 0;
+  const NODE_ID = typeof process !== "undefined" ? process.env.NEXUS_PROJECT_ID : void 0;
+  const NODE_KEY = typeof process !== "undefined" ? process.env.NEXUS_API_KEY : void 0;
+  const NODE_URL = typeof process !== "undefined" ? process.env.NEXUS_API_URL : void 0;
+  const NODE_ENV = typeof process !== "undefined" ? process.env.NODE_ENV : "production";
+  const isDev = NODE_ENV === "development" || typeof window !== "undefined" && window.location.hostname === "localhost";
+  const projectId = NEXT_PUBLIC_ID ?? NODE_ID;
+  const apiKey = NEXT_PUBLIC_KEY ?? NODE_KEY;
+  const apiUrl = NEXT_PUBLIC_URL ?? NODE_URL ?? (isDev ? LOCAL_NEST_URL : DEFAULT_API_URL);
+  const analyticsUrl = apiUrl.includes("localhost") ? LOCAL_RUST_URL : DEFAULT_ANALYTICS_URL;
+  return {
+    projectId,
+    apiKey,
+    apiUrl,
+    analyticsUrl
+  };
+};
+var mergeConfigs = (base, override) => {
+  const mergedApiUrl = override.apiUrl || base.apiUrl || DEFAULT_API_URL;
+  const mergedAnalyticsUrl = override.analyticsUrl || base.analyticsUrl || (mergedApiUrl.includes("localhost") ? LOCAL_RUST_URL : DEFAULT_ANALYTICS_URL);
+  return {
+    ...base,
+    ...override,
+    apiUrl: mergedApiUrl,
+    analyticsUrl: mergedAnalyticsUrl,
+    projectId: override.projectId || base.projectId,
+    apiKey: override.apiKey || base.apiKey
+  };
+};
+var getFullConfig = (partialConfig) => {
+  const envConfig = getEnvConfig();
+  return mergeConfigs(envConfig, partialConfig || {});
+};
+var validateConfig = (config) => {
+  const errors = [];
+  if (!config.projectId) errors.push("Missing projectId");
+  if (!config.apiUrl) errors.push("Missing apiUrl");
+  return errors;
+};
+
+// src/content/cache-implementations.ts
+var CacheTags = {
+  project: (projectId) => `nexus_project_${projectId}`,
+  content: (slug) => `content_${slug}`,
+  collection: (collectionId) => `collection_${collectionId}`,
+  global: "nexus_global_config",
+  user: (userId) => `user_${userId}`,
+  media: (mediaId) => `media_${mediaId}`
+};
+var MemoryCache = class {
+  constructor(options = {}) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.tagIndex = /* @__PURE__ */ new Map();
+    this.stats = {
+      size: 0,
+      hits: 0,
+      misses: 0,
+      hitRate: 0,
+      evictions: 0
+    };
+    this.maxSize = options.maxSize || 1e3;
+    this.defaultTTL = options.ttl || 5 * 60 * 1e3;
+  }
+  set(key, data, options = {}) {
+    if (this.cache.size >= this.maxSize) {
+      this.evictLRU();
+    }
+    const metadata = {
+      timestamp: Date.now(),
+      expiresAt: Date.now() + (options.ttl || this.defaultTTL),
+      tags: options.tags || [],
+      size: this.calculateSize(data)
+    };
+    this.cache.set(key, { data, metadata });
+    this.stats.size = this.cache.size;
+    metadata.tags.forEach((tag) => {
+      if (!this.tagIndex.has(tag)) {
+        this.tagIndex.set(tag, /* @__PURE__ */ new Set());
+      }
+      this.tagIndex.get(tag).add(key);
+    });
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      this.stats.misses++;
+      this.updateHitRate();
+      return null;
+    }
+    if (Date.now() > entry.metadata.expiresAt) {
+      this.delete(key);
+      this.stats.misses++;
+      this.updateHitRate();
+      return null;
+    }
+    entry.metadata.timestamp = Date.now();
+    this.stats.hits++;
+    this.updateHitRate();
+    return entry;
+  }
+  delete(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+    entry.metadata.tags.forEach((tag) => {
+      const keys = this.tagIndex.get(tag);
+      if (keys) {
+        keys.delete(key);
+        if (keys.size === 0) {
+          this.tagIndex.delete(tag);
+        }
+      }
+    });
+    this.cache.delete(key);
+    this.stats.size = this.cache.size;
+    return true;
+  }
+  invalidateByTags(tags) {
+    const keysToDelete = /* @__PURE__ */ new Set();
+    tags.forEach((tag) => {
+      const keys = this.tagIndex.get(tag);
+      if (keys) {
+        keys.forEach((key) => keysToDelete.add(key));
+        this.tagIndex.delete(tag);
+      }
+    });
+    keysToDelete.forEach((key) => this.delete(key));
+    if (process.env.NODE_ENV === "development") {
+      console.log(
+        `[MemoryCache] Invalidated ${keysToDelete.size} entries by tags: ${tags.join(", ")}`
+      );
+    }
+  }
+  clear() {
+    this.cache.clear();
+    this.tagIndex.clear();
+    this.stats = {
+      size: 0,
+      hits: 0,
+      misses: 0,
+      hitRate: 0,
+      evictions: 0
+    };
+  }
+  getStats() {
+    return { ...this.stats };
+  }
+  evictLRU() {
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.metadata.timestamp < oldestTime) {
+        oldestTime = entry.metadata.timestamp;
+        oldestKey = key;
+      }
+    }
+    if (oldestKey) {
+      this.delete(oldestKey);
+      this.stats.evictions++;
+    }
+  }
+  calculateSize(data) {
+    try {
+      const jsonString = JSON.stringify(data);
+      return new Blob([jsonString]).size;
+    } catch {
+      return 0;
+    }
+  }
+  updateHitRate() {
+    const total = this.stats.hits + this.stats.misses;
+    this.stats.hitRate = total > 0 ? this.stats.hits / total : 0;
+  }
+};
+var BrowserCache = class {
+  constructor(projectId) {
+    this.projectId = projectId;
+    this.prefix = "nexushub_";
+    this.maxSize = 5 * 1024 * 1024;
+    // 5MB standard LocalStorage limit
+    this.currentSize = 0;
+    if (typeof window !== "undefined") {
+      this.calculateCurrentSize();
+    }
+  }
+  set(key, data, ttl = 5 * 60 * 1e3) {
+    if (typeof window === "undefined") return;
+    const storageKey = this.getStorageKey(key);
+    const entry = {
+      data,
+      metadata: {
+        timestamp: Date.now(),
+        expiresAt: Date.now() + ttl,
+        size: this.calculateStorageSize(data)
+      }
+    };
+    const serialized = JSON.stringify(entry);
+    const newSize = new Blob([serialized]).size;
+    if (this.currentSize + newSize > this.maxSize) {
+      this.evictOldest();
+    }
+    try {
+      localStorage.setItem(storageKey, serialized);
+      this.currentSize += newSize;
+    } catch (error) {
+      console.warn("[BrowserCache] Failed to save to localStorage:", error);
+      this.evictOldest();
+      try {
+        localStorage.setItem(storageKey, serialized);
+      } catch (e) {
+      }
+    }
+  }
+  get(key) {
+    if (typeof window === "undefined") return null;
+    const storageKey = this.getStorageKey(key);
+    const item = localStorage.getItem(storageKey);
+    if (!item) return null;
+    try {
+      const entry = JSON.parse(item);
+      if (Date.now() > entry.metadata.expiresAt) {
+        this.delete(key);
+        return null;
+      }
+      return entry.data;
+    } catch {
+      this.delete(key);
+      return null;
+    }
+  }
+  delete(key) {
+    if (typeof window === "undefined") return;
+    const storageKey = this.getStorageKey(key);
+    const item = localStorage.getItem(storageKey);
+    if (item) {
+      this.currentSize -= new Blob([item]).size;
+    }
+    localStorage.removeItem(storageKey);
+  }
+  clear() {
+    if (typeof window === "undefined") return;
+    const keysToRemove = [];
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key?.startsWith(this.prefix)) {
+        keysToRemove.push(key);
+      }
+    }
+    keysToRemove.forEach((key) => localStorage.removeItem(key));
+    this.currentSize = 0;
+  }
+  getStorageKey(key) {
+    return `${this.prefix}${this.projectId}_${key}`;
+  }
+  calculateCurrentSize() {
+    this.currentSize = 0;
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key?.startsWith(this.prefix)) {
+        const item = localStorage.getItem(key);
+        if (item) {
+          this.currentSize += new Blob([item]).size;
+        }
+      }
+    }
+  }
+  calculateStorageSize(data) {
+    return new Blob([JSON.stringify(data)]).size;
+  }
+  evictOldest() {
+    let oldestKey = null;
+    let oldestTime = Infinity;
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key?.startsWith(this.prefix)) {
+        const item = localStorage.getItem(key);
+        if (item) {
+          try {
+            const entry = JSON.parse(item);
+            if (entry.metadata.timestamp < oldestTime) {
+              oldestTime = entry.metadata.timestamp;
+              oldestKey = key;
+            }
+          } catch {
+            localStorage.removeItem(key);
+          }
+        }
+      }
+    }
+    if (oldestKey) {
+      const item = localStorage.getItem(oldestKey);
+      if (item) {
+        this.currentSize -= new Blob([item]).size;
+      }
+      localStorage.removeItem(oldestKey);
+    }
+  }
+};
+
+// src/content/cache.ts
+var LocalCacheProxy = class {
+  constructor(cachePath) {
+    this.instance = null;
+    this.cachePath = cachePath;
+  }
+  async getInstance() {
+    if (this.instance) return this.instance;
+    if (typeof window === "undefined") {
+      const mod = await import("./local-cache-server-DBJWR7HD.js");
+      this.instance = new mod.LocalCache(this.cachePath);
+    } else {
+      const mod = await import("./local-cache-client-I6UYVJJV.js");
+      this.instance = new mod.LocalCache(this.cachePath);
+    }
+    return this.instance;
+  }
+  isLoaded() {
+    return this.instance?.isLoaded() || false;
+  }
+  async getPage(slug) {
+    const inst = await this.getInstance();
+    return inst.getPage(slug);
+  }
+  async getCollection(id) {
+    const inst = await this.getInstance();
+    return inst.getCollection(id);
+  }
+  async getGlobals() {
+    const inst = await this.getInstance();
+    return inst.getGlobals();
+  }
+  async getAllData() {
+    const inst = await this.getInstance();
+    return inst.getAllData();
+  }
+};
+
+// src/content/strategies.ts
+var RateLimiter = class {
+  constructor(config) {
+    this.requests = [];
+    this.config = config;
+  }
+  async checkLimit() {
+    while (true) {
+      const now = Date.now();
+      const windowStart = now - this.config.timeWindow;
+      this.requests = this.requests.filter((time) => time > windowStart);
+      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 {
+      }
+    }
+  }
+  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 };
+  }
+};
+var ExponentialBackoff = class {
+  constructor(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++) {
+      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));
+      }
+    }
+    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;
+  }
+};
+var CircuitBreaker = class {
+  constructor() {
+    this.state = 0 /* CLOSED */;
+    this.failures = 0;
+    this.lastFailureTime = 0;
+    this.failureThreshold = 5;
+    this.resetTimeout = 3e4;
+  }
+  // 30 seconds
+  isOpen() {
+    if (this.state === 1 /* OPEN */) {
+      if (Date.now() - this.lastFailureTime > this.resetTimeout) {
+        this.state = 2 /* HALF_OPEN */;
+        return false;
+      }
+      return true;
+    }
+    return false;
+  }
+  recordSuccess() {
+    this.failures = 0;
+    this.state = 0 /* CLOSED */;
+  }
+  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."
+        );
+      }
+    }
+  }
+};
+var RequestBatcher = class {
+  constructor(batchWindow = 10, maxBatchSize = 20) {
+    this.batchWindow = batchWindow;
+    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
+        );
+      }
+    });
+  }
+  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);
+      }
+    }
+  }
+};
+
+// 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) {
+    this.config = config;
+    this.isServer = typeof window === "undefined";
+    this.localCache = new LocalCacheProxy();
+    this.memoryCache = new MemoryCache({
+      maxSize: 500,
+      ttl: 5 * 60 * 1e3
+      // 5 minutes
+    });
+    if (!this.isServer) {
+      this.browserCache = new BrowserCache(config.projectId);
+    }
+    this.rateLimiter = new RateLimiter({
+      maxRequests: config.debug ? 100 : 50,
+      timeWindow: 6e4
+    });
+    this.backoff = new ExponentialBackoff({
+      maxRetries: config.retries || 3,
+      baseDelay: 100,
+      maxDelay: 5e3,
+      jitter: true
+    });
+    this.requestBatcher = new RequestBatcher(20, 50);
+    this.circuitBreaker = new CircuitBreaker();
+    this.defaultRevalidate = config.revalidateTime || 60;
+    this.cacheStrategy = config.cacheStrategy || "memory";
+    if (!this.isServer) {
+      window.addEventListener("beforeunload", this.cleanup.bind(this));
+    }
+  }
+  /**
+   * Fetch a Single Page with full strategy pipeline
+   */
+  async getPage(slug, options = {}) {
+    const { result, duration } = measurePerformance(
+      `getPage("${slug}")`,
+      () => this._getPage(slug, options)
+    );
+    if (this.config.debug && duration > 100) {
+      console.warn(
+        `[NexusHub] \u26A0\uFE0F getPage("${slug}") took ${duration.toFixed(2)}ms`
+      );
+    }
+    return result;
+  }
+  async _getPage(slug, options = {}) {
+    validateSlug(slug);
+    const {
+      revalidate = this.defaultRevalidate,
+      tags = [],
+      forceRefresh = false,
+      includeMetadata = false
+    } = options;
+    const cacheKey = `page:${slug}`;
+    const cached = await this.checkCaches(
+      cacheKey,
+      forceRefresh,
+      includeMetadata
+    );
+    if (cached) {
+      if (this.config.debug) console.log(`[NexusHub] \u26A1 Cache hit: ${slug}`);
+      return includeMetadata ? cached : cached.data;
+    }
+    if (this.circuitBreaker.isOpen()) {
+      throw new Error(`[NexusHub] Circuit open. API is unavailable.`);
+    }
+    try {
+      await this.rateLimiter.checkLimit();
+      const data = await this.backoff.execute(
+        async () => {
+          return this.fetchPage(
+            slug,
+            cacheKey,
+            tags,
+            revalidate,
+            forceRefresh
+          );
+        },
+        (attempt, delay, error) => {
+          if (this.config.debug) {
+            console.log(
+              `[NexusHub] \u{1F504} Retry ${attempt} for '${slug}' after ${delay}ms: ${error.message}`
+            );
+          }
+        }
+      );
+      this.circuitBreaker.recordSuccess();
+      return includeMetadata ? data : data.data;
+    } catch (error) {
+      this.circuitBreaker.recordFailure();
+      const staleCache = this.memoryCache.get(cacheKey);
+      if (staleCache && !forceRefresh) {
+        console.warn(`[NexusHub] \u26A0\uFE0F Serving stale content for '${slug}'`);
+        return includeMetadata ? staleCache : staleCache.data;
+      }
+      throw this.normalizeError(error, `Failed to fetch page '${slug}'`);
+    }
+  }
+  /**
+   * Fetch a Collection (Optimized)
+   */
+  async getCollection(collectionId, query = {}, options = {}) {
+    const { result, duration } = measurePerformance(
+      `getCollection("${collectionId}")`,
+      () => this._getCollection(collectionId, query, options)
+    );
+    if (this.config.debug && duration > 100) {
+      console.warn(
+        `[NexusHub] \u26A0\uFE0F getCollection("${collectionId}") took ${duration.toFixed(2)}ms`
+      );
+    }
+    return result;
+  }
+  async _getCollection(collectionId, query = {}, options = {}) {
+    const normalizedQuery = normalizeQuery(query);
+    const {
+      revalidate = this.defaultRevalidate,
+      tags = [],
+      forceRefresh = false,
+      includeMetadata = false
+    } = options;
+    const queryString = buildQueryString(normalizedQuery);
+    const cacheKey = `collection:${collectionId}:${queryString}`;
+    const cached = await this.checkCaches(
+      cacheKey,
+      forceRefresh,
+      includeMetadata
+    );
+    if (cached) {
+      if (this.config.debug) {
+        console.log(
+          `[NexusHub] \u26A1 Served collection '${collectionId}' from memory cache.`
+        );
+      }
+      return includeMetadata ? cached : cached.data;
+    }
+    if (!forceRefresh && process.env.NODE_ENV === "development") {
+      const localCollection = await this.localCache.getCollection(collectionId);
+      if (localCollection) {
+        const result = this.applyLocalQuery(
+          localCollection,
+          normalizedQuery
+        );
+        if (this.config.debug) {
+          console.log(
+            `[NexusHub] \u{1F4C1} Served collection '${collectionId}' from local cache.`
+          );
+        }
+        this.memoryCache.set(cacheKey, result, {
+          tags: [...tags, CacheTags.collection(collectionId)],
+          revalidate
+        });
+        return result;
+      }
+    }
+    if (this.circuitBreaker.isOpen()) throw new Error("Circuit open");
+    try {
+      await this.rateLimiter.checkLimit();
+      const result = await this.backoff.execute(async () => {
+        return this.fetchCollection(
+          collectionId,
+          normalizedQuery,
+          cacheKey,
+          tags,
+          revalidate
+        );
+      });
+      this.circuitBreaker.recordSuccess();
+      return includeMetadata ? result : result.data;
+    } catch (error) {
+      this.circuitBreaker.recordFailure();
+      const staleCache = this.memoryCache.get(cacheKey);
+      if (staleCache && !forceRefresh) {
+        console.warn(
+          `[NexusHub] \u26A0\uFE0F Using stale cache for collection '${collectionId}'`
+        );
+        return includeMetadata ? staleCache : staleCache.data;
+      }
+      throw this.normalizeError(
+        error,
+        `Failed to fetch collection '${collectionId}'`
+      );
+    }
+  }
+  /**
+   * Fetch Global Settings with nested includes support
+   */
+  async getGlobals(options = {}) {
+    const {
+      include = [],
+      revalidate = this.defaultRevalidate,
+      forceRefresh = false
+    } = options;
+    const cacheKey = `globals:${include.join(",")}`;
+    if (!forceRefresh && this.cacheStrategy === "memory") {
+      const cached = this.memoryCache.get(cacheKey);
+      if (cached && this.isCacheValid(cached.metadata)) {
+        if (this.config.debug)
+          console.log("[NexusHub] \u26A1 Served globals from memory cache.");
+        return cached.data;
+      }
+    }
+    if (!forceRefresh && !this.isServer && this.cacheStrategy === "localStorage" && this.browserCache) {
+      const cached = this.browserCache.get(cacheKey);
+      if (cached) {
+        return cached;
+      }
+    }
+    if (!forceRefresh && process.env.NODE_ENV === "development") {
+      const localGlobals = this.localCache.getGlobals();
+      if (localGlobals) {
+        this.memoryCache.set(cacheKey, localGlobals, {
+          tags: [CacheTags.global],
+          revalidate
+        });
+        return localGlobals;
+      }
+    }
+    try {
+      await this.rateLimiter.checkLimit();
+      const url = `${this.config.apiUrl}/content/${this.config.projectId}/globals`;
+      const params = include.length > 0 ? `?include=${include.join(",")}` : "";
+      const res = await this.fetchWithTimeout(`${url}${params}`, {
+        method: "GET",
+        headers: this.getHeaders()
+      });
+      if (!res.ok) {
+        throw new Error(`API Error ${res.status}: ${res.statusText}`);
+      }
+      const json = await res.json();
+      const data = json.data || json;
+      this.writeCache(cacheKey, data, {
+        revalidate,
+        tags: [CacheTags.project(this.config.projectId), CacheTags.global]
+      });
+      return data;
+    } catch (error) {
+      const staleCache = this.memoryCache.get(cacheKey);
+      if (staleCache && !forceRefresh) {
+        console.warn("[NexusHub] \u26A0\uFE0F Using stale cache for globals");
+        return staleCache.data;
+      }
+      throw this.normalizeError(error, "Failed to fetch globals");
+    }
+  }
+  /**
+   * Get a single item from a collection (Uses Request Batching)
+   * If you call this 10 times in a loop, it sends 1 HTTP request.
+   */
+  async getItem(collectionId, itemId, options = {}) {
+    const cacheKey = `item:${collectionId}:${itemId}`;
+    if (this.cacheStrategy === "memory") {
+      const cached = this.memoryCache.get(cacheKey);
+      if (cached && this.isCacheValid(cached.metadata)) {
+        if (this.config.debug) {
+          console.log(`[NexusHub] \u26A1 Served item '${itemId}' from cache.`);
+        }
+        return cached.data;
+      }
+    }
+    return this.requestBatcher.schedule(cacheKey, async () => {
+      const params = new URLSearchParams();
+      if (options.include?.length) {
+        params.append("include", options.include.join(","));
+      }
+      const url = `${this.config.apiUrl}/content/${this.config.projectId}/collection/${collectionId}/${itemId}?${params}`;
+      const res = await this.fetchWithTimeout(url, {
+        method: "GET",
+        headers: this.getHeaders()
+      });
+      if (!res.ok) {
+        throw new Error(`API Error ${res.status}: ${res.statusText}`);
+      }
+      const json = await res.json();
+      const data = json.data || json;
+      this.writeCache(cacheKey, data, {
+        revalidate: options.revalidate || this.defaultRevalidate,
+        tags: [
+          CacheTags.project(this.config.projectId),
+          CacheTags.collection(collectionId),
+          `item_${itemId}`,
+          ...options.tags || []
+        ]
+      });
+      return data;
+    });
+  }
+  /**
+   * Search across collections
+   */
+  async search(query, options = {}) {
+    const params = new URLSearchParams({
+      q: query,
+      limit: (options.limit || 20).toString()
+    });
+    if (options.collections?.length) {
+      params.append("collections", options.collections.join(","));
+    }
+    if (options.fields?.length) {
+      params.append("fields", options.fields.join(","));
+    }
+    const url = `${this.config.apiUrl}/content/${this.config.projectId}/search?${params}`;
+    const res = await this.fetchWithTimeout(url, {
+      method: "GET",
+      headers: this.getHeaders()
+    });
+    if (!res.ok) {
+      throw new Error(`API Error ${res.status}: ${res.statusText}`);
+    }
+    return await res.json();
+  }
+  /**
+   * Prefetch content for better performance
+   */
+  async prefetch(urls) {
+    if (typeof window !== "undefined" && "requestIdleCallback" in window) {
+      requestIdleCallback(async () => {
+        await Promise.allSettled(
+          urls.map((url) => fetch(url, { priority: "low" }))
+        );
+      });
+    }
+  }
+  /**
+   * Robust Real-time Subscriptions (SSE) with Auto-Reconnect
+   */
+  subscribeToUpdates(callback) {
+    if (this.isServer || typeof EventSource === "undefined") {
+      console.warn("[NexusHub] EventSource not supported in this environment");
+      return () => {
+      };
+    }
+    let eventSource = null;
+    let retryCount = 0;
+    let isClosed = false;
+    const connect = () => {
+      if (isClosed) return;
+      const url = `${this.config.apiUrl}/content/${this.config.projectId}/updates?key=${this.config.apiKey}`;
+      eventSource = new EventSource(url);
+      eventSource.onopen = () => {
+        retryCount = 0;
+        if (this.config.debug)
+          console.log("[NexusHub] \u{1F7E2} Real-time stream connected");
+      };
+      eventSource.onmessage = (event) => {
+        try {
+          const data = JSON.parse(event.data);
+          if (data.type === "content.updated" && data.slug) {
+            this.invalidateCache([CacheTags.content(data.slug)]);
+          }
+          if (data.type === "collection.updated") {
+            this.invalidateCache([CacheTags.collection(data.collectionId)]);
+          }
+          callback(data);
+        } catch (e) {
+          console.error("[NexusHub] SSE Parse Error", e);
+        }
+      };
+      eventSource.onerror = () => {
+        eventSource?.close();
+        if (isClosed) return;
+        const timeout = Math.min(1e3 * Math.pow(2, retryCount), 1e4);
+        retryCount++;
+        console.warn(
+          `[NexusHub] \u{1F534} Stream disconnected. Reconnecting in ${timeout}ms...`
+        );
+        setTimeout(connect, timeout);
+      };
+    };
+    connect();
+    return () => {
+      isClosed = true;
+      eventSource?.close();
+    };
+  }
+  // --- CACHE MANAGEMENT ---
+  /**
+   * Check all caches in order of speed
+   */
+  async checkCaches(key, forceRefresh, includeMetadata) {
+    if (forceRefresh) return null;
+    if (this.cacheStrategy === "memory") {
+      const cached = this.memoryCache.get(key);
+      if (cached && this.isCacheValid(cached.metadata)) {
+        return cached;
+      }
+    }
+    if (!this.isServer && this.cacheStrategy === "localStorage" && this.browserCache) {
+      const cached = this.browserCache.get(key);
+      if (cached) {
+        return {
+          data: cached,
+          metadata: {
+            timestamp: 0,
+            expiresAt: Infinity,
+            tags: [],
+            etag: void 0
+          }
+        };
+      }
+    }
+    if (process.env.NODE_ENV === "development") {
+      if (key.startsWith("page:")) {
+        const slug = key.split(":")[1];
+        const local = await this.localCache.getPage(slug);
+        if (local) {
+          return {
+            data: local,
+            metadata: {
+              timestamp: 0,
+              expiresAt: Infinity,
+              tags: [],
+              etag: void 0
+            }
+          };
+        }
+      }
+    }
+    return null;
+  }
+  writeCache(key, data, options) {
+    if (this.cacheStrategy === "memory") {
+      this.memoryCache.set(key, data, {
+        tags: options.tags,
+        revalidate: options.revalidate
+      });
+    }
+    if (!this.isServer && this.cacheStrategy === "localStorage" && this.browserCache) {
+      this.browserCache.set(key, data, options.revalidate * 1e3);
+    }
+  }
+  // packages/client-sdk/src/content/index.ts
+  /**
+   * ⚡ THE PULSE: Next.js Cache Revalidation Receiver
+   * Used in app/api/nexus-revalidate/route.ts to handle instant updates from the NexusHub backend.
+   *
+   * @param req The incoming Request object from Next.js
+   * @param revalidateFn The revalidateTag function imported from 'next/cache'
+   */
+  async handleRevalidation(req, revalidateFn) {
+    try {
+      if (!req.body) {
+        return { success: false, message: "Missing Pulse Payload" };
+      }
+      const body = await req.json();
+      const { secret, tag } = body;
+      if (!secret || secret !== this.config.projectId) {
+        if (this.config.debug) {
+          console.warn(`[NexusHub] \u26A0\uFE0F Blocked unauthorized Pulse request.`);
+        }
+        return { success: false, message: "Invalid Pulse Signature" };
+      }
+      const targetTag = tag || "content_all";
+      revalidateFn(targetTag);
+      this.invalidateCache([targetTag]);
+      if (this.config.debug) {
+        console.log(
+          `[NexusHub] \u26A1 Pulse Received: Successfully revalidated tag [${targetTag}]`
+        );
+      }
+      return { success: true, now: Date.now() };
+    } catch (e) {
+      if (this.config.debug) {
+        console.error(`[NexusHub] \u274C Pulse Processing Error:`, e.message);
+      }
+      return {
+        success: false,
+        message: "Malformed Pulse Payload or Processing Error"
+      };
+    }
+  }
+  /**
+   * Invalidate cache by tags
+   */
+  invalidateCache(tags) {
+    this.memoryCache.invalidateByTags(tags);
+    if (this.config.debug) {
+      console.log(
+        `[NexusHub] \u267B\uFE0F Invalidated cache for tags: ${tags.join(", ")}`
+      );
+    }
+  }
+  /**
+   * Clear all caches
+   */
+  clearCache() {
+    this.memoryCache.clear();
+    if (this.browserCache) {
+      this.browserCache.clear();
+    }
+    if (this.config.debug) {
+      console.log("[NexusHub] \u{1F9F9} Cleared all caches");
+    }
+  }
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    const stats = {
+      memory: this.memoryCache.getStats(),
+      local: { loaded: this.localCache.isLoaded() }
+    };
+    if (this.browserCache) {
+      stats.browser = { size: 0 };
+    }
+    return stats;
+  }
+  // --- REQUEST METHODS ---
+  async fetchPage(slug, cacheKey, tags, revalidate, forceRefresh) {
+    const url = `${this.config.apiUrl}/content/${this.config.projectId}/page/${slug}`;
+    if (this.config.debug) {
+      console.log(`[NexusHub] \u{1F310} Fetching: ${url}`);
+    }
+    const res = await this.fetchWithTimeout(url, {
+      method: "GET",
+      headers: this.getHeaders(),
+      tags,
+      revalidate
+    });
+    if (!res.ok) {
+      if (res.status === 404) {
+        throw new Error(
+          `Page '${slug}' not found. Check your Dashboard or Seed data.`
+        );
+      }
+      throw new Error(`API Error ${res.status}: ${res.statusText}`);
+    }
+    const json = await res.json();
+    const etag = res.headers.get("etag");
+    const cacheEntry = {
+      data: json.data,
+      metadata: {
+        timestamp: Date.now(),
+        etag: etag || void 0,
+        expiresAt: Date.now() + revalidate * 1e3,
+        tags: [...tags, CacheTags.content(slug)]
+      }
+    };
+    this.writeCache(cacheKey, cacheEntry.data, {
+      revalidate,
+      tags: [
+        CacheTags.project(this.config.projectId),
+        CacheTags.content(slug),
+        ...tags
+      ]
+    });
+    return cacheEntry;
+  }
+  async fetchCollection(collectionId, query, cacheKey, tags, revalidate) {
+    const params = buildQueryString(query);
+    const url = `${this.config.apiUrl}/content/${this.config.projectId}/collection/${collectionId}?${params}`;
+    if (this.config.debug) {
+      console.log(`[NexusHub] \u{1F310} Fetching Collection: ${url}`);
+    }
+    const res = await this.fetchWithTimeout(url, {
+      method: "GET",
+      headers: this.getHeaders(),
+      tags,
+      revalidate
+    });
+    if (!res.ok) {
+      throw new Error(`API Error ${res.status}: ${res.statusText}`);
+    }
+    const json = await res.json();
+    const etag = res.headers.get("etag");
+    const cacheEntry = {
+      data: json,
+      metadata: {
+        timestamp: Date.now(),
+        etag: etag || void 0,
+        expiresAt: Date.now() + revalidate * 1e3,
+        tags: [...tags, CacheTags.collection(collectionId)]
+      }
+    };
+    this.writeCache(cacheKey, cacheEntry.data, {
+      revalidate,
+      tags: [
+        CacheTags.project(this.config.projectId),
+        CacheTags.collection(collectionId),
+        ...tags
+      ]
+    });
+    return cacheEntry;
+  }
+  // --- HELPER METHODS ---
+  applyLocalQuery(items, query) {
+    let filtered = [...items];
+    if (query.search) {
+      const searchLower = query.search.toLowerCase();
+      filtered = filtered.filter(
+        (item) => JSON.stringify(item).toLowerCase().includes(searchLower)
+      );
+    }
+    if (query.filter) {
+      filtered = filtered.filter((item) => {
+        return Object.entries(query.filter).every(([key, value]) => {
+          const itemValue = item[key];
+          if (itemValue === void 0) return false;
+          if (Array.isArray(value)) {
+            return value.includes(itemValue);
+          }
+          return itemValue === value;
+        });
+      });
+    }
+    if (query.sort) {
+      filtered.sort((a, b) => {
+        const aVal = a[query.sort];
+        const bVal = b[query.sort];
+        const order = query.order === "asc" ? 1 : -1;
+        if (aVal < bVal) return -1 * order;
+        if (aVal > bVal) return 1 * order;
+        return 0;
+      });
+    }
+    const page = query.page || 1;
+    const limit = query.limit || 10;
+    const start = (page - 1) * limit;
+    const end = start + limit;
+    const total = filtered.length;
+    return {
+      items: filtered.slice(start, end),
+      total,
+      page,
+      limit,
+      totalPages: Math.ceil(total / limit),
+      hasNext: end < total,
+      hasPrev: start > 0
+    };
+  }
+  async fetchWithTimeout(url, options = {}) {
+    const {
+      timeout = this.config.timeout || 1e4,
+      tags = [],
+      revalidate,
+      ...fetchOptions
+    } = options;
+    const controller = new AbortController();
+    const id = setTimeout(() => controller.abort(), timeout);
+    const nextConfig = this.isServer ? { next: { tags, revalidate } } : {};
+    try {
+      const response = await fetch(url, {
+        ...fetchOptions,
+        ...nextConfig,
+        // Inject Next.js tags
+        signal: controller.signal
+      });
+      clearTimeout(id);
+      return response;
+    } catch (error) {
+      clearTimeout(id);
+      throw error;
+    }
+  }
+  getHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Nexus-Client": "client-sdk/1.0.0",
+      "X-Nexus-Project": this.config.projectId
+    };
+    if (this.config.apiKey) {
+      headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+    }
+    return headers;
+  }
+  isCacheValid(metadata) {
+    return Date.now() < metadata.expiresAt;
+  }
+  normalizeError(error, context) {
+    if (error instanceof Error) {
+      if (error.name === "AbortError") {
+        return new Error(`${context}: Request timeout`);
+      }
+      return error;
+    }
+    return new Error(`${context}: ${String(error)}`);
+  }
+  /**
+   * Cancel ongoing requests
+   */
+  cancelRequests() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = new AbortController();
+    }
+  }
+  /**
+   * Cleanup resources
+   */
+  cleanup() {
+    this.cancelRequests();
+    if (!this.isServer) {
+      window.removeEventListener("beforeunload", this.cleanup.bind(this));
+    }
+  }
+};
+
+// src/analytics/fingerprint.ts
+var cachedEntropy = null;
+var getDeviceEntropy = async () => {
+  if (cachedEntropy) return cachedEntropy;
+  if (typeof window === "undefined") return {};
+  const nav = window.navigator;
+  cachedEntropy = {
+    screen_resolution: `${window.screen.width}x${window.screen.height}`,
+    color_depth: window.screen.colorDepth,
+    pixel_ratio: window.devicePixelRatio || 1,
+    hardware_concurrency: nav.hardwareConcurrency,
+    device_memory: nav.deviceMemory,
+    // Chrome/Edge only
+    timezone_offset: (/* @__PURE__ */ new Date()).getTimezoneOffset(),
+    platform: nav.platform,
+    language: nav.language,
+    touch_support: "ontouchstart" in window || nav.maxTouchPoints > 0,
+    canvas_hash: await generateCanvasHash()
+  };
+  return cachedEntropy;
+};
+var generateCanvasHash = async () => {
+  try {
+    const canvas = document.createElement("canvas");
+    const ctx = canvas.getContext("2d");
+    if (!ctx) return "";
+    canvas.width = 200;
+    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";
+    ctx.fillText("NexusHub Rocks! <canvas> 1.0", 2, 15);
+    ctx.fillStyle = "rgba(102, 204, 0, 0.7)";
+    ctx.fillText("NexusHub Rocks! <canvas> 1.0", 4, 17);
+    const dataUrl = canvas.toDataURL();
+    let hash = 0;
+    for (let i = 0; i < dataUrl.length; i++) {
+      const char = dataUrl.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return hash.toString(16);
+  } catch {
+    return "";
+  }
+};
+var getVisitorId = async () => {
+  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 random = Math.random().toString(36).substring(2, 15);
+    const timestamp = Date.now().toString(36);
+    const fingerprint = [
+      entropy.screen_resolution,
+      entropy.hardware_concurrency,
+      entropy.timezone_offset,
+      entropy.platform,
+      entropy.canvas_hash
+    ].join("|");
+    let hash = 0;
+    for (let i = 0; i < fingerprint.length; i++) {
+      hash = (hash << 5) - hash + fingerprint.charCodeAt(i);
+      hash |= 0;
+    }
+    vid = `vis_${hash.toString(16)}_${timestamp}_${random}`;
+    localStorage.setItem(STORAGE_KEY, vid);
+  }
+  return vid;
+};
+
+// src/analytics/vitals.ts
+import { onCLS, onLCP, onTTFB, onINP, onFCP } from "web-vitals";
+var METRIC_KEY_MAP = {
+  CLS: "cls",
+  LCP: "lcp",
+  INP: "inp",
+  TTFB: "ttfb",
+  FCP: "fcp"
+};
+var VitalsCollector = class {
+  constructor() {
+    this.metrics = {};
+    this.hasUpdates = false;
+    if (typeof window !== "undefined") {
+      this.init();
+    }
+  }
+  init() {
+    const recordMetric = (metric) => {
+      const key = METRIC_KEY_MAP[metric.name];
+      this.metrics[key] = metric.value;
+      this.hasUpdates = true;
+    };
+    onCLS(recordMetric);
+    onLCP(recordMetric);
+    onTTFB(recordMetric);
+    onINP(recordMetric);
+    onFCP(recordMetric);
+    const navEntry = performance.getEntriesByType("navigation")[0];
+    if (navEntry) {
+      this.metrics.navigation_timing = {
+        dns_lookup: navEntry.domainLookupEnd - navEntry.domainLookupStart,
+        tcp_connect: navEntry.connectEnd - navEntry.connectStart,
+        request_time: navEntry.responseEnd - navEntry.requestStart,
+        dom_load: navEntry.domComplete - navEntry.domInteractive,
+        // NEW: raw fields matching Rust NavigationTiming struct
+        domain_lookup_start: navEntry.domainLookupStart,
+        domain_lookup_end: navEntry.domainLookupEnd,
+        connect_start: navEntry.connectStart,
+        connect_end: navEntry.connectEnd,
+        secure_connection_start: navEntry.secureConnectionStart > 0 ? navEntry.secureConnectionStart : void 0
+      };
+      this.hasUpdates = true;
+    }
+    const resourceEntries = performance.getEntriesByType(
+      "resource"
+    );
+    if (resourceEntries.length > 0) {
+      this.metrics.resources = resourceEntries.filter((r) => !r.name.includes("/api/collect")).sort((a, b) => b.duration - a.duration).slice(0, 20).map((r) => ({
+        name: r.name,
+        initiatorType: r.initiatorType,
+        duration: Math.round(r.duration),
+        transferSize: r.transferSize > 0 ? r.transferSize : void 0,
+        encodedBodySize: r.encodedBodySize > 0 ? r.encodedBodySize : void 0,
+        decodedBodySize: r.decodedBodySize > 0 ? r.decodedBodySize : void 0,
+        startTime: Math.round(r.startTime),
+        responseEnd: Math.round(r.responseEnd)
+      }));
+      this.hasUpdates = true;
+    }
+    const mem = performance.memory;
+    if (mem) {
+      this.metrics.memory_usage = {
+        used_js_heap_size: mem.usedJSHeapSize,
+        total_js_heap_size: mem.totalJSHeapSize,
+        js_heap_size_limit: mem.jsHeapSizeLimit
+      };
+      this.hasUpdates = true;
+    }
+  }
+  getMetricsSnapshot() {
+    if (!this.hasUpdates) return null;
+    this.hasUpdates = false;
+    const snapshot = { ...this.metrics };
+    this.metrics.resources = void 0;
+    return snapshot;
+  }
+};
+var vitalsCollector = new VitalsCollector();
+var initVitals = (_tracker) => {
+  if (process.env.NODE_ENV === "development") {
+    console.log("[NexusHub] Web Vitals monitoring active");
+  }
+};
+
+// src/analytics/storage.ts
+var DB_NAME = "NexusHub_Analytics";
+var STORE_NAME = "events_queue";
+var DB_VERSION = 2;
+var MAX_QUEUE_SIZE = 500;
+var EventStorage = class {
+  constructor() {
+    this.db = null;
+    this.isReady = this.init();
+  }
+  init() {
+    if (typeof window === "undefined" || !window.indexedDB) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      const request = indexedDB.open(DB_NAME, DB_VERSION);
+      request.onerror = () => {
+        console.warn(
+          "[NexusHub] Failed to open IndexedDB. Falling back to memory."
+        );
+        resolve();
+      };
+      request.onsuccess = (event) => {
+        this.db = event.target.result;
+        resolve();
+      };
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (db.objectStoreNames.contains(STORE_NAME)) {
+          db.deleteObjectStore(STORE_NAME);
+        }
+        db.createObjectStore(STORE_NAME, {
+          keyPath: "id",
+          autoIncrement: true
+        });
+      };
+    });
+  }
+  /**
+   * Add an event to the persistent queue.
+   * Evicts the oldest entry if the queue is already at MAX_QUEUE_SIZE.
+   */
+  async enqueue(payload) {
+    await this.isReady;
+    if (!this.db) return;
+    const currentCount = await this.count();
+    if (currentCount >= MAX_QUEUE_SIZE) {
+      const oldest = await this.peek(1);
+      if (oldest.length > 0 && oldest[0].id !== void 0) {
+        await this.remove([oldest[0].id]);
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([STORE_NAME], "readwrite");
+      const store = transaction.objectStore(STORE_NAME);
+      const request = store.add({
+        payload,
+        timestamp: Date.now(),
+        retryCount: 0
+      });
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error);
+    });
+  }
+  /**
+   * Get a batch of the oldest events without removing them.
+   */
+  async peek(limit = 20) {
+    await this.isReady;
+    if (!this.db) return [];
+    return new Promise((resolve) => {
+      const transaction = this.db.transaction([STORE_NAME], "readonly");
+      const store = transaction.objectStore(STORE_NAME);
+      const request = store.getAll(null, limit);
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => resolve([]);
+    });
+  }
+  /**
+   * Remove events by ID after a successful upload.
+   */
+  async remove(ids) {
+    await this.isReady;
+    if (!this.db || ids.length === 0) return;
+    return new Promise((resolve, reject) => {
+      const transaction = this.db.transaction([STORE_NAME], "readwrite");
+      const store = transaction.objectStore(STORE_NAME);
+      transaction.oncomplete = () => resolve();
+      transaction.onerror = () => reject(transaction.error);
+      transaction.onabort = () => reject(new Error("Delete transaction aborted"));
+      ids.forEach((id) => {
+        store.delete(id);
+      });
+    });
+  }
+  /**
+   * Count pending events in the queue.
+   */
+  async count() {
+    await this.isReady;
+    if (!this.db) return 0;
+    return new Promise((resolve) => {
+      const transaction = this.db.transaction([STORE_NAME], "readonly");
+      const store = transaction.objectStore(STORE_NAME);
+      const request = store.count();
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => resolve(0);
+    });
+  }
+};
+var eventStorage = new EventStorage();
+
+// src/analytics/tracker.ts
+var SDK_VERSION = "0.1.0";
+var safeGetItem = (key) => {
+  try {
+    return localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+};
+var safeSetItem = (key, value) => {
+  try {
+    localStorage.setItem(key, value);
+  } catch {
+  }
+};
+var safeRemoveItem = (key) => {
+  try {
+    localStorage.removeItem(key);
+  } catch {
+  }
+};
+var generateUUID = () => {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+};
+var Tracker = class {
+  constructor(config) {
+    this.sessionId = "";
+    this.visitorId = "";
+    this.anonymousId = "";
+    this.isFlushing = false;
+    this.config = config;
+    this.endpoint = `${this.config.analyticsUrl}/api/collect`;
+    this.circuitBreaker = new CircuitBreaker();
+    this.sessionStart = Date.now();
+    if (typeof window !== "undefined") {
+      this.initSession();
+      this.startFlushing();
+    }
+  }
+  async initSession() {
+    this.visitorId = await getVisitorId();
+    let anonId = safeGetItem("nexus_anon_id");
+    if (!anonId) {
+      anonId = `anon_${generateUUID().replace(/-/g, "")}`;
+      safeSetItem("nexus_anon_id", anonId);
+    }
+    this.anonymousId = anonId;
+    let sid = safeGetItem("nexus_sid");
+    const lastActivity = safeGetItem("nexus_last_active");
+    const now = Date.now();
+    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}`;
+      safeSetItem("nexus_sid", sid);
+      this.sessionStart = now;
+    }
+    safeSetItem("nexus_last_active", now.toString());
+    this.sessionId = sid;
+  }
+  async send(eventType, data = {}, eventName, ecommerce) {
+    if (typeof window === "undefined") return;
+    safeSetItem("nexus_last_active", Date.now().toString());
+    const entropy = await getDeviceEntropy();
+    const perfMetrics = vitalsCollector.getMetricsSnapshot();
+    const utmParams = extractUtmParams(window.location.href);
+    const payload = {
+      projectId: this.config.projectId,
+      sessionId: this.sessionId,
+      visitorId: this.visitorId,
+      anonymousId: this.anonymousId,
+      messageId: generateUUID(),
+      sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version: SDK_VERSION,
+      url: window.location.href,
+      referrer: document.referrer,
+      userAgent: window.navigator.userAgent,
+      screenWidth: window.screen.width,
+      screenHeight: window.screen.height,
+      language: window.navigator.language,
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      eventType,
+      eventName,
+      eventData: data,
+      ecommerce: ecommerce ?? void 0,
+      performance: perfMetrics || void 0,
+      context: {
+        device: {
+          hardwareConcurrency: entropy.hardware_concurrency,
+          deviceMemory: entropy.device_memory,
+          pixelRatio: entropy.pixel_ratio,
+          canvasFingerprint: entropy.canvas_hash,
+          platform: entropy.platform
+        },
+        visitorIdLocal: this.visitorId,
+        utm: utmParams
+      },
+      clientTimestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await eventStorage.enqueue(payload);
+    const count = await eventStorage.count();
+    if (count >= 10 || eventType === "purchase" || eventType === "identify") {
+      this.flushQueue();
+    }
+  }
+  startFlushing() {
+    this.flushInterval = setInterval(() => this.flushQueue(), 5e3);
+    window.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "hidden") this.flushQueue(true);
+    });
+  }
+  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);
+        } else {
+          failureCount++;
+        }
+      });
+      if (successIds.length > 0) {
+        await eventStorage.remove(successIds);
+        this.circuitBreaker.recordSuccess();
+      }
+      if (failureCount > 0) {
+        this.circuitBreaker.recordFailure();
+      }
+    } 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);
+      }
+    }
+  }
+  getSession() {
+    return this.sessionId;
+  }
+  getVisitorId() {
+    return this.visitorId;
+  }
+  getAnonymousId() {
+    return this.anonymousId;
+  }
+  getSessionDuration() {
+    return Date.now() - this.sessionStart;
+  }
+  clearIdentity() {
+    safeRemoveItem("nexus_anon_id");
+    this.anonymousId = "";
+  }
+  stop() {
+    if (this.flushInterval) {
+      clearInterval(this.flushInterval);
+    }
+    this.flushQueue(true);
+  }
+};
+function extractUtmParams(url) {
+  try {
+    const params = new URL(url).searchParams;
+    const utmKeys = [
+      "utm_source",
+      "utm_medium",
+      "utm_campaign",
+      "utm_term",
+      "utm_content"
+    ];
+    const result = {};
+    utmKeys.forEach((key) => {
+      const val = params.get(key);
+      if (val) result[key] = val;
+    });
+    return result;
+  } catch {
+    return {};
+  }
+}
+
+// src/analytics/index.ts
+var safeRemoveItem2 = (key) => {
+  try {
+    localStorage.removeItem(key);
+  } catch {
+  }
+};
+var AnalyticsEngine = class {
+  constructor(config) {
+    this.cleanupFns = [];
+    this.isInitialized = false;
+    this.maxScrollDepth = 0;
+    this.scrollThresholdsFired = /* @__PURE__ */ new Set();
+    this.lastPath = typeof window !== "undefined" ? window.location.pathname : "";
+    this.clickBuffer = [];
+    this.tracker = new Tracker(config);
+  }
+  start() {
+    if (this.isInitialized || typeof window === "undefined") return;
+    this.isInitialized = true;
+    this.pageView();
+    initVitals(this.tracker);
+    this.setupClickTracking();
+    this.setupFormTracking();
+    this.setupRouteTracking();
+    this.setupShareTracking();
+    this.setupScrollTracking();
+    this.setupOutboundTracking();
+    this.setupVideoTracking();
+    this.setupErrorTracking();
+    if (process.env.NODE_ENV === "development") {
+      console.log("[NexusHub] \u{1F680} Analytics Engine Started");
+    }
+  }
+  pageView(customReferrer) {
+    if (typeof window === "undefined") return;
+    const currentPath = window.location.pathname;
+    this.maxScrollDepth = 0;
+    this.scrollThresholdsFired.clear();
+    this.tracker.send("page_view", {
+      path: currentPath,
+      search: window.location.search,
+      title: document.title,
+      timezone_offset: (/* @__PURE__ */ new Date()).getTimezoneOffset(),
+      referrer: customReferrer || (this.lastPath !== currentPath ? this.lastPath : document.referrer)
+    });
+    this.lastPath = currentPath;
+  }
+  setupShareTracking() {
+    if (typeof window === "undefined") return;
+    const copyHandler = () => {
+      this.tracker.send("social_share", {
+        method: "clipboard_copy",
+        url: window.location.href
+      });
+    };
+    window.addEventListener("copy", copyHandler, { passive: true });
+    this.cleanupFns.push(() => window.removeEventListener("copy", copyHandler));
+    if (typeof navigator !== "undefined" && navigator.share) {
+      const originalShare = navigator.share.bind(navigator);
+      navigator.share = (data) => {
+        this.tracker.send("social_share", {
+          method: "native_share_menu",
+          url: data?.url || window.location.href,
+          title: data?.title
+        });
+        return originalShare(data);
+      };
+      this.cleanupFns.push(() => {
+        navigator.share = originalShare;
+      });
+    }
+  }
+  setupScrollTracking() {
+    if (typeof window === "undefined") return;
+    const THRESHOLDS = [25, 50, 75, 100];
+    const scrollHandler = () => {
+      const scrollTop = window.scrollY || document.documentElement.scrollTop;
+      const docHeight = document.documentElement.scrollHeight - document.documentElement.clientHeight;
+      if (docHeight <= 0) return;
+      const pct = Math.round(scrollTop / docHeight * 100);
+      if (pct > this.maxScrollDepth) {
+        this.maxScrollDepth = pct;
+      }
+      clearTimeout(this.scrollTimer);
+      this.scrollTimer = setTimeout(() => {
+        for (const threshold of THRESHOLDS) {
+          if (this.maxScrollDepth >= threshold && !this.scrollThresholdsFired.has(threshold)) {
+            this.scrollThresholdsFired.add(threshold);
+            this.tracker.send("scroll", {
+              depth: threshold / 100,
+              depth_percent: threshold,
+              path: window.location.pathname
+            });
+          }
+        }
+      }, 300);
+    };
+    window.addEventListener("scroll", scrollHandler, { passive: true });
+    this.cleanupFns.push(() => {
+      window.removeEventListener("scroll", scrollHandler);
+      clearTimeout(this.scrollTimer);
+    });
+  }
+  setupClickTracking() {
+    if (typeof window === "undefined") return;
+    const clickHandler = (e) => {
+      const target = e.target;
+      const link = target.closest("a");
+      if (link) {
+        this.tracker.send("click", {
+          element_type: "link",
+          href: link.href,
+          text: link.innerText?.substring(0, 50),
+          id: link.id,
+          classes: link.className,
+          dataset: { ...link.dataset },
+          coordinates: { x: e.clientX, y: e.clientY }
+        });
+      }
+      const button = target.closest("button");
+      if (button) {
+        this.tracker.send("click", {
+          element_type: "button",
+          text: button.innerText?.substring(0, 50),
+          id: button.id,
+          classes: button.className,
+          coordinates: { x: e.clientX, y: e.clientY }
+        });
+      }
+      const now = Date.now();
+      const ZONE = 400;
+      const WINDOW_MS = 1e3;
+      const RAGE_THRESHOLD = 3;
+      this.clickBuffer.push({ x: e.clientX, y: e.clientY, t: now });
+      this.clickBuffer = this.clickBuffer.filter((c) => now - c.t < WINDOW_MS);
+      const zone = {
+        x: Math.floor(e.clientX / ZONE),
+        y: Math.floor(e.clientY / ZONE)
+      };
+      const zoneClicks = this.clickBuffer.filter(
+        (c) => Math.floor(c.x / ZONE) === zone.x && Math.floor(c.y / ZONE) === zone.y
+      );
+      if (zoneClicks.length >= RAGE_THRESHOLD) {
+        this.tracker.send(
+          "click",
+          {
+            element_type: target.tagName.toLowerCase(),
+            event_name: "rage_click",
+            coordinates: { x: e.clientX, y: e.clientY },
+            click_count: zoneClicks.length,
+            path: window.location.pathname
+          },
+          "rage_click"
+        );
+        this.clickBuffer = [];
+      }
+      const isInteractive = target.closest(
+        "a, button, input, select, textarea, [onclick], [role='button']"
+      );
+      if (!isInteractive) {
+        const pathBefore = window.location.pathname;
+        setTimeout(() => {
+          const pathAfter = window.location.pathname;
+          if (pathBefore === pathAfter) {
+            this.tracker.send(
+              "click",
+              {
+                element_type: target.tagName.toLowerCase(),
+                event_name: "dead_click",
+                selector: getSelector(target),
+                coordinates: { x: e.clientX, y: e.clientY },
+                path: window.location.pathname
+              },
+              "dead_click"
+            );
+          }
+        }, 300);
+      }
+    };
+    window.addEventListener("click", clickHandler, { passive: true });
+    this.cleanupFns.push(
+      () => window.removeEventListener("click", clickHandler)
+    );
+  }
+  setupFormTracking() {
+    if (typeof document === "undefined") return;
+    const submitHandler = (e) => {
+      const form = e.target;
+      if (form) {
+        this.tracker.send("form_submit", {
+          form_id: form.id || form.name || "unknown_form",
+          action: form.action,
+          method: form.method,
+          field_count: form.elements.length
+        });
+      }
+    };
+    document.addEventListener("submit", submitHandler, { passive: true });
+    this.cleanupFns.push(
+      () => document.removeEventListener("submit", submitHandler)
+    );
+  }
+  setupOutboundTracking() {
+    if (typeof window === "undefined") return;
+    const outboundHandler = (e) => {
+      const link = e.target.closest("a");
+      if (!link || !link.href) return;
+      try {
+        const linkHost = new URL(link.href).hostname;
+        if (linkHost && linkHost !== window.location.hostname) {
+          this.tracker.send(
+            "click",
+            {
+              event_name: "outbound_click",
+              href: link.href,
+              text: link.innerText?.substring(0, 50),
+              destination_host: linkHost,
+              coordinates: { x: e.clientX, y: e.clientY }
+            },
+            "outbound_click"
+          );
+        }
+      } catch {
+      }
+    };
+    window.addEventListener("click", outboundHandler, { passive: true });
+    this.cleanupFns.push(
+      () => window.removeEventListener("click", outboundHandler)
+    );
+  }
+  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"
+        );
+      });
+      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"
+          );
+        }
+      });
+      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 });
+    this.cleanupFns.push(() => observer.disconnect());
+  }
+  setupErrorTracking() {
+    if (typeof window === "undefined") return;
+    const errorHandler = (e) => {
+      this.tracker.send("error", {
+        message: e.message,
+        filename: e.filename,
+        lineno: e.lineno,
+        colno: e.colno,
+        stack: e.error?.stack,
+        url: window.location.href,
+        type: "uncaught_error"
+      });
+    };
+    const rejectionHandler = (e) => {
+      const reason = e.reason instanceof Error ? e.reason.message : String(e.reason);
+      const stack = e.reason instanceof Error ? e.reason.stack : void 0;
+      this.tracker.send("error", {
+        message: reason,
+        stack,
+        url: window.location.href,
+        type: "unhandled_rejection"
+      });
+    };
+    window.addEventListener("error", errorHandler);
+    window.addEventListener("unhandledrejection", rejectionHandler);
+    this.cleanupFns.push(() => {
+      window.removeEventListener("error", errorHandler);
+      window.removeEventListener("unhandledrejection", rejectionHandler);
+    });
+  }
+  setupRouteTracking() {
+    if (typeof window === "undefined" || typeof window.history === "undefined")
+      return;
+    const originalPushState = history.pushState.bind(history);
+    const originalReplaceState = history.replaceState.bind(history);
+    history.pushState = (...args) => {
+      const prevPath = window.location.pathname;
+      originalPushState(...args);
+      if (!this.isInitializedByReactProvider()) {
+        this.pageView(prevPath);
+      }
+    };
+    history.replaceState = (...args) => {
+      originalReplaceState(...args);
+    };
+    const popStateHandler = () => {
+      if (!this.isInitializedByReactProvider()) {
+        this.pageView();
+      }
+    };
+    window.addEventListener("popstate", popStateHandler);
+    this.cleanupFns.push(() => {
+      history.pushState = originalPushState;
+      history.replaceState = originalReplaceState;
+      window.removeEventListener("popstate", popStateHandler);
+    });
+  }
+  isInitializedByReactProvider() {
+    return !!document.getElementById("__nexus_react_active");
+  }
+  async identify(userId, traits = {}) {
+    return this.sendIdentityRequest("identify", { user_id: userId, traits });
+  }
+  async group(groupId, traits = {}) {
+    return this.sendIdentityRequest("group", { group_id: groupId, traits });
+  }
+  async alias(newId) {
+    return this.sendIdentityRequest("alias", {
+      previous_id: this.tracker.getSession(),
+      user_id: newId
+    });
+  }
+  reset(performGdprScrub = false) {
+    const config = this.tracker.config;
+    this.tracker.stop();
+    localStorage.removeItem("nexus_sid");
+    localStorage.removeItem("nexus_vid");
+    safeRemoveItem2("nexus_anon_id");
+    this.tracker.clearIdentity();
+    if (performGdprScrub) {
+      const endpoint = `${config.analyticsUrl}/api/privacy/scrub`;
+      const userId = this.tracker.getVisitorId();
+      fetch(endpoint, {
+        method: "DELETE",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${config.apiKey}`
+        },
+        body: JSON.stringify({
+          project_id: config.projectId,
+          user_id: userId
+        })
+      }).catch((err) => console.error("[NexusHub] Privacy scrub failed:", err));
+    }
+    window.location.reload();
+  }
+  track(eventName, properties = {}) {
+    this.tracker.send(
+      "custom_event",
+      { event_name: eventName, ...properties },
+      eventName
+    );
+  }
+  trackPurchase(orderData) {
+    const ecommerce = {
+      orderId: orderData.orderId,
+      total: orderData.total,
+      revenue: orderData.revenue ?? orderData.total,
+      currency: orderData.currency || "USD",
+      products: orderData.products.map((p) => ({
+        productId: p.id,
+        sku: p.sku,
+        name: p.name,
+        price: p.price,
+        quantity: p.quantity
+      }))
+    };
+    this.tracker.send(
+      "purchase",
+      { order_id: orderData.orderId },
+      "purchase",
+      ecommerce
+    );
+  }
+  trackError(error, context) {
+    this.tracker.send("error", {
+      message: error.message,
+      stack: error.stack,
+      context,
+      url: typeof window !== "undefined" ? window.location.href : "",
+      type: "manual"
+    });
+  }
+  async sendIdentityRequest(type, data) {
+    try {
+      const config = this.tracker.config;
+      const endpoint = `${config.analyticsUrl}/api/${type}`;
+      const payload = {
+        projectId: config.projectId,
+        sessionId: this.tracker.getSession(),
+        visitorId: this.tracker.getVisitorId(),
+        anonymousId: this.tracker.getAnonymousId(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        ...data
+      };
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${config.apiKey}`
+        },
+        body: JSON.stringify(payload)
+      });
+      return response.ok;
+    } catch (error) {
+      console.error(`[NexusHub] ${type} failed:`, error);
+      return false;
+    }
+  }
+  getSessionId() {
+    return this.tracker.getSession();
+  }
+  stop(isFinalShutdown = false) {
+    this.cleanupFns.forEach((fn) => fn());
+    this.cleanupFns = [];
+    if (isFinalShutdown) {
+      this.tracker.send("session_end", {
+        session_id: this.tracker.getSession(),
+        duration: this.tracker.getSessionDuration(),
+        max_scroll_depth: this.maxScrollDepth / 100
+      });
+    }
+    this.tracker.stop();
+    this.isInitialized = false;
+  }
+};
+function getSelector(el, depth = 0) {
+  if (!el || depth > 2) return "";
+  const tag = el.tagName.toLowerCase();
+  const id = el.id ? `#${el.id}` : "";
+  const cls = el.className && typeof el.className === "string" ? `.${el.className.trim().split(/\s+/).slice(0, 2).join(".")}` : "";
+  const self = `${tag}${id}${cls}`;
+  const parent = el.parentElement && depth < 2 ? `${getSelector(el.parentElement, depth + 1)} > ` : "";
+  return `${parent}${self}`;
+}
+
+// src/client.ts
+var NexusClient = class {
+  constructor(config) {
+    const fullConfig = getFullConfig(config);
+    this.config = {
+      debug: config?.debug ?? false,
+      cacheStrategy: config?.cacheStrategy ?? "memory",
+      revalidateTime: config?.revalidateTime ?? 60,
+      timeout: config?.timeout ?? 1e4,
+      retries: config?.retries ?? 3,
+      ...fullConfig
+    };
+    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.");
+      }
+    }
+    this.content = new ContentEngine(this.config);
+    if (typeof window !== "undefined") {
+      this.analytics = new AnalyticsEngine(this.config);
+      this.analytics.start();
+    }
+  }
+  /**
+   * Helper alias for cleaner content fetching.
+   */
+  getPage(slug, options) {
+    return this.content.getPage(slug, options);
+  }
+  /**
+   * Returns a readonly snapshot of the current config.
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * 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.
+   */
+  updateConfig(updates) {
+    this.config = { ...this.config, ...updates };
+  }
+};
+var nexus = new NexusClient();
+
+// src/auth/context.tsx
 import {
-  AuthProvider,
-  NexusProvider,
-  useNexus,
-  useNexusAnalytics,
-  useNexusAuth,
-  useNexusLiveFeed
-} from "./chunk-G4SHBWAQ.js";
+  createContext,
+  useContext,
+  useEffect,
+  useState,
+  useCallback
+} from "react";
+import { jsx } 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 AUTH_BASE = `${config.apiUrl}/auth/project/${config.projectId}`;
+  const checkSession = useCallback(async () => {
+    try {
+      const res = await fetch(`${AUTH_BASE}/me`, {
+        headers: getHeaders(config)
+      });
+      if (res.ok) {
+        const data = await res.json();
+        setUser(data.user);
+        if (nexus.analytics) {
+          nexus.analytics.identify(data.user.id, {
+            email: data.user.email,
+            role: data.user.role,
+            ...data.user.metadata
+          });
+        }
+      } else {
+        setUser(null);
+      }
+    } catch (err) {
+      console.debug("[NexusHub Auth] Session check failed:", err);
+      setUser(null);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [AUTH_BASE, config]);
+  useEffect(() => {
+    checkSession();
+  }, [checkSession]);
+  const login = async (creds) => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const res = await fetch(`${AUTH_BASE}/login`, {
+        method: "POST",
+        headers: getHeaders(config),
+        body: JSON.stringify(creds)
+      });
+      if (!res.ok) throw await parseError(res);
+      const data = await res.json();
+      setUser(data.user);
+      if (nexus.analytics) {
+        await nexus.analytics.identify(data.user.id, {
+          email: data.user.email,
+          role: data.user.role,
+          login_method: "email",
+          ...data.user.metadata
+        });
+      }
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  const register = async (creds) => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const res = await fetch(`${AUTH_BASE}/register`, {
+        method: "POST",
+        headers: getHeaders(config),
+        body: JSON.stringify(creds)
+      });
+      if (!res.ok) throw await parseError(res);
+      const data = await res.json();
+      setUser(data.user);
+      if (nexus.analytics) {
+        nexus.analytics.track("signup", { method: "email" });
+        nexus.analytics.identify(data.user.id, {
+          email: data.user.email,
+          role: data.user.role,
+          ...data.user.metadata
+        });
+      }
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  const logout = async () => {
+    setIsLoading(true);
+    try {
+      await fetch(`${AUTH_BASE}/logout`, {
+        method: "POST",
+        headers: getHeaders(config)
+      });
+    } catch (e) {
+      console.warn("Logout network error", e);
+    } finally {
+      setUser(null);
+      setIsLoading(false);
+      if (nexus.analytics) {
+        nexus.analytics.track("logout");
+      }
+    }
+  };
+  const updateProfile = async (updates) => {
+    try {
+      const res = await fetch(`${AUTH_BASE}/profile`, {
+        method: "PATCH",
+        headers: getHeaders(config),
+        body: JSON.stringify(updates)
+      });
+      if (!res.ok) throw await parseError(res);
+      const data = await res.json();
+      setUser(data.user);
+      if (nexus.analytics) {
+        nexus.analytics.identify(data.user.id, updates);
+      }
+    } catch (err) {
+      setError(err);
+      throw err;
+    }
+  };
+  const requestPasswordReset = async (email) => {
+    const res = await fetch(`${AUTH_BASE}/password/reset-request`, {
+      method: "POST",
+      headers: getHeaders(config),
+      body: JSON.stringify({ email })
+    });
+    if (!res.ok) throw await parseError(res);
+  };
+  return /* @__PURE__ */ jsx(
+    AuthContext.Provider,
+    {
+      value: {
+        user,
+        isLoading,
+        error,
+        isAuthenticated: !!user,
+        login,
+        register,
+        logout,
+        updateProfile,
+        requestPasswordReset
+      },
+      children
+    }
+  );
+};
+var useNexusAuth = () => {
+  const context = useContext(AuthContext);
+  if (!context) {
+    throw new Error("useNexusAuth must be used within a NexusProvider");
+  }
+  return context;
+};
+function getHeaders(config) {
+  return {
+    "Content-Type": "application/json",
+    "x-nexus-project": config.projectId,
+    Authorization: `Bearer ${config.apiKey}`
+    // 👈 CRITICAL: Send the nx_pk_ key
+    // Note: We do NOT send the Master API Key here.
+    // This is client-side. The backend uses Cookies or public tokens.
+  };
+}
+async function parseError(res) {
+  try {
+    const json = await res.json();
+    return {
+      status: res.status,
+      code: json.code || "UNKNOWN_ERROR",
+      message: json.message || "An error occurred during authentication"
+    };
+  } catch {
+    return {
+      status: res.status,
+      code: "NETWORK_ERROR",
+      message: res.statusText
+    };
+  }
+}
+
+// src/components/NexusProvider.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var NexusContext = createContext2(nexus);
+var NexusLiveFeedContext = createContext2({
+  latestEvent: null,
+  isConnected: false
+});
+var useNexusLiveFeed = () => React2.useContext(NexusLiveFeedContext);
+function NexusAnalyticsTracker({
+  disableAnalytics
+}) {
+  const pathname = usePathname();
+  const searchParams = useSearchParams();
+  const prevPathRef = useRef("");
+  const searchParamsString = searchParams.toString();
+  useEffect2(() => {
+    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" } });
+}
+var NexusProvider = ({
+  children,
+  projectId,
+  disableAnalytics = false,
+  hasConsent = true,
+  // NEW: default true to preserve existing behaviour
+  enableLiveFeed = false,
+  // NEW
+  onLiveEvent
+  // NEW
+}) => {
+  const isInitialized = useRef(false);
+  const socketRef = useRef(null);
+  const [latestEvent, setLatestEvent] = useState2(
+    null
+  );
+  const [isConnected, setIsConnected] = useState2(false);
+  const liveFeedValue = useMemo(
+    () => ({ latestEvent, isConnected }),
+    [latestEvent, isConnected]
+  );
+  const config = useMemo(() => {
+    if (projectId && nexus.getConfig().projectId !== projectId) {
+      nexus.updateConfig({ projectId });
+    }
+    return nexus.getConfig();
+  }, [projectId]);
+  useEffect2(() => {
+    if (typeof window === "undefined" || disableAnalytics || !hasConsent)
+      return;
+    if (!isInitialized.current) {
+      if (!nexus.analytics) {
+        nexus.analytics = new AnalyticsEngine(nexus.getConfig());
+      }
+      nexus.analytics.start();
+      isInitialized.current = true;
+      if (nexus.getConfig().debug) {
+        console.log("[NexusHub] \u{1F680} Provider initialized analytics");
+      }
+    }
+    return () => {
+      if (nexus.analytics) {
+        nexus.analytics.stop();
+        isInitialized.current = false;
+      }
+    };
+  }, [disableAnalytics, hasConsent]);
+  const connectLiveFeed = useCallback2(async () => {
+    if (typeof window === "undefined" || !enableLiveFeed) return;
+    try {
+      const { io } = await import("socket.io-client");
+      const cfg = nexus.getConfig();
+      const wsUrl = cfg.apiUrl || "http://localhost:3001";
+      const socket = io(`${wsUrl}/analytics`, {
+        auth: { token: cfg.apiKey },
+        query: { projectId: cfg.projectId },
+        transports: ["websocket"],
+        reconnectionAttempts: 5,
+        reconnectionDelay: 2e3
+      });
+      socket.on("connect", () => {
+        setIsConnected(true);
+        if (cfg.debug) console.log("[NexusHub] \u{1F534} Live feed connected");
+      });
+      socket.on("disconnect", () => {
+        setIsConnected(false);
+        if (cfg.debug) console.log("[NexusHub] Live feed disconnected");
+      });
+      socket.on("live_event", (event) => {
+        setLatestEvent(event);
+        onLiveEvent?.(event);
+      });
+      socketRef.current = socket;
+    } catch (err) {
+      console.error("[NexusHub] Live feed connection failed:", err);
+    }
+  }, [enableLiveFeed, onLiveEvent]);
+  useEffect2(() => {
+    if (enableLiveFeed) {
+      connectLiveFeed();
+    }
+    return () => {
+      if (socketRef.current) {
+        socketRef.current.disconnect();
+        socketRef.current = null;
+        setIsConnected(false);
+      }
+    };
+  }, [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 }) }),
+    children
+  ] }) }) });
+};
+var useNexus = () => {
+  const context = React2.useContext(NexusContext);
+  if (!context) {
+    throw new Error("useNexus must be used within a NexusProvider");
+  }
+  return context;
+};
+var useNexusAnalytics = () => {
+  const client = useNexus();
+  if (!client.analytics) {
+    return {
+      track: () => {
+      },
+      identify: async () => false,
+      group: async () => false,
+      alias: async () => false,
+      trackPurchase: () => {
+      },
+      trackError: () => {
+      },
+      reset: () => {
+      }
+    };
+  }
+  return {
+    track: client.analytics.track.bind(client.analytics),
+    identify: client.analytics.identify.bind(client.analytics),
+    group: client.analytics.group.bind(client.analytics),
+    alias: client.analytics.alias.bind(client.analytics),
+    trackPurchase: client.analytics.trackPurchase.bind(client.analytics),
+    trackError: client.analytics.trackError.bind(client.analytics),
+    reset: client.analytics.reset.bind(client.analytics)
+  };
+};
 export {
   AuthProvider,
   NexusProvider,