@ianmenethil/zp-observer 6.0.0

package/dist/session.cjs

@@ -0,0 +1,1186 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/session.ts
+var session_exports = {};
+__export(session_exports, {
+  createZenPaySession: () => createZenPaySession
+});
+module.exports = __toCommonJS(session_exports);
+
+// src/core/detection.ts
+var DEFAULT_IFRAME_SELECTORS = [
+  "iframe.zp-payment-frame",
+  'iframe[src*="zenithpayments"]',
+  'iframe[src*="travelpay"]',
+  ".modal-payment iframe",
+  "div.modal.show iframe"
+];
+function startDetection(hooks, opts) {
+  if (typeof document === "undefined") {
+    return { stop() {
+    } };
+  }
+  let stopped = false;
+  let pollTimer = null;
+  let mutationObserver = null;
+  let bootstrapHandler = null;
+  const startedAt = Date.now();
+  const findIframe = () => {
+    for (const selector of opts.selectors) {
+      const el = document.querySelector(selector);
+      if (el instanceof HTMLIFrameElement) return el;
+    }
+    return null;
+  };
+  const stopPolling = () => {
+    if (pollTimer !== null) {
+      clearInterval(pollTimer);
+      pollTimer = null;
+    }
+  };
+  const watchForRemoval = (iframe) => {
+    if (typeof MutationObserver === "undefined" || !document.body) return;
+    mutationObserver = new MutationObserver((mutations) => {
+      for (const m of mutations) {
+        for (const node of Array.from(m.removedNodes)) {
+          if (node === iframe || node instanceof Node && node.contains(iframe)) {
+            hooks.onRemoved();
+            return;
+          }
+        }
+      }
+    });
+    mutationObserver.observe(document.body, { childList: true, subtree: true });
+  };
+  const watchBootstrapModal = () => {
+    if (typeof document.addEventListener !== "function") return;
+    bootstrapHandler = () => hooks.onBootstrapHidden();
+    document.addEventListener("hidden.bs.modal", bootstrapHandler, true);
+  };
+  const onFound = (iframe) => {
+    stopPolling();
+    watchForRemoval(iframe);
+    watchBootstrapModal();
+    hooks.onFound(iframe);
+  };
+  const existing = findIframe();
+  if (existing) {
+    queueMicrotask(() => {
+      if (!stopped) onFound(existing);
+    });
+  } else {
+    pollTimer = setInterval(() => {
+      if (stopped) return;
+      if (Date.now() - startedAt > opts.timeoutMs) {
+        stopPolling();
+        hooks.onTimeout();
+        return;
+      }
+      const found = findIframe();
+      if (found) onFound(found);
+    }, opts.intervalMs);
+  }
+  return {
+    stop() {
+      stopped = true;
+      stopPolling();
+      if (mutationObserver) {
+        mutationObserver.disconnect();
+        mutationObserver = null;
+      }
+      if (bootstrapHandler) {
+        document.removeEventListener(
+          "hidden.bs.modal",
+          bootstrapHandler,
+          true
+        );
+        bootstrapHandler = null;
+      }
+    }
+  };
+}
+
+// src/core/beacon.ts
+var JSON_TYPE = "application/json";
+function postJsonBeacon(url, body) {
+  if (typeof navigator === "undefined" || typeof navigator.sendBeacon !== "function") {
+    return false;
+  }
+  try {
+    const blob = new Blob([JSON.stringify(body)], { type: JSON_TYPE });
+    return navigator.sendBeacon(url, blob);
+  } catch {
+    return false;
+  }
+}
+
+// src/core/experimental.ts
+function hasGlobalExperimentalFeatures(exp) {
+  if (!exp) return false;
+  return !!(exp.pageLifecycleBeaconUrl || exp.captureWasDiscarded || exp.capturePageShow || exp.captureWindowFocus || exp.captureVisibilityDetail || exp.captureFreezeResume || exp.capturePerformanceEntries);
+}
+function hasIframeExperimentalFeatures(exp) {
+  if (!exp) return false;
+  return !!(exp.captureIframeResize || exp.captureIframeSrcChanges);
+}
+function logDiag(debug, ...args) {
+  if (debug && typeof console !== "undefined") {
+    console.log("[ZPObserver/experimental]", ...args);
+  }
+}
+function captureUserActivation() {
+  try {
+    const ua = typeof navigator !== "undefined" ? navigator.userActivation : void 0;
+    if (!ua) return void 0;
+    return {
+      hasBeenActive: ua.hasBeenActive ?? false,
+      isActive: ua.isActive ?? false
+    };
+  } catch {
+    return void 0;
+  }
+}
+function readNavigationDetail() {
+  try {
+    const entries = performance.getEntriesByType("navigation");
+    const nav = entries[0];
+    if (!nav) return null;
+    const wasDiscarded = "wasDiscarded" in nav ? Boolean(nav.wasDiscarded) : null;
+    return {
+      wasDiscarded,
+      redirectCount: nav.redirectCount ?? null,
+      transferSize: nav.transferSize ?? null,
+      type: nav.type ?? null
+    };
+  } catch {
+    return null;
+  }
+}
+function readOpenExperimentalFields(exp) {
+  if (!exp) return {};
+  const out = {};
+  if (exp.captureUserActivation) {
+    const ua = captureUserActivation();
+    if (ua) out.userActivation = ua;
+  }
+  if (exp.captureNavigationTimingDetail) {
+    const nav = readNavigationDetail();
+    if (nav) out.navigationDetail = nav;
+  }
+  return out;
+}
+function installGlobalExperimental(ctx) {
+  const { experimental: exp, onDiagnostic, debug, sessionId, getNavigationType: getNavigationType2 } = ctx;
+  const stops = [];
+  const beaconUrl = exp.pageLifecycleBeaconUrl;
+  const fireBeacon = (phase, extra) => {
+    if (!beaconUrl) return;
+    const payload = { phase, sessionId, timestamp: Date.now(), ...extra };
+    const ok = postJsonBeacon(beaconUrl, payload);
+    onDiagnostic({ kind: "exp.page_lifecycle_beacon", phase, ok, timestamp: Date.now() });
+    logDiag(debug, "pageLifecycleBeacon", phase, ok);
+  };
+  if (beaconUrl) {
+    fireBeacon("navigation", { navType: getNavigationType2() });
+  }
+  if (exp.captureWasDiscarded) {
+    const nav = readNavigationDetail();
+    const wasDiscarded = nav?.wasDiscarded ?? null;
+    onDiagnostic({ kind: "exp.was_discarded", wasDiscarded, timestamp: Date.now() });
+    logDiag(debug, "wasDiscarded", wasDiscarded);
+  }
+  if ((exp.capturePageShow || beaconUrl) && typeof window !== "undefined") {
+    const handler = (ev) => {
+      const persisted = ev.persisted === true;
+      if (exp.capturePageShow) {
+        onDiagnostic({
+          kind: "exp.pageshow",
+          persisted,
+          navigationType: getNavigationType2(),
+          timestamp: Date.now()
+        });
+        logDiag(debug, "pageshow", { persisted });
+      }
+      if (beaconUrl) fireBeacon("pageshow", { persisted });
+    };
+    window.addEventListener("pageshow", handler, { passive: true });
+    stops.push(() => window.removeEventListener("pageshow", handler));
+  }
+  if (beaconUrl && typeof window !== "undefined") {
+    const ph = (ev) => {
+      fireBeacon("pagehide", { persisted: ev.persisted === true });
+    };
+    window.addEventListener("pagehide", ph, { passive: true });
+    stops.push(() => window.removeEventListener("pagehide", ph));
+  }
+  if (exp.captureWindowFocus && typeof window !== "undefined") {
+    const onF = () => {
+      onDiagnostic({ kind: "exp.window_focus", timestamp: Date.now() });
+      logDiag(debug, "window focus");
+    };
+    const onB = () => {
+      onDiagnostic({ kind: "exp.window_blur", timestamp: Date.now() });
+      logDiag(debug, "window blur");
+    };
+    window.addEventListener("focus", onF, { passive: true });
+    window.addEventListener("blur", onB, { passive: true });
+    stops.push(() => {
+      window.removeEventListener("focus", onF);
+      window.removeEventListener("blur", onB);
+    });
+  }
+  if (exp.captureVisibilityDetail && typeof document !== "undefined") {
+    let lastState = document.visibilityState ?? "visible";
+    let lastChangeAt = Date.now();
+    const handler = () => {
+      const now = Date.now();
+      const curr = document.visibilityState ?? "visible";
+      const prev = lastState;
+      lastState = curr;
+      const deltaMs = now - lastChangeAt;
+      lastChangeAt = now;
+      const hasFocus = typeof document.hasFocus === "function" ? document.hasFocus() : null;
+      const onLine = typeof navigator !== "undefined" && typeof navigator.onLine === "boolean" ? navigator.onLine : null;
+      onDiagnostic({
+        kind: "exp.visibility_detail",
+        prevState: prev,
+        currState: curr,
+        prevStateDurationMs: deltaMs,
+        hasFocus,
+        onLine,
+        timestamp: now
+      });
+      logDiag(debug, "visibility_detail", { prev, curr, hasFocus, onLine });
+    };
+    document.addEventListener("visibilitychange", handler, { passive: true });
+    stops.push(() => document.removeEventListener("visibilitychange", handler));
+  }
+  if (exp.captureFreezeResume && typeof document !== "undefined") {
+    const onFreeze = () => {
+      onDiagnostic({ kind: "exp.freeze", timestamp: Date.now() });
+      logDiag(debug, "freeze");
+    };
+    const onResume = () => {
+      onDiagnostic({ kind: "exp.resume", timestamp: Date.now() });
+      logDiag(debug, "resume");
+    };
+    try {
+      document.addEventListener("freeze", onFreeze, { passive: true });
+      document.addEventListener("resume", onResume, { passive: true });
+      stops.push(() => {
+        document.removeEventListener("freeze", onFreeze);
+        document.removeEventListener("resume", onResume);
+      });
+    } catch {
+      logDiag(debug, "freeze/resume not supported");
+    }
+  }
+  if (exp.capturePerformanceEntries && typeof PerformanceObserver !== "undefined") {
+    const types = exp.perfEntryTypes ?? ["longtask", "largest-contentful-paint"];
+    const emitPerf = (entry) => {
+      if (entry.entryType === "longtask") {
+        onDiagnostic({
+          kind: "exp.perf_entry",
+          entryType: entry.entryType,
+          name: entry.name,
+          startTime: entry.startTime,
+          duration: entry.duration,
+          timestamp: Date.now()
+        });
+      } else if (entry.entryType === "largest-contentful-paint") {
+        const lcp = entry;
+        onDiagnostic({
+          kind: "exp.perf_entry",
+          entryType: entry.entryType,
+          name: entry.name,
+          startTime: entry.startTime,
+          ...lcp.size !== void 0 && { size: lcp.size },
+          ...lcp.url !== void 0 && { url: lcp.url },
+          timestamp: Date.now()
+        });
+      } else {
+        onDiagnostic({
+          kind: "exp.perf_entry",
+          entryType: entry.entryType,
+          name: entry.name,
+          startTime: entry.startTime,
+          timestamp: Date.now()
+        });
+      }
+      logDiag(debug, "perf", entry.entryType, entry.name);
+    };
+    for (const t of types) {
+      try {
+        const obs = new PerformanceObserver((list) => {
+          for (const entry of list.getEntries()) emitPerf(entry);
+        });
+        try {
+          obs.observe({ type: t, buffered: true });
+        } catch {
+          obs.observe({ entryTypes: [t] });
+        }
+        stops.push(() => obs.disconnect());
+      } catch (err) {
+        logDiag(debug, "PerformanceObserver failed for", t, err);
+      }
+    }
+  }
+  return {
+    stop() {
+      for (const s of stops) s();
+    }
+  };
+}
+function installIframeExperimental(iframe, ctx) {
+  const { experimental: exp, onDiagnostic, debug } = ctx;
+  const stops = [];
+  if (exp.captureIframeResize && typeof ResizeObserver !== "undefined") {
+    const ro = new ResizeObserver((entries) => {
+      const e = entries[entries.length - 1];
+      if (!e) return;
+      const { width, height } = e.contentRect;
+      onDiagnostic({
+        kind: "exp.iframe_resize",
+        width: Math.round(width),
+        height: Math.round(height),
+        timestamp: Date.now()
+      });
+      logDiag(debug, "iframe_resize", width, height);
+    });
+    ro.observe(iframe);
+    stops.push(() => ro.disconnect());
+  }
+  if (exp.captureIframeSrcChanges && typeof MutationObserver !== "undefined") {
+    let prev = iframe.src || null;
+    const mo = new MutationObserver(() => {
+      const cur = iframe.src || "";
+      if (cur !== prev) {
+        onDiagnostic({
+          kind: "exp.iframe_src",
+          previousSrc: prev,
+          currentSrc: cur,
+          timestamp: Date.now()
+        });
+        logDiag(debug, "iframe_src", prev, cur);
+        prev = cur || null;
+      }
+    });
+    mo.observe(iframe, { attributes: true, attributeFilter: ["src"] });
+    stops.push(() => mo.disconnect());
+  }
+  return {
+    stop() {
+      for (const s of stops) s();
+    }
+  };
+}
+
+// src/core/heartbeat.ts
+function startHeartbeat(sessionId, correlationId, getMetadata, sender, hooks, opts) {
+  let sequence = 0;
+  let missed = 0;
+  let abandoned = false;
+  let timer = null;
+  const tick = () => {
+    if (abandoned) return;
+    sequence += 1;
+    const ev = {
+      kind: "heartbeat",
+      sessionId,
+      correlationId,
+      timestamp: Date.now(),
+      sequence,
+      missedBeats: missed,
+      metadata: getMetadata()
+    };
+    void sender.sendHeartbeat(ev).then((result) => {
+      if (result.ok) {
+        missed = 0;
+      } else {
+        missed += 1;
+        if (missed >= opts.missThreshold && !abandoned) {
+          abandoned = true;
+          hooks.onAbandoned(missed);
+        }
+      }
+      hooks.onTick(sequence, missed);
+    }).catch(() => {
+      missed += 1;
+      if (missed >= opts.missThreshold && !abandoned) {
+        abandoned = true;
+        hooks.onAbandoned(missed);
+      }
+      hooks.onTick(sequence, missed);
+    });
+  };
+  timer = setInterval(tick, opts.intervalMs);
+  return {
+    stop() {
+      abandoned = true;
+      if (timer !== null) {
+        clearInterval(timer);
+        timer = null;
+      }
+    },
+    heartbeatCount: () => sequence,
+    missedBeats: () => missed
+  };
+}
+
+// src/core/lifecycle.ts
+function installPageLifecycle(hooks) {
+  if (typeof document === "undefined" || typeof window === "undefined") {
+    return { stop() {
+    } };
+  }
+  const visibilityHandler = () => {
+    if (document.visibilityState === "hidden") hooks.onHidden();
+    else if (document.visibilityState === "visible") hooks.onVisible();
+  };
+  const pageHideHandler = (event) => {
+    const persisted = event.persisted === true;
+    hooks.onPageHide(persisted);
+  };
+  document.addEventListener("visibilitychange", visibilityHandler);
+  window.addEventListener("pagehide", pageHideHandler);
+  return {
+    stop() {
+      document.removeEventListener("visibilitychange", visibilityHandler);
+      window.removeEventListener("pagehide", pageHideHandler);
+    }
+  };
+}
+function observeIframeVisibility(iframe, onChange) {
+  if (typeof IntersectionObserver === "undefined") {
+    return { stop() {
+    } };
+  }
+  const io = new IntersectionObserver(
+    (entries) => {
+      const entry = entries[entries.length - 1];
+      if (entry) onChange(entry.isIntersecting);
+    },
+    { threshold: 0.01 }
+  );
+  io.observe(iframe);
+  return {
+    stop() {
+      io.disconnect();
+    }
+  };
+}
+
+// src/core/shortcode.ts
+var PREFIX = "zpcb_";
+function generateShortcodeName() {
+  const ts = Date.now().toString(36);
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    const buf = new Uint32Array(2);
+    crypto.getRandomValues(buf);
+    return `${PREFIX}${ts}_${buf[0].toString(36)}${buf[1].toString(36)}`;
+  }
+  const rand = Math.floor(Math.random() * 4294967295).toString(36);
+  return `${PREFIX}${ts}_${rand}`;
+}
+function registerShortcode(name, fn) {
+  if (typeof window !== "undefined") {
+    window[name] = fn;
+  }
+  return `window.${name}`;
+}
+function unregisterShortcode(name) {
+  if (typeof window !== "undefined") {
+    try {
+      delete window[name];
+    } catch {
+      window[name] = void 0;
+    }
+  }
+}
+
+// src/core/random.ts
+function fallbackUUID() {
+  const hex = "0123456789abcdef";
+  const template = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
+  let result = "";
+  for (const ch of template) {
+    if (ch === "-") {
+      result += "-";
+    } else if (ch === "4") {
+      result += "4";
+    } else if (ch === "y") {
+      result += hex[Math.random() * 16 | 0];
+    } else {
+      result += hex[Math.random() * 16 | 0];
+    }
+  }
+  return result;
+}
+function generateUUID() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return fallbackUUID();
+}
+
+// src/core/event-bus.ts
+function createEventBus(transport, beforeSend, outbox) {
+  function applyBeforeSend(ev) {
+    if (!beforeSend) return ev;
+    try {
+      return beforeSend(ev);
+    } catch {
+      return ev;
+    }
+  }
+  function sendViaTransport(ev) {
+    return transport.send(ev).catch(() => ({ ok: false }));
+  }
+  const bus = {
+    emit(ev) {
+      const filtered = applyBeforeSend(ev);
+      if (!filtered) return;
+      if (outbox && ev.kind !== "heartbeat") {
+        outbox.push(filtered);
+      }
+      void sendViaTransport(filtered).then((result) => {
+        if (result.ok && outbox && ev.kind !== "heartbeat") {
+          outbox.remove(filtered);
+        }
+      });
+    },
+    async sendHeartbeat(ev) {
+      const filtered = applyBeforeSend(ev);
+      if (!filtered) return { ok: true };
+      const result = await sendViaTransport(filtered);
+      return result;
+    },
+    drain(sessionId) {
+      if (!outbox) return;
+      const pending = outbox.drain(sessionId);
+      for (const ev of pending) {
+        void sendViaTransport(ev).then((result) => {
+          if (result.ok) outbox.remove(ev);
+        });
+      }
+    }
+  };
+  return bus;
+}
+
+// src/core/outbox.ts
+var STORAGE_KEY = "__zpobs_outbox_v1";
+var MAX_ENTRIES = 64;
+function createOutbox(onUnavailable) {
+  if (typeof localStorage === "undefined") {
+    return null;
+  }
+  function readAll() {
+    try {
+      const raw = localStorage.getItem(STORAGE_KEY);
+      if (!raw) return [];
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed)) return [];
+      return parsed;
+    } catch {
+      onUnavailable("Failed to read outbox from localStorage");
+      return [];
+    }
+  }
+  function writeAll(entries) {
+    try {
+      const trimmed = entries.slice(-MAX_ENTRIES);
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(trimmed));
+      return true;
+    } catch (err) {
+      onUnavailable(
+        err instanceof Error ? err.message : "localStorage write failed (quota or private mode)"
+      );
+      return false;
+    }
+  }
+  return {
+    push(event) {
+      const entries = readAll();
+      entries.push({ sessionId: event.sessionId, correlationId: event.correlationId, event });
+      writeAll(entries);
+    },
+    remove(event) {
+      const entries = readAll();
+      const filtered = entries.filter(
+        (e) => !(e.event.kind === event.kind && e.event.timestamp === event.timestamp && e.event.sessionId === event.sessionId)
+      );
+      writeAll(filtered);
+    },
+    drain(targetSessionId) {
+      const entries = readAll();
+      const match = entries.filter((e) => e.sessionId === targetSessionId);
+      const rest = entries.filter((e) => e.sessionId !== targetSessionId);
+      writeAll(rest);
+      return match.map((e) => e.event);
+    }
+  };
+}
+
+// src/core/observer.ts
+function getNavigationType() {
+  try {
+    const entries = performance.getEntriesByType("navigation");
+    const entry = entries[0];
+    return entry?.type ?? null;
+  } catch {
+    return null;
+  }
+}
+function logDebug(enabled, ...args) {
+  if (enabled && typeof console !== "undefined") {
+    console.log("[ZPObserver]", ...args);
+  }
+}
+function createObserver(options) {
+  if (!options || typeof options !== "object") {
+    throw new Error("[ZPObserver] createObserver(options) requires an options object");
+  }
+  if (!options.sessionId || typeof options.sessionId !== "string") {
+    throw new Error("[ZPObserver] options.sessionId is required");
+  }
+  if (!options.transport) {
+    throw new Error("[ZPObserver] options.transport is required");
+  }
+  const sessionId = options.sessionId;
+  const correlationId = options.correlationId ?? generateUUID();
+  const transport = options.transport;
+  const metadata = options.metadata ?? {};
+  const beforeSend = options.beforeSend;
+  const heartbeatMs = options.heartbeatMs ?? 5e3;
+  const missThreshold = options.heartbeatMissThreshold ?? 3;
+  const idleTimeoutMs = options.idleTimeoutMs ?? 15 * 60 * 1e3;
+  const detectionIntervalMs = options.detectionIntervalMs ?? 100;
+  const detectionTimeoutMs = options.detectionTimeoutMs ?? 3e4;
+  const iframeSelectors = options.iframeSelectors ?? Array.from(DEFAULT_IFRAME_SELECTORS);
+  const debug = options.debug === true;
+  const experimental = options.experimental;
+  const diagMax = experimental?.diagnosticsMax ?? 50;
+  const diagnosticsBuffer = [];
+  const recentEvents = [];
+  const eventsMax = 50;
+  let uiState = "IDLE";
+  let transportState = "CONNECTED";
+  let isActive = false;
+  let startedAtMs = 0;
+  let iframeEl = null;
+  let closed = false;
+  let detectionHandle = null;
+  let lifecycleHandle = null;
+  let visibilityHandle = null;
+  let heartbeat = null;
+  let idleTimer = null;
+  let experimentalGlobalHandle = null;
+  let experimentalIframeHandle = null;
+  const shortcodeName = generateShortcodeName();
+  const shortcode = registerShortcode(shortcodeName, () => {
+    logDebug(debug, `shortcode invoked: ${shortcodeName}`);
+    stop("user.callback_invoked");
+  });
+  const emitDiagnostic = (e) => {
+    diagnosticsBuffer.push(e);
+    while (diagnosticsBuffer.length > diagMax) diagnosticsBuffer.shift();
+    options.onDiagnostic?.(e);
+    logDebug(debug, "diagnostic", e);
+  };
+  const outbox = options.persistence === "localStorage" ? createOutbox((error) => {
+    emitDiagnostic({ kind: "system.persistence_unavailable", error, timestamp: Date.now() });
+  }) : null;
+  const bus = createEventBus(transport, beforeSend, outbox);
+  const trackEvent = (ev) => {
+    recentEvents.push(ev);
+    while (recentEvents.length > eventsMax) recentEvents.shift();
+  };
+  const emit = (event) => {
+    trackEvent(event);
+    bus.emit(event);
+  };
+  const getMetadata = () => {
+    const base = { ...metadata };
+    if (experimental?.attachDiagnosticsToHeartbeat) {
+      base.zpObserverDiagnostics = diagnosticsBuffer.slice();
+    }
+    return base;
+  };
+  const resetIdleTimer = () => {
+    if (idleTimeoutMs <= 0) return;
+    if (idleTimer !== null) clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => {
+      logDebug(debug, "idle timeout reached");
+      stop("system.idle_timeout");
+    }, idleTimeoutMs);
+  };
+  const sendOpen = (iframe) => {
+    const openExtras = readOpenExperimentalFields(experimental);
+    const ev = {
+      kind: "open",
+      sessionId,
+      correlationId,
+      timestamp: Date.now(),
+      iframeSrc: iframe.src || null,
+      userAgent: typeof navigator !== "undefined" ? navigator.userAgent : "",
+      screenWidth: typeof screen !== "undefined" ? screen.width : 0,
+      screenHeight: typeof screen !== "undefined" ? screen.height : 0,
+      navigationType: getNavigationType(),
+      metadata: getMetadata(),
+      ...openExtras
+    };
+    emit(ev);
+  };
+  const sendClose = (reason, wasPersisted) => {
+    const hbCount = heartbeat?.heartbeatCount() ?? 0;
+    const missed = heartbeat?.missedBeats() ?? 0;
+    const ev = {
+      kind: "close",
+      sessionId,
+      correlationId,
+      timestamp: Date.now(),
+      reason,
+      elapsedMs: startedAtMs ? Date.now() - startedAtMs : 0,
+      heartbeatCount: hbCount,
+      missedBeats: missed,
+      wasPersisted,
+      metadata: getMetadata()
+    };
+    emit(ev);
+  };
+  const start = () => {
+    if (isActive) {
+      logDebug(debug, "start() called while already active \u2014 ignoring");
+      return;
+    }
+    isActive = true;
+    closed = false;
+    startedAtMs = Date.now();
+    uiState = "DETECTING";
+    bus.drain(sessionId);
+    emit({
+      kind: "payment.session_init",
+      sessionId,
+      correlationId,
+      timestamp: Date.now(),
+      metadata: getMetadata()
+    });
+    if (hasGlobalExperimentalFeatures(experimental) && experimental) {
+      experimentalGlobalHandle = installGlobalExperimental({
+        sessionId,
+        experimental,
+        onDiagnostic: emitDiagnostic,
+        debug,
+        getNavigationType
+      });
+    }
+    lifecycleHandle = installPageLifecycle({
+      onHidden: () => {
+        if (uiState === "ACTIVE_MODAL_VISIBLE") uiState = "BACKGROUND_HIDDEN";
+      },
+      onVisible: () => {
+        if (uiState === "BACKGROUND_HIDDEN") uiState = "ACTIVE_MODAL_VISIBLE";
+      },
+      onPageHide: (persisted) => {
+        if (!closed) stopInternal("page.pagehide", persisted);
+      }
+    });
+    detectionHandle = startDetection(
+      {
+        onFound: (iframe) => {
+          iframeEl = iframe;
+          uiState = "ACTIVE_MODAL_VISIBLE";
+          logDebug(debug, "iframe detected:", iframe.src);
+          sendOpen(iframe);
+          heartbeat = startHeartbeat(
+            sessionId,
+            correlationId,
+            getMetadata,
+            bus,
+            {
+              onTick: (_seq, missed) => {
+                transportState = missed === 0 ? "CONNECTED" : missed < missThreshold ? "HEARTBEAT_LATE" : "DISCONNECTED";
+                if (missed === 0) resetIdleTimer();
+              },
+              onAbandoned: () => {
+                transportState = "DISCONNECTED";
+                if (!closed) stop("system.network_abandoned");
+              }
+            },
+            { intervalMs: heartbeatMs, missThreshold }
+          );
+          visibilityHandle = observeIframeVisibility(iframe, (visible) => {
+            logDebug(debug, "iframe visibility:", visible);
+          });
+          if (hasIframeExperimentalFeatures(experimental) && experimental) {
+            experimentalIframeHandle = installIframeExperimental(iframe, {
+              sessionId,
+              experimental,
+              onDiagnostic: emitDiagnostic,
+              debug,
+              getNavigationType
+            });
+          }
+          resetIdleTimer();
+        },
+        onRemoved: () => {
+          if (!closed) stop("user.modal_closed");
+        },
+        onBootstrapHidden: () => {
+          if (!closed) stop("user.modal_closed");
+        },
+        onTimeout: () => {
+          logDebug(debug, "detection timeout \u2014 no iframe found");
+        }
+      },
+      {
+        selectors: iframeSelectors,
+        intervalMs: detectionIntervalMs,
+        timeoutMs: detectionTimeoutMs
+      }
+    );
+    logDebug(debug, `started session ${sessionId}, correlationId=${correlationId}, shortcode=${shortcode}`);
+  };
+  const stopInternal = (reason, wasPersisted) => {
+    if (closed) return;
+    closed = true;
+    isActive = false;
+    uiState = "DISMISSED";
+    logDebug(debug, `stopping: ${reason}`);
+    if (detectionHandle) {
+      detectionHandle.stop();
+      detectionHandle = null;
+    }
+    if (heartbeat) {
+      heartbeat.stop();
+      heartbeat = null;
+    }
+    if (visibilityHandle) {
+      visibilityHandle.stop();
+      visibilityHandle = null;
+    }
+    if (experimentalIframeHandle) {
+      experimentalIframeHandle.stop();
+      experimentalIframeHandle = null;
+    }
+    if (idleTimer !== null) {
+      clearTimeout(idleTimer);
+      idleTimer = null;
+    }
+    if (lifecycleHandle) {
+      lifecycleHandle.stop();
+      lifecycleHandle = null;
+    }
+    if (experimentalGlobalHandle) {
+      experimentalGlobalHandle.stop();
+      experimentalGlobalHandle = null;
+    }
+    sendClose(reason, wasPersisted);
+    unregisterShortcode(shortcodeName);
+  };
+  const stop = (reason = "user.manual_close") => {
+    stopInternal(reason, null);
+  };
+  const getState = () => ({
+    ui: uiState,
+    transport: transportState,
+    sessionId,
+    correlationId,
+    shortcode,
+    isActive,
+    iframeDetected: iframeEl !== null,
+    heartbeatCount: heartbeat?.heartbeatCount() ?? 0,
+    missedBeats: heartbeat?.missedBeats() ?? 0,
+    elapsedMs: startedAtMs ? Date.now() - startedAtMs : 0
+  });
+  const diagnostics = {
+    dump() {
+      return {
+        sessionId,
+        correlationId,
+        state: getState(),
+        recentEvents: recentEvents.slice(),
+        diagnostics: diagnosticsBuffer.slice(),
+        configuredTransport: transport.constructor?.name ?? "custom",
+        version: "6.0.0"
+      };
+    }
+  };
+  return { sessionId, correlationId, shortcode, start, stop, getState, emit, diagnostics };
+}
+
+// src/integration/zenpay-auto-patch.ts
+function logDebug2(enabled, ...args) {
+  if (enabled && typeof console !== "undefined") {
+    console.log("[ZPObserver/auto-patch]", ...args);
+  }
+}
+function resolveAndCallWindowPath(windowPath) {
+  const path = windowPath.replace(/^window\./, "").split(".");
+  let ref = window;
+  for (const part of path) {
+    if (ref && typeof ref === "object" && part in ref) {
+      ref = ref[part];
+    } else {
+      ref = void 0;
+      break;
+    }
+  }
+  if (typeof ref === "function") ref();
+}
+function wrapOptions(opts, shortcode, chainExisting) {
+  const next = { ...opts ?? {} };
+  const existing = next.onPluginClose;
+  if (chainExisting && existing != null) {
+    if (typeof window !== "undefined") {
+      const wrapperName = `__zpobs_chain_${Date.now().toString(36)}`;
+      window[wrapperName] = () => {
+        try {
+          if (typeof existing === "function") {
+            existing();
+          } else if (typeof existing === "string") {
+            resolveAndCallWindowPath(existing);
+          }
+        } catch {
+        }
+        try {
+          resolveAndCallWindowPath(shortcode);
+        } catch {
+        }
+      };
+      next.onPluginClose = `window.${wrapperName}`;
+      return next;
+    }
+  }
+  next.onPluginClose = shortcode;
+  return next;
+}
+function patchJQueryPlugin($, shortcode, chainExisting, debug, onInvoke) {
+  const original = $.fn.zpPayment;
+  if (typeof original !== "function" || original.__zpobsPatched) {
+    return false;
+  }
+  const patched = function(opts) {
+    onInvoke();
+    return original.call(this, wrapOptions(opts, shortcode, chainExisting));
+  };
+  patched.__zpobsPatched = true;
+  $.fn.zpPayment = patched;
+  logDebug2(debug, "patched $.fn.zpPayment");
+  return true;
+}
+function patchZenPayGlobal(shortcode, chainExisting, debug, onInvoke) {
+  const w = window;
+  const original = w.ZenPay;
+  if (typeof original !== "function" || original.__zpobsPatched) {
+    return false;
+  }
+  const handler = {
+    construct(target, args) {
+      onInvoke();
+      const [first, ...rest] = args;
+      const wrapped = wrapOptions(first, shortcode, chainExisting);
+      return Reflect.construct(target, [wrapped, ...rest]);
+    },
+    apply(target, thisArg, args) {
+      onInvoke();
+      const [first, ...rest] = args;
+      const wrapped = wrapOptions(first, shortcode, chainExisting);
+      return Reflect.apply(target, thisArg, [
+        wrapped,
+        ...rest
+      ]);
+    }
+  };
+  const patched = new Proxy(original, handler);
+  patched.__zpobsPatched = true;
+  w.ZenPay = patched;
+  logDebug2(debug, "patched window.ZenPay");
+  return true;
+}
+function installZenPayAutoPatch(observer, options = {}) {
+  if (typeof window === "undefined") {
+    return { uninstall() {
+    }, isPatched: () => false };
+  }
+  const pollIntervalMs = options.pollIntervalMs ?? 200;
+  const pollTimeoutMs = options.pollTimeoutMs ?? 3e4;
+  const chainExisting = options.chainExisting !== false;
+  const debug = options.debug === true;
+  let patched = false;
+  const shortcode = observer.shortcode;
+  const w = window;
+  const emitHppInit = () => {
+    observer.emit({
+      kind: "payment.hpp_init",
+      sessionId: observer.sessionId,
+      correlationId: observer.correlationId,
+      timestamp: Date.now(),
+      metadata: {}
+    });
+  };
+  const tryPatch = () => {
+    let didSomething = false;
+    const jq = w.jQuery ?? w.$;
+    if (jq && typeof jq === "object" && "fn" in jq) {
+      if (patchJQueryPlugin(jq, shortcode, chainExisting, debug, emitHppInit)) didSomething = true;
+    }
+    if ("ZenPay" in window) {
+      if (patchZenPayGlobal(shortcode, chainExisting, debug, emitHppInit)) didSomething = true;
+    }
+    if (didSomething) patched = true;
+    return didSomething;
+  };
+  tryPatch();
+  const startedAt = Date.now();
+  let pollTimer = setInterval(() => {
+    if (Date.now() - startedAt > pollTimeoutMs) {
+      if (pollTimer !== null) {
+        clearInterval(pollTimer);
+        pollTimer = null;
+      }
+      return;
+    }
+    tryPatch();
+  }, pollIntervalMs);
+  return {
+    uninstall() {
+      if (pollTimer !== null) {
+        clearInterval(pollTimer);
+        pollTimer = null;
+      }
+    },
+    isPatched: () => patched
+  };
+}
+
+// src/integration/hpp-bridge.ts
+function installHPPBridge(observer) {
+  if (typeof window === "undefined") {
+    return { uninstall() {
+    } };
+  }
+  const w = window;
+  const original = w.onPaymentPluginLoaded;
+  const wrapper = () => {
+    try {
+      observer.emit({
+        kind: "payment.hpp_iframe_loaded",
+        sessionId: observer.sessionId,
+        correlationId: observer.correlationId,
+        timestamp: Date.now(),
+        metadata: {}
+      });
+    } catch {
+    }
+    if (typeof original === "function") {
+      try {
+        original();
+      } catch {
+      }
+    }
+  };
+  w.onPaymentPluginLoaded = wrapper;
+  return {
+    uninstall() {
+      w.onPaymentPluginLoaded = original ?? null;
+    }
+  };
+}
+
+// src/session.ts
+function createZenPaySession(options) {
+  const {
+    sessionId,
+    transport,
+    correlationId,
+    metadata,
+    persistence,
+    autoPatch,
+    heartbeatMs,
+    debug
+  } = options;
+  const observer = createObserver({
+    sessionId,
+    transport,
+    ...correlationId !== void 0 ? { correlationId } : {},
+    ...metadata !== void 0 ? { metadata } : {},
+    ...persistence !== void 0 ? { persistence } : {},
+    ...heartbeatMs !== void 0 ? { heartbeatMs } : {},
+    ...debug !== void 0 ? { debug } : {}
+  });
+  observer.start();
+  installZenPayAutoPatch(observer, autoPatch);
+  installHPPBridge(observer);
+  const fpObserver = observer;
+  const hooks = {
+    onFingerprintStarted(attempt) {
+      fpObserver.emit({
+        kind: "payment.fingerprint_started",
+        sessionId,
+        correlationId: fpObserver.correlationId,
+        timestamp: Date.now(),
+        attempt,
+        metadata: metadata ?? {}
+      });
+    },
+    onFingerprintCacheHit(age) {
+      fpObserver.emit({
+        kind: "payment.fingerprint_cache_hit",
+        sessionId,
+        correlationId: fpObserver.correlationId,
+        timestamp: Date.now(),
+        age,
+        metadata: metadata ?? {}
+      });
+    },
+    onFingerprintSucceeded() {
+      fpObserver.emit({
+        kind: "payment.fingerprint_succeeded",
+        sessionId,
+        correlationId: fpObserver.correlationId,
+        timestamp: Date.now(),
+        metadata: metadata ?? {}
+      });
+    },
+    onFingerprintFailed(error, attempt) {
+      fpObserver.emit({
+        kind: "payment.fingerprint_failed",
+        sessionId,
+        correlationId: fpObserver.correlationId,
+        timestamp: Date.now(),
+        error,
+        attempt,
+        metadata: metadata ?? {}
+      });
+    }
+  };
+  return {
+    sessionId,
+    correlationId: observer.correlationId,
+    observer,
+    hppDefaults: {
+      onPluginClose: observer.shortcode
+    },
+    fingerprint: { hooks }
+  };
+}
+//# sourceMappingURL=session.cjs.map