zubbl-sdk 1.1.15 → 1.1.16

package/dist/zubbl-sdk.umd.js

@@ -1,256 +1,722 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('axios')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'axios'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ZubblSdk = {}, global.axios));
-})(this, (function (exports, axios) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('crypto')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'crypto'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ZubblSdk = {}, global.crypto));
+})(this, (function (exports, crypto) { 'use strict';
 
-  let config = {
-    apiKey: null,
-    tenantId: null,
-    appId: null,
-    baseUrl: "https://api.zubbl.com/api",
-    injectWorkerHeaders: false,
-    workerSecret: null,
-  };
-
-  // ---- Telemetry State ----
-  let sampleRatio = 0.1; // default 1 in 10
-  let endpointBuffer = [];
-  let debounceTimer = null;
-
-  function shouldSample() {
-    return Math.random() < sampleRatio;
-  }
-
-  function setSamplingRatio(ratio) {
-    if (ratio < 0 || ratio > 1) throw new Error("Sampling ratio must be between 0 and 1");
-    sampleRatio = ratio;
-  }
-
-  function emitEndpoint(payload) {
-    if (!shouldSample()) return;
-    const enriched = { ...payload, ts: Date.now(), source: "sdk" };
-    endpointBuffer.push(enriched);
-    console.log("[Zubbl SDK][Telemetry] Queued endpoint:", enriched);
-
-    if (!debounceTimer) {
-      debounceTimer = setTimeout(flushEndpointBuffer, 200);
+    // src/core/config.ts
+    // -----------------------------------------------------------
+    // Universal environment detection + SDK configuration
+    // -----------------------------------------------------------
+    const isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+    const isNode = typeof process !== "undefined" &&
+        !!process.versions?.node &&
+        !isBrowser;
+    const isWorker = typeof self !== "undefined" &&
+        typeof self.importScripts === "function" &&
+        !isNode;
+    let config = {
+        apiKey: null,
+        tenantId: null,
+        appId: null,
+        baseUrl: "https://api.zubbl.com/api",
+        injectWorkerHeaders: false,
+        workerSecret: null,
+    };
+    // -----------------------------------------------------------
+    // Browser safety check
+    // -----------------------------------------------------------
+    function assertBrowserSafety(config) {
+        if (isBrowser || isWorker) {
+            const key = config.apiKey ?? "";
+            // Simple rule: if the key looks like a secret (sk_ or very long)
+            const looksSecret = key.startsWith("sk_") || key.length > 40;
+            if (looksSecret) {
+                throw new Error("[Zubbl SDK] Secret or server key detected in browser environment. " +
+                    "Use a public SDK key instead (prefix pk_).");
+            }
+        }
+    }
+    // -----------------------------------------------------------
+    // Public API
+    // -----------------------------------------------------------
+    function init$1(partial) {
+        config = { ...config, ...partial };
+        assertBrowserSafety(config); // 🔒 check that key is safe in browser
+    }
+    function getConfig() {
+        return config;
+    }
+    // -----------------------------------------------------------
+    // Header builder (used by HTTP layer)
+    // -----------------------------------------------------------
+    function buildHeaders(extra = {}) {
+        if (!config.apiKey || !config.tenantId || !config.appId) {
+            throw new Error("[Zubbl SDK] Not initialized – call init() first.");
+        }
+        return {
+            Authorization: `Bearer ${config.apiKey}`,
+            "X-Tenant-Id": config.tenantId,
+            "X-App-Id": config.appId,
+            "Content-Type": "application/json",
+            ...extra,
+        };
     }
-  }
-
-  async function flushEndpointBuffer() {
-    if (endpointBuffer.length === 0) {
-      debounceTimer = null;
-      return;
-    }
-    const batch = [...endpointBuffer];
-    endpointBuffer = [];
-    debounceTimer = null;
-
-    const telemetryUrl =
-      process.env.ZUBBL_TELEMETRY_URL || `${config.baseUrl.replace(/\/$/, "")}/sdk/log`;
 
-    const headers = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${config.apiKey}`,
-      "X-Tenant-Id": config.tenantId,
-      "X-App-Id": config.appId,
+    // src/core/context.ts
+    // -----------------------------------------------------------
+    // Adaptive Context Engine — Geo + Stability Enrichment + Persistence
+    // -----------------------------------------------------------
+    const MAX_HISTORY = 100;
+    const CACHE_KEY = "zubbl-stability";
+    let state = loadStability() ?? {
+        routes: [],
+        geo: "unknown",
+        stability: 1.0,
+        lastGeoChange: Date.now(),
     };
-  const firstWithUser = batch.find(ev => ev.external_user_id);
-  if (firstWithUser?.external_user_id) {
-    headers["X-External-User-Id"] = firstWithUser.external_user_id;
-  }
-    console.log("[Zubbl SDK][Telemetry] Flushing batch:", {
-      url: telemetryUrl,
-      count: batch.length,
-      sampleRatio,
-      payload: batch,
-      headers,
-    });
-
-    try {
-      const resp = await fetch(telemetryUrl, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(batch),
-      });
-
-      const text = await resp.text();
-      console.log("[Zubbl SDK][Telemetry] Response:", {
-        status: resp.status,
-        body: text,
-      });
-    } catch (err) {
-      console.error("[Zubbl SDK][Telemetry] Failed to send batch:", err);
-    }
-  }
+    // -----------------------------------------------------------
+    // 💾 Persistence Helpers
+    // -----------------------------------------------------------
+    function loadStability() {
+        if (!isBrowser || typeof localStorage === "undefined")
+            return null;
+        try {
+            const raw = localStorage.getItem(CACHE_KEY);
+            if (!raw)
+                return null;
+            const parsed = JSON.parse(raw);
+            if (!parsed.geo || !parsed.stability)
+                return null;
+            return { ...parsed, routes: [] };
+        }
+        catch {
+            return null;
+        }
+    }
+    function saveStability() {
+        if (!isBrowser || typeof localStorage === "undefined")
+            return;
+        try {
+            const payload = {
+                geo: state.geo,
+                stability: state.stability,
+                lastGeoChange: state.lastGeoChange,
+            };
+            localStorage.setItem(CACHE_KEY, JSON.stringify(payload));
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    // -----------------------------------------------------------
+    // 🌍 Geo Detection (Node, Browser, Worker)
+    // -----------------------------------------------------------
+    function detectGeo() {
+        try {
+            if (isBrowser && typeof window !== "undefined" && window.navigator?.language) {
+                return window.navigator.language.split("-")[1] || "unknown";
+            }
+            if (isWorker && typeof self !== "undefined" && self.navigator?.language) {
+                return self.navigator.language.split("-")[1] || "unknown";
+            }
+            if (isNode && typeof process !== "undefined") {
+                const envGeo = process.env.ZUBBL_GEO || process.env.GEO;
+                if (envGeo && /^[A-Z]{2}$/i.test(envGeo))
+                    return envGeo.toUpperCase();
+                return "GB";
+            }
+            return "unknown";
+        }
+        catch (err) {
+            console.warn("[Zubbl SDK][Geo Detect] Failed:", err);
+            return "unknown";
+        }
+    }
+    // -----------------------------------------------------------
+    // 🧭 Update Geo & Stability (with persistence)
+    // -----------------------------------------------------------
+    function updateGeo(geoHint) {
+        const newGeo = geoHint || detectGeo();
+        if (newGeo !== state.geo) {
+            const now = Date.now();
+            const elapsed = (now - state.lastGeoChange) / 1000;
+            state.stability = Math.max(0.5, Math.min(1.0, elapsed / 3600));
+            state.geo = newGeo;
+            state.lastGeoChange = now;
+            saveStability();
+        }
+        else {
+            state.stability = Math.min(1.0, state.stability + 0.01);
+            saveStability();
+        }
+    }
+    // -----------------------------------------------------------
+    // 🧮 Record Context Samples
+    // -----------------------------------------------------------
+    function recordContextSample(path, method, status, latency) {
+        state.routes.push({ path, method, ts: Date.now(), status, latency });
+        if (state.routes.length > MAX_HISTORY)
+            state.routes.shift();
+        updateGeo(); // auto-refresh geo info
+    }
+    // -----------------------------------------------------------
+    // 📦 Get Adaptive Headers
+    // -----------------------------------------------------------
+    function getAdaptiveHeaders() {
+        const currentGeo = detectGeo();
+        updateGeo(currentGeo);
+        const summary = btoa(JSON.stringify({
+            env: isNode ? "node" : isBrowser ? "browser" : "worker",
+            routeCount: state.routes.length,
+            lastGeo: state.geo,
+            avgLatency: state.routes.reduce((a, b) => a + b.latency, 0) /
+                Math.max(1, state.routes.length),
+        }));
+        return {
+            "X-Zubbl-Context-Summary": summary,
+            "X-Zubbl-Geo-Stability": `${state.geo}/${state.stability.toFixed(2)}`,
+        };
+    }
+    // -----------------------------------------------------------
+    // 🌍 Initialize Geo Context Immediately
+    // -----------------------------------------------------------
+    updateGeo(process.env.ZUBBL_GEO);
 
-  async function zubblFetch(input, init = {}, context = {}) {
-    const start = performance.now();
-    let response;
-    try {
-      response = await fetch(input, init);
-      return response;
-    } finally {
-      const latency_ms = performance.now() - start;
-      try {
-        const url = new URL(input, window.location.origin);
-        emitEndpoint({
-          tenant_id: context.tenant_id || config.tenantId,
-          app_id: context.app_id || config.appId,
-          external_user_id: context.external_user_id,
-          method: init.method || "GET",
-          path: url.pathname, // fixed to "path"
-          status: response?.status ?? 0,
-          latency_ms,
+    // -----------------------------------------------------------
+    // 🔐 Secure Signing & Nonce Generator
+    // -----------------------------------------------------------
+    // -----------------------------------------------------------
+    // Generate UUIDv4 Nonce
+    // -----------------------------------------------------------
+    function generateNonce() {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, c => {
+            const r = (Math.random() * 16) | 0;
+            const v = c === "x" ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
         });
-      } catch (e) {
-        console.warn("[Zubbl SDK] Failed to record endpoint telemetry", e);
-      }
     }
-  }
-
-  /**
-   * Initialize SDK with API credentials.
-   */
-  function init({
-    apiKey,
-    tenantId,
-    appId,
-    baseUrl,
-    injectWorkerHeaders = false,
-    workerSecret = null,
-  }) {
-    if (!apiKey || !tenantId || !appId) {
-      throw new Error("apiKey, tenantId, and appId are required");
-    }
-    config = {
-      apiKey,
-      tenantId,
-      appId,
-      baseUrl: baseUrl || "https://api.zubbl.com/api",
-      injectWorkerHeaders,
-      workerSecret,
-    };
-  }
-
-  /**
-   * Identify a user by email (and optional name).
-   * Backend will return or generate a valid UUID for external_user_id.
-   */
-  async function identifyUser({ email, name }) {
-    if (!config.apiKey || !config.tenantId || !config.appId) {
-      throw new Error("Zubbl SDK not initialized");
-    }
-    if (!email) throw new Error("email is required");
-
-    const headers = {
-      Authorization: `Bearer ${config.apiKey}`,
-      "X-Tenant-Id": config.tenantId,
-      "X-App-Id": config.appId,
-      "Content-Type": "application/json",
-    };
-    if (config.injectWorkerHeaders && config.workerSecret) {
-      headers["X-Zubbl-Worker-Secret"] = config.workerSecret;
-      headers["X-Zubbl-Internal-Call"] = "true";
+    // -----------------------------------------------------------
+    // Compute SHA256 HMAC signature
+    // -----------------------------------------------------------
+    async function signPayload(payload, secret) {
+        if (isNode) {
+            // ✅ Node.js native HMAC
+            return crypto.createHmac("sha256", secret).update(payload).digest("hex");
+        }
+        // ✅ Browser / Worker using WebCrypto
+        if (typeof window !== "undefined" && window.crypto?.subtle) {
+            const key = await window.crypto.subtle.importKey("raw", new TextEncoder().encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+            const sig = await window.crypto.subtle.sign("HMAC", key, new TextEncoder().encode(payload));
+            return Array.from(new Uint8Array(sig))
+                .map(b => b.toString(16).padStart(2, "0"))
+                .join("");
+        }
+        throw new Error("No crypto implementation available in this environment");
     }
-
-    const response = await axios.post(
-      `${config.baseUrl}/sdk/identify`,
-      { email, name },
-      { headers }
-    );
-
-    const { external_user_id } = response.data;
-    if (!external_user_id) {
-      throw new Error("Backend did not return external_user_id");
+    // -----------------------------------------------------------
+    // Attach signing headers to a request
+    // -----------------------------------------------------------
+    async function attachSigningHeaders(method, url, body, secretKey) {
+        const nonce = generateNonce();
+        // Compute canonical string (deterministic)
+        const bodyHash = body
+            ? crypto.createHash("sha256").update(body).digest("hex")
+            : "";
+        const canonical = `${method.toUpperCase()}\n${url}\n${nonce}\n${bodyHash}`;
+        // ⚙️ Always include nonce even if secret is missing
+        if (!secretKey) {
+            return { "X-Zubbl-Nonce": nonce };
+        }
+        const signature = await signPayload(canonical, secretKey);
+        return {
+            "X-Zubbl-Nonce": nonce,
+            "X-Zubbl-Signature": signature,
+        };
     }
 
-    // ✅ Ensure UUID format
-    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-    if (!uuidRegex.test(external_user_id)) {
-      throw new Error(`Invalid external_user_id received: ${external_user_id}`);
+    // src/core/http.ts
+    // -----------------------------------------------------------
+    // Isomorphic HTTP transport for Node, Browser, and Workers
+    // Includes adaptive context, telemetry, signing & safety timeout
+    // -----------------------------------------------------------
+    async function httpRequest(url, options = {}) {
+        // 🔧 Default timeout lowered for SDK-12 hardening
+        const { timeoutMs = 250, ...fetchOpts } = options;
+        // ---------------------------------------------------------
+        // Polyfill fetch for Node
+        // ---------------------------------------------------------
+        let fetchImpl;
+        if (isNode) {
+            const { fetch } = await import('undici');
+            // @ts-expect-error Node native fetch lacks duplex definition in undici types
+            fetchImpl = fetch;
+        }
+        else if (isBrowser || isWorker) {
+            fetchImpl = fetch;
+        }
+        else {
+            console.warn("[Zubbl SDK][HTTP] Unsupported runtime environment");
+            return null;
+        }
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        const start = performance.now();
+        try {
+            const config = getConfig();
+            const bodyText = fetchOpts.body && typeof fetchOpts.body === "string"
+                ? fetchOpts.body
+                : fetchOpts.body
+                    ? JSON.stringify(fetchOpts.body)
+                    : "";
+            // ---------------------------------------------------------
+            // 🔐 Signing headers (adds X-Zubbl-Nonce and X-Zubbl-Signature)
+            // ---------------------------------------------------------
+            const signingHeaders = await attachSigningHeaders(fetchOpts.method ?? "GET", url, bodyText, config.workerSecret ?? null);
+            // ---------------------------------------------------------
+            // 🧠 Adaptive context headers
+            // ---------------------------------------------------------
+            const adaptiveHeaders = getAdaptiveHeaders();
+            // ✅ Merge headers cleanly — final order matters
+            fetchOpts.headers = {
+                ...(fetchOpts.headers || {}),
+                ...adaptiveHeaders,
+                ...signingHeaders,
+            };
+            // ---------------------------------------------------------
+            // Perform request
+            // ---------------------------------------------------------
+            const response = await fetchImpl(url, { ...fetchOpts, signal: controller.signal });
+            const latencyMs = performance.now() - start;
+            const status = response?.status ?? 0;
+            // -----------------------------------------------------
+            // Telemetry hook — record runtime discovery + metrics
+            // -----------------------------------------------------
+            await Promise.resolve().then(function () { return telemetry; }).then(({ recordRequestTelemetry, logRuntimeDiscovery }) => {
+                logRuntimeDiscovery(url);
+                recordRequestTelemetry(url, fetchOpts.method ?? "GET", status, latencyMs);
+            });
+            // -----------------------------------------------------
+            // Adaptive context sample recording
+            // -----------------------------------------------------
+            recordContextSample(url, fetchOpts.method ?? "GET", status, latencyMs);
+            // -----------------------------------------------------
+            // Error handling / Soft fail behaviour
+            // -----------------------------------------------------
+            if (!response.ok) {
+                const text = await response.text().catch(() => "");
+                console.warn(`[Zubbl SDK][HTTP] Non-OK response ${status}: ${text}`);
+                return response; // still return so host can inspect
+            }
+            return response;
+        }
+        catch (err) {
+            const latencyMs = performance.now() - start;
+            const reason = err?.name === "AbortError"
+                ? `timeout (${timeoutMs}ms)`
+                : err?.message || "unknown network error";
+            console.warn(`[Zubbl SDK][HTTP] Request failed: ${reason}`, { url, latencyMs });
+            return null; // 🧩 Never throw to host app
+        }
+        finally {
+            clearTimeout(timeout);
+        }
     }
 
-    return response.data;
-  }
-
-  /**
-   * Fetch effective tiles for a given user.
-   * Requires valid external_user_id (UUID).
-   */
-  async function getTiles({ external_user_id, app_id = null }) {
-    if (!config.apiKey || !config.tenantId || !config.appId) {
-      throw new Error("Zubbl SDK not initialized");
-    }
-    if (!external_user_id) throw new Error("external_user_id is required");
-
-    // ✅ Validate UUID format
-    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-    if (!uuidRegex.test(external_user_id)) {
-      throw new Error(`Invalid external_user_id: ${external_user_id}. Must be UUID.`);
+    // src/core/storage.ts
+    // ------------------------------------------------------
+    // Node (in-memory) implementation
+    // ------------------------------------------------------
+    class NodeStorage {
+        constructor() {
+            this.store = new Map();
+        }
+        get(key) {
+            const entry = this.store.get(key);
+            if (!entry)
+                return null;
+            if (entry.expiresAt && entry.expiresAt < Date.now()) {
+                this.store.delete(key);
+                return null;
+            }
+            return entry.value;
+        }
+        set(key, value, ttlSeconds) {
+            const expiresAt = ttlSeconds ? Date.now() + ttlSeconds * 1000 : undefined;
+            this.store.set(key, { value, expiresAt });
+        }
+        remove(key) {
+            this.store.delete(key);
+        }
     }
-
-    const headers = {
-      Authorization: `Bearer ${config.apiKey}`,
-      "X-Tenant-Id": config.tenantId,
-      "X-App-Id": config.appId,
-      "X-External-User-Id": external_user_id,
-    };
-    if (config.injectWorkerHeaders && config.workerSecret) {
-      headers["X-Zubbl-Worker-Secret"] = config.workerSecret;
-      headers["X-Zubbl-Internal-Call"] = "true";
+    // ------------------------------------------------------
+    // Browser (localStorage) implementation
+    // ------------------------------------------------------
+    class BrowserStorage {
+        constructor() {
+            this.prefix = "zubbl_sdk_";
+        }
+        get(key) {
+            try {
+                const raw = localStorage.getItem(this.prefix + key);
+                if (!raw)
+                    return null;
+                const { value, expiresAt } = JSON.parse(raw);
+                if (expiresAt && expiresAt < Date.now()) {
+                    localStorage.removeItem(this.prefix + key);
+                    return null;
+                }
+                return value;
+            }
+            catch {
+                return null;
+            }
+        }
+        set(key, value, ttlSeconds) {
+            try {
+                const expiresAt = ttlSeconds ? Date.now() + ttlSeconds * 1000 : undefined;
+                localStorage.setItem(this.prefix + key, JSON.stringify({ value, expiresAt }));
+            }
+            catch (err) {
+                // localStorage quota exceeded → silently ignore
+                console.warn("[Zubbl SDK][Storage] Failed to persist item:", err);
+            }
+        }
+        remove(key) {
+            localStorage.removeItem(this.prefix + key);
+        }
+    }
+    // ------------------------------------------------------
+    // Factory
+    // ------------------------------------------------------
+    function createStorage() {
+        if (isNode)
+            return new NodeStorage();
+        if (isBrowser)
+            return new BrowserStorage();
+        // Fallback: safe no-op storage for tests / fake environments
+        return {
+            get: () => null,
+            set: () => { },
+            remove: () => { },
+        };
     }
 
-    const params = new URLSearchParams({ external_user_id });
-    params.set("app_id", app_id || config.appId);
-
-    const response = await axios.get(
-      `${config.baseUrl.replace(/\/$/, "")}/tiles/effective?${params.toString()}`,
-      { headers }
-    );
-    return response.data;
-  }
+    // -----------------------------------------------------------
+    // 🌍 Zubbl Geo Engine — Multi-Provider Fallback + 15min Cache
+    // -----------------------------------------------------------
+    // Fully typed, aligns with Zubbl GEO Enforcement Policy
+    // -----------------------------------------------------------
+    const GEO_CACHE_KEY = "zubbl-geo-cache";
+    const GEO_TTL_MS = 15 * 60 * 1000; // 15 minutes
+    // -----------------------------------------------------------
+    // 🗃 Cache Helpers
+    // -----------------------------------------------------------
+    function loadGeoCache() {
+        try {
+            if (!isBrowser || typeof localStorage === "undefined")
+                return null;
+            const raw = localStorage.getItem(GEO_CACHE_KEY);
+            if (!raw)
+                return null;
+            const parsed = JSON.parse(raw);
+            if (!parsed.data?.ip || Date.now() - parsed.timestamp > GEO_TTL_MS)
+                return null;
+            return parsed.data;
+        }
+        catch {
+            return null;
+        }
+    }
+    function saveGeoCache(data) {
+        try {
+            if (!isBrowser || typeof localStorage === "undefined")
+                return;
+            localStorage.setItem(GEO_CACHE_KEY, JSON.stringify({ data, timestamp: Date.now() }));
+        }
+        catch { }
+    }
+    // -----------------------------------------------------------
+    // 🌐 Provider Wrappers
+    // -----------------------------------------------------------
+    async function fetchJSON(url, timeoutMs = 3000) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const resp = await fetch(url, { signal: controller.signal });
+            clearTimeout(timeout);
+            if (!resp.ok)
+                throw new Error(`HTTP ${resp.status}`);
+            return await resp.json();
+        }
+        catch (err) {
+            clearTimeout(timeout);
+            throw err;
+        }
+    }
+    async function providerIpInfo() {
+        const d = await fetchJSON("https://ipinfo.io/json?token=public");
+        return {
+            ip: d.ip || null,
+            country: d.country || "unknown",
+            asn: d.org?.replace(/^AS/, "") || null,
+            privacy: { vpn: false, hosting: false },
+        };
+    }
+    async function providerIpApi() {
+        const d = await fetchJSON("https://ipapi.co/json/");
+        return {
+            ip: d.ip || null,
+            country: d.country_code || "unknown",
+            asn: d.asn?.replace(/^AS/, "") || null,
+            privacy: { vpn: false, hosting: false },
+        };
+    }
+    async function providerGeoJs() {
+        const d = await fetchJSON("https://get.geojs.io/v1/ip/geo.json");
+        return {
+            ip: d.ip || null,
+            country: d.country_code || "unknown",
+            asn: null,
+            privacy: { vpn: false, hosting: false },
+        };
+    }
+    // -----------------------------------------------------------
+    // 🧠 Fallback Resolver
+    // -----------------------------------------------------------
+    async function getGeoInfo() {
+        const cached = loadGeoCache();
+        if (cached)
+            return cached;
+        const providers = [providerIpInfo, providerIpApi, providerGeoJs];
+        for (const fn of providers) {
+            try {
+                const result = await fn();
+                if (result?.country && result.country !== "unknown") {
+                    saveGeoCache(result);
+                    return result;
+                }
+            }
+            catch (err) {
+                console.warn("[Zubbl SDK][Geo] Provider failed:", fn.name, "-", err.message);
+            }
+        }
+        const fallback = {
+            ip: null,
+            country: "unknown",
+            asn: null,
+            privacy: { vpn: false, hosting: false },
+        };
+        saveGeoCache(fallback);
+        return fallback;
+    }
+    async function getGeoHeaders() {
+        const geo = await getGeoInfo();
+        return {
+            "X-Zubbl-Geo-Country": geo.country || "unknown",
+            "X-Zubbl-ASN": geo.asn || "unknown",
+            "X-Zubbl-IP": geo.ip || "",
+            "X-Zubbl-Privacy-VPN": String(geo.privacy?.vpn ?? false),
+            "X-Zubbl-Privacy-Hosting": String(geo.privacy?.hosting ?? false),
+        };
+    }
 
-  async function enforce({ external_user_id, app_id = null }) {
-    if (!config.apiKey || !config.tenantId || !config.appId) {
-      throw new Error("Zubbl SDK not initialized");
+    // ---------------------------------------------------------
+    // Zubbl SDK — Unified Bootstrap (Adaptive + GEO Aware)
+    // ---------------------------------------------------------
+    // ---------------------------------------------------------
+    // Initialization
+    // ---------------------------------------------------------
+    async function init({ apiKey, tenantId, appId, baseUrl = "https://api.zubbl.com/api", injectWorkerHeaders = false, workerSecret = null, }) {
+        // Initialize core configuration
+        init$1({ apiKey, tenantId, appId, baseUrl, injectWorkerHeaders, workerSecret });
+        // Prime GEO context cache
+        try {
+            const geo = await getGeoInfo();
+            console.log(`[Zubbl SDK] 🌍 GEO detected: ${geo.country} (ASN ${geo.asn || "?"})`);
+        }
+        catch (err) {
+            console.warn("[Zubbl SDK] GEO init failed:", err?.message);
+        }
     }
-    if (!external_user_id) throw new Error("external_user_id is required");
+    // ---------------------------------------------------------
+    // Identify User
+    // ---------------------------------------------------------
+    async function identifyUser({ email, name }) {
+        const config = getConfig();
+        if (!config.apiKey || !config.tenantId || !config.appId) {
+            throw new Error("Zubbl SDK not initialized");
+        }
+        const adaptiveHeaders = getAdaptiveHeaders();
+        const geoHeaders = await getGeoHeaders();
+        const headers = buildHeaders({
+            "Content-Type": "application/json",
+            ...adaptiveHeaders,
+            ...geoHeaders,
+        });
+        const body = JSON.stringify({ email, name });
+        const resp = await httpRequest(`${config.baseUrl}/sdk/identify`, {
+            method: "POST",
+            headers,
+            body,
+        });
+        const data = await resp.json().catch(() => ({}));
+        if (!data.external_user_id) {
+            console.warn("[Zubbl SDK] identifyUser: missing external_user_id");
+        }
+        return data;
+    }
+    // ---------------------------------------------------------
+    // Fetch Effective Tiles
+    // ---------------------------------------------------------
+    async function getTiles({ external_user_id, app_id = null, }) {
+        const config = getConfig();
+        if (!config.apiKey || !config.tenantId || !config.appId) {
+            throw new Error("Zubbl SDK not initialized");
+        }
+        if (!external_user_id)
+            throw new Error("external_user_id is required");
+        const adaptiveHeaders = getAdaptiveHeaders();
+        const geoHeaders = await getGeoHeaders();
+        const headers = buildHeaders({
+            "X-External-User-Id": external_user_id,
+            ...adaptiveHeaders,
+            ...geoHeaders,
+        });
+        const params = new URLSearchParams({ external_user_id });
+        params.set("app_id", app_id || config.appId);
+        const resp = await httpRequest(`${config.baseUrl.replace(/\/$/, "")}/tiles/effective?${params.toString()}`, { method: "GET", headers });
+        return resp.json();
+    }
+    // ---------------------------------------------------------
+    // Policy Enforcement
+    // ---------------------------------------------------------
+    async function enforce({ external_user_id, app_id = null, }) {
+        const config = getConfig();
+        if (!config.apiKey || !config.tenantId || !config.appId) {
+            throw new Error("Zubbl SDK not initialized");
+        }
+        const adaptiveHeaders = getAdaptiveHeaders();
+        const geoHeaders = await getGeoHeaders();
+        const headers = buildHeaders({
+            "X-External-User-Id": external_user_id,
+            ...adaptiveHeaders,
+            ...geoHeaders,
+        });
+        const resp = await httpRequest(`${config.baseUrl.replace(/\/$/, "")}/sdk/test-enforcement`, { method: "POST", headers });
+        const json = await resp.json().catch(() => ({}));
+        return { decision: "allow", status: resp.status, data: json };
+    }
+    // ---------------------------------------------------------
+    // Exposed Helpers
+    // ---------------------------------------------------------
+    const storage = createStorage();
 
-    const headers = {
-      Authorization: `Bearer ${config.apiKey}`,
-      "X-Tenant-Id": config.tenantId,
-      "X-App-Id": app_id || config.appId,
-      "X-External-User-Id": external_user_id,
-      "Content-Type": "application/json",
-    };
-    if (config.injectWorkerHeaders && config.workerSecret) {
-      headers["X-Zubbl-Worker-Secret"] = config.workerSecret;
-      headers["X-Zubbl-Internal-Call"] = "true";
+    // -----------------------------------------------------------
+    // Zubbl Telemetry Core (Endpoint Discovery)
+    // -----------------------------------------------------------
+    // Local telemetry buffer
+    let sampleRatio = 0.1; // 1 in 10 by default
+    let buffer = [];
+    let debounceTimer = null;
+    function shouldSample() {
+        return Math.random() < sampleRatio;
+    }
+    // -----------------------------------------------------------
+    // Emit telemetry events
+    // -----------------------------------------------------------
+    function emitEndpoint(payload) {
+        if (!shouldSample())
+            return;
+        const enriched = {
+            ...payload,
+            ts: Date.now(),
+            source: isBrowser ? "browser" : isNode ? "node" : "worker",
+        };
+        buffer.push(enriched);
+        if (!debounceTimer) {
+            debounceTimer = setTimeout(flushBuffer, 200);
+        }
+    }
+    // -----------------------------------------------------------
+    // Flush logic (batch send)
+    // -----------------------------------------------------------
+    async function flushBuffer() {
+        if (buffer.length === 0) {
+            debounceTimer = null;
+            return;
+        }
+        const batch = [...buffer];
+        buffer = [];
+        debounceTimer = null;
+        const config = getConfig();
+        const url = `${config.baseUrl.replace(/\/$/, "")}/sdk/log`;
+        const headers = {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${config.apiKey}`,
+            "X-Tenant-Id": config.tenantId ?? "",
+            "X-App-Id": config.appId ?? "",
+        };
+        try {
+            const resp = await fetch(url, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(batch),
+            });
+            const text = await resp.text();
+            console.log("[Zubbl SDK][Telemetry] Flushed", batch.length, "events →", resp.status, text);
+        }
+        catch (err) {
+            console.warn("[Zubbl SDK][Telemetry] Failed to send batch:", err.message);
+        }
+    }
+    // -----------------------------------------------------------
+    // Helper for HTTP wrapping
+    // -----------------------------------------------------------
+    async function recordRequestTelemetry(url, method, status, latency, extra = {}) {
+        try {
+            const path = new URL(url).pathname;
+            emitEndpoint({
+                path,
+                method,
+                status,
+                latency,
+                ...extra,
+            });
+        }
+        catch (err) {
+            console.warn("[Zubbl SDK][Telemetry] Failed to record telemetry", err);
+        }
+    }
+    // -----------------------------------------------------------
+    // Runtime Endpoint Discovery
+    // -----------------------------------------------------------
+    let hasLoggedDiscovery = false;
+    function logRuntimeDiscovery(url) {
+        if (hasLoggedDiscovery)
+            return; // only once per runtime
+        hasLoggedDiscovery = true;
+        const runtime = isNode ? "Node" : isBrowser ? "Browser" : isWorker ? "Worker" : "Unknown";
+        const time = new Date().toISOString();
+        console.log(`[Zubbl SDK][Discovery] Runtime: ${runtime}`);
+        console.log(`[Zubbl SDK][Discovery] Timestamp: ${time}`);
+        console.log(`[Zubbl SDK][Discovery] Initial endpoint: ${url}`);
     }
 
-    try {
-      const resp = await axios.post(
-        `${config.baseUrl.replace(/\/$/, "")}/sdk/test-enforcement`,
-        {},
-        { headers }
-      );
-      return { decision: "allow", status: resp.status, data: resp.data };
-    } catch (e) {
-      if (e.response && e.response.status === 429) {
-        return { decision: "block", status: 429, data: e.response.data };
-      }
-      throw e;
-    }
-  }
+    var telemetry = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        emitEndpoint: emitEndpoint,
+        logRuntimeDiscovery: logRuntimeDiscovery,
+        recordRequestTelemetry: recordRequestTelemetry
+    });
 
-  exports.emitEndpoint = emitEndpoint;
-  exports.enforce = enforce;
-  exports.getTiles = getTiles;
-  exports.identifyUser = identifyUser;
-  exports.init = init;
-  exports.setSamplingRatio = setSamplingRatio;
-  exports.zubblFetch = zubblFetch;
+    exports.enforce = enforce;
+    exports.getConfig = getConfig;
+    exports.getTiles = getTiles;
+    exports.httpRequest = httpRequest;
+    exports.identifyUser = identifyUser;
+    exports.init = init;
+    exports.storage = storage;
 
 }));
+//# sourceMappingURL=zubbl-sdk.umd.js.map