@nexushub/client 0.9.0 → 1.1.1

package/dist/index.js

@@ -9,27 +9,32 @@ var __export = (target, all) => {
 };
 
 // src/config.ts
-var DEFAULT_API_URL, DEFAULT_ANALYTICS_URL, LOCAL_NEST_URL, LOCAL_RUST_URL, getEnvConfig, mergeConfigs, getFullConfig, validateConfig;
+var DEFAULT_API_URL, DEFAULT_ANALYTICS_URL, SDK_VERSION, LOCAL_NEST_URL, LOCAL_RUST_URL, getEnvConfig, mergeConfigs, getFullConfig, validateConfig, hasRequiredConfig;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
     DEFAULT_API_URL = "https://api.gnapex.com";
     DEFAULT_ANALYTICS_URL = "https://sentry.gnapex.com";
+    SDK_VERSION = "1.1.0";
     LOCAL_NEST_URL = "https://api.gnapex.com";
     LOCAL_RUST_URL = "https://sentry.gnapex.com";
     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 NEXT_PUBLIC_ID = typeof process !== "undefined" ? process.env.NEXT_PUBLIC_GNAPEX_ID ?? process.env.NEXT_PUBLIC_NEXUS_ID : void 0;
+      const NEXT_PUBLIC_KEY = typeof process !== "undefined" ? process.env.NEXT_PUBLIC_GNAPEX_KEY ?? process.env.NEXT_PUBLIC_NEXUS_KEY : void 0;
+      const NEXT_PUBLIC_URL = typeof process !== "undefined" ? process.env.NEXT_PUBLIC_GNAPEX_API_URL ?? process.env.NEXT_PUBLIC_NEXUS_API_URL : void 0;
+      const NEXT_PUBLIC_ANALYTICS_URL = typeof process !== "undefined" ? process.env.NEXT_PUBLIC_GNAPEX_ANALYTICS_URL ?? process.env.NEXT_PUBLIC_NEXUS_ANALYTICS_URL : void 0;
+      const NODE_ID = typeof process !== "undefined" ? process.env.GNAPEX_PROJECT_ID ?? process.env.NEXUS_PROJECT_ID : void 0;
+      const NODE_KEY = typeof process !== "undefined" ? process.env.GNAPEX_API_KEY ?? process.env.NEXUS_API_KEY : void 0;
+      const NODE_URL = typeof process !== "undefined" ? process.env.GNAPEX_API_URL ?? process.env.NEXUS_API_URL : void 0;
+      const NODE_ANALYTICS_URL = typeof process !== "undefined" ? process.env.GNAPEX_ANALYTICS_URL ?? process.env.NEXUS_ANALYTICS_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;
+      const runtime = typeof window !== "undefined" ? window.__GNAPEX__ ?? window.__NEXUS__ : void 0;
+      const meta = typeof document !== "undefined" ? (name) => document.querySelector(`meta[name="${name}"]`)?.getAttribute("content") ?? void 0 : (_name) => void 0;
+      const projectId = runtime?.projectId ?? meta("gnapex-project") ?? meta("nexus-project") ?? NEXT_PUBLIC_ID ?? NODE_ID;
+      const apiKey = runtime?.apiKey ?? meta("gnapex-key") ?? meta("nexus-key") ?? NEXT_PUBLIC_KEY ?? NODE_KEY;
+      const apiUrl = runtime?.apiUrl ?? meta("gnapex-api") ?? meta("nexus-api") ?? NEXT_PUBLIC_URL ?? NODE_URL ?? (isDev ? LOCAL_NEST_URL : DEFAULT_API_URL);
+      const analyticsUrl = runtime?.analyticsUrl ?? meta("gnapex-analytics") ?? meta("nexus-analytics") ?? NEXT_PUBLIC_ANALYTICS_URL ?? NODE_ANALYTICS_URL ?? (apiUrl.includes("localhost") ? LOCAL_RUST_URL : DEFAULT_ANALYTICS_URL);
       return {
         projectId,
         apiKey,
@@ -57,8 +62,12 @@ var init_config = __esm({
       const errors = [];
       if (!config.projectId) errors.push("Missing projectId");
       if (!config.apiUrl) errors.push("Missing apiUrl");
+      else if (!/^https?:\/\//.test(config.apiUrl)) {
+        errors.push("apiUrl must be a valid URL starting with http:// or https://");
+      }
       return errors;
     };
+    hasRequiredConfig = (config) => validateConfig(config).length === 0;
   }
 });
 
@@ -166,6 +175,61 @@ var init_binary_compiler = __esm({
   }
 });
 
+// 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 };
+}
+var init_utils = __esm({
+  "src/content/utils.ts"() {
+    "use strict";
+  }
+});
+
 // src/content/local-cache-server.ts
 var local_cache_server_exports = {};
 __export(local_cache_server_exports, {
@@ -179,6 +243,7 @@ var init_local_cache_server = __esm({
     "use strict";
     init_config();
     init_binary_compiler();
+    init_utils();
     LocalCache = class {
       constructor(customPath, apiKey) {
         this.apiKey = "";
@@ -189,9 +254,6 @@ var init_local_cache_server = __esm({
       isLoaded() {
         return fs.existsSync(path.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") {
@@ -220,9 +282,14 @@ var init_local_cache_server = __esm({
         }
       }
       /**
-       * Retrieve a specific page directly from its .nx file.
+       * Retrieve a specific page safely from its .nx file.
        */
       async getPage(slug) {
+        try {
+          validateSlug(slug);
+        } catch {
+          return null;
+        }
         const filePath = path.resolve(
           process.cwd(),
           this.baseDir,
@@ -241,9 +308,14 @@ var init_local_cache_server = __esm({
         return null;
       }
       /**
-       * Retrieve an entire collection from its specific .nx file.
+       * Retrieve an entire collection safely from its specific .nx file.
        */
       async getCollection(collectionId) {
+        try {
+          validateSlug(collectionId);
+        } catch {
+          return null;
+        }
         const filePath = path.resolve(
           process.cwd(),
           this.baseDir,
@@ -669,90 +741,69 @@ var LocalCacheProxy = class {
 // src/content/strategies.ts
 var RateLimiter = class {
   constructor(config) {
-    this.requests = [];
     this.config = config;
+    this.requests = [];
   }
   async checkLimit() {
     while (true) {
       const now = Date.now();
-      const windowStart = now - this.config.timeWindow;
-      this.requests = this.requests.filter((time) => time > windowStart);
+      const cutoff = now - this.config.timeWindow;
+      this.requests = this.requests.filter((t) => t > cutoff);
       if (this.requests.length < this.config.maxRequests) {
         this.requests.push(now);
         return;
       }
-      const oldestRequest = this.requests[0];
-      const waitTime = oldestRequest + this.config.timeWindow - now;
-      if (waitTime > 0) {
-        await new Promise((resolve) => setTimeout(resolve, waitTime));
-      } else {
-      }
+      await new Promise((r) => setTimeout(r, Math.max(1, this.requests[0] + this.config.timeWindow - now)));
     }
   }
   getStats() {
     const now = Date.now();
-    const windowStart = now - this.config.timeWindow;
-    const currentRequests = this.requests.filter(
-      (time) => time > windowStart
-    ).length;
-    return { currentRequests, limit: this.config.maxRequests };
+    return { currentRequests: this.requests.filter((t) => t > now - this.config.timeWindow).length, limit: this.config.maxRequests };
   }
 };
 var ExponentialBackoff = class {
   constructor(config) {
+    this.config = config;
     this.config = { jitter: true, ...config };
   }
   async execute(fn, onRetry) {
-    let lastError = new Error("Unknown error");
-    for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
+    let last;
+    for (let a = 0; a <= this.config.maxRetries; a++) {
       try {
         return await fn();
-      } catch (error) {
-        lastError = error;
-        if (this.isClientError(error) && !this.isRateLimitError(error)) {
-          throw error;
-        }
-        if (attempt === this.config.maxRetries) break;
-        const delay = this.calculateDelay(attempt);
-        if (onRetry) onRetry(attempt + 1, delay, error);
-        await new Promise((resolve) => setTimeout(resolve, delay));
+      } catch (e) {
+        last = e;
+        if (e?.code === "ABORTED" || e?.code === "VALIDATION_ERROR" || e?.status >= 400 && e?.status < 500 && e?.status !== 429) throw e;
+        if (a === this.config.maxRetries) break;
+        let delay = Math.min(this.config.maxDelay, this.config.baseDelay * 2 ** a);
+        if (this.config.jitter) delay *= 0.5 + Math.random();
+        onRetry?.(a + 1, delay, e);
+        await new Promise((r) => setTimeout(r, delay));
       }
     }
-    throw lastError;
-  }
-  calculateDelay(attempt) {
-    let delay = this.config.baseDelay * Math.pow(2, attempt);
-    delay = Math.min(delay, this.config.maxDelay);
-    if (this.config.jitter) {
-      delay = delay * (0.5 + Math.random());
-    }
-    return delay;
-  }
-  isClientError(error) {
-    return error?.status >= 400 && error?.status < 500;
-  }
-  isRateLimitError(error) {
-    return error?.status === 429;
+    throw last;
   }
 };
+var CircuitState = /* @__PURE__ */ ((CircuitState2) => {
+  CircuitState2[CircuitState2["CLOSED"] = 0] = "CLOSED";
+  CircuitState2[CircuitState2["OPEN"] = 1] = "OPEN";
+  CircuitState2[CircuitState2["HALF_OPEN"] = 2] = "HALF_OPEN";
+  return CircuitState2;
+})(CircuitState || {});
 var CircuitBreaker = class {
-  constructor() {
+  constructor(threshold = 5, reset = 3e4) {
+    this.threshold = threshold;
+    this.reset = reset;
     this.state = 0 /* CLOSED */;
     this.failures = 0;
-    this.lastFailureTime = 0;
-    this.failureThreshold = 5;
-    this.resetTimeout = 3e4;
+    this.lastFailure = 0;
   }
-  // 30 seconds
   isOpen() {
-    if (this.state === 1 /* OPEN */) {
-      if (Date.now() - this.lastFailureTime > this.resetTimeout) {
-        this.state = 2 /* HALF_OPEN */;
-        return false;
-      }
-      return true;
+    if (this.state === 1 /* OPEN */ && Date.now() - this.lastFailure >= this.reset) {
+      this.state = 2 /* HALF_OPEN */;
+      return false;
     }
-    return false;
+    return this.state === 1 /* OPEN */;
   }
   recordSuccess() {
     this.failures = 0;
@@ -760,111 +811,35 @@ var CircuitBreaker = class {
   }
   recordFailure() {
     this.failures++;
-    this.lastFailureTime = Date.now();
-    if (this.failures >= this.failureThreshold) {
-      this.state = 1 /* OPEN */;
-      if (process.env.NODE_ENV === "development") {
-        console.warn(
-          "[NexusHub] \u{1F50C} Circuit Breaker OPEN. Pausing network requests."
-        );
-      }
-    }
+    this.lastFailure = Date.now();
+    if (this.failures >= this.threshold) this.state = 1 /* OPEN */;
+  }
+  getState() {
+    return CircuitState[this.state];
   }
 };
 var RequestBatcher = class {
-  constructor(batchWindow = 10, maxBatchSize = 20) {
-    this.batchWindow = batchWindow;
+  constructor(windowMs = 10, maxBatchSize = 50) {
+    this.windowMs = windowMs;
     this.maxBatchSize = maxBatchSize;
-    this.batch = [];
-    this.processing = false;
-  }
-  async schedule(key, request) {
-    return new Promise((resolve, reject) => {
-      this.batch.push({ key, resolve, reject });
-      if (this.batch.length >= this.maxBatchSize) {
-        this.processBatch(request);
-      } else if (!this.batchTimeout) {
-        this.batchTimeout = setTimeout(
-          () => this.processBatch(request),
-          this.batchWindow
-        );
-      }
+    this.pending = /* @__PURE__ */ new Map();
+  }
+  schedule(key, request) {
+    const existing = this.pending.get(key);
+    if (existing) return existing;
+    const promise = new Promise((resolve, reject) => setTimeout(() => request().then(resolve, reject), this.windowMs));
+    this.pending.set(key, promise);
+    promise.finally(() => this.pending.delete(key)).catch(() => {
     });
+    return promise;
   }
-  async processBatch(request) {
-    if (this.processing || this.batch.length === 0) return;
-    this.processing = true;
-    if (this.batchTimeout) {
-      clearTimeout(this.batchTimeout);
-      this.batchTimeout = void 0;
-    }
-    const currentBatch = [...this.batch];
-    this.batch = [];
-    try {
-      const result = await request();
-      currentBatch.forEach((item) => item.resolve(result));
-    } catch (error) {
-      currentBatch.forEach((item) => item.reject(error));
-    } finally {
-      this.processing = false;
-      if (this.batch.length > 0) {
-        setTimeout(() => this.processBatch(request), 0);
-      }
-    }
+  clear() {
+    this.pending.clear();
   }
 };
 
-// src/content/utils.ts
-function validateSlug(slug) {
-  if (!slug || typeof slug !== "string") {
-    throw new Error("Slug must be a non-empty string");
-  }
-  if (!/^[a-z0-9-_]+$/.test(slug)) {
-    throw new Error("Slug can only contain lowercase letters, numbers, hyphens, and underscores");
-  }
-}
-function normalizeQuery(query) {
-  const normalized = { ...query };
-  normalized.page = Math.max(1, normalized.page || 1);
-  normalized.limit = Math.min(100, Math.max(1, normalized.limit || 10));
-  normalized.order = normalized.order || "desc";
-  if (normalized.page < 1) {
-    throw new Error("Page must be greater than 0");
-  }
-  if (normalized.limit < 1 || normalized.limit > 100) {
-    throw new Error("Limit must be between 1 and 100");
-  }
-  return normalized;
-}
-function buildQueryString(query) {
-  const params = new URLSearchParams();
-  if (query.page) params.append("page", query.page.toString());
-  if (query.limit) params.append("limit", query.limit.toString());
-  if (query.sort) params.append("sort", query.sort);
-  if (query.order) params.append("order", query.order);
-  if (query.search) params.append("search", query.search);
-  if (query.include?.length) {
-    params.append("include", query.include.join(","));
-  }
-  if (query.fields?.length) {
-    params.append("fields", query.fields.join(","));
-  }
-  if (query.filter) {
-    params.append("filter", JSON.stringify(query.filter));
-  }
-  return params.toString();
-}
-function measurePerformance(name, fn) {
-  const start = performance.now();
-  const result = fn();
-  const end = performance.now();
-  if (process.env.NODE_ENV === "development") {
-    console.log(`\u23F1\uFE0F ${name}: ${(end - start).toFixed(2)}ms`);
-  }
-  return { result, duration: end - start };
-}
-
 // src/content/index.ts
+init_utils();
 var ContentEngine = class {
   constructor(config) {
     this.config = config;
@@ -896,6 +871,12 @@ var ContentEngine = class {
       window.addEventListener("beforeunload", this.cleanup.bind(this));
     }
   }
+  /** Update runtime configuration without exposing internal mutation. */
+  updateConfig(config) {
+    this.config = config;
+    this.defaultRevalidate = config.revalidateTime ?? false;
+    this.cacheStrategy = config.cacheStrategy || "memory";
+  }
   /**
    * Fetch a Single Page with full strategy pipeline
    */
@@ -1054,7 +1035,7 @@ var ContentEngine = class {
     }
   }
   /**
-   * Fetch Global Settings with nested includes support
+   * Fetch Global Settings
    */
   async getGlobals(options = {}) {
     const {
@@ -1106,6 +1087,9 @@ var ContentEngine = class {
         revalidate
       });
       if (!res.ok) {
+        if (res.status === 408) {
+          throw new Error("Request timeout");
+        }
         throw new Error(`API Error ${res.status}: ${res.statusText}`);
       }
       const json = await res.json();
@@ -1154,12 +1138,12 @@ var ContentEngine = class {
         method: "GET",
         headers: this.getHeaders(),
         tags: fetchTags,
-        // ?? not || — see the constructor comment on defaultRevalidate for
-        // why: an explicit `revalidate: 0` on this call must not be
-        // discarded in favor of the engine's default.
         revalidate: options.revalidate ?? this.defaultRevalidate
       });
       if (!res.ok) {
+        if (res.status === 408) {
+          throw new Error("Request timeout");
+        }
         throw new Error(`API Error ${res.status}: ${res.statusText}`);
       }
       const json = await res.json();
@@ -1191,12 +1175,15 @@ var ContentEngine = class {
       headers: this.getHeaders()
     });
     if (!res.ok) {
+      if (res.status === 408) {
+        throw new Error("Request timeout");
+      }
       throw new Error(`API Error ${res.status}: ${res.statusText}`);
     }
     return await res.json();
   }
   /**
-   * Prefetch content for better performance
+   * Prefetch content
    */
   async prefetch(urls) {
     if (typeof window !== "undefined" && "requestIdleCallback" in window) {
@@ -1209,41 +1196,19 @@ var ContentEngine = class {
   }
   /**
    * Robust Real-time Subscriptions (SSE) with Auto-Reconnect
-   *
-   * ⚠️ SCOPE — READ BEFORE RELYING ON THIS FOR "instant" UPDATES:
-   * This connects from the BROWSER TAB it's called in, and on message it
-   * only clears THIS SDK INSTANCE's in-memory `memoryCache` (via
-   * invalidateCache below) in THAT browser tab's JS heap. In a typical
-   * Next.js deployment — and Cloudflare specifically, which is stateless
-   * per-request at the edge — that is a different process/isolate than the
-   * one that will render the NEXT server request for this content. So:
-   *   - ✅ Useful for: a client component that reads from `nexus.content`
-   *     directly in the browser and re-renders in place without a page
-   *     navigation (e.g. a live-updating dashboard widget).
-   *   - ❌ NOT sufficient for: "user A edits content in the CMS, user B's
-   *     already-loaded page updates" via a server-rendered page. That
-   *     requires the backend's /api/revalidate webhook (see
-   *     content.service.ts `pingNextRevalidateWebhook`) to have actually
-   *     cleared the *server's* Data Cache, so the NEXT navigation or
-   *     server request picks up fresh data. This SSE channel does not
-   *     replace that — it's a complementary, browser-local optimization.
-   * If your symptom was "stale content after editing," fix the webhook
-   * wiring first; treat this method as an enhancement layered on top.
    */
   subscribeToUpdates(callback) {
     if (this.isServer || typeof EventSource === "undefined") {
       if (this.config.debug) {
         console.warn(
-          "[NexusHub] subscribeToUpdates() called in a non-browser environment (server render or SSR pass) \u2014 this is expected and safely skipped; EventSource only makes sense client-side."
+          "[NexusHub] subscribeToUpdates() called in a non-browser environment."
         );
       }
       return () => {
       };
     }
     if (!this.config.apiKey) {
-      console.warn(
-        "[NexusHub] subscribeToUpdates(): no apiKey configured, the SSE connection will likely be rejected by the backend. Set NEXT_PUBLIC_NEXUS_KEY."
-      );
+      console.warn("[NexusHub] subscribeToUpdates(): no apiKey configured.");
     }
     let eventSource = null;
     let retryCount = 0;
@@ -1407,6 +1372,9 @@ var ContentEngine = class {
           `Page '${slug}' not found. Check your Dashboard or Seed data.`
         );
       }
+      if (res.status === 408) {
+        throw new Error("Request timeout");
+      }
       throw new Error(`API Error ${res.status}: ${res.statusText}`);
     }
     const json = await res.json();
@@ -1441,6 +1409,9 @@ var ContentEngine = class {
       revalidate
     });
     if (!res.ok) {
+      if (res.status === 408) {
+        throw new Error("Request timeout");
+      }
       throw new Error(`API Error ${res.status}: ${res.statusText}`);
     }
     const json = await res.json();
@@ -1527,7 +1498,6 @@ var ContentEngine = class {
       const response = await fetch(url, {
         ...fetchOptions,
         ...nextConfig,
-        // Inject Next.js tags
         signal: controller.signal
       });
       clearTimeout(id);
@@ -1540,7 +1510,8 @@ var ContentEngine = class {
   getHeaders() {
     const headers = {
       "Content-Type": "application/json",
-      "X-Nexus-Client": "client-sdk/1.0.0",
+      "X-Nexus-Client": `client-sdk/${this.config.sdkVersion ?? "1.1.0"}`,
+      "X-Nexus-Request-ID": typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : `nx_${Date.now()}_${Math.random().toString(36).slice(2)}`,
       "X-Nexus-Project": this.config.projectId
     };
     if (this.config.apiKey) {
@@ -1551,13 +1522,22 @@ var ContentEngine = class {
   isCacheValid(metadata) {
     return Date.now() < metadata.expiresAt;
   }
+  /**
+   * 🛡️ FIX: Normalizes timeout errors (AbortError, 408, or Timeout messages)
+   * into clean, standardized "Request timeout" errors.
+   */
   normalizeError(error, context) {
     if (error instanceof Error) {
-      if (error.name === "AbortError") {
+      const msg = error.message.toLowerCase();
+      if (error.name === "AbortError" || error.message.includes("408") || msg.includes("timeout") || msg.includes("aborted")) {
         return new Error(`${context}: Request timeout`);
       }
       return error;
     }
+    const str = String(error).toLowerCase();
+    if (str.includes("408") || str.includes("timeout") || str.includes("aborted")) {
+      return new Error(`${context}: Request timeout`);
+    }
     return new Error(`${context}: ${String(error)}`);
   }
   cancelRequests() {
@@ -1574,9 +1554,12 @@ var ContentEngine = class {
   }
 };
 
+// src/analytics/tracker.ts
+init_config();
+
 // src/analytics/fingerprint.ts
 var cachedEntropy = null;
-var getDeviceEntropy = async () => {
+var getDeviceEntropy = async (allowFingerprinting = true) => {
   if (cachedEntropy) return cachedEntropy;
   if (typeof window === "undefined") return {};
   const nav = window.navigator;
@@ -1591,7 +1574,7 @@ var getDeviceEntropy = async () => {
     platform: nav.platform,
     language: nav.language,
     touch_support: "ontouchstart" in window || nav.maxTouchPoints > 0,
-    canvas_hash: await generateCanvasHash()
+    canvas_hash: allowFingerprinting ? await generateCanvasHash() : void 0
   };
   return cachedEntropy;
 };
@@ -1604,7 +1587,6 @@ var generateCanvasHash = async () => {
     canvas.height = 50;
     ctx.textBaseline = "top";
     ctx.font = '16px "Arial"';
-    ctx.textBaseline = "alphabetic";
     ctx.fillStyle = "#f60";
     ctx.fillRect(125, 1, 62, 20);
     ctx.fillStyle = "#069";
@@ -1623,12 +1605,12 @@ var generateCanvasHash = async () => {
     return "";
   }
 };
-var getVisitorId = async () => {
+var getVisitorId = async (allowFingerprinting = true) => {
   if (typeof window === "undefined") return "server_visitor";
   const STORAGE_KEY = "nexus_vid";
   let vid = localStorage.getItem(STORAGE_KEY);
   if (!vid) {
-    const entropy = await getDeviceEntropy();
+    const entropy = await getDeviceEntropy(allowFingerprinting);
     const random = Math.random().toString(36).substring(2, 15);
     const timestamp = Date.now().toString(36);
     const fingerprint = [
@@ -1636,7 +1618,7 @@ var getVisitorId = async () => {
       entropy.hardware_concurrency,
       entropy.timezone_offset,
       entropy.platform,
-      entropy.canvas_hash
+      entropy.canvas_hash || "standard_entropy"
     ].join("|");
     let hash = 0;
     for (let i = 0; i < fingerprint.length; i++) {
@@ -1847,7 +1829,6 @@ var EventStorage = class {
 var eventStorage = new EventStorage();
 
 // src/analytics/tracker.ts
-var SDK_VERSION = "0.1.0";
 var safeGetItem = (key) => {
   try {
     return localStorage.getItem(key);
@@ -1883,6 +1864,8 @@ var Tracker = class {
     this.visitorId = "";
     this.anonymousId = "";
     this.isFlushing = false;
+    this.flushPromise = null;
+    this.batchSize = 25;
     this.config = config;
     this.endpoint = `${this.config.analyticsUrl}/api/collect`;
     this.circuitBreaker = new CircuitBreaker();
@@ -1893,7 +1876,9 @@ var Tracker = class {
     }
   }
   async initSession() {
-    this.visitorId = await getVisitorId();
+    this.visitorId = await getVisitorId(
+      this.config.privacy?.fingerprinting ?? false
+    );
     let anonId = safeGetItem("nexus_anon_id");
     if (!anonId) {
       anonId = `anon_${generateUUID().replace(/-/g, "")}`;
@@ -1906,8 +1891,8 @@ var Tracker = class {
     const SESSION_TIMEOUT = 30 * 60 * 1e3;
     const isExpired = !sid || !lastActivity || now - parseInt(lastActivity, 10) > SESSION_TIMEOUT;
     if (isExpired) {
-      const uuid = generateUUID().replace(/-/g, "").substring(0, 16);
-      sid = `sess_${uuid}_${now}`;
+      const uuid2 = generateUUID().replace(/-/g, "").substring(0, 16);
+      sid = `sess_${uuid2}_${now}`;
       safeSetItem("nexus_sid", sid);
       this.sessionStart = now;
     }
@@ -1917,7 +1902,9 @@ var Tracker = class {
   async send(eventType, data = {}, eventName, ecommerce) {
     if (typeof window === "undefined") return;
     safeSetItem("nexus_last_active", Date.now().toString());
-    const entropy = await getDeviceEntropy();
+    const entropy = await getDeviceEntropy(
+      this.config.privacy?.fingerprinting ?? false
+    );
     const perfMetrics = vitalsCollector.getMetricsSnapshot();
     const utmParams = extractUtmParams(window.location.href);
     const payload = {
@@ -1928,6 +1915,7 @@ var Tracker = class {
       messageId: generateUUID(),
       sentAt: (/* @__PURE__ */ new Date()).toISOString(),
       version: SDK_VERSION,
+      // Dynamically synced to SDK 1.1.0
       url: window.location.href,
       referrer: document.referrer,
       userAgent: window.navigator.userAgent,
@@ -1945,8 +1933,8 @@ var Tracker = class {
           hardwareConcurrency: entropy.hardware_concurrency,
           deviceMemory: entropy.device_memory,
           pixelRatio: entropy.pixel_ratio,
-          canvasFingerprint: entropy.canvas_hash,
-          platform: entropy.platform
+          platform: entropy.platform,
+          ...this.config.privacy?.fingerprinting ? { canvasFingerprint: entropy.canvas_hash } : {}
         },
         visitorIdLocal: this.visitorId,
         utm: utmParams
@@ -1966,53 +1954,69 @@ var Tracker = class {
     });
   }
   async flushQueue(useBeacon = false) {
-    if (this.isFlushing) return;
-    if (this.circuitBreaker.isOpen()) return;
-    this.isFlushing = true;
-    try {
-      const storedEvents = await eventStorage.peek(20);
-      if (storedEvents.length === 0) {
-        this.isFlushing = false;
-        return;
-      }
-      const payloads = storedEvents.map((e) => e.payload);
-      const promises = payloads.map(
-        (event) => fetch(this.endpoint, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${this.config.apiKey}`
-          },
-          body: JSON.stringify(event),
-          keepalive: useBeacon
-        })
-      );
-      const results = await Promise.allSettled(promises);
-      const successIds = [];
-      let failureCount = 0;
-      results.forEach((res, index) => {
-        if (res.status === "fulfilled" && res.value.ok) {
-          successIds.push(storedEvents[index].id);
+    if (this.flushPromise) return this.flushPromise;
+    this.flushPromise = (async () => {
+      if (this.circuitBreaker.isOpen()) return;
+      try {
+        const storedEvents = await eventStorage.peek(this.batchSize);
+        if (!storedEvents.length) return;
+        const payloads = storedEvents.map((e) => e.payload);
+        const headers = {
+          "Content-Type": "application/json",
+          Authorization: this.config.apiKey ? `Bearer ${this.config.apiKey}` : "",
+          "X-Nexus-Client": `analytics/${SDK_VERSION}`,
+          "X-Nexus-Project": this.config.projectId
+        };
+        let response;
+        try {
+          response = await fetch(
+            `${this.config.analyticsUrl}/api/collect/batch`,
+            {
+              method: "POST",
+              headers,
+              body: JSON.stringify({ events: payloads }),
+              keepalive: useBeacon
+            }
+          );
+        } catch {
+          response = void 0;
+        }
+        if (!response || response.status === 404 || response.status === 405) {
+          const results = await Promise.allSettled(
+            payloads.map(
+              (event) => fetch(this.endpoint, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(event),
+                keepalive: useBeacon
+              })
+            )
+          );
+          const successIds = results.flatMap(
+            (r, i) => r.status === "fulfilled" && r.value.ok ? [storedEvents[i].id] : []
+          );
+          if (successIds.length) await eventStorage.remove(successIds);
+          if (successIds.length === storedEvents.length) {
+            this.circuitBreaker.recordSuccess();
+          } else {
+            this.circuitBreaker.recordFailure();
+          }
+        } else if (response.ok) {
+          await eventStorage.remove(storedEvents.map((e) => e.id));
+          this.circuitBreaker.recordSuccess();
         } else {
-          failureCount++;
+          this.circuitBreaker.recordFailure();
         }
-      });
-      if (successIds.length > 0) {
-        await eventStorage.remove(successIds);
-        this.circuitBreaker.recordSuccess();
-      }
-      if (failureCount > 0) {
+      } catch (err) {
         this.circuitBreaker.recordFailure();
+        if (this.config.debug) {
+          console.warn("[GN-Apex] Analytics flush deferred:", err);
+        }
+      } finally {
+        this.flushPromise = null;
       }
-    } catch (err) {
-      console.error("[NexusHub] Network Error:", err);
-      this.circuitBreaker.recordFailure();
-    } finally {
-      this.isFlushing = false;
-      if (!this.circuitBreaker.isOpen() && await eventStorage.count() > 0) {
-        setTimeout(() => this.flushQueue(), 100);
-      }
-    }
+    })();
+    return this.flushPromise;
   }
   getSession() {
     return this.sessionId;
@@ -2291,70 +2295,35 @@ var AnalyticsEngine = class {
   }
   setupVideoTracking() {
     if (typeof document === "undefined") return;
-    const attachVideoListeners = (video) => {
-      if (video.__nexus_tracked) return;
-      video.__nexus_tracked = true;
-      const src = video.src || video.currentSrc || "unknown";
-      let milestone50Fired = false;
-      video.addEventListener("play", () => {
-        this.tracker.send(
-          "custom_event",
-          { event_name: "video_play", src },
-          "video_play"
-        );
-      });
-      video.addEventListener("pause", () => {
-        this.tracker.send(
-          "custom_event",
-          {
-            event_name: "video_pause",
-            src,
-            position_seconds: Math.round(video.currentTime)
-          },
-          "video_pause"
-        );
-      });
+    const attach = (video) => {
+      const v = video;
+      if (v.__gnexusTracked) return;
+      v.__gnexusTracked = true;
+      v.__gnexusMilestones = /* @__PURE__ */ new Set();
+      const src = () => video.currentSrc || video.src || "unknown";
+      const emit = (name, data = {}) => this.tracker.send("media", { media_type: "video", event_name: name, src: src(), ...data }, name);
+      video.addEventListener("loadedmetadata", () => emit("video_loaded", { duration_seconds: Number.isFinite(video.duration) ? Math.round(video.duration) : void 0 }));
+      video.addEventListener("play", () => emit("video_play", { position_seconds: Math.round(video.currentTime) }));
+      video.addEventListener("pause", () => emit("video_pause", { position_seconds: Math.round(video.currentTime) }));
+      video.addEventListener("seeking", () => emit("video_seek", { position_seconds: Math.round(video.currentTime) }));
+      video.addEventListener("ended", () => emit("video_complete", { duration_seconds: Math.round(video.duration) }));
+      video.addEventListener("error", () => emit("video_error"));
       video.addEventListener("timeupdate", () => {
-        if (!video.duration || video.duration === Infinity) return;
-        const pct = video.currentTime / video.duration;
-        if (pct >= 0.5 && !milestone50Fired) {
-          milestone50Fired = true;
-          this.tracker.send(
-            "custom_event",
-            {
-              event_name: "video_50_percent",
-              src
-            },
-            "video_50_percent"
-          );
+        if (!Number.isFinite(video.duration) || video.duration <= 0) return;
+        for (const milestone of [25, 50, 75, 90, 100]) {
+          if (video.currentTime / video.duration * 100 >= milestone && !v.__gnexusMilestones.has(milestone)) {
+            v.__gnexusMilestones.add(milestone);
+            emit(`video_${milestone}_percent`, { progress: milestone / 100 });
+          }
         }
       });
-      video.addEventListener("ended", () => {
-        this.tracker.send(
-          "custom_event",
-          {
-            event_name: "video_complete",
-            src,
-            duration_seconds: Math.round(video.duration)
-          },
-          "video_complete"
-        );
-      });
     };
-    document.querySelectorAll("video").forEach((v) => attachVideoListeners(v));
-    const observer = new MutationObserver((mutations) => {
-      mutations.forEach((m) => {
-        m.addedNodes.forEach((node) => {
-          if (node instanceof HTMLVideoElement) {
-            attachVideoListeners(node);
-          }
-          if (node instanceof Element) {
-            node.querySelectorAll("video").forEach((v) => attachVideoListeners(v));
-          }
-        });
-      });
-    });
-    observer.observe(document.body, { childList: true, subtree: true });
+    document.querySelectorAll("video").forEach((v) => attach(v));
+    const observer = new MutationObserver((ms) => ms.forEach((m) => m.addedNodes.forEach((n) => {
+      if (n instanceof HTMLVideoElement) attach(n);
+      if (n instanceof Element) n.querySelectorAll("video").forEach((v) => attach(v));
+    })));
+    if (document.body) observer.observe(document.body, { childList: true, subtree: true });
     this.cleanupFns.push(() => observer.disconnect());
   }
   setupErrorTracking() {
@@ -2543,65 +2512,397 @@ function getSelector(el, depth = 0) {
   return `${parent}${self}`;
 }
 
+// src/errors.ts
+var NexusError = class extends Error {
+  constructor(message, code = "UNKNOWN", status, requestId, details, retryable = false, cause) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.requestId = requestId;
+    this.details = details;
+    this.retryable = retryable;
+    this.cause = cause;
+    this.name = "NexusError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var isNexusError = (e) => e instanceof NexusError;
+
+// src/events.ts
+var NexusEventBus = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  on(event, listener) {
+    const set = this.listeners.get(event) ?? /* @__PURE__ */ new Set();
+    set.add(listener);
+    this.listeners.set(event, set);
+    return () => set.delete(listener);
+  }
+  emit(event, payload) {
+    this.listeners.get(event)?.forEach((l) => {
+      try {
+        l(payload);
+      } catch {
+      }
+    });
+  }
+  clear() {
+    this.listeners.clear();
+  }
+};
+
+// src/http.ts
+var uuid = () => typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : `nx_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+var NexusHttpClient = class {
+  constructor(config, events = new NexusEventBus()) {
+    this.config = config;
+    this.events = events;
+    this.breaker = new CircuitBreaker();
+    this.limiter = new RateLimiter({
+      maxRequests: config.debug ? 200 : 100,
+      timeWindow: 6e4
+    });
+    this.backoff = new ExponentialBackoff({
+      maxRetries: config.retries ?? 3,
+      baseDelay: 150,
+      maxDelay: 8e3,
+      jitter: true
+    });
+  }
+  updateConfig(config) {
+    this.config = config;
+  }
+  async request(input, options = {}) {
+    if (this.breaker.isOpen()) {
+      throw new NexusError(
+        "GN-Apex service circuit is open",
+        "CIRCUIT_OPEN",
+        void 0,
+        void 0,
+        void 0,
+        true
+      );
+    }
+    const requestId = uuid();
+    const url = input;
+    const started = Date.now();
+    const headers = new Headers(options.headers);
+    headers.set("X-Nexus-Request-ID", requestId);
+    headers.set(
+      "X-Nexus-Client",
+      `gnexus-sdk/${this.config.sdkVersion ?? "1.1.0"}`
+    );
+    headers.set("X-Nexus-Project", this.config.projectId);
+    if (this.config.apiKey)
+      headers.set("Authorization", `Bearer ${this.config.apiKey}`);
+    this.events.emit("request:start", {
+      requestId,
+      url,
+      method: options.method ?? "GET"
+    });
+    try {
+      await this.limiter.checkLimit();
+      const response = await this.backoff.execute(async () => {
+        const controller = new AbortController();
+        const timeout = options.timeout ?? this.config.timeout ?? 1e4;
+        const timer = setTimeout(() => controller.abort(), timeout);
+        try {
+          return await fetch(url, {
+            ...options,
+            headers,
+            signal: options.signal ?? controller.signal
+          });
+        } catch (e) {
+          if (e?.name === "AbortError") {
+            throw new NexusError(
+              `Request timed out after ${timeout}ms`,
+              "TIMEOUT",
+              void 0,
+              requestId,
+              void 0,
+              true,
+              e
+            );
+          }
+          throw new NexusError(
+            "Network request failed",
+            "NETWORK_ERROR",
+            void 0,
+            requestId,
+            void 0,
+            true,
+            e
+          );
+        } finally {
+          clearTimeout(timer);
+        }
+      });
+      if (!response.ok) {
+        const retryable = response.status === 408 || response.status === 429 || response.status >= 500;
+        let details;
+        try {
+          details = await response.clone().json();
+        } catch {
+        }
+        const code = response.status === 404 ? "NOT_FOUND" : response.status === 429 ? "RATE_LIMITED" : "HTTP_ERROR";
+        const err = new NexusError(
+          `API request failed (${response.status})`,
+          code,
+          response.status,
+          response.headers.get("x-nexus-request-id") ?? requestId,
+          details,
+          retryable
+        );
+        throw err;
+      }
+      this.breaker.recordSuccess();
+      this.events.emit("request:end", {
+        requestId,
+        url,
+        status: response.status,
+        duration: Date.now() - started
+      });
+      return response;
+    } catch (e) {
+      if (e instanceof NexusError) {
+        if (e.retryable || e.status && (e.status >= 500 || e.status === 429)) {
+          this.breaker.recordFailure();
+        } else {
+          this.breaker.recordSuccess();
+        }
+      } else {
+        this.breaker.recordFailure();
+      }
+      this.events.emit("error", { error: e });
+      throw e;
+    }
+  }
+  getStats() {
+    return {
+      rateLimit: this.limiter.getStats(),
+      circuit: this.breaker.getState()
+    };
+  }
+};
+
+// src/flags.ts
+var FeatureFlags = class {
+  constructor(initial) {
+    this.values = {};
+    this.values = { ...initial };
+  }
+  set(values) {
+    this.values = { ...this.values, ...values };
+  }
+  isEnabled(key, fallback = false) {
+    const v = this.values[key];
+    return typeof v === "boolean" ? v : fallback;
+  }
+  get(key, fallback) {
+    return this.values[key] ?? fallback;
+  }
+  all() {
+    return { ...this.values };
+  }
+};
+var RemoteConfig = class {
+  constructor() {
+    this.values = {};
+  }
+  set(values) {
+    this.values = { ...this.values, ...values };
+  }
+  get(key, fallback) {
+    return this.values[key] ?? fallback;
+  }
+  all() {
+    return { ...this.values };
+  }
+};
+
+// src/diagnostics.ts
+var getDiagnostics = (version, environment) => ({ version, environment, online: typeof navigator === "undefined" ? true : navigator.onLine, userAgent: typeof navigator === "undefined" ? void 0 : navigator.userAgent, memory: typeof performance !== "undefined" && "memory" in performance ? performance.memory?.usedJSHeapSize : void 0 });
+
 // src/client.ts
-var DEFAULT_REVALIDATE_SECONDS = false;
 var NexusClient = class {
-  constructor(config) {
-    const fullConfig = getFullConfig(config);
+  constructor(config = {}) {
+    const full = getFullConfig(config);
     this.config = {
-      debug: config?.debug ?? false,
-      cacheStrategy: config?.cacheStrategy ?? "memory",
-      // Only fall through to the safe default when revalidateTime is
-      // genuinely *unset* (undefined). An explicit `false` from the caller
-      // is a deliberate "never revalidate" choice and must be respected,
-      // not silently upgraded — `??` (not `||`) is required here so that
-      // `0` (revalidate on every request) also passes through untouched
-      // instead of being treated as falsy.
-      revalidateTime: config?.revalidateTime ?? DEFAULT_REVALIDATE_SECONDS,
-      timeout: config?.timeout ?? 1e4,
-      retries: config?.retries ?? 3,
-      ...fullConfig
+      debug: false,
+      cacheStrategy: "memory",
+      revalidateTime: false,
+      timeout: 1e4,
+      retries: 3,
+      sdkVersion: SDK_VERSION,
+      cacheInvalidation: "platform",
+      environment: typeof process !== "undefined" && process.env?.NODE_ENV === "development" ? "development" : "production",
+      autoTracking: true,
+      publicKeyOnly: true,
+      // 🚀 Default: fingerprinting: true (Active by default for high-precision analytics)
+      privacy: { analytics: true, fingerprinting: true, redact: true },
+      ...full,
+      ...config
     };
     const errors = validateConfig(this.config);
-    if (errors.length > 0) {
-      console.warn("\u26A0\uFE0F NexusHub: Configuration issues:", errors.join(", "));
-      if (!this.config.projectId) {
-        console.warn("\u26A0\uFE0F NexusHub: No Project ID found. Tracking will fail.");
-      }
+    if (errors.length && this.config.debug) {
+      console.warn("[GN-Apex] Configuration warnings:", errors);
     }
+    this.events = new NexusEventBus();
+    this.http = new NexusHttpClient(this.config, this.events);
+    this.flags = new FeatureFlags();
+    this.remoteConfig = new RemoteConfig();
     this.content = new ContentEngine(this.config);
-    if (typeof window !== "undefined") {
+    if (typeof window !== "undefined" && this.config.autoTracking !== false && this.config.privacy?.analytics !== false) {
       this.analytics = new AnalyticsEngine(this.config);
       this.analytics.start();
     }
   }
   /**
-   * Helper alias for cleaner content fetching.
+   * Helper alias for cleaner page content fetching.
    */
   getPage(slug, options) {
     return this.content.getPage(slug, options);
   }
   /**
-   * Returns a readonly snapshot of the current config.
+   * Returns a readonly snapshot of the active configuration.
    */
   getConfig() {
-    return { ...this.config };
+    return Object.freeze({
+      ...this.config,
+      privacy: { ...this.config.privacy }
+    });
   }
   /**
-   * Updates specific config fields at runtime.
-   * Replaces the previous pattern of `(nexus as any).config.projectId = x`
-   * which bypassed TypeScript and mutated internal state unsafely.
+   * Updates runtime configuration dynamically without breaking active listeners.
    */
   updateConfig(updates) {
-    this.config = { ...this.config, ...updates };
+    this.config = {
+      ...this.config,
+      ...updates,
+      privacy: { ...this.config.privacy, ...updates.privacy }
+    };
+    this.http.updateConfig(this.config);
+    this.content.updateConfig?.(this.config);
+    if (typeof window !== "undefined" && this.config.autoTracking !== false && this.config.privacy?.analytics !== false && !this.analytics) {
+      this.analytics = new AnalyticsEngine(this.config);
+      this.analytics.start();
+    }
+    if (this.config.privacy?.analytics === false) {
+      this.analytics?.stop();
+    }
+  }
+  /**
+   * Returns deep system diagnostics including HTTP and cache performance.
+   */
+  diagnostics() {
+    return {
+      ...getDiagnostics(SDK_VERSION, this.config.environment ?? "production"),
+      cache: this.content.getCacheStats(),
+      http: this.http.getStats(),
+      analyticsQueue: this.analytics ? void 0 : 0
+    };
+  }
+  /**
+   * Gracefully terminates background tasks and cleans up listeners.
+   */
+  destroy() {
+    this.analytics?.stop(true);
+    this.content.cleanup?.();
+    this.events.clear();
   }
 };
 var nexus = new NexusClient();
-var createNexusClient = (config) => new NexusClient(config);
+var createNexusClient = (config = {}) => new NexusClient(config);
 
 // src/index.ts
 init_config();
-var VERSION = "0.0.1";
+
+// src/notifications/push-client.ts
+var NexusPushClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Helper to convert Base64 VAPID key to Uint8Array for WebPush security
+   */
+  urlBase64ToUint8Array(base64String) {
+    const padding = "=".repeat((4 - base64String.length % 4) % 4);
+    const base64 = (base64String + padding).replace(/\-/g, "+").replace(/_/g, "/");
+    const rawData = window.atob(base64);
+    const outputArray = new Uint8Array(rawData.length);
+    for (let i = 0; i < rawData.length; ++i) {
+      outputArray[i] = rawData.charCodeAt(i);
+    }
+    return outputArray;
+  }
+  /**
+   * Requests browser notification permissions and registers the WebPush subscription
+   */
+  async requestSubscription(serviceWorkerPath = "/sw.js") {
+    if (typeof window === "undefined" || !("serviceWorker" in navigator) || !("PushManager" in window)) {
+      console.warn(
+        "[NexusHub] Push notifications are not supported in this browser environment."
+      );
+      return false;
+    }
+    try {
+      const permission = await Notification.requestPermission();
+      if (permission !== "granted") {
+        console.warn("[NexusHub] Notification permission denied by user.");
+        return false;
+      }
+      const vapidRes = await fetch(
+        `${this.config.apiUrl}/notifications/vapid-key`,
+        {
+          headers: {
+            Authorization: `Bearer ${this.config.apiKey}`,
+            "x-nexus-project": this.config.projectId
+          }
+        }
+      );
+      if (!vapidRes.ok) throw new Error("Failed to fetch VAPID public key.");
+      const { publicKey } = await vapidRes.json();
+      const registration = await navigator.serviceWorker.register(serviceWorkerPath);
+      await navigator.serviceWorker.ready;
+      const subscription = await registration.pushManager.subscribe({
+        userVisibleOnly: true,
+        // 🚀 RESOLVED: Cast as 'any' to bypass strict DOM BufferSource typings
+        applicationServerKey: this.urlBase64ToUint8Array(publicKey)
+      });
+      const rawSub = subscription.toJSON();
+      if (!rawSub.endpoint || !rawSub.keys?.auth || !rawSub.keys?.p256dh) {
+        throw new Error(
+          "Malformed subscription payload received from browser."
+        );
+      }
+      const res = await fetch(
+        `${this.config.apiUrl}/notifications/project/${this.config.projectId}/subscribe`,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.config.apiKey}`,
+            "x-nexus-project": this.config.projectId
+          },
+          body: JSON.stringify({
+            endpoint: rawSub.endpoint,
+            auth: rawSub.keys.auth,
+            p256dh: rawSub.keys.p256dh,
+            provider: "WEB_PUSH"
+          })
+        }
+      );
+      return res.ok;
+    } catch (err) {
+      console.error("[NexusHub] WebPush subscription failed:", err);
+      return false;
+    }
+  }
+};
+
+// src/index.ts
+var VERSION = "1.1.0";
 export {
   AnalyticsEngine,
   BrowserCache,
@@ -2609,15 +2910,25 @@ export {
   ContentEngine,
   DEFAULT_ANALYTICS_URL,
   DEFAULT_API_URL,
+  FeatureFlags,
   LOCAL_NEST_URL,
   LOCAL_RUST_URL,
   LocalCacheProxy as LocalCache,
   MemoryCache,
   NexusClient,
+  NexusError,
+  NexusEventBus,
+  NexusHttpClient,
+  NexusPushClient,
+  RemoteConfig,
+  SDK_VERSION,
   VERSION,
   createNexusClient,
+  getDiagnostics,
   getEnvConfig,
   getFullConfig,
+  hasRequiredConfig,
+  isNexusError,
   mergeConfigs,
   nexus,
   validateConfig