@cross-deck/web 0.1.0 → 0.2.0

package/README.md

@@ -33,12 +33,46 @@ That's the full happy path.
 
 ## What it does
 
+- **Auto-tracking, on by default.** Sessions, page views, and device info (OS, browser, locale, timezone, screen size, app version) ship from boot. No instrumentation needed for the basics. Disable any of them via `autoTrack: { sessions: false }` etc.
 - **One identity for every device + user.** Pre-login events get an `anonymousId`. After login, `identify()` links them to your user ID through Crossdeck's identity graph. The SDK persists both so subsequent app launches resume where you left off.
 - **Synchronous entitlement reads.** `getEntitlements()` populates a local cache. `isEntitled("pro")` is a Set lookup — no network call, no waiting.
 - **Batched telemetry.** `track()` queues events in memory; the SDK flushes every 5 seconds (configurable) or when the buffer hits 20 events. Network failures re-queue the batch — events aren't lost on a flaky connection.
 - **Boot heartbeat.** On `start()` the SDK pings `/v1/sdk/heartbeat` so the dashboard's Apps page can show you "last seen" per install. Disable with `autoHeartbeat: false`.
 - **Stripe-style errors.** Every async method throws `CrossdeckError` with `type`, `code`, `requestId`, and `status` — same shape as Stripe's SDKs, so generic error handlers transfer.
 
+## Auto-tracked events
+
+| Event | When |
+|---|---|
+| `session.started` | On boot. Carries `sessionId`. |
+| `session.ended` | On `pagehide` / `beforeunload`, OR when returning to a tab after >30 min idle. Carries `sessionId` and `durationMs`. |
+| `page.viewed` | On initial load + every SPA navigation (`history.pushState`, `replaceState`, `popstate`). Carries `path`, `url`, `search`, `hash`, `title`, `referrer`. |
+
+Every event — auto-tracked and developer-emitted — is enriched with the device-info payload below. Quick tab switches (Cmd-Tab, switching browser tabs) don't end the session — only real closes do, matching GA4's session-window convention.
+
+## Auto-attached device info
+
+Every event's `properties` is enriched with whatever the SDK can detect:
+
+```ts
+{
+  os: "macOS" | "iOS" | "Android" | "Windows" | "Linux",
+  osVersion: "14.4",
+  browser: "Safari" | "Chrome" | "Firefox" | "Edge" | "Opera",
+  browserVersion: "17.5",
+  locale: "en-US",
+  timezone: "Africa/Johannesburg",
+  screenWidth: 2560,
+  screenHeight: 1440,
+  viewportWidth: 1440,
+  viewportHeight: 900,
+  devicePixelRatio: 2,
+  appVersion: "1.2.3",   // only when you set Crossdeck.start({ appVersion })
+}
+```
+
+No fingerprinting, no IP collection on the event document, no canvas hashing. Privacy by default. Caller-supplied properties always override auto-detected ones, so you can override `appVersion` per event if you A/B builds.
+
 ## API
 
 ### `Crossdeck.start(options)`
@@ -49,6 +83,9 @@ Boot the client. Idempotent — calling twice with the same options is fine.
 Crossdeck.start({
   publicKey: "cd_pub_live_…",         // required
   baseUrl: "https://api.cross-deck.com/v1",  // override for self-host or emulator
+  appVersion: "1.2.3",                // attached to every event as properties.appVersion
+  autoTrack: true,                    // default — sessions, page views, device info
+  // …or granular: autoTrack: { sessions: false } keeps page views + device info
   autoHeartbeat: true,                // default; set false for high-frequency boots
   eventFlushBatchSize: 20,            // default
   eventFlushIntervalMs: 5_000,        // default

package/dist/index.d.mts

@@ -90,6 +90,34 @@ interface CrossdeckOptions {
     eventFlushIntervalMs?: number;
     /** Override the SDK version reported on heartbeats. Default: package version. */
     sdkVersion?: string;
+    /**
+     * Auto-tracking. Default: every flag is `true` in browsers, all
+     * silently no-op in Node.
+     *
+     * Pass `false` to disable everything, or a partial object to override
+     * individual flags:
+     *
+     *   Crossdeck.start({
+     *     publicKey: "...",
+     *     autoTrack: { pageViews: false }, // sessions + deviceInfo still on
+     *   });
+     */
+    autoTrack?: boolean | Partial<AutoTrackOptions>;
+    /**
+     * Your app's version (e.g. "1.2.3"). Auto-attached to every event as
+     * `properties.appVersion` when `autoTrack.deviceInfo` is enabled.
+     * Useful for slicing dashboards by build.
+     */
+    appVersion?: string;
+}
+/** Auto-tracking flags. See CrossdeckOptions.autoTrack. */
+interface AutoTrackOptions {
+    /** Emit `session.started` / `session.ended` automatically. Default true (browser only). */
+    sessions: boolean;
+    /** Emit `page.viewed` on initial load + SPA navigation. Default true (browser only). */
+    pageViews: boolean;
+    /** Auto-attach os/browser/locale/screen/etc to every event's `properties`. Default true (browser only). */
+    deviceInfo: boolean;
 }
 /** Minimal interface for any pluggable key-value persistence. */
 interface KeyValueStorage {
@@ -300,7 +328,41 @@ declare class MemoryStorage implements KeyValueStorage {
  * fetch shim, no transitive deps.
  */
 declare const SDK_NAME = "@cross-deck/web";
-declare const SDK_VERSION = "0.1.0";
+declare const SDK_VERSION = "0.2.0";
 declare const DEFAULT_BASE_URL = "https://api.cross-deck.com/v1";
 
-export { type AliasResult, type AuditRail, Crossdeck, CrossdeckClient, CrossdeckError, type CrossdeckErrorPayload, type CrossdeckErrorType, type CrossdeckOptions, DEFAULT_BASE_URL, type Diagnostics, type EntitlementsListResponse, type Environment, type EventProperties, type HeartbeatResponse, type IdentifyOptions, type KeyValueStorage, MemoryStorage, type Platform, type PublicEntitlement, type PurchaseResult, SDK_NAME, SDK_VERSION };
+/**
+ * Device + environment enrichment.
+ *
+ * Auto-attached to every event the SDK emits when `autoTrack.deviceInfo` is
+ * enabled (default). Caller-supplied event properties always override
+ * auto-detected ones (so a developer can manually set `app.version` per
+ * event if they want to A/B between builds).
+ *
+ * Privacy posture:
+ *   - No fingerprinting (no canvas hashes, no font enumeration).
+ *   - No precise geolocation (only timezone + locale, both of which the
+ *     browser exposes to every page anyway).
+ *   - No IP collection — the backend logs the request IP for rate-limit
+ *     purposes; it isn't stored on the event document.
+ *   - All fields are typed enums or short strings; we never echo back
+ *     full User-Agent strings to avoid surfacing fingerprintable detail
+ *     in dashboards.
+ */
+interface DeviceInfo {
+    os?: string;
+    osVersion?: string;
+    browser?: string;
+    browserVersion?: string;
+    locale?: string;
+    timezone?: string;
+    screenWidth?: number;
+    screenHeight?: number;
+    viewportWidth?: number;
+    viewportHeight?: number;
+    devicePixelRatio?: number;
+    /** Caller-supplied. Set via Crossdeck.start({ appVersion: "1.2.3" }). */
+    appVersion?: string;
+}
+
+export { type AliasResult, type AuditRail, type AutoTrackOptions, Crossdeck, CrossdeckClient, CrossdeckError, type CrossdeckErrorPayload, type CrossdeckErrorType, type CrossdeckOptions, DEFAULT_BASE_URL, type DeviceInfo, type Diagnostics, type EntitlementsListResponse, type Environment, type EventProperties, type HeartbeatResponse, type IdentifyOptions, type KeyValueStorage, MemoryStorage, type Platform, type PublicEntitlement, type PurchaseResult, SDK_NAME, SDK_VERSION };

package/dist/index.d.ts

@@ -90,6 +90,34 @@ interface CrossdeckOptions {
     eventFlushIntervalMs?: number;
     /** Override the SDK version reported on heartbeats. Default: package version. */
     sdkVersion?: string;
+    /**
+     * Auto-tracking. Default: every flag is `true` in browsers, all
+     * silently no-op in Node.
+     *
+     * Pass `false` to disable everything, or a partial object to override
+     * individual flags:
+     *
+     *   Crossdeck.start({
+     *     publicKey: "...",
+     *     autoTrack: { pageViews: false }, // sessions + deviceInfo still on
+     *   });
+     */
+    autoTrack?: boolean | Partial<AutoTrackOptions>;
+    /**
+     * Your app's version (e.g. "1.2.3"). Auto-attached to every event as
+     * `properties.appVersion` when `autoTrack.deviceInfo` is enabled.
+     * Useful for slicing dashboards by build.
+     */
+    appVersion?: string;
+}
+/** Auto-tracking flags. See CrossdeckOptions.autoTrack. */
+interface AutoTrackOptions {
+    /** Emit `session.started` / `session.ended` automatically. Default true (browser only). */
+    sessions: boolean;
+    /** Emit `page.viewed` on initial load + SPA navigation. Default true (browser only). */
+    pageViews: boolean;
+    /** Auto-attach os/browser/locale/screen/etc to every event's `properties`. Default true (browser only). */
+    deviceInfo: boolean;
 }
 /** Minimal interface for any pluggable key-value persistence. */
 interface KeyValueStorage {
@@ -300,7 +328,41 @@ declare class MemoryStorage implements KeyValueStorage {
  * fetch shim, no transitive deps.
  */
 declare const SDK_NAME = "@cross-deck/web";
-declare const SDK_VERSION = "0.1.0";
+declare const SDK_VERSION = "0.2.0";
 declare const DEFAULT_BASE_URL = "https://api.cross-deck.com/v1";
 
-export { type AliasResult, type AuditRail, Crossdeck, CrossdeckClient, CrossdeckError, type CrossdeckErrorPayload, type CrossdeckErrorType, type CrossdeckOptions, DEFAULT_BASE_URL, type Diagnostics, type EntitlementsListResponse, type Environment, type EventProperties, type HeartbeatResponse, type IdentifyOptions, type KeyValueStorage, MemoryStorage, type Platform, type PublicEntitlement, type PurchaseResult, SDK_NAME, SDK_VERSION };
+/**
+ * Device + environment enrichment.
+ *
+ * Auto-attached to every event the SDK emits when `autoTrack.deviceInfo` is
+ * enabled (default). Caller-supplied event properties always override
+ * auto-detected ones (so a developer can manually set `app.version` per
+ * event if they want to A/B between builds).
+ *
+ * Privacy posture:
+ *   - No fingerprinting (no canvas hashes, no font enumeration).
+ *   - No precise geolocation (only timezone + locale, both of which the
+ *     browser exposes to every page anyway).
+ *   - No IP collection — the backend logs the request IP for rate-limit
+ *     purposes; it isn't stored on the event document.
+ *   - All fields are typed enums or short strings; we never echo back
+ *     full User-Agent strings to avoid surfacing fingerprintable detail
+ *     in dashboards.
+ */
+interface DeviceInfo {
+    os?: string;
+    osVersion?: string;
+    browser?: string;
+    browserVersion?: string;
+    locale?: string;
+    timezone?: string;
+    screenWidth?: number;
+    screenHeight?: number;
+    viewportWidth?: number;
+    viewportHeight?: number;
+    devicePixelRatio?: number;
+    /** Caller-supplied. Set via Crossdeck.start({ appVersion: "1.2.3" }). */
+    appVersion?: string;
+}
+
+export { type AliasResult, type AuditRail, type AutoTrackOptions, Crossdeck, CrossdeckClient, CrossdeckError, type CrossdeckErrorPayload, type CrossdeckErrorType, type CrossdeckOptions, DEFAULT_BASE_URL, type DeviceInfo, type Diagnostics, type EntitlementsListResponse, type Environment, type EventProperties, type HeartbeatResponse, type IdentifyOptions, type KeyValueStorage, MemoryStorage, type Platform, type PublicEntitlement, type PurchaseResult, SDK_NAME, SDK_VERSION };

package/dist/index.js

@@ -78,7 +78,7 @@ function typeMapForStatus(status) {
 
 // src/http.ts
 var SDK_NAME = "@cross-deck/web";
-var SDK_VERSION = "0.1.0";
+var SDK_VERSION = "0.2.0";
 var DEFAULT_BASE_URL = "https://api.cross-deck.com/v1";
 var HttpClient = class {
   constructor(config) {
@@ -389,6 +389,244 @@ function detectDefaultStorage() {
   return new MemoryStorage();
 }
 
+// src/device-info.ts
+function isBrowser() {
+  return typeof globalThis.window !== "undefined" && typeof globalThis.document !== "undefined" && typeof globalThis.navigator !== "undefined";
+}
+function collectDeviceInfo(extra) {
+  const info = {};
+  if (extra?.appVersion) info.appVersion = extra.appVersion;
+  if (!isBrowser()) return info;
+  const w = globalThis.window;
+  const nav = globalThis.navigator;
+  const doc = globalThis.document;
+  try {
+    if (typeof nav.language === "string") info.locale = nav.language;
+  } catch {
+  }
+  try {
+    info.timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  } catch {
+  }
+  try {
+    if (w.screen) {
+      info.screenWidth = w.screen.width;
+      info.screenHeight = w.screen.height;
+    }
+    info.viewportWidth = w.innerWidth;
+    info.viewportHeight = w.innerHeight;
+    info.devicePixelRatio = w.devicePixelRatio;
+  } catch {
+  }
+  try {
+    const ua = nav.userAgent ?? "";
+    const parsed = parseUserAgent(ua);
+    Object.assign(info, parsed);
+  } catch {
+  }
+  try {
+    const uaData = nav.userAgentData;
+    if (uaData?.platform && !info.os) info.os = uaData.platform;
+    if (uaData?.brands && !info.browser) {
+      const real = uaData.brands.find(
+        (b) => !/Not[ .;A]*Brand/i.test(b.brand) && !/Chromium/i.test(b.brand)
+      );
+      if (real) {
+        info.browser = real.brand;
+        info.browserVersion = real.version;
+      }
+    }
+  } catch {
+  }
+  void doc;
+  return info;
+}
+function parseUserAgent(ua) {
+  const out = {};
+  if (/iPad|iPhone|iPod/.test(ua)) {
+    out.os = "iOS";
+    const m = ua.match(/OS (\d+[._]\d+(?:[._]\d+)?)/);
+    if (m?.[1]) out.osVersion = m[1].replace(/_/g, ".");
+  } else if (/Android/.test(ua)) {
+    out.os = "Android";
+    const m = ua.match(/Android (\d+(?:\.\d+)*)/);
+    if (m?.[1]) out.osVersion = m[1];
+  } else if (/Windows/.test(ua)) {
+    out.os = "Windows";
+    const m = ua.match(/Windows NT (\d+\.\d+)/);
+    if (m?.[1]) out.osVersion = m[1];
+  } else if (/Mac OS X|Macintosh/.test(ua)) {
+    out.os = "macOS";
+    const m = ua.match(/Mac OS X (\d+[._]\d+(?:[._]\d+)?)/);
+    if (m?.[1]) out.osVersion = m[1].replace(/_/g, ".");
+  } else if (/Linux/.test(ua)) {
+    out.os = "Linux";
+  }
+  if (/Edg\/(\d+(?:\.\d+)*)/.test(ua)) {
+    out.browser = "Edge";
+    out.browserVersion = ua.match(/Edg\/(\d+(?:\.\d+)*)/)?.[1];
+  } else if (/Firefox\/(\d+(?:\.\d+)*)/.test(ua)) {
+    out.browser = "Firefox";
+    out.browserVersion = ua.match(/Firefox\/(\d+(?:\.\d+)*)/)?.[1];
+  } else if (/OPR\/(\d+(?:\.\d+)*)/.test(ua)) {
+    out.browser = "Opera";
+    out.browserVersion = ua.match(/OPR\/(\d+(?:\.\d+)*)/)?.[1];
+  } else if (/Chrome\/(\d+(?:\.\d+)*)/.test(ua)) {
+    out.browser = "Chrome";
+    out.browserVersion = ua.match(/Chrome\/(\d+(?:\.\d+)*)/)?.[1];
+  } else if (/Version\/(\d+(?:\.\d+)*).*Safari/.test(ua)) {
+    out.browser = "Safari";
+    out.browserVersion = ua.match(/Version\/(\d+(?:\.\d+)*)/)?.[1];
+  }
+  return out;
+}
+
+// src/auto-track.ts
+var DEFAULT_AUTO_TRACK = {
+  sessions: true,
+  pageViews: true,
+  deviceInfo: true
+};
+var SESSION_RESUME_THRESHOLD_MS = 30 * 60 * 1e3;
+var AutoTracker = class {
+  constructor(cfg, track) {
+    this.cfg = cfg;
+    this.track = track;
+    this.session = null;
+    this.cleanups = [];
+  }
+  install() {
+    if (!isBrowserSafe()) return;
+    if (this.cfg.sessions) this.installSessionTracking();
+    if (this.cfg.pageViews) this.installPageViewTracking();
+  }
+  uninstall() {
+    while (this.cleanups.length) {
+      const fn = this.cleanups.pop();
+      try {
+        fn?.();
+      } catch {
+      }
+    }
+    if (this.session && !this.session.endedSent) {
+      this.emitSessionEnd();
+    }
+    this.session = null;
+  }
+  /** Exposed for tests + consumers that want to reset the session manually. */
+  resetSession() {
+    if (this.session && !this.session.endedSent) this.emitSessionEnd();
+    this.session = this.startNewSession();
+    this.emitSessionStart();
+  }
+  /** Exposed for inspection/tests — returns the current sessionId (or null if not in a session). */
+  get currentSessionId() {
+    return this.session?.sessionId ?? null;
+  }
+  // ---------- sessions ----------
+  installSessionTracking() {
+    this.session = this.startNewSession();
+    this.emitSessionStart();
+    const onVisChange = () => {
+      if (!this.session) return;
+      const doc2 = globalThis.document;
+      if (doc2.visibilityState === "hidden") {
+        this.session.hiddenAt = Date.now();
+      } else if (doc2.visibilityState === "visible") {
+        const hiddenFor = this.session.hiddenAt ? Date.now() - this.session.hiddenAt : 0;
+        if (hiddenFor >= SESSION_RESUME_THRESHOLD_MS) {
+          this.emitSessionEnd();
+          this.session = this.startNewSession();
+          this.emitSessionStart();
+        } else {
+          this.session.hiddenAt = null;
+        }
+      }
+    };
+    const onPageHide = () => this.emitSessionEnd();
+    const w = globalThis.window;
+    const doc = globalThis.document;
+    doc.addEventListener("visibilitychange", onVisChange);
+    w.addEventListener("pagehide", onPageHide);
+    w.addEventListener("beforeunload", onPageHide);
+    this.cleanups.push(() => {
+      doc.removeEventListener("visibilitychange", onVisChange);
+      w.removeEventListener("pagehide", onPageHide);
+      w.removeEventListener("beforeunload", onPageHide);
+    });
+  }
+  startNewSession() {
+    return {
+      sessionId: mintSessionId(),
+      startedAt: Date.now(),
+      hiddenAt: null,
+      endedSent: false
+    };
+  }
+  emitSessionStart() {
+    if (!this.session) return;
+    this.track("session.started", { sessionId: this.session.sessionId });
+  }
+  emitSessionEnd() {
+    if (!this.session || this.session.endedSent) return;
+    const duration = Date.now() - this.session.startedAt;
+    this.track("session.ended", {
+      sessionId: this.session.sessionId,
+      durationMs: duration
+    });
+    this.session.endedSent = true;
+  }
+  // ---------- page views ----------
+  installPageViewTracking() {
+    const w = globalThis.window;
+    const doc = globalThis.document;
+    const fire = () => {
+      const loc = w.location;
+      this.track("page.viewed", {
+        path: loc.pathname,
+        url: loc.href,
+        search: loc.search || void 0,
+        hash: loc.hash || void 0,
+        title: doc.title,
+        // referrer only on the first hit of the session — afterward it's
+        // always our previous URL, which isn't useful.
+        referrer: doc.referrer || void 0
+      });
+    };
+    fire();
+    const origPush = w.history.pushState;
+    const origReplace = w.history.replaceState;
+    function patchedPush(data, unused, url) {
+      origPush.apply(this, [data, unused, url]);
+      queueMicrotask(fire);
+    }
+    function patchedReplace(data, unused, url) {
+      origReplace.apply(this, [data, unused, url]);
+      queueMicrotask(fire);
+    }
+    w.history.pushState = patchedPush;
+    w.history.replaceState = patchedReplace;
+    const onPopState = () => fire();
+    w.addEventListener("popstate", onPopState);
+    this.cleanups.push(() => {
+      if (w.history.pushState === patchedPush) {
+        w.history.pushState = origPush;
+      }
+      if (w.history.replaceState === patchedReplace) {
+        w.history.replaceState = origReplace;
+      }
+      w.removeEventListener("popstate", onPopState);
+    });
+  }
+};
+function isBrowserSafe() {
+  return typeof globalThis.window !== "undefined" && typeof globalThis.document !== "undefined";
+}
+function mintSessionId() {
+  const ts = Date.now().toString(36);
+  return `sess_${ts}${randomChars(10)}`;
+}
+
 // src/crossdeck.ts
 var CrossdeckClient = class {
   constructor() {
@@ -409,6 +647,7 @@ var CrossdeckClient = class {
     }
     const storage = options.storage ?? detectDefaultStorage();
     const persistIdentity = options.persistIdentity ?? true;
+    const autoTrack = resolveAutoTrack(options.autoTrack);
     const opts = {
       publicKey: options.publicKey,
       baseUrl: options.baseUrl ?? DEFAULT_BASE_URL,
@@ -417,7 +656,9 @@ var CrossdeckClient = class {
       autoHeartbeat: options.autoHeartbeat ?? true,
       eventFlushBatchSize: options.eventFlushBatchSize ?? 20,
       eventFlushIntervalMs: options.eventFlushIntervalMs ?? 5e3,
-      sdkVersion: options.sdkVersion ?? SDK_VERSION
+      sdkVersion: options.sdkVersion ?? SDK_VERSION,
+      autoTrack,
+      appVersion: options.appVersion ?? null
     };
     const http = new HttpClient({
       publicKey: opts.publicKey,
@@ -432,14 +673,25 @@ var CrossdeckClient = class {
       batchSize: opts.eventFlushBatchSize,
       intervalMs: opts.eventFlushIntervalMs
     });
+    const deviceInfo = autoTrack.deviceInfo ? collectDeviceInfo({ appVersion: opts.appVersion ?? void 0 }) : opts.appVersion ? { appVersion: opts.appVersion } : {};
     this.state = {
       http,
       identity,
       entitlements,
       events,
+      autoTracker: null,
+      deviceInfo,
       options: opts,
       developerUserId: null
     };
+    if (autoTrack.sessions || autoTrack.pageViews) {
+      const tracker = new AutoTracker(
+        autoTrack,
+        (name, properties) => this.track(name, properties)
+      );
+      this.state.autoTracker = tracker;
+      tracker.install();
+    }
     if (opts.autoHeartbeat) {
       void this.heartbeat().catch(() => void 0);
     }
@@ -510,11 +762,15 @@ var CrossdeckClient = class {
         message: "track(name) requires a non-empty name."
       });
     }
+    const enriched = { ...s.deviceInfo };
+    const sessionId = s.autoTracker?.currentSessionId;
+    if (sessionId) enriched.sessionId = sessionId;
+    if (properties) Object.assign(enriched, properties);
     const event = {
       eventId: this.mintEventId(),
       name,
       timestamp: Date.now(),
-      properties: properties ?? {}
+      properties: enriched
     };
     Object.assign(event, this.identityHintForEvent());
     s.events.enqueue(event);
@@ -556,10 +812,19 @@ var CrossdeckClient = class {
    */
   reset() {
     if (!this.state) return;
+    this.state.autoTracker?.uninstall();
     this.state.identity.reset();
     this.state.entitlements.clear();
     this.state.events.reset();
     this.state.developerUserId = null;
+    if (this.state.autoTracker) {
+      const tracker = new AutoTracker(
+        this.state.options.autoTrack,
+        (name, props) => this.track(name, props)
+      );
+      this.state.autoTracker = tracker;
+      tracker.install();
+    }
   }
   /**
    * Diagnostic: current state + queue stats. Useful for the dashboard's
@@ -642,6 +907,19 @@ var CrossdeckClient = class {
   }
 };
 var Crossdeck = new CrossdeckClient();
+function resolveAutoTrack(input) {
+  if (input === false) {
+    return { sessions: false, pageViews: false, deviceInfo: false };
+  }
+  if (input === void 0 || input === true) {
+    return { ...DEFAULT_AUTO_TRACK };
+  }
+  return {
+    sessions: input.sessions ?? DEFAULT_AUTO_TRACK.sessions,
+    pageViews: input.pageViews ?? DEFAULT_AUTO_TRACK.pageViews,
+    deviceInfo: input.deviceInfo ?? DEFAULT_AUTO_TRACK.deviceInfo
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Crossdeck,