@nexushub/client 0.0.4 → 0.0.7

package/dist/index.cjs

@@ -0,0 +1,2008 @@
+'use strict';
+
+var chunk2JRYABGG_cjs = require('./chunk-2JRYABGG.cjs');
+var webVitals = require('web-vitals');
+var react = require('react');
+var navigation = require('next/navigation');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/config.ts
+var DEFAULT_API_URL = "http://localhost:3001";
+var DEFAULT_ANALYTICS_URL = "http://localhost:3002";
+var LOCAL_NEST_URL = "http://localhost:3001";
+var LOCAL_RUST_URL = "http://localhost:3002";
+var hasEnv = () => {
+  return typeof process !== "undefined" && typeof process.env !== "undefined" && Object.keys(process.env).length > 0;
+};
+var getEnvConfig = () => {
+  const env = hasEnv() ? process.env : {};
+  const isDev = env.NODE_ENV === "development" || env.NEXT_PUBLIC_NODE_ENV === "development";
+  const projectId = env.NEXT_PUBLIC_NEXUS_ID ?? env.NEXUS_PROJECT_ID;
+  const apiKey = env.NEXT_PUBLIC_NEXUS_KEY ?? env.NEXUS_API_KEY;
+  const apiUrl = env.NEXT_PUBLIC_NEXUS_API_URL ?? env.NEXUS_API_URL ?? (isDev ? LOCAL_NEST_URL : DEFAULT_API_URL);
+  const analyticsUrl = env.NEXT_PUBLIC_NEXUS_ANALYTICS_URL ?? (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
+  };
+};
+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");
+  if (config.apiUrl && !config.apiUrl.startsWith("http")) {
+    errors.push("apiUrl must be a valid URL (http:// or https://)");
+  }
+  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/strategies.ts
+var RateLimiter = class {
+  constructor(config) {
+    this.requests = [];
+    this.config = config;
+  }
+  async checkLimit() {
+    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[0];
+      const waitTime = windowStart + this.config.timeWindow - now;
+      if (waitTime > 0) {
+        await new Promise((resolve) => setTimeout(resolve, waitTime));
+        return this.checkLimit();
+      }
+    }
+    this.requests.push(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
+    };
+  }
+};
+var ExponentialBackoff = class {
+  constructor(config) {
+    this.config = {
+      jitter: true,
+      ...config
+    };
+  }
+  async execute(fn, onRetry) {
+    let lastError;
+    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 */) {
+      const now = Date.now();
+      if (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 chunk2JRYABGG_cjs.LocalCache();
+    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 = 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 = 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 = 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
+   */
+  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 = 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);
+    }
+  }
+  /**
+   * 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()
+    });
+    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()
+    });
+    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, ...fetchOptions } = options;
+    const controller = new AbortController();
+    const id = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(url, {
+        ...fetchOptions,
+        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 getDeviceEntropy = async () => {
+  if (typeof window === "undefined") return {};
+  const nav = window.navigator;
+  return {
+    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,
+    // Only available in Chrome/Edge
+    timezone_offset: (/* @__PURE__ */ new Date()).getTimezoneOffset(),
+    platform: nav.platform,
+    language: nav.language,
+    touch_support: "ontouchstart" in window || nav.maxTouchPoints > 0,
+    // Optional: Calculate Canvas Fingerprint for high-security modes
+    canvas_hash: await generateCanvasHash()
+  };
+};
+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;
+};
+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;
+    };
+    webVitals.onCLS(recordMetric);
+    webVitals.onLCP(recordMetric);
+    webVitals.onTTFB(recordMetric);
+    webVitals.onINP(recordMetric);
+    webVitals.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
+      };
+      this.hasUpdates = true;
+    }
+  }
+  getMetricsSnapshot() {
+    if (!this.hasUpdates) return null;
+    this.hasUpdates = false;
+    return { ...this.metrics };
+  }
+};
+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 = 1;
+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, reject) => {
+      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.createObjectStore(STORE_NAME, { keyPath: "id", autoIncrement: true });
+        }
+      };
+    });
+  }
+  /**
+   * Add an event to the persistent queue
+   */
+  async enqueue(payload) {
+    await this.isReady;
+    if (!this.db) return;
+    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 oldest events
+   */
+  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 after 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);
+      ids.forEach((id) => {
+        store.delete(id);
+      });
+    });
+  }
+  /**
+   * Count pending events
+   */
+  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 Tracker = class {
+  // 🆕
+  constructor(config) {
+    this.sessionId = "";
+    this.visitorId = "";
+    // FIX: Add this property
+    this.isFlushing = false;
+    this.config = config;
+    this.config.apiUrl.replace("/v1", "").replace(/\/$/, "");
+    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 sid = localStorage.getItem("nexus_sid");
+    let lastActivity = localStorage.getItem("nexus_last_active");
+    const now = Date.now();
+    const SESSION_TIMEOUT = 30 * 60 * 1e3;
+    if (!sid || !lastActivity || now - parseInt(lastActivity) > SESSION_TIMEOUT) {
+      sid = `sess_${Math.random().toString(36).substring(2, 9)}_${now}`;
+      localStorage.setItem("nexus_sid", sid);
+      this.sessionStart = now;
+    }
+    localStorage.setItem("nexus_last_active", now.toString());
+    this.sessionId = sid;
+  }
+  async send(eventType, data = {}, eventName) {
+    if (typeof window === "undefined") return;
+    localStorage.setItem("nexus_last_active", Date.now().toString());
+    const entropy = await getDeviceEntropy();
+    const perfMetrics = vitalsCollector.getMetricsSnapshot();
+    const payload = {
+      project_id: this.config.projectId,
+      session_id: this.sessionId,
+      // We send this, Rust verifies it
+      url: window.location.href,
+      referrer: document.referrer,
+      user_agent: window.navigator.userAgent,
+      screen_width: window.screen.width,
+      screen_height: window.screen.height,
+      language: window.navigator.language,
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      event_type: eventType,
+      event_name: eventName,
+      event_data: data,
+      // 3. Attach Performance Data (Rust: Option<PerformanceMetrics>)
+      performance: perfMetrics || void 0,
+      // 4. Attach Hardware Signals for Anomaly Detection (Rust: DeviceData)
+      context: {
+        device: {
+          hardware_concurrency: entropy.hardware_concurrency,
+          device_memory: entropy.device_memory,
+          pixel_ratio: entropy.pixel_ratio,
+          canvas_fingerprint: entropy.canvas_hash,
+          platform: entropy.platform
+        },
+        visitor_id_local: this.visitorId
+        // Hint for stitching
+      },
+      client_timestamp: (/* @__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;
+  }
+  // FIX: Add this method to satisfy AnalyticsEngine
+  getSessionDuration() {
+    return Date.now() - this.sessionStart;
+  }
+  // FIX: Add this method to satisfy AnalyticsEngine
+  stop() {
+    if (this.flushInterval) {
+      clearInterval(this.flushInterval);
+    }
+    this.flushQueue(true);
+  }
+};
+
+// src/analytics/index.ts
+var AnalyticsEngine = class {
+  constructor(config) {
+    this.cleanupFns = [];
+    this.isInitialized = false;
+    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();
+    console.log("[NexusHub] \u{1F680} Analytics Engine Started");
+  }
+  pageView() {
+    if (typeof window === "undefined") return;
+    this.tracker.send("page_view", {
+      path: window.location.pathname,
+      search: window.location.search,
+      title: document.title,
+      timezone_offset: (/* @__PURE__ */ new Date()).getTimezoneOffset()
+    });
+  }
+  // 🆕 PRIVATE: Track "Dark Social" Intent
+  setupShareTracking() {
+    if (typeof window === "undefined") return;
+    const copyHandler = () => {
+      this.tracker.send("social_share", {
+        method: "clipboard_copy",
+        url: window.location.href
+      });
+    };
+    if (navigator.share) {
+      const originalShare = navigator.share;
+      navigator.share = (data) => {
+        this.tracker.send("social_share", {
+          method: "native_share_menu",
+          url: data?.url || window.location.href,
+          title: data?.title
+        });
+        return originalShare.apply(navigator, [data]);
+      };
+    }
+    window.addEventListener("copy", copyHandler, { passive: true });
+    this.cleanupFns.push(() => window.removeEventListener("copy", copyHandler));
+  }
+  // --- IDENTITY & B2B (The Missing Pieces) ---
+  /**
+   * 1. IDENTIFY: Link anonymous session to a User ID
+   */
+  async identify(userId, traits = {}) {
+    return this.sendIdentityRequest("identify", {
+      user_id: userId,
+      traits
+    });
+  }
+  /**
+   * 2. GROUP: Link the current user to a Company/Organization (B2B)
+   * Required for the /api/group Rust route.
+   */
+  async group(groupId, traits = {}) {
+    return this.sendIdentityRequest("group", {
+      group_id: groupId,
+      // The Rust backend handles looking up the user from the session if not provided,
+      // but passing the user_id if known is safer.
+      traits
+    });
+  }
+  /**
+   * 3. ALIAS: Merge two identities (e.g. "Guest_123" -> "User_99")
+   * Required for the /api/alias Rust route.
+   */
+  async alias(newId) {
+    return this.sendIdentityRequest("alias", {
+      previous_id: this.tracker.getSession(),
+      // Or the old visitor_id
+      user_id: newId
+    });
+  }
+  /**
+   * 4. RESET: Clear local data and (optionally) request GDPR scrub
+   */
+  reset(performGdprScrub = false) {
+    const config = this.tracker["config"];
+    this.tracker.stop();
+    localStorage.removeItem("nexus_sid");
+    localStorage.removeItem("nexus_vid");
+    if (performGdprScrub) {
+      const endpoint = `${config.analyticsUrl}/api/privacy/scrub`;
+      const userId = this.tracker.visitorId;
+      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();
+  }
+  // --- E-COMMERCE & CUSTOM ---
+  track(eventName, properties = {}) {
+    this.tracker.send(
+      "custom_event",
+      { event_name: eventName, ...properties },
+      eventName
+    );
+  }
+  trackPurchase(orderData) {
+    this.tracker.send("purchase", {
+      ...orderData,
+      currency: orderData.currency || "USD",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  trackError(error, context) {
+    this.tracker.send("error", {
+      message: error.message,
+      stack: error.stack,
+      context,
+      url: typeof window !== "undefined" ? window.location.href : ""
+    });
+  }
+  // --- INTERNAL HELPER ---
+  async sendIdentityRequest(type, data) {
+    try {
+      const config = this.tracker["config"];
+      const endpoint = `${config.analyticsUrl}/api/${type}`;
+      const payload = {
+        project_id: this.tracker["config"].projectId,
+        session_id: this.tracker.getSession(),
+        visitor_id: this.tracker.visitorId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        ...data
+      };
+      if (type === "group" && !payload.user_id) {
+      }
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.tracker["config"].apiKey}`
+        },
+        body: JSON.stringify(payload)
+      });
+      if (response.ok) {
+        this.tracker.send(type, data);
+        return true;
+      }
+      return false;
+    } catch (error) {
+      console.error(`[NexusHub] ${type} failed:`, error);
+      return false;
+    }
+  }
+  // --- PRIVATE EVENT LISTENERS (Keep existing setupClickTracking, setupFormTracking, setupRouteTracking) ---
+  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 }
+        });
+      }
+      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 }
+        });
+      }
+    };
+    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)
+    );
+  }
+  setupRouteTracking() {
+    if (typeof window === "undefined" || typeof window.history === "undefined")
+      return;
+    const originalPushState = history.pushState;
+    const originalReplaceState = history.replaceState;
+    history.pushState = (...args) => {
+      originalPushState.apply(history, args);
+      this.pageView();
+    };
+    history.replaceState = (...args) => {
+      originalReplaceState.apply(history, args);
+      this.pageView();
+    };
+    const popStateHandler = () => this.pageView();
+    window.addEventListener("popstate", popStateHandler);
+    this.cleanupFns.push(
+      () => window.removeEventListener("popstate", popStateHandler)
+    );
+  }
+  getSessionId() {
+    return this.tracker.getSession();
+  }
+  stop() {
+    this.cleanupFns.forEach((fn) => fn());
+    this.cleanupFns = [];
+    this.tracker.send("session_end", {
+      session_id: this.tracker.getSession(),
+      duration: this.tracker.getSessionDuration()
+    });
+    this.tracker.stop();
+    this.isInitialized = false;
+  }
+};
+
+// src/client.ts
+var NexusClient = class {
+  // Make this public/accessible
+  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
+    };
+    this.content = new ContentEngine(this.config);
+    if (typeof window !== "undefined") {
+      this.analytics = new AnalyticsEngine(this.config);
+      this.analytics.start();
+    }
+    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. Content fetching will fail.");
+      }
+    }
+    this.content = new ContentEngine(this.config);
+  }
+  // Helper alias for cleaner code
+  getPage(slug, options) {
+    return this.content.getPage(slug, options);
+  }
+  // Get current config (readonly)
+  getConfig() {
+    return { ...this.config };
+  }
+};
+var nexus = new NexusClient();
+var createNexusClient = (config) => new NexusClient(config);
+var AuthContext = react.createContext(null);
+var AuthProvider = ({
+  children,
+  config
+}) => {
+  const [user, setUser] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const AUTH_BASE = `${config.apiUrl}/auth/project/${config.projectId}`;
+  const checkSession = react.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]);
+  react.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__ */ jsxRuntime.jsx(AuthContext.Provider, { value: {
+    user,
+    isLoading,
+    error,
+    isAuthenticated: !!user,
+    login,
+    register,
+    logout,
+    updateProfile,
+    requestPasswordReset
+  }, children });
+};
+var useNexusAuth = () => {
+  const context = react.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
+    // 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
+    };
+  }
+}
+var NexusContext = react.createContext(nexus);
+var NexusProvider = ({
+  children,
+  projectId,
+  disableAnalytics = false
+}) => {
+  const pathname = navigation.usePathname();
+  const searchParams = navigation.useSearchParams();
+  const isInitialized = react.useRef(false);
+  const config = react.useMemo(() => {
+    const currentConfig = nexus.getConfig();
+    if (projectId && currentConfig.projectId !== projectId) {
+      nexus.config.projectId = projectId;
+    }
+    return nexus.getConfig();
+  }, [projectId]);
+  react.useEffect(() => {
+    if (typeof window === "undefined" || disableAnalytics) 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]);
+  react.useEffect(() => {
+    if (nexus.analytics && !disableAnalytics) {
+      nexus.analytics.pageView();
+    }
+  }, [pathname, searchParams, disableAnalytics]);
+  return /* @__PURE__ */ jsxRuntime.jsx(NexusContext.Provider, { value: nexus, children: /* @__PURE__ */ jsxRuntime.jsx(AuthProvider, { config, children }) });
+};
+
+// src/index.ts
+var VERSION = "0.0.1";
+
+Object.defineProperty(exports, "LocalCache", {
+  enumerable: true,
+  get: function () { return chunk2JRYABGG_cjs.LocalCache; }
+});
+exports.AnalyticsEngine = AnalyticsEngine;
+exports.AuthProvider = AuthProvider;
+exports.BrowserCache = BrowserCache;
+exports.CacheTags = CacheTags;
+exports.ContentEngine = ContentEngine;
+exports.DEFAULT_ANALYTICS_URL = DEFAULT_ANALYTICS_URL;
+exports.DEFAULT_API_URL = DEFAULT_API_URL;
+exports.LOCAL_NEST_URL = LOCAL_NEST_URL;
+exports.LOCAL_RUST_URL = LOCAL_RUST_URL;
+exports.MemoryCache = MemoryCache;
+exports.NexusClient = NexusClient;
+exports.NexusProvider = NexusProvider;
+exports.VERSION = VERSION;
+exports.createNexusClient = createNexusClient;
+exports.getEnvConfig = getEnvConfig;
+exports.getFullConfig = getFullConfig;
+exports.mergeConfigs = mergeConfigs;
+exports.nexus = nexus;
+exports.useNexusAuth = useNexusAuth;
+exports.validateConfig = validateConfig;