@cross-deck/web 1.5.6 → 1.6.1

package/dist/react.cjs

@@ -93,7 +93,7 @@ function typeMapForStatus(status) {
 }
 
 // src/_version.ts
-var SDK_VERSION = "1.5.3";
+var SDK_VERSION = "1.6.1";
 var SDK_NAME = "@cross-deck/web";
 
 // src/http.ts
@@ -1442,6 +1442,8 @@ var DEFAULT_AUTO_TRACK = {
   errors: true
 };
 var SESSION_RESUME_THRESHOLD_MS = 30 * 60 * 1e3;
+var SESSION_STORAGE_KEY = "crossdeck:session";
+var ACTIVITY_PERSIST_THROTTLE_MS = 5e3;
 var EMPTY_ACQUISITION = {
   utm_source: "",
   utm_medium: "",
@@ -1457,11 +1459,13 @@ var EMPTY_ACQUISITION = {
   twclid: ""
 };
 var AutoTracker = class {
-  constructor(cfg, track) {
+  constructor(cfg, track, opts) {
     this.cfg = cfg;
     this.track = track;
     this.session = null;
     this.cleanups = [];
+    /** Last time we flushed lastActivityAt to storage (throttle gate). */
+    this.lastPersistAt = 0;
     /**
      * Stable per-page-view identifier. Minted at every `page.viewed`
      * emission and attached to every subsequent event until the next
@@ -1473,6 +1477,8 @@ var AutoTracker = class {
      * install if `autoTrack.pageViews !== false`).
      */
     this.pageviewId = null;
+    this.storage = opts?.storage ?? null;
+    this.sessionKey = opts?.storageKey ?? SESSION_STORAGE_KEY;
   }
   install() {
     if (!isBrowserSafe()) return;
@@ -1491,6 +1497,7 @@ var AutoTracker = class {
     if (this.session && !this.session.endedSent) {
       this.emitSessionEnd();
     }
+    this.clearStoredSession();
     this.session = null;
   }
   /** Exposed for tests + consumers that want to reset the session manually. */
@@ -1498,8 +1505,24 @@ var AutoTracker = class {
     if (this.session && !this.session.endedSent) this.emitSessionEnd();
     this.pageviewId = null;
     this.session = this.startNewSession();
+    this.persistSession();
     this.emitSessionStart();
   }
+  /**
+   * Keep the rolling session window alive. Called by the host on EVERY
+   * tracked event (auto or custom) so any activity — not just the
+   * pageviews/clicks AutoTracker emits itself — pushes the 30-min idle
+   * boundary forward. In-memory time is updated exactly; the storage
+   * flush is throttled (pagehide forces a final flush).
+   */
+  markActivity() {
+    if (!this.session) return;
+    const now = Date.now();
+    this.session.lastActivityAt = now;
+    if (now - this.lastPersistAt >= ACTIVITY_PERSIST_THROTTLE_MS) {
+      this.persistSession();
+    }
+  }
   /** Exposed for inspection/tests — returns the current sessionId (or null if not in a session). */
   get currentSessionId() {
     return this.session?.sessionId ?? null;
@@ -1522,26 +1545,43 @@ var AutoTracker = class {
   }
   // ---------- sessions ----------
   installSessionTracking() {
-    this.session = this.startNewSession();
-    this.emitSessionStart();
+    const now = Date.now();
+    const stored = this.readStoredSession();
+    if (stored && now - stored.lastActivityAt < SESSION_RESUME_THRESHOLD_MS) {
+      this.session = {
+        sessionId: stored.id,
+        startedAt: stored.startedAt,
+        lastActivityAt: now,
+        hiddenAt: null,
+        endedSent: false,
+        acquisition: stored.acquisition
+      };
+      this.persistSession();
+    } else {
+      this.session = this.startNewSession();
+      this.persistSession();
+      this.emitSessionStart();
+    }
     const onVisChange = () => {
       if (!this.session) return;
       const doc2 = globalThis.document;
       if (doc2.visibilityState === "hidden") {
         this.session.hiddenAt = Date.now();
+        this.persistSession();
       } else if (doc2.visibilityState === "visible") {
-        const hiddenFor = this.session.hiddenAt ? Date.now() - this.session.hiddenAt : 0;
-        if (hiddenFor >= SESSION_RESUME_THRESHOLD_MS) {
+        const idleFor = Date.now() - this.session.lastActivityAt;
+        if (idleFor >= SESSION_RESUME_THRESHOLD_MS) {
           this.emitSessionEnd();
           this.pageviewId = null;
           this.session = this.startNewSession();
+          this.persistSession();
           this.emitSessionStart();
         } else {
           this.session.hiddenAt = null;
         }
       }
     };
-    const onPageHide = () => this.emitSessionEnd();
+    const onPageHide = () => this.persistSession();
     const w = globalThis.window;
     const doc = globalThis.document;
     doc.addEventListener("visibilitychange", onVisChange);
@@ -1554,14 +1594,63 @@ var AutoTracker = class {
     });
   }
   startNewSession() {
+    const now = Date.now();
     return {
       sessionId: mintSessionId(),
-      startedAt: Date.now(),
+      startedAt: now,
+      lastActivityAt: now,
       hiddenAt: null,
       endedSent: false,
       acquisition: captureAcquisition()
     };
   }
+  /**
+   * Read the persisted session continuity record. Returns null on no
+   * storage, no record, malformed JSON, or a record missing its required
+   * fields — every failure degrades to "no session to resume", which is
+   * the safe (start-fresh) path.
+   */
+  readStoredSession() {
+    if (!this.storage) return null;
+    try {
+      const raw = this.storage.getItem(this.sessionKey);
+      if (!raw) return null;
+      const p = JSON.parse(raw);
+      if (!p || typeof p.id !== "string" || typeof p.startedAt !== "number" || typeof p.lastActivityAt !== "number") {
+        return null;
+      }
+      return {
+        id: p.id,
+        startedAt: p.startedAt,
+        lastActivityAt: p.lastActivityAt,
+        acquisition: p.acquisition && typeof p.acquisition === "object" ? p.acquisition : EMPTY_ACQUISITION
+      };
+    } catch {
+      return null;
+    }
+  }
+  /** Flush the current session to storage. No-op without storage/session. */
+  persistSession() {
+    if (!this.storage || !this.session) return;
+    this.lastPersistAt = Date.now();
+    try {
+      const rec = {
+        id: this.session.sessionId,
+        startedAt: this.session.startedAt,
+        lastActivityAt: this.session.lastActivityAt,
+        acquisition: this.session.acquisition
+      };
+      this.storage.setItem(this.sessionKey, JSON.stringify(rec));
+    } catch {
+    }
+  }
+  clearStoredSession() {
+    if (!this.storage) return;
+    try {
+      this.storage.removeItem(this.sessionKey);
+    } catch {
+    }
+  }
   emitSessionStart() {
     if (!this.session) return;
     this.track("session.started", { sessionId: this.session.sessionId });
@@ -1733,6 +1822,78 @@ function isInsidePasswordField(el) {
   if (el.closest('input[type="password"]')) return true;
   return false;
 }
+var INLINE_LABEL_TAGS = /* @__PURE__ */ new Set([
+  "span",
+  "b",
+  "strong",
+  "em",
+  "i",
+  "small",
+  "mark",
+  "u",
+  "label",
+  "abbr",
+  "time",
+  "bdi",
+  "cite",
+  "code",
+  "kbd",
+  "q",
+  "sub",
+  "sup"
+]);
+var NON_LABEL_SUBTREES = /* @__PURE__ */ new Set(["svg", "style", "script", "noscript"]);
+var CONTAINER_MARKERS = "a[href], button, input, select, textarea, [role='button'], [role='link'], h1, h2, h3, h4, h5, h6";
+var HEADING_SELECTOR = "h1, h2, h3, h4, h5, h6";
+function collapseWs(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
+function boundaryText(el) {
+  let out = "";
+  const walk = (node) => {
+    const kids = node.childNodes;
+    for (let i = 0; i < kids.length; i++) {
+      const child = kids[i];
+      if (!child) continue;
+      if (child.nodeType === 3) {
+        out += child.textContent || "";
+      } else if (child.nodeType === 1) {
+        if (NON_LABEL_SUBTREES.has(child.tagName.toLowerCase())) continue;
+        out += " ";
+        walk(child);
+        out += " ";
+      }
+    }
+  };
+  walk(el);
+  return collapseWs(out);
+}
+function directLabel(el) {
+  let out = "";
+  const kids = el.childNodes;
+  for (let i = 0; i < kids.length; i++) {
+    const child = kids[i];
+    if (!child) continue;
+    if (child.nodeType === 3) {
+      out += " " + (child.textContent || "");
+    } else if (child.nodeType === 1 && INLINE_LABEL_TAGS.has(child.tagName.toLowerCase())) {
+      out += " " + boundaryText(child);
+    }
+  }
+  return collapseWs(out);
+}
+function visibleLabel(el) {
+  const isContainer = el.querySelector(CONTAINER_MARKERS) !== null;
+  if (!isContainer) return boundaryText(el);
+  const direct = directLabel(el);
+  if (direct) return direct;
+  const heading = el.querySelector(HEADING_SELECTOR);
+  if (heading) {
+    const h = boundaryText(heading);
+    if (h) return h;
+  }
+  return "";
+}
 function extractText(el) {
   const clean = (s) => s.replace(/\s+/g, " ").trim();
   const explicit = el.getAttribute("data-cd-track") || el.getAttribute("data-track") || el.getAttribute("data-testid");
@@ -1759,7 +1920,7 @@ function extractText(el) {
     const t = clean(el.value);
     if (t) return t;
   }
-  const text = clean(el.textContent || "");
+  const text = visibleLabel(el);
   if (text) return text;
   const title = el.getAttribute("title");
   if (title) {
@@ -2400,7 +2561,7 @@ var BreadcrumbBuffer = class {
 };
 
 // src/_diagnostic-telemetry.ts
-var DIAGNOSTIC_TELEMETRY_ENDPOINT = "https://api.cross-deck.com/v1/sdk/diagnostic";
+var DIAGNOSTIC_TELEMETRY_ENDPOINT = "https://api.cross-deck.com/v1/events";
 var DIAGNOSTIC_TELEMETRY_PUBLISHABLE_KEY = "cd_pub_live_9490e7aa029c432abf";
 function isDiagnosticTelemetryEnabled() {
   return !DIAGNOSTIC_TELEMETRY_PUBLISHABLE_KEY.startsWith(
@@ -2438,7 +2599,15 @@ function sendDiagnosticTelemetry(payload) {
   if (!isDiagnosticTelemetryEnabled()) return;
   const filtered = filterDiagnosticPayload(payload);
   if (Object.keys(filtered).length === 0) return;
-  const body = JSON.stringify(filtered);
+  const body = JSON.stringify({
+    events: [
+      {
+        name: "crossdeck.contract_failed",
+        timestamp: Date.now(),
+        properties: filtered
+      }
+    ]
+  });
   const f = globalThis.fetch;
   if (typeof f !== "function") return;
   try {
@@ -3298,19 +3467,58 @@ var DEFAULT_ERROR_CAPTURE = {
     "ResizeObserver loop completed with undelivered notifications",
     "Non-Error promise rejection captured"
     // NOTE: We deliberately do NOT drop cross-origin "Script error."
-    // events here. They used to be silently filtered as noise, but
-    // silent drops are the opposite of "developer sleeps well at
-    // night". We now capture them with a clear label and the
-    // `cross_origin` tag so the dashboard surfaces them as a
-    // distinct, actionable category (the fix is always the same —
-    // add `crossorigin="anonymous"` to the script tag + CORS
-    // headers on the script's origin). Apps that genuinely want
-    // them muted can re-add "Script error" to ignoreErrors via
-    // init config.
+    // events here. The actionability principle (see denyUrls
+    // comment below) draws the line at "developer cannot act":
+    // cross-origin CORS opacity HAS a real, code-shaped fix (add
+    // `crossorigin="anonymous"` to the script tag + CORS headers
+    // on the script's origin). The dashboard surfaces these with a
+    // `cross_origin` tag pointing at that fix. Apps that genuinely
+    // want them muted can re-add "Script error" to ignoreErrors
+    // via init config.
   ],
   allowUrls: [],
   denyUrls: [
-    // Common third-party extensions that pollute error streams.
+    // The actionability principle
+    // ---------------------------
+    // Crossdeck's default philosophy is "classify, don't silently
+    // drop" — surfacing errors the developer can fix is more useful
+    // than hiding them. That's right for cross-origin "Script
+    // error." (real, code-shaped CORS fix) and for plain
+    // application bugs (obviously real).
+    //
+    // It's NOT right for events the developer cannot act on.
+    //   - A user's installed browser extension throwing inside
+    //     its own `chrome-extension://` URL: the developer can't
+    //     ship a fix for someone else's extension.
+    //   - An ad blocker preventing `googletagmanager.com` from
+    //     loading: the developer can't unblock the user's blocker.
+    //
+    // Capturing these creates a noise tab that's always non-empty
+    // and never actionable, which trains the dev to ignore the
+    // noise tab — and then the actionable noise (CORS opacity,
+    // etc.) gets ignored along with it. Same lesson as Crossdeck's
+    // "0-2 notifications a week" discipline: a signal that fires
+    // constantly with nothing actionable behind it stops being a
+    // signal.
+    //
+    // So we drop at the source for the unactionable category, and
+    // keep capturing for the actionable category. Same principle
+    // applied to two structurally different inputs — not a new
+    // philosophy.
+    //
+    // The bootstrap list below is the minimum that ships in code.
+    // The full, versioned list arrives at boot via /v1/config —
+    // see `backend/src/lib/error-noise-deny-list.ts`. The SDK
+    // applies the union of (bootstrap + remote), so a freshly-
+    // installed SDK protects users immediately, and remote updates
+    // (new ad-network domains, new pixel hosts) reach every
+    // install without an SDK release.
+    //
+    // The backend Layer-2 classifier
+    // (`backend/src/api/lib/noise-classifier.ts`) is the safety
+    // net for events that slip past these patterns — older SDK
+    // versions in the wild that haven't fetched the remote list
+    // yet, or brand-new patterns the list hasn't named.
     /^chrome-extension:\/\//,
     /^moz-extension:\/\//,
     /^safari-extension:\/\//,
@@ -4103,7 +4311,12 @@ var CrossdeckClient = class {
     if (autoTrack.sessions || autoTrack.pageViews) {
       const tracker = new AutoTracker(
         autoTrack,
-        (name, properties) => this.track(name, properties)
+        (name, properties) => this.track(name, properties),
+        // Persist session continuity on the SAME adapter as identity, so
+        // a visit survives full-page navigations (multi-page sites
+        // re-install the SDK on every page) and honours the same consent
+        // posture — MemoryStorage when identity persistence is off.
+        { storage: effectiveStorage, storageKey: opts.storagePrefix + "session" }
       );
       this.state.autoTracker = tracker;
       tracker.install();
@@ -4568,6 +4781,12 @@ var CrossdeckClient = class {
    * true even before the session's first network round-trip. Returns
    * false only for a genuinely new install that has never completed a
    * getEntitlements(), or for an entitlement past its own validUntil.
+   *
+   * Throws `not_initialized` (CrossdeckError, type
+   * `configuration_error`) if called before `Crossdeck.init()`. The
+   * `useEntitlement` React hook and the Vue composable both swallow
+   * this and return `false`; bare callers must guard for it (or call
+   * after `init()` resolves).
    */
   isEntitled(key) {
     const s = this.requireStarted();
@@ -4583,8 +4802,21 @@ var CrossdeckClient = class {
    *
    * The listener is invoked AFTER the cache mutates — once after a
    * successful `getEntitlements()` warms it, again after `syncPurchases()`
-   * delivers fresh entitlements, and once on `reset()` to fire the
-   * empty-cache state for logout flows.
+   * delivers fresh entitlements, once on `reset()` to fire the empty-
+   * cache state for logout flows, AND once on `identify()` after the
+   * per-user cache slot rotates and re-hydrates from device storage.
+   *
+   * IMPORTANT — the `identify()` fire is a TRAP if you treat it as
+   * authoritative network state. `identify()` does NOT fetch entitlements;
+   * it switches the per-user cache slot and rehydrates from device
+   * storage (which is empty for a brand-new install, and last-known-good
+   * — possibly stale — for a returning user). A listener that gates a
+   * paywall on the first fire after an identity switch will read
+   * `false` for a paying customer on a fresh device and let them past
+   * the gate as free. The network-truth fire is the one that follows
+   * the next `getEntitlements()` resolution. Either call
+   * `getEntitlements()` explicitly after `identify()`, or have your
+   * gating code tolerate the empty-then-populated transition.
    *
    * It is NOT invoked synchronously on subscribe. Callers that need
    * the current state should read it via `isEntitled()` / `listEntitlements()`
@@ -4693,6 +4925,7 @@ var CrossdeckClient = class {
         );
       }
     }
+    s.autoTracker?.markActivity();
     const enriched = { ...s.deviceInfo };
     const sessionId = s.autoTracker?.currentSessionId;
     if (sessionId) enriched.sessionId = sessionId;
@@ -4738,7 +4971,7 @@ var CrossdeckClient = class {
         callerProperties: validation.properties,
         superProperties: supers,
         deviceProperties: s.deviceInfo,
-        mergedProperties: finalProperties
+        mergedProperties: enriched
       });
     }
     if (!isError && !isWebVital) {
@@ -4947,6 +5180,25 @@ var CrossdeckClient = class {
       events: s.events.getStats()
     };
   }
+  /**
+   * The stable reference to hand Stripe at checkout so the resulting
+   * purchase attributes to THIS person. Stamp it on the Checkout Session
+   * as `metadata.crossdeck_ref` (see docs/connect-stripe) — the platform
+   * webhook reads it back, validates it, and attaches the subscription to
+   * the right customer instead of stranding it on an anonymous record.
+   *
+   * Returns the strongest identifier the SDK currently holds, in the same
+   * precedence the server resolves by:
+   *   crossdeckCustomerId (cdcust_…) > developerUserId > anonymousId
+   * anonymousId is always present, so this always returns a usable,
+   * non-empty reference — even before identify(). Identify the user as
+   * early as you can, though, so the reference is their stable identity
+   * and not a per-device anon id.
+   */
+  getCheckoutReference() {
+    const s = this.requireStarted();
+    return s.identity.crossdeckCustomerId ?? s.developerUserId ?? s.identity.anonymousId;
+  }
   // ---------- private helpers ----------
   requireStarted() {
     if (!this.state) {