@nexushub/client 0.4.2 → 0.4.4

package/dist/index.cjs

@@ -1,51 +1,2649 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});"use client";
-
-
-
-
-
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/config.ts
+var DEFAULT_API_URL, DEFAULT_ANALYTICS_URL, LOCAL_NEST_URL, LOCAL_RUST_URL, getEnvConfig, mergeConfigs, getFullConfig, validateConfig;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    DEFAULT_API_URL = "https://endpoints.gnexus.co.tz";
+    DEFAULT_ANALYTICS_URL = "https://sentry.gnexus.co.tz";
+    LOCAL_NEST_URL = "https://endpoints.gnexus.co.tz";
+    LOCAL_RUST_URL = "https://sentry.gnexus.co.tz";
+    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
+      };
+    };
+    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
+      };
+    };
+    getFullConfig = (partialConfig) => {
+      const envConfig = getEnvConfig();
+      return mergeConfigs(envConfig, partialConfig || {});
+    };
+    validateConfig = (config) => {
+      const errors = [];
+      if (!config.projectId) errors.push("Missing projectId");
+      if (!config.apiUrl) errors.push("Missing apiUrl");
+      return errors;
+    };
+  }
+});
 
+// src/content/binary-compiler.ts
+var crypto2, BinaryCompiler;
+var init_binary_compiler = __esm({
+  "src/content/binary-compiler.ts"() {
+    "use strict";
+    crypto2 = __toESM(require("crypto"), 1);
+    BinaryCompiler = class {
+      /**
+       * Generates a secure, deterministic cryptographic key from the project's API key.
+       */
+      static deriveKeys(apiKey) {
+        const hash = crypto2.createHash("sha256").update(apiKey).digest();
+        const encryptionKey = hash;
+        const hmacKey = crypto2.createHmac("sha256", apiKey).update("nexus-integrity-key").digest();
+        return { encryptionKey, hmacKey };
+      }
+      /**
+       * Compiles JSON content data into a secure, signed, and encrypted .nx binary buffer.
+       */
+      static compile(data, apiKey, projectId, metadataOverrides = {}) {
+        const { encryptionKey, hmacKey } = this.deriveKeys(apiKey);
+        const metadata = {
+          version: "2.0.0",
+          compiledAt: (/* @__PURE__ */ new Date()).toISOString(),
+          projectId,
+          ...metadataOverrides
+        };
+        const metadataStr = JSON.stringify(metadata);
+        const metadataBuffer = Buffer.from(metadataStr, "utf-8");
+        const iv = crypto2.randomBytes(16);
+        const cipher = crypto2.createCipheriv(this.ALGORITHM, encryptionKey, iv);
+        const plainTextPayload = JSON.stringify(data);
+        let encryptedPayload = cipher.update(plainTextPayload, "utf8");
+        encryptedPayload = Buffer.concat([encryptedPayload, cipher.final()]);
+        const payloadBuffer = Buffer.concat([iv, encryptedPayload]);
+        const headerBuffer = Buffer.from(this.MAGIC_HEADER, "ascii");
+        const metaLengthBuffer = Buffer.alloc(4);
+        metaLengthBuffer.writeUInt32BE(metadataBuffer.length, 0);
+        const payloadLengthBuffer = Buffer.alloc(4);
+        payloadLengthBuffer.writeUInt32BE(payloadBuffer.length, 0);
+        const prefixBlock = Buffer.concat([
+          headerBuffer,
+          metaLengthBuffer,
+          metadataBuffer,
+          payloadLengthBuffer,
+          payloadBuffer
+        ]);
+        const hmac = crypto2.createHmac("sha256", hmacKey);
+        hmac.update(prefixBlock);
+        const signature = hmac.digest();
+        return Buffer.concat([prefixBlock, signature]);
+      }
+      /**
+       * Verifies, decrypts, and decompiles a .nx binary buffer back into clean, type-safe JSON.
+       * Throws structured errors on integrity verification failures or file corruption.
+       */
+      static decompile(buffer, apiKey) {
+        if (buffer.length < 44) {
+          throw new Error(
+            "Corrupted File: Binary payload is too short to be a valid Nexus node."
+          );
+        }
+        const { encryptionKey, hmacKey } = this.deriveKeys(apiKey);
+        const prefixBlockLength = buffer.length - 32;
+        const prefixBlock = buffer.subarray(0, prefixBlockLength);
+        const expectedSignature = buffer.subarray(prefixBlockLength);
+        const hmac = crypto2.createHmac("sha256", hmacKey);
+        hmac.update(prefixBlock);
+        const actualSignature = hmac.digest();
+        if (!crypto2.timingSafeEqual(expectedSignature, actualSignature)) {
+          throw new Error(
+            "DATA_INTEGRITY_VIOLATION: Cryptographic signature mismatch. This local node has been modified externally or tampered with."
+          );
+        }
+        const magicHeader = prefixBlock.subarray(0, 4).toString("ascii");
+        if (magicHeader !== this.MAGIC_HEADER) {
+          throw new Error(
+            "Invalid Format: File lacks the correct Nexus binary magic header."
+          );
+        }
+        const metaLength = prefixBlock.readUInt32BE(4);
+        const metaStart = 8;
+        const metaEnd = metaStart + metaLength;
+        const metadataStr = prefixBlock.subarray(metaStart, metaEnd).toString("utf-8");
+        const metadata = JSON.parse(metadataStr);
+        const payloadLength = prefixBlock.readUInt32BE(metaEnd);
+        const payloadStart = metaEnd + 4;
+        const payloadEnd = payloadStart + payloadLength;
+        const payloadBuffer = prefixBlock.subarray(payloadStart, payloadEnd);
+        const iv = payloadBuffer.subarray(0, 16);
+        const cipherText = payloadBuffer.subarray(16);
+        const decipher = crypto2.createDecipheriv(this.ALGORITHM, encryptionKey, iv);
+        let decrypted = decipher.update(cipherText);
+        decrypted = Buffer.concat([decrypted, decipher.final()]);
+        const data = JSON.parse(decrypted.toString("utf8"));
+        return { data, metadata };
+      }
+    };
+    BinaryCompiler.MAGIC_HEADER = "NEXS";
+    // 4-byte ASCII magic identifier
+    BinaryCompiler.ALGORITHM = "aes-256-cbc";
+  }
+});
 
+// src/content/local-cache-server.ts
+var local_cache_server_exports = {};
+__export(local_cache_server_exports, {
+  LocalCache: () => LocalCache
+});
+var import_fs, import_path, LocalCache;
+var init_local_cache_server = __esm({
+  "src/content/local-cache-server.ts"() {
+    "use strict";
+    import_fs = __toESM(require("fs"), 1);
+    import_path = __toESM(require("path"), 1);
+    init_config();
+    init_binary_compiler();
+    LocalCache = class {
+      constructor(customPath) {
+        this.apiKey = "";
+        this.baseDir = customPath || ".nexus/local";
+        const config = getEnvConfig();
+        this.apiKey = config.apiKey || "";
+      }
+      isLoaded() {
+        return import_fs.default.existsSync(import_path.default.resolve(process.cwd(), this.baseDir));
+      }
+      /**
+       * Helper to decrypt and decompile `.nx` files on-the-fly.
+       */
+      decompileFile(filePath) {
+        if (!this.apiKey) {
+          if (process.env.NODE_ENV === "development") {
+            console.warn(
+              "\u26A0\uFE0F  NexusHub: Missing NEXUS_API_KEY. Local decryption bypassed."
+            );
+          }
+          return null;
+        }
+        try {
+          const encryptedBuffer = import_fs.default.readFileSync(filePath);
+          const decompiled = BinaryCompiler.decompile(encryptedBuffer, this.apiKey);
+          return decompiled.data;
+        } catch (error) {
+          if (process.env.NODE_ENV === "development") {
+            console.error(
+              `
+\u{1F6A8}  NexusHub Security Alert: Data Integrity Violation in file:
+    ${filePath}
+    Error: ${error.message}
+    This file has been disabled until regenerated via npx nexus pull.
+`
+            );
+          }
+          return null;
+        }
+      }
+      /**
+       * Retrieve a specific page directly from its .nx file.
+       */
+      async getPage(slug) {
+        const filePath = import_path.default.resolve(
+          process.cwd(),
+          this.baseDir,
+          "pages",
+          `${slug}.nx`
+        );
+        if (import_fs.default.existsSync(filePath)) {
+          const pageData = this.decompileFile(filePath);
+          if (!pageData) return null;
+          return pageData.data !== void 0 ? pageData.data : pageData;
+        }
+        return null;
+      }
+      /**
+       * Retrieve an entire collection from its specific .nx file.
+       */
+      async getCollection(collectionId) {
+        const filePath = import_path.default.resolve(
+          process.cwd(),
+          this.baseDir,
+          "collections",
+          `${collectionId}.nx`
+        );
+        if (import_fs.default.existsSync(filePath)) {
+          return this.decompileFile(filePath);
+        }
+        return null;
+      }
+      /**
+       * Retrieve global settings from its .nx file.
+       */
+      async getGlobals() {
+        const filePath = import_path.default.resolve(process.cwd(), this.baseDir, "globals.nx");
+        if (import_fs.default.existsSync(filePath)) {
+          return this.decompileFile(filePath);
+        }
+        return null;
+      }
+      /**
+       * Returns a merged JSON of the entire workspace structure.
+       */
+      async getAllData() {
+        const pages = {};
+        const collections = {};
+        let globals = {};
+        try {
+          const pagesDir = import_path.default.resolve(process.cwd(), this.baseDir, "pages");
+          if (import_fs.default.existsSync(pagesDir)) {
+            for (const file of import_fs.default.readdirSync(pagesDir)) {
+              if (file.endsWith(".nx")) {
+                const slug = import_path.default.basename(file, ".nx");
+                pages[slug] = await this.getPage(slug);
+              }
+            }
+          }
+          const colsDir = import_path.default.resolve(process.cwd(), this.baseDir, "collections");
+          if (import_fs.default.existsSync(colsDir)) {
+            for (const file of import_fs.default.readdirSync(colsDir)) {
+              if (file.endsWith(".nx")) {
+                const id = import_path.default.basename(file, ".nx");
+                collections[id] = await this.getCollection(id) || [];
+              }
+            }
+          }
+          globals = await this.getGlobals() || {};
+        } catch {
+        }
+        return { pages, collections, globals };
+      }
+    };
+  }
+});
 
+// src/content/local-cache-client.ts
+var local_cache_client_exports = {};
+__export(local_cache_client_exports, {
+  LocalCache: () => LocalCache2
+});
+var LocalCache2;
+var init_local_cache_client = __esm({
+  "src/content/local-cache-client.ts"() {
+    "use strict";
+    LocalCache2 = class {
+      constructor(customPath) {
+        // Maintain private properties for type parity with the Server version
+        this.data = null;
+        this.hasLoaded = false;
+        this.cachePath = customPath || ".nexus/cache.json";
+      }
+      /**
+       * Always returns false in the browser as local file caching
+       * is a server-side only feature.
+       */
+      isLoaded() {
+        return false;
+      }
+      /**
+       * No-op method to maintain internal API compatibility.
+       */
+      load() {
+        return;
+      }
+      /**
+       * Returns null. Browsers should fetch pages from the Remote API
+       * or the Memory/Browser cache.
+       */
+      async getPage(_slug) {
+        return null;
+      }
+      /**
+       * Returns null. Browsers should fetch collections from the Remote API.
+       */
+      async getCollection(_collectionId) {
+        return null;
+      }
+      /**
+       * Returns null.
+       */
+      async getGlobals() {
+        return null;
+      }
+      /**
+       * Returns null.
+       */
+      async getAllData() {
+        return null;
+      }
+      /**
+       * Dummy helper to match Node implementation.
+       */
+      shouldWarnAboutMissingCache(error) {
+        const isMissing = error.code === "ENOENT";
+        const isMalformed = error instanceof SyntaxError;
+        if (process.env.NODE_ENV !== "development") return false;
+        return !isMissing || isMalformed;
+      }
+    };
+  }
+});
 
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AnalyticsEngine: () => AnalyticsEngine,
+  BrowserCache: () => BrowserCache,
+  CacheTags: () => CacheTags,
+  ContentEngine: () => ContentEngine,
+  DEFAULT_ANALYTICS_URL: () => DEFAULT_ANALYTICS_URL,
+  DEFAULT_API_URL: () => DEFAULT_API_URL,
+  LOCAL_NEST_URL: () => LOCAL_NEST_URL,
+  LOCAL_RUST_URL: () => LOCAL_RUST_URL,
+  LocalCache: () => LocalCacheProxy,
+  MemoryCache: () => MemoryCache,
+  NexusClient: () => NexusClient,
+  VERSION: () => VERSION,
+  createNexusClient: () => createNexusClient,
+  getEnvConfig: () => getEnvConfig,
+  getFullConfig: () => getFullConfig,
+  mergeConfigs: () => mergeConfigs,
+  nexus: () => nexus,
+  validateConfig: () => validateConfig
+});
+module.exports = __toCommonJS(index_exports);
 
+// src/client.ts
+init_config();
 
+// 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 Promise.resolve().then(() => (init_local_cache_server(), local_cache_server_exports));
+      this.instance = new mod.LocalCache(this.cachePath);
+    } else {
+      const mod = await Promise.resolve().then(() => (init_local_cache_client(), local_cache_client_exports));
+      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
+var import_web_vitals = require("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;
+    };
+    (0, import_web_vitals.onCLS)(recordMetric);
+    (0, import_web_vitals.onLCP)(recordMetric);
+    (0, import_web_vitals.onTTFB)(recordMetric);
+    (0, import_web_vitals.onINP)(recordMetric);
+    (0, import_web_vitals.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}`;
+}
 
-var _chunkFMMFQP5Ocjs = require('./chunk-FMMFQP5O.cjs');
+// 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();
+var createNexusClient = (config) => new NexusClient(config);
 
 // src/index.ts
+init_config();
 var VERSION = "0.0.1";
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.AnalyticsEngine = _chunkFMMFQP5Ocjs.AnalyticsEngine; exports.AuthProvider = _chunkFMMFQP5Ocjs.AuthProvider; exports.BrowserCache = _chunkFMMFQP5Ocjs.BrowserCache; exports.CacheTags = _chunkFMMFQP5Ocjs.CacheTags; exports.ContentEngine = _chunkFMMFQP5Ocjs.ContentEngine; exports.DEFAULT_ANALYTICS_URL = _chunkFMMFQP5Ocjs.DEFAULT_ANALYTICS_URL; exports.DEFAULT_API_URL = _chunkFMMFQP5Ocjs.DEFAULT_API_URL; exports.LOCAL_NEST_URL = _chunkFMMFQP5Ocjs.LOCAL_NEST_URL; exports.LOCAL_RUST_URL = _chunkFMMFQP5Ocjs.LOCAL_RUST_URL; exports.LocalCache = _chunkFMMFQP5Ocjs.LocalCacheProxy; exports.MemoryCache = _chunkFMMFQP5Ocjs.MemoryCache; exports.NexusClient = _chunkFMMFQP5Ocjs.NexusClient; exports.NexusProvider = _chunkFMMFQP5Ocjs.NexusProvider; exports.VERSION = VERSION; exports.createNexusClient = _chunkFMMFQP5Ocjs.createNexusClient; exports.getEnvConfig = _chunkFMMFQP5Ocjs.getEnvConfig; exports.getFullConfig = _chunkFMMFQP5Ocjs.getFullConfig; exports.mergeConfigs = _chunkFMMFQP5Ocjs.mergeConfigs; exports.nexus = _chunkFMMFQP5Ocjs.nexus; exports.useNexus = _chunkFMMFQP5Ocjs.useNexus; exports.useNexusAuth = _chunkFMMFQP5Ocjs.useNexusAuth; exports.validateConfig = _chunkFMMFQP5Ocjs.validateConfig;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnalyticsEngine,
+  BrowserCache,
+  CacheTags,
+  ContentEngine,
+  DEFAULT_ANALYTICS_URL,
+  DEFAULT_API_URL,
+  LOCAL_NEST_URL,
+  LOCAL_RUST_URL,
+  LocalCache,
+  MemoryCache,
+  NexusClient,
+  VERSION,
+  createNexusClient,
+  getEnvConfig,
+  getFullConfig,
+  mergeConfigs,
+  nexus,
+  validateConfig
+});