@aranova/tracking-next 0.24.1 → 0.25.0

package/dist/client.mjs

@@ -0,0 +1,3540 @@
+"use client";
+
+// src/ConsentBanner.tsx
+import { useEffect as useEffect2, useState as useState2 } from "react";
+
+// src/hooks.ts
+import { useCallback, useEffect, useState } from "react";
+
+// ../tracking-core/src/phone.ts
+import { AsYouType, parsePhoneNumberFromString } from "libphonenumber-js";
+var DEFAULT_PHONE_COUNTRY = "CA";
+function parsePhone(raw, country) {
+  const region = country ?? DEFAULT_PHONE_COUNTRY;
+  const parsed = parsePhoneNumberFromString(raw ?? "", region);
+  if (!parsed) {
+    return { e164: null, national: "", international: "", country: region, isValid: false };
+  }
+  const isValid = parsed.isValid();
+  return {
+    // E.164 is only surfaced for a *valid* number — a possible-but-invalid input
+    // (e.g. too few digits) still parses but must not be transmitted.
+    e164: isValid ? parsed.number : null,
+    national: parsed.formatNational(),
+    international: parsed.formatInternational(),
+    country: parsed.country ?? region,
+    isValid
+  };
+}
+function toE164(raw, country) {
+  return parsePhone(raw, country).e164;
+}
+function formatPhone(value, format = "national", country) {
+  const parsed = parsePhone(value, country);
+  if (typeof format === "function") return format(parsed);
+  switch (format) {
+    case "international":
+      return parsed.international || value;
+    case "e164":
+      return parsed.e164 ?? value;
+    case "national":
+    default:
+      return parsed.national || value;
+  }
+}
+function formatPhoneAsTyped(raw, country) {
+  return new AsYouType(country ?? DEFAULT_PHONE_COUNTRY).input(raw ?? "");
+}
+
+// ../tracking-core/src/user-data.ts
+var EMAIL_SHAPE = /^[^@\s]+@[^@\s]+\.[^@\s]+$/;
+var EMAIL_NAME_HINT = /e[-_]?mail/i;
+var PHONE_NAME_HINT = /(^|[^a-z])(phone|tel|mobile|cell)/i;
+var stash = { email: null, phoneNumber: null };
+function normalizeEmail(raw) {
+  if (typeof raw !== "string") return null;
+  const cleaned = raw.trim().toLowerCase();
+  return EMAIL_SHAPE.test(cleaned) ? cleaned : null;
+}
+function fieldText(field, key) {
+  const value = field[key];
+  return typeof value === "string" ? value : "";
+}
+function extractUserDataFromFormFields(fields, country) {
+  const result = { email: null, phoneNumber: null };
+  if (!Array.isArray(fields)) return result;
+  const passes = [
+    (field, _hint, type) => fieldText(field, "type").toLowerCase() === type,
+    (field, hint) => hint.test(fieldText(field, "name")) || hint.test(fieldText(field, "label"))
+  ];
+  for (const matches of passes) {
+    for (const raw of fields) {
+      if (raw === null || typeof raw !== "object") continue;
+      const field = raw;
+      if (typeof field.value !== "string" || field.value.length === 0) continue;
+      if (result.email === null && matches(field, EMAIL_NAME_HINT, "email")) {
+        result.email = normalizeEmail(field.value);
+      }
+      if (result.phoneNumber === null && matches(field, PHONE_NAME_HINT, "tel")) {
+        try {
+          result.phoneNumber = toE164(field.value, country);
+        } catch {
+        }
+      }
+    }
+    if (result.email !== null && result.phoneNumber !== null) break;
+  }
+  return result;
+}
+function stashUserDataFromFormFields(fields, country) {
+  try {
+    const extracted = extractUserDataFromFormFields(fields, country);
+    stash = {
+      email: extracted.email ?? stash.email,
+      phoneNumber: extracted.phoneNumber ?? stash.phoneNumber
+    };
+  } catch {
+  }
+}
+function clearStashedUserData() {
+  stash = { email: null, phoneNumber: null };
+}
+function applyUserDataForConversion(explicit, country) {
+  if (typeof window === "undefined" || typeof window.gtag !== "function") return false;
+  let email = stash.email;
+  let phoneNumber = stash.phoneNumber;
+  if (explicit) {
+    const normalizedEmail = normalizeEmail(explicit.email);
+    if (normalizedEmail) email = normalizedEmail;
+    if (typeof explicit.phone === "string" && explicit.phone.length > 0) {
+      try {
+        phoneNumber = toE164(explicit.phone, country) ?? phoneNumber;
+      } catch {
+      }
+    }
+  }
+  if (email === null && phoneNumber === null) return false;
+  try {
+    window.gtag("set", "user_data", {
+      ...email !== null ? { email } : {},
+      ...phoneNumber !== null ? { phone_number: phoneNumber } : {}
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ../tracking-core/src/consent.ts
+var CONSENT_STATE_KEY = "consent_state";
+var CONSENT_TIMESTAMP_KEY = "consent_timestamp";
+var CONSENT_EXPIRES_AT_KEY = "consent_expires_at";
+var DEFAULT_DECLINE_TTL_DAYS = 90;
+var DAY_MS = 864e5;
+var DEFAULT_CHOICE = {
+  state: "granted",
+  source: "default",
+  updatedAt: null,
+  expiresAt: null
+};
+var changeListeners = /* @__PURE__ */ new Set();
+function onConsentChange(listener) {
+  changeListeners.add(listener);
+  return () => {
+    changeListeners.delete(listener);
+  };
+}
+function notifyConsentChanged(choice) {
+  for (const listener of changeListeners) {
+    try {
+      listener(choice);
+    } catch {
+    }
+  }
+}
+function buildConsentPayload(state) {
+  return {
+    ad_storage: state,
+    ad_user_data: state,
+    ad_personalization: state,
+    analytics_storage: state
+  };
+}
+function getConsentChoice() {
+  if (typeof window === "undefined") return DEFAULT_CHOICE;
+  try {
+    const stored = window.localStorage.getItem(CONSENT_STATE_KEY);
+    const updatedAt = window.localStorage.getItem(CONSENT_TIMESTAMP_KEY);
+    if (stored === "granted")
+      return { state: "granted", source: "explicit", updatedAt, expiresAt: null };
+    if (stored === "denied") {
+      let expiresAt = window.localStorage.getItem(CONSENT_EXPIRES_AT_KEY);
+      if (!expiresAt) {
+        expiresAt = new Date(Date.now() + DEFAULT_DECLINE_TTL_DAYS * DAY_MS).toISOString();
+        try {
+          window.localStorage.setItem(CONSENT_EXPIRES_AT_KEY, expiresAt);
+        } catch {
+        }
+      }
+      if (!(Date.parse(expiresAt) <= Date.now()))
+        return { state: "denied", source: "explicit", updatedAt, expiresAt };
+    }
+  } catch {
+  }
+  return DEFAULT_CHOICE;
+}
+function getConsentState() {
+  return getConsentChoice().state;
+}
+function pushConsentToPlatforms(state) {
+  if (typeof window === "undefined") return;
+  if (typeof window.gtag === "function")
+    window.gtag("consent", "update", buildConsentPayload(state));
+  if (typeof window.fbq === "function")
+    window.fbq("consent", state === "granted" ? "grant" : "revoke");
+}
+function setConsentState(state, options) {
+  if (typeof window === "undefined") return;
+  const requestedTtl = options?.declineTtlDays;
+  const ttlDays = typeof requestedTtl === "number" && Number.isFinite(requestedTtl) && requestedTtl > 0 ? requestedTtl : DEFAULT_DECLINE_TTL_DAYS;
+  const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const expiresAt = state === "denied" ? new Date(Date.now() + ttlDays * DAY_MS).toISOString() : null;
+  try {
+    window.localStorage.setItem(CONSENT_STATE_KEY, state);
+    window.localStorage.setItem(CONSENT_TIMESTAMP_KEY, updatedAt);
+    if (expiresAt !== null) {
+      window.localStorage.setItem(CONSENT_EXPIRES_AT_KEY, expiresAt);
+    } else {
+      window.localStorage.removeItem(CONSENT_EXPIRES_AT_KEY);
+    }
+  } catch {
+  }
+  pushConsentToPlatforms(state);
+  if (state === "denied") {
+    clearStashedUserData();
+    try {
+      if (typeof window.gtag === "function") window.gtag("set", "user_data", null);
+    } catch {
+    }
+  }
+  notifyConsentChanged({ state, source: "explicit", updatedAt, expiresAt });
+}
+function optIn() {
+  setConsentState("granted");
+}
+function optOut(options) {
+  setConsentState("denied", options);
+}
+function resetConsent() {
+  if (typeof window === "undefined") return;
+  try {
+    window.localStorage.removeItem(CONSENT_STATE_KEY);
+    window.localStorage.removeItem(CONSENT_TIMESTAMP_KEY);
+    window.localStorage.removeItem(CONSENT_EXPIRES_AT_KEY);
+  } catch {
+  }
+  pushConsentToPlatforms("granted");
+  notifyConsentChanged(DEFAULT_CHOICE);
+}
+function createEffectiveConsentSnippet() {
+  return `
+var aranovaConsent = (function () {
+  try {
+    if (window.localStorage.getItem('${CONSENT_STATE_KEY}') === 'denied') {
+      var exp = window.localStorage.getItem('${CONSENT_EXPIRES_AT_KEY}');
+      var expMs = exp ? Date.parse(exp) : NaN;
+      if (!(expMs <= Date.now())) return 'denied';
+    }
+  } catch (e) {}
+  return 'granted';
+})();
+`.trim();
+}
+
+// ../tracking-core/src/capabilities.ts
+var TRACKING_CAPABILITIES = [
+  "ad_tags_google",
+  "ad_tags_meta",
+  "base_tracking",
+  "blog_rendering",
+  "calendar_read",
+  "calendar_write",
+  "consent_controls",
+  "conversion_goals_auto",
+  "conversion_goals_manual",
+  "cta_click_capture",
+  "form_capture",
+  "phone_click_capture",
+  "phone_fields"
+];
+var CAPABILITY_DOM_ATTRIBUTE = "data-aranova-capability";
+var registered = /* @__PURE__ */ new Set();
+function registerCapability(capability) {
+  registered.add(capability);
+}
+function getRegisteredCapabilities() {
+  const all = new Set(registered);
+  for (const marker of readDomMarkers()) all.add(marker);
+  return Array.from(all).sort();
+}
+function readDomMarkers() {
+  if (typeof document === "undefined") return [];
+  const known = new Set(TRACKING_CAPABILITIES);
+  const found = [];
+  for (const node of document.querySelectorAll(`[${CAPABILITY_DOM_ATTRIBUTE}]`)) {
+    const value = node.getAttribute(CAPABILITY_DOM_ATTRIBUTE);
+    if (value && known.has(value)) found.push(value);
+  }
+  return found;
+}
+
+// ../tracking-core/src/tracking.ts
+var TRACKING_COOKIE_MAX_AGE_SECONDS = 7776e3;
+var TRACKING_PARAM_KEYS = [
+  "gclid",
+  // Google's iOS/Safari replacement click IDs — issued when privacy features
+  // withhold gclid (wbraid: web-to-web, gbraid: app-to-web). First-class
+  // citizens: captured, persisted, and attributed exactly like gclid.
+  "wbraid",
+  "gbraid",
+  // Yelp Ads click id (40 hex chars), appended to ad-click URLs.
+  "ylpcid",
+  "fbclid",
+  "utm_source",
+  "utm_medium",
+  "utm_campaign",
+  "utm_term",
+  "utm_content"
+];
+function createEmptyTrackingParams() {
+  return {
+    gclid: null,
+    wbraid: null,
+    gbraid: null,
+    ylpcid: null,
+    fbclid: null,
+    utm_source: null,
+    utm_medium: null,
+    utm_campaign: null,
+    utm_term: null,
+    utm_content: null
+  };
+}
+function normalizeTrackingCookieValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function getTrackingParamsFromCookieReader(readCookie) {
+  return TRACKING_PARAM_KEYS.reduce((params, key) => {
+    params[key] = normalizeTrackingCookieValue(readCookie(key));
+    return params;
+  }, createEmptyTrackingParams());
+}
+function getTrackingQueryValues(searchParams) {
+  return TRACKING_PARAM_KEYS.reduce((params, key) => {
+    const value = searchParams.get(key);
+    if (typeof value === "string" && value.trim().length > 0) {
+      params[key] = value;
+    }
+    return params;
+  }, {});
+}
+var FALLBACK_STORAGE_PREFIX = "_aranova_track_";
+function fallbackKey(name) {
+  return `${FALLBACK_STORAGE_PREFIX}${name}`;
+}
+function persistCookieValue(name, value, maxAgeSeconds = TRACKING_COOKIE_MAX_AGE_SECONDS) {
+  const encoded = encodeURIComponent(value);
+  if (typeof document !== "undefined") {
+    try {
+      document.cookie = `${name}=${encoded}; Max-Age=${maxAgeSeconds}; Path=/; SameSite=Lax`;
+    } catch {
+    }
+  }
+  if (typeof window !== "undefined") {
+    try {
+      window.localStorage.setItem(fallbackKey(name), encoded);
+    } catch {
+    }
+  }
+}
+function readCookieValue(name) {
+  if (typeof document !== "undefined") {
+    const cookies = document.cookie ? document.cookie.split("; ") : [];
+    const match = cookies.find((cookie) => cookie.startsWith(`${name}=`));
+    if (match) {
+      const [, rawValue = ""] = match.split("=");
+      return normalizeTrackingCookieValue(decodeURIComponent(rawValue));
+    }
+  }
+  if (typeof window !== "undefined") {
+    try {
+      const stored = window.localStorage.getItem(fallbackKey(name));
+      if (stored) return normalizeTrackingCookieValue(decodeURIComponent(stored));
+    } catch {
+    }
+  }
+  return null;
+}
+function getCookieValueFromDocument(key) {
+  return readCookieValue(key);
+}
+function setTrackingCookie(key, value, maxAgeSeconds = TRACKING_COOKIE_MAX_AGE_SECONDS) {
+  persistCookieValue(key, value, maxAgeSeconds);
+}
+function mergeTrackingParams(primary, fallback) {
+  return TRACKING_PARAM_KEYS.reduce((merged, key) => {
+    merged[key] = primary[key] ?? fallback[key];
+    return merged;
+  }, createEmptyTrackingParams());
+}
+function persistTrackingParamsFromSearchParams(searchParams, maxAgeSeconds = TRACKING_COOKIE_MAX_AGE_SECONDS) {
+  const trackingValues = getTrackingQueryValues(searchParams);
+  Object.entries(trackingValues).forEach(([key, value]) => {
+    setTrackingCookie(key, value, maxAgeSeconds);
+  });
+  return trackingValues;
+}
+function captureTrackingParamsFromLocation(url = typeof window === "undefined" ? "" : window.location.href, maxAgeSeconds = TRACKING_COOKIE_MAX_AGE_SECONDS) {
+  const resolvedUrl = typeof window === "undefined" ? new URL(url || "https://example.invalid") : new URL(url, window.location.origin);
+  persistTrackingParamsFromSearchParams(resolvedUrl.searchParams, maxAgeSeconds);
+  return getTrackingParamsFromCookieReader(getCookieValueFromDocument);
+}
+
+// ../tracking-core/src/gtag.ts
+var GTAG_SCRIPT_HOST = "https://www.googletagmanager.com/gtag/js";
+var TRACKING_SCRIPT_ATTRIBUTE = "data-aranova-tracking";
+function getScriptMarker(id) {
+  return `aranova-${id}`;
+}
+var GTAG_ID_PATTERN = /^[A-Z]{1,3}-[A-Za-z0-9_-]+$/;
+function isValidGtagId(id) {
+  return GTAG_ID_PATTERN.test(id);
+}
+function createConsentDefaultScript() {
+  return `
+window.dataLayer = window.dataLayer || [];
+function gtag(){dataLayer.push(arguments);}
+window.gtag = gtag;
+${createEffectiveConsentSnippet()}
+gtag('consent', 'default', {
+  ad_storage: aranovaConsent,
+  ad_user_data: aranovaConsent,
+  ad_personalization: aranovaConsent,
+  analytics_storage: aranovaConsent
+});
+`.trim();
+}
+function createGtagInitScript(gtagId) {
+  if (!isValidGtagId(gtagId)) return "";
+  return `
+window.dataLayer = window.dataLayer || [];
+function gtag(){dataLayer.push(arguments);}
+window.gtag = gtag;
+gtag('js', new Date());
+gtag('config', '${gtagId}');
+`.trim();
+}
+function ensureGtagFunction() {
+  window.dataLayer = window.dataLayer || [];
+  if (typeof window.gtag === "function") return window.gtag;
+  function gtag() {
+    window.dataLayer?.push(arguments);
+  }
+  window.gtag = gtag;
+  return window.gtag;
+}
+var SEND_TO_RE = /^AW-[A-Za-z0-9]+\/[A-Za-z0-9_-]+$/;
+function isValidSendTo(sendTo) {
+  return SEND_TO_RE.test(sendTo);
+}
+function fireGtagConversion(input) {
+  if (typeof window === "undefined" || typeof window.gtag !== "function") return false;
+  if (!isValidSendTo(input.sendTo)) return false;
+  const params = { send_to: input.sendTo };
+  if (input.value != null) params.value = input.value;
+  if (input.currency) params.currency = input.currency;
+  if (input.transactionId) params.transaction_id = input.transactionId;
+  try {
+    window.gtag("event", "conversion", params);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function applyDefaultConsentState() {
+  const gtag = ensureGtagFunction();
+  gtag(
+    "consent",
+    "default",
+    buildConsentPayload(getConsentState() === "denied" ? "denied" : "granted")
+  );
+}
+function loadGtagScript(gtagId) {
+  if (typeof document === "undefined") return;
+  const marker = getScriptMarker("gtag-loader");
+  const existingScript = document.querySelector(
+    `script[${TRACKING_SCRIPT_ATTRIBUTE}="${marker}"]`
+  );
+  if (existingScript) return;
+  const script = document.createElement("script");
+  script.async = true;
+  script.src = `${GTAG_SCRIPT_HOST}?id=${encodeURIComponent(gtagId)}`;
+  script.setAttribute(TRACKING_SCRIPT_ATTRIBUTE, marker);
+  document.head.append(script);
+}
+function createGtagInitScriptMulti(gtagIds) {
+  const safeIds = gtagIds.filter(isValidGtagId);
+  const configs = safeIds.map((id) => `gtag('config', '${id}');`).join("\n");
+  return `
+window.dataLayer = window.dataLayer || [];
+function gtag(){dataLayer.push(arguments);}
+window.gtag = gtag;
+gtag('js', new Date());
+${configs}
+`.trim();
+}
+
+// ../tracking-core/src/fbq.ts
+var FB_EVENTS_SCRIPT_HOST = "https://connect.facebook.net/en_US/fbevents.js";
+var FBC_COOKIE = "_fbc";
+var FBP_COOKIE = "_fbp";
+var META_PIXEL_ID_PATTERN = /^\d{15,16}$/;
+function isValidMetaPixelId(id) {
+  return META_PIXEL_ID_PATTERN.test(id);
+}
+function computeFbSubdomainIndex(hostname) {
+  const labels = hostname.split(".").filter(Boolean);
+  return Math.max(0, labels.length - 1);
+}
+function buildFbc(fbclid, now, hostname) {
+  const host = hostname ?? (typeof window === "undefined" ? "" : window.location.hostname);
+  return `fb.${computeFbSubdomainIndex(host)}.${now}.${fbclid}`;
+}
+function getFbcCookie() {
+  return readCookieValue(FBC_COOKIE);
+}
+function getFbpCookie() {
+  return readCookieValue(FBP_COOKIE);
+}
+function readFbclidFromUrl() {
+  if (typeof window === "undefined") return null;
+  try {
+    const value = new URL(window.location.href).searchParams.get("fbclid");
+    return value && value.trim().length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+function captureFbc(now = typeof Date === "undefined" ? 0 : Date.now()) {
+  if (typeof window === "undefined") return;
+  if (getFbcCookie()) return;
+  const fbclid = readFbclidFromUrl() ?? readCookieValue("fbclid");
+  if (!fbclid) return;
+  persistCookieValue(FBC_COOKIE, buildFbc(fbclid, now), TRACKING_COOKIE_MAX_AGE_SECONDS);
+}
+function fbqStubScript() {
+  return `
+!function(f,b,e,v,n,t,s){if(f.fbq)return;n=f.fbq=function(){n.callMethod?
+n.callMethod.apply(n,arguments):n.queue.push(arguments)};if(!f._fbq)f._fbq=n;
+n.push=n;n.loaded=!0;n.version='2.0';n.queue=[];t=b.createElement(e);t.async=!0;
+t.src=v;s=b.getElementsByTagName(e)[0];s.parentNode.insertBefore(t,s)}(window,
+document,'script','${FB_EVENTS_SCRIPT_HOST}');`.trim();
+}
+function createMetaConsentDefaultScript() {
+  return `${fbqStubScript()}
+${createEffectiveConsentSnippet()}
+fbq('consent', aranovaConsent === 'denied' ? 'revoke' : 'grant');`;
+}
+function createMetaPixelInitScript(pixelId) {
+  if (!isValidMetaPixelId(pixelId)) return "";
+  return `fbq('init', '${pixelId}');
+fbq('track', 'PageView');`;
+}
+function createMetaPixelInitScriptMulti(pixelIds) {
+  const inits = pixelIds.filter(isValidMetaPixelId).map((id) => `fbq('init', '${id}');`);
+  if (inits.length === 0) return "";
+  return `${inits.join("\n")}
+fbq('track', 'PageView');`;
+}
+
+// ../tracking-core/src/landing.ts
+var LANDING_STORAGE_KEY = "_aranova_track_landing";
+var memoryRecord = null;
+function sanitizeParams(value) {
+  if (typeof value !== "object" || value === null) return {};
+  const source = value;
+  return TRACKING_PARAM_KEYS.reduce((params, key) => {
+    const entry = source[key];
+    if (typeof entry === "string" && entry.length > 0) params[key] = entry;
+    return params;
+  }, {});
+}
+function readStoredRecord() {
+  try {
+    const raw = window.localStorage.getItem(LANDING_STORAGE_KEY);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.session_id !== "string" || parsed.session_id.length === 0) return null;
+    return { session_id: parsed.session_id, params: sanitizeParams(parsed.params) };
+  } catch {
+    return null;
+  }
+}
+function writeRecord(record) {
+  memoryRecord = record;
+  try {
+    window.localStorage.setItem(LANDING_STORAGE_KEY, JSON.stringify(record));
+  } catch {
+  }
+}
+function captureFromUrl(url) {
+  try {
+    const resolved = new URL(url ?? window.location.href, window.location.origin);
+    return getTrackingQueryValues(resolved.searchParams);
+  } catch {
+    return {};
+  }
+}
+function getOrCaptureLandingParams(sessionId, url) {
+  if (typeof window === "undefined") return {};
+  const stored = readStoredRecord();
+  if (stored && stored.session_id === sessionId) {
+    memoryRecord = stored;
+    return stored.params;
+  }
+  if (memoryRecord && memoryRecord.session_id === sessionId) {
+    return memoryRecord.params;
+  }
+  const record = { session_id: sessionId, params: captureFromUrl(url) };
+  writeRecord(record);
+  return record.params;
+}
+function buildLandingPayloadFields(sessionId, override) {
+  const params = override ?? (typeof window === "undefined" ? null : getOrCaptureLandingParams(sessionId));
+  if (params === null) return {};
+  return {
+    landing_gclid: params.gclid ?? null,
+    landing_wbraid: params.wbraid ?? null,
+    landing_gbraid: params.gbraid ?? null,
+    landing_ylpcid: params.ylpcid ?? null,
+    landing_fbclid: params.fbclid ?? null,
+    landing_utm_source: params.utm_source ?? null,
+    landing_utm_medium: params.utm_medium ?? null,
+    landing_utm_campaign: params.utm_campaign ?? null,
+    landing_utm_term: params.utm_term ?? null,
+    landing_utm_content: params.utm_content ?? null
+  };
+}
+
+// ../tracking-core/src/resources/conversion-firing.ts
+var DEDUP_PREFIX = "_aranova_conv_";
+function dedupKey(input) {
+  return `${DEDUP_PREFIX}${input.transactionId ?? ""}:${input.sendTo}`;
+}
+function alreadyFired(input) {
+  if (!input.transactionId || typeof window === "undefined") return false;
+  try {
+    return window.sessionStorage.getItem(dedupKey(input)) !== null;
+  } catch {
+    return false;
+  }
+}
+function markFired(input) {
+  if (!input.transactionId || typeof window === "undefined") return;
+  try {
+    window.sessionStorage.setItem(dedupKey(input), "1");
+  } catch {
+  }
+}
+function fireConversionWithConsent(input, options) {
+  if (getConsentState() === "denied") return "denied";
+  if (alreadyFired(input)) return "duplicate";
+  if (!isValidSendTo(input.sendTo)) return "invalid";
+  try {
+    applyUserDataForConversion(options?.userData);
+    if (!fireGtagConversion(input)) return "retryable";
+    markFired(input);
+    return "fired";
+  } catch {
+    return "retryable";
+  }
+}
+
+// ../tracking-core/src/resources/conversion-config.ts
+function isStringMap(value) {
+  return typeof value === "object" && value !== null && Object.values(value).every((v) => typeof v === "string");
+}
+function parseFiring(value) {
+  if (!value || typeof value !== "object") return null;
+  const f = value;
+  if (typeof f.send_to !== "string") return null;
+  return {
+    send_to: f.send_to,
+    value_cents: typeof f.value_cents === "number" ? f.value_cents : null,
+    currency: typeof f.currency === "string" ? f.currency : null
+  };
+}
+function parseTrigger(value) {
+  if (!value || typeof value !== "object") return null;
+  const t = value;
+  if (typeof t.event_type !== "string") return null;
+  const spec = { event_type: t.event_type };
+  if (typeof t.threshold_percent === "number") spec.threshold_percent = t.threshold_percent;
+  if (typeof t.threshold_seconds === "number") spec.threshold_seconds = t.threshold_seconds;
+  if (typeof t.page_threshold === "number") spec.page_threshold = t.page_threshold;
+  if (typeof t.page_name === "string") spec.page_name = t.page_name;
+  return spec;
+}
+function parseConversionConfig(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const obj = raw;
+  const servicesRaw = Array.isArray(obj.services) ? obj.services : [];
+  const services = servicesRaw.flatMap((entry) => {
+    if (!entry || typeof entry !== "object") return [];
+    const s = entry;
+    if (typeof s.key !== "string") return [];
+    return [
+      {
+        key: s.key,
+        label: typeof s.label === "string" ? s.label : void 0,
+        firing: parseFiring(s.firing)
+      }
+    ];
+  });
+  const goalsRaw = Array.isArray(obj.goals) ? obj.goals : null;
+  const goals = goalsRaw ? goalsRaw.flatMap((entry) => {
+    if (!entry || typeof entry !== "object") return [];
+    const g = entry;
+    if (typeof g.key !== "string") return [];
+    return [
+      {
+        key: g.key,
+        label: typeof g.label === "string" ? g.label : void 0,
+        kind: g.kind === "event" ? "event" : "sale",
+        trigger: parseTrigger(g.trigger),
+        firing: parseFiring(g.firing)
+      }
+    ];
+  }) : services.map((s) => ({
+    key: s.key,
+    label: s.label,
+    kind: "sale",
+    trigger: null,
+    firing: s.firing
+  }));
+  return {
+    schema_version: typeof obj.schema_version === "number" ? obj.schema_version : 1,
+    config_version: typeof obj.config_version === "number" ? obj.config_version : 0,
+    business_id: typeof obj.business_id === "string" ? obj.business_id : void 0,
+    customer_id: typeof obj.customer_id === "string" ? obj.customer_id : null,
+    environment: typeof obj.environment === "string" ? obj.environment : void 0,
+    google_tracking_state: obj.google_tracking_state === "active" ? "active" : "disabled",
+    gtag_ids: isStringMap(obj.gtag_ids) ? obj.gtag_ids : {},
+    meta_pixel_ids: isStringMap(obj.meta_pixel_ids) ? obj.meta_pixel_ids : {},
+    services,
+    goals
+  };
+}
+var CACHE_PREFIX = "_aranova_cfg_";
+function cacheKey(url) {
+  return `${CACHE_PREFIX}${url}`;
+}
+function readCache(url) {
+  if (typeof window === "undefined") return null;
+  try {
+    const raw = window.sessionStorage.getItem(cacheKey(url));
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    const config = parseConversionConfig(parsed.config);
+    if (!config) return null;
+    return {
+      etag: typeof parsed.etag === "string" ? parsed.etag : null,
+      config
+    };
+  } catch {
+    return null;
+  }
+}
+function writeCache(url, entry) {
+  if (typeof window === "undefined") return;
+  try {
+    window.sessionStorage.setItem(cacheKey(url), JSON.stringify(entry));
+  } catch {
+  }
+}
+function resolveConversionConfig(options) {
+  const cached = readCache(options.cdnUrl);
+  let current = cached?.config ?? options.baked ?? null;
+  let etag = cached?.etag ?? null;
+  const goalsByKey = /* @__PURE__ */ new Map();
+  const resolveListeners = /* @__PURE__ */ new Set();
+  function rebuildIndex() {
+    goalsByKey.clear();
+    for (const goal of current?.goals ?? []) {
+      goalsByKey.set(goal.key, goal);
+    }
+  }
+  function notifyResolved() {
+    const listeners2 = [...resolveListeners];
+    resolveListeners.clear();
+    for (const listener of listeners2) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  }
+  function adopt(next, nextEtag) {
+    if (!next) return;
+    if (current && next.config_version <= current.config_version) return;
+    const wasEmpty = current === null;
+    current = next;
+    etag = nextEtag;
+    rebuildIndex();
+    writeCache(options.cdnUrl, { etag, config: next });
+    if (wasEmpty) notifyResolved();
+  }
+  async function revalidate() {
+    if (typeof window === "undefined") return;
+    try {
+      const doFetch = options.fetchImpl ?? globalThis.fetch;
+      if (!doFetch) return;
+      const headers = {};
+      if (etag) headers["If-None-Match"] = etag;
+      const response = await doFetch(options.cdnUrl, {
+        method: "GET",
+        headers
+      });
+      if (response.status === 304 || !response.ok) return;
+      adopt(parseConversionConfig(await response.json()), response.headers.get("ETag"));
+    } catch {
+    }
+  }
+  rebuildIndex();
+  void revalidate();
+  return {
+    getFiring: (key) => goalsByKey.get(key)?.firing ?? null,
+    getGoal: (key) => goalsByKey.get(key) ?? null,
+    listGoals: () => [...goalsByKey.values()],
+    current: () => current,
+    isReady: () => current !== null,
+    onResolve: (listener) => {
+      if (current !== null) {
+        listener();
+        return () => {
+        };
+      }
+      resolveListeners.add(listener);
+      return () => resolveListeners.delete(listener);
+    },
+    revalidate
+  };
+}
+
+// ../tracking-core/src/resources/automatic-transaction.ts
+var STORAGE_KEY = "_aranova_auto_txn_map";
+var transactionIds = /* @__PURE__ */ new Map();
+var legacyCounter = 0;
+function scopeKey(sessionId, goalKey, path) {
+  return JSON.stringify([sessionId, goalKey, path]);
+}
+function randomId() {
+  const cryptoApi = globalThis.crypto;
+  if (typeof cryptoApi?.randomUUID === "function") return cryptoApi.randomUUID();
+  if (typeof cryptoApi?.getRandomValues === "function") {
+    const bytes = cryptoApi.getRandomValues(new Uint8Array(16));
+    return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+  legacyCounter = (legacyCounter + 1) % 4294967296;
+  const timestamp = Date.now().toString(16).padStart(12, "0");
+  const counter = legacyCounter.toString(16).padStart(8, "0");
+  const random = Math.floor(Math.random() * 281474976710655).toString(16).padStart(12, "0");
+  return `${timestamp}${counter}${random}`.slice(0, 32);
+}
+function isValidTransactionId(value) {
+  return typeof value === "string" && /^auto:(?:[0-9a-f]{32}|[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})$/i.test(
+    value
+  ) && value.length <= 64;
+}
+function readStoredMap(sessionId) {
+  if (typeof window === "undefined") return { sessionId, entries: {} };
+  try {
+    const raw = window.localStorage.getItem(STORAGE_KEY);
+    if (!raw) return { sessionId, entries: {} };
+    const parsed = JSON.parse(raw);
+    if (parsed.sessionId !== sessionId || !parsed.entries || typeof parsed.entries !== "object" || Array.isArray(parsed.entries)) {
+      return { sessionId, entries: {} };
+    }
+    return { sessionId, entries: parsed.entries };
+  } catch {
+    return { sessionId, entries: {} };
+  }
+}
+function writeStoredMap(stored) {
+  if (typeof window === "undefined") return;
+  try {
+    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(stored));
+  } catch {
+  }
+}
+function getAutomaticTransactionId(sessionId, goalKey, path) {
+  const key = scopeKey(sessionId, goalKey, path);
+  const existing = transactionIds.get(key);
+  if (existing) return existing;
+  const stored = readStoredMap(sessionId);
+  const storedId = stored.entries[key];
+  if (isValidTransactionId(storedId)) {
+    transactionIds.set(key, storedId);
+    return storedId;
+  }
+  const transactionId = `auto:${randomId()}`;
+  transactionIds.set(key, transactionId);
+  const latest = readStoredMap(sessionId);
+  const concurrentId = latest.entries[key];
+  if (isValidTransactionId(concurrentId)) {
+    transactionIds.set(key, concurrentId);
+    return concurrentId;
+  }
+  latest.entries[key] = transactionId;
+  writeStoredMap(latest);
+  return transactionId;
+}
+
+// ../tracking-core/src/resources/automatic-trigger.ts
+function hasNumberField(metadata, key) {
+  return typeof metadata[key] === "number";
+}
+function hasStringField(metadata, key) {
+  return typeof metadata[key] === "string";
+}
+function automaticThresholdMet(goal, eventType, metadata) {
+  const trigger = goal.trigger;
+  if (!trigger || trigger.event_type !== eventType) return false;
+  switch (eventType) {
+    case "scroll_depth":
+      return hasNumberField(metadata, "depth_percent") && trigger.threshold_percent != null && metadata.depth_percent >= trigger.threshold_percent;
+    case "time_on_site":
+      return hasNumberField(metadata, "duration_ms") && trigger.threshold_seconds != null && metadata.duration_ms >= trigger.threshold_seconds * 1e3;
+    case "multi_page_session":
+      return hasNumberField(metadata, "page_count") && trigger.page_threshold != null && metadata.page_count >= trigger.page_threshold;
+    case "specific_page_visit":
+      return hasStringField(metadata, "page_name") && metadata.page_name === trigger.page_name;
+    case "page_view":
+    case "form_start":
+    case "phone_click":
+      return true;
+    default:
+      return false;
+  }
+}
+
+// ../tracking-core/src/resources/sales/money.ts
+var MINOR_UNIT_EXPONENT = {
+  USD: 2,
+  CAD: 2
+};
+function exponentFor(currency) {
+  return MINOR_UNIT_EXPONENT[currency] ?? 2;
+}
+function fromMinor(cents, currency) {
+  return cents / 10 ** exponentFor(currency);
+}
+
+// ../tracking-core/src/resources/tracking-config-runtime.ts
+var DEFAULT_CDN_BASE_URL = "https://demos.aranova.io";
+function trackingConfigKey(businessId, environment) {
+  return `tracking-config/v1/${businessId}-${environment}.json`;
+}
+function resolveTrackingConfigUrl(ref) {
+  if (ref.cdnUrl) return ref.cdnUrl;
+  const configured = ref.cdnBaseUrl?.trim();
+  const base = (configured || DEFAULT_CDN_BASE_URL).replace(/\/+$/, "");
+  return `${base}/${trackingConfigKey(ref.businessId, ref.environment)}`;
+}
+var CACHE_PREFIX2 = "_aranova_cfg_runtime_";
+var AUTHORITY_TTL_MS = 6e4;
+var MAX_QUEUE_LENGTH = 50;
+var RETRY_BASE_MS = 5e3;
+var RETRY_MAX_MS = 5 * 6e4;
+var runtimes = /* @__PURE__ */ new Map();
+var configuredIds = /* @__PURE__ */ new Set();
+var scriptLoad = null;
+var jsInitialized = false;
+function cacheKey2(url) {
+  return `${CACHE_PREFIX2}${url}`;
+}
+function pushBounded(queue, item) {
+  queue.push(item);
+  if (queue.length > MAX_QUEUE_LENGTH) queue.splice(0, queue.length - MAX_QUEUE_LENGTH);
+}
+function readCache2(url) {
+  if (typeof window === "undefined") return null;
+  try {
+    const raw = window.sessionStorage.getItem(cacheKey2(url));
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    const config = parseConversionConfig(parsed.config);
+    if (!config) return null;
+    return {
+      etag: typeof parsed.etag === "string" ? parsed.etag : null,
+      config
+    };
+  } catch {
+    return null;
+  }
+}
+function writeCache2(url, entry) {
+  if (typeof window === "undefined") return;
+  try {
+    window.sessionStorage.setItem(cacheKey2(url), JSON.stringify(entry));
+  } catch {
+  }
+}
+function isTombstone(config) {
+  return config.google_tracking_state === "disabled" || Object.keys(config.gtag_ids).length === 0;
+}
+function validateConfig(config, ref) {
+  return config.business_id === ref.businessId && config.environment === ref.environment && (config.google_tracking_state === "active" || config.google_tracking_state === "disabled");
+}
+function pageViewSnapshot() {
+  if (typeof window === "undefined" || typeof document === "undefined") return null;
+  return {
+    href: window.location.href,
+    title: document.title || null,
+    referrer: document.referrer || null
+  };
+}
+function ensureScript(gtagId) {
+  if (typeof window === "undefined" || typeof document === "undefined") return Promise.resolve();
+  applyDefaultConsentState();
+  loadGtagScript(gtagId);
+  if (scriptLoad) return scriptLoad;
+  scriptLoad = new Promise((resolve) => {
+    const script = document.querySelector(
+      'script[data-aranova-tracking="aranova-gtag-loader"]'
+    );
+    if (!script) {
+      resolve();
+      return;
+    }
+    if (script.dataset.loaded === "true") {
+      resolve();
+      return;
+    }
+    window.setTimeout(resolve, 0);
+    script.addEventListener(
+      "load",
+      () => {
+        script.dataset.loaded = "true";
+        resolve();
+      },
+      { once: true }
+    );
+    script.addEventListener("error", () => resolve(), { once: true });
+  });
+  return scriptLoad;
+}
+var TrackingConfigRuntime = class {
+  constructor(ref, fetchImpl = globalThis.fetch) {
+    this.ref = ref;
+    this.current = null;
+    this.etag = null;
+    this.stateValue = "unconfirmed";
+    this.confirmedAt = 0;
+    this.authorityGeneration = 0;
+    this.inFlight = null;
+    this.flushInFlight = null;
+    this.flushRequested = false;
+    this.retryTimer = null;
+    this.started = false;
+    /** Consecutive failed authority attempts — drives the revalidate backoff. */
+    this.authorityFailures = 0;
+    /** Epoch ms before which `ensureAuthority` must not issue another request. */
+    this.nextAuthorityAttemptAt = 0;
+    this.conversionQueue = [];
+    this.automaticQueue = [];
+    this.pageQueue = [];
+    this.listeners = /* @__PURE__ */ new Set();
+    this.fetchImpl = fetchImpl.bind(globalThis);
+    this.url = resolveTrackingConfigUrl(ref);
+    const cached = readCache2(this.url);
+    this.current = cached?.config ?? null;
+    this.etag = cached?.etag ?? null;
+    this.start();
+  }
+  /** The URL this runtime actually fetches (composed or explicit). */
+  configUrl() {
+    return this.url;
+  }
+  /**
+   * Explicitly start authority resolution and Google-tag bootstrap.
+   *
+   * Idempotent so framework effects can call it after hydration without
+   * depending on constructor timing.
+   */
+  start() {
+    if (this.started) {
+      void this.flush();
+      return;
+    }
+    this.started = true;
+    void this.revalidate();
+    if (typeof window !== "undefined") {
+      window.addEventListener("visibilitychange", () => {
+        if (document.visibilityState === "visible") void this.revalidate();
+      });
+      window.addEventListener("focus", () => void this.revalidate());
+    }
+  }
+  state() {
+    return this.stateValue;
+  }
+  config() {
+    return this.stateValue === "active" || this.stateValue === "tombstone" ? this.current : null;
+  }
+  __unsafeExpireAuthorityForTests() {
+    this.confirmedAt = Number.NEGATIVE_INFINITY;
+    this.nextAuthorityAttemptAt = 0;
+  }
+  /** Queue depths — asserted by tests to pin the bound. */
+  __queueDepthsForTests() {
+    return {
+      conversions: this.conversionQueue.length,
+      automatic: this.automaticQueue.length,
+      pages: this.pageQueue.length
+    };
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  async ensureAuthority() {
+    if (this.stateValue !== "unconfirmed" && Date.now() - this.confirmedAt < AUTHORITY_TTL_MS) {
+      return true;
+    }
+    if (Date.now() < this.nextAuthorityAttemptAt) return false;
+    await this.revalidateAuthority();
+    return this.stateValue !== "unconfirmed" && Date.now() - this.confirmedAt < AUTHORITY_TTL_MS;
+  }
+  async revalidate() {
+    this.nextAuthorityAttemptAt = 0;
+    await this.revalidateAuthority();
+    await this.flush();
+  }
+  async revalidateAuthority() {
+    if (typeof window === "undefined" || !this.fetchImpl) return;
+    if (this.inFlight) return this.inFlight;
+    this.inFlight = this.revalidateNow().finally(() => {
+      this.inFlight = null;
+    });
+    return this.inFlight;
+  }
+  queuePageView(snapshot = pageViewSnapshot()) {
+    if (!snapshot) return;
+    pushBounded(this.pageQueue, snapshot);
+    void this.flush();
+  }
+  fireConversion(key, options) {
+    pushBounded(this.conversionQueue, { key, ...options });
+    void this.flush();
+  }
+  queueAutomaticEvent(eventType, metadata, transactionPath, transactionScope) {
+    pushBounded(this.automaticQueue, {
+      eventType,
+      metadata,
+      transactionPath,
+      transactionScope
+    });
+    void this.flush();
+  }
+  listGoals() {
+    return this.current?.goals ?? [];
+  }
+  async revalidateNow() {
+    try {
+      const headers = {};
+      if (this.etag) headers["If-None-Match"] = this.etag;
+      const response = await this.fetchImpl(this.url, {
+        method: "GET",
+        headers,
+        cache: "no-cache"
+      });
+      if (response.status === 304 && this.current && validateConfig(this.current, this.ref)) {
+        this.confirm(this.current, this.etag);
+        return;
+      }
+      if (!response.ok) {
+        this.expireAuthority();
+        return;
+      }
+      const next = parseConversionConfig(await response.json());
+      if (!next || !validateConfig(next, this.ref)) {
+        this.expireAuthority();
+        return;
+      }
+      if (this.current && next.config_version < this.current.config_version) {
+        this.expireAuthority();
+        return;
+      }
+      this.confirm(next, response.headers.get("ETag"));
+    } catch {
+      this.expireAuthority();
+    }
+  }
+  expireAuthority() {
+    this.authorityGeneration += 1;
+    if (this.stateValue !== "unconfirmed") this.stateValue = "unconfirmed";
+    this.authorityFailures += 1;
+    const delay = Math.min(RETRY_MAX_MS, RETRY_BASE_MS * 2 ** (this.authorityFailures - 1));
+    this.nextAuthorityAttemptAt = Date.now() + delay;
+  }
+  confirm(config, etag) {
+    this.authorityGeneration += 1;
+    this.current = config;
+    this.etag = etag;
+    this.confirmedAt = Date.now();
+    this.authorityFailures = 0;
+    this.nextAuthorityAttemptAt = 0;
+    this.stateValue = isTombstone(config) ? "tombstone" : "active";
+    writeCache2(this.url, { etag, config });
+    if (this.stateValue === "tombstone") {
+      if (this.retryTimer !== null) {
+        window.clearTimeout(this.retryTimer);
+        this.retryTimer = null;
+      }
+      this.conversionQueue.length = 0;
+      this.automaticQueue.length = 0;
+      this.pageQueue.length = 0;
+    }
+    for (const listener of this.listeners) listener();
+  }
+  async flush() {
+    if (this.flushInFlight) {
+      this.flushRequested = true;
+      return this.flushInFlight;
+    }
+    this.flushRequested = false;
+    this.flushInFlight = this.flushNow().finally(() => {
+      this.flushInFlight = null;
+      if (this.flushRequested && this.stateValue === "active") void this.flush();
+    });
+    return this.flushInFlight;
+  }
+  scheduleRetry() {
+    if (this.retryTimer !== null || typeof window === "undefined") return;
+    this.retryTimer = window.setTimeout(() => {
+      this.retryTimer = null;
+      void this.flush();
+    }, 1e3);
+  }
+  async flushNow() {
+    if (!await this.ensureAuthority()) return;
+    if (this.stateValue !== "active" || !this.current) return;
+    const config = this.current;
+    const generation = this.authorityGeneration;
+    const ids = Object.values(config.gtag_ids).filter(
+      (id) => typeof id === "string" && isValidGtagId(id)
+    );
+    if (ids.length === 0) return;
+    await ensureScript(ids[0]);
+    if (this.authorityGeneration !== generation || this.stateValue !== "active" || this.current !== config) {
+      return;
+    }
+    const gtag = window.gtag;
+    if (typeof gtag !== "function") return;
+    try {
+      if (!jsInitialized) {
+        gtag("js", /* @__PURE__ */ new Date());
+        jsInitialized = true;
+      }
+      for (const id of ids) {
+        if (configuredIds.has(id)) continue;
+        gtag("config", id, { send_page_view: false });
+        configuredIds.add(id);
+      }
+    } catch {
+      this.scheduleRetry();
+      return;
+    }
+    while (this.pageQueue.length > 0) {
+      const page = this.pageQueue[0];
+      try {
+        gtag("event", "page_view", {
+          page_location: page.href,
+          page_title: page.title ?? void 0,
+          page_referrer: page.referrer ?? void 0
+        });
+        this.pageQueue.shift();
+      } catch {
+        this.scheduleRetry();
+        return;
+      }
+    }
+    while (this.automaticQueue.length > 0) {
+      const event = this.automaticQueue[0];
+      for (const goal of config.goals) {
+        if (goal.kind !== "event" || !goal.firing) continue;
+        if (!automaticThresholdMet(goal, event.eventType, event.metadata)) continue;
+        pushBounded(this.conversionQueue, {
+          key: goal.key,
+          transactionId: getAutomaticTransactionId(
+            event.transactionScope,
+            goal.key,
+            event.transactionPath
+          )
+        });
+      }
+      this.automaticQueue.shift();
+    }
+    while (this.conversionQueue.length > 0) {
+      const item = this.conversionQueue[0];
+      const goal = config.goals.find((g) => g.key === item.key);
+      const firing = goal?.firing;
+      if (!firing) {
+        this.conversionQueue.shift();
+        continue;
+      }
+      const currency = item.currency ?? firing.currency ?? null;
+      const value = item.value ?? (firing.value_cents != null && currency ? fromMinor(firing.value_cents, currency) : null);
+      const outcome = fireConversionWithConsent({
+        sendTo: firing.send_to,
+        value,
+        currency,
+        transactionId: item.transactionId ?? null
+      });
+      if (outcome === "retryable") {
+        this.scheduleRetry();
+        return;
+      }
+      this.conversionQueue.shift();
+    }
+  }
+};
+function getTrackingConfigRuntime(ref, fetchImpl) {
+  const key = `${resolveTrackingConfigUrl(ref)}|${ref.businessId}|${ref.environment}`;
+  const existing = runtimes.get(key);
+  if (existing) return existing;
+  const runtime = new TrackingConfigRuntime(ref, fetchImpl ?? globalThis.fetch);
+  runtimes.set(key, runtime);
+  return runtime;
+}
+
+// ../tracking-core/src/resources/conversion-autofire.ts
+function currentPath() {
+  return typeof window === "undefined" ? "" : window.location.pathname;
+}
+var MAX_BUFFERED_EVENTS = 50;
+function createConversionAutoFire(store) {
+  const pending = [];
+  let subscribed = false;
+  function fireMatching(eventType, metadata, transactionScope) {
+    for (const goal of store.listGoals()) {
+      if (goal.kind !== "event" || !goal.firing) continue;
+      if (!automaticThresholdMet(goal, eventType, metadata)) continue;
+      const transactionId = getAutomaticTransactionId(transactionScope, goal.key, currentPath());
+      if ("queueAutomaticEvent" in store) {
+        store.fireConversion(goal.key, {
+          transactionId
+        });
+        continue;
+      }
+      const firing = goal.firing;
+      const cents = firing.value_cents ?? null;
+      const currency = firing.currency ?? null;
+      fireConversionWithConsent({
+        sendTo: firing.send_to,
+        value: cents != null && currency ? fromMinor(cents, currency) : null,
+        currency,
+        transactionId
+      });
+    }
+  }
+  return {
+    onAutomaticEvent(eventType, metadata, transactionScope) {
+      if ("queueAutomaticEvent" in store) {
+        store.queueAutomaticEvent(eventType, metadata, currentPath(), transactionScope);
+        return;
+      }
+      if (store.isReady()) {
+        fireMatching(eventType, metadata, transactionScope);
+        return;
+      }
+      if (pending.length < MAX_BUFFERED_EVENTS) {
+        pending.push({ eventType, metadata, transactionScope });
+      }
+      if (!subscribed) {
+        subscribed = true;
+        store.onResolve(() => {
+          const buffered = pending.splice(0);
+          for (const event of buffered) {
+            fireMatching(event.eventType, event.metadata, event.transactionScope);
+          }
+        });
+      }
+    }
+  };
+}
+function withConversionAutoFire(client, autoFire) {
+  return {
+    ...client,
+    trackEvent: (input) => {
+      client.trackEvent(input);
+      try {
+        autoFire.onAutomaticEvent(input.eventType, input.metadata ?? {}, client.getSessionId());
+      } catch {
+      }
+    }
+  };
+}
+
+// ../tracking-core/src/session.ts
+var VISITOR_STORAGE_KEY = "aranova_tracking_visitor";
+var SESSION_STORAGE_KEY = "aranova_tracking_session";
+var SESSION_IDLE_MS = 30 * 60 * 1e3;
+function safeUuid() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function")
+    return crypto.randomUUID();
+  return `${Date.now().toString(16)}-${Math.random().toString(16).slice(2)}-${Math.random().toString(16).slice(2)}`;
+}
+function readLocalStorage(key) {
+  try {
+    return window.localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+function writeLocalStorage(key, value) {
+  try {
+    window.localStorage.setItem(key, value);
+  } catch {
+  }
+}
+function getVisitorId() {
+  if (typeof window === "undefined") return safeUuid();
+  const existing = readLocalStorage(VISITOR_STORAGE_KEY);
+  if (existing && existing.length > 0) return existing;
+  const fresh = safeUuid();
+  writeLocalStorage(VISITOR_STORAGE_KEY, fresh);
+  return fresh;
+}
+function getOrRotateSessionId(now = Date.now()) {
+  if (typeof window === "undefined") return { id: safeUuid(), isNew: true };
+  const raw = readLocalStorage(SESSION_STORAGE_KEY);
+  if (raw) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (typeof parsed.id === "string" && typeof parsed.last_event_at === "number") {
+        if (now - parsed.last_event_at <= SESSION_IDLE_MS) {
+          const refreshed = { id: parsed.id, last_event_at: now };
+          writeLocalStorage(SESSION_STORAGE_KEY, JSON.stringify(refreshed));
+          return { id: parsed.id, isNew: false };
+        }
+      }
+    } catch {
+    }
+  }
+  const fresh = { id: safeUuid(), last_event_at: now };
+  writeLocalStorage(SESSION_STORAGE_KEY, JSON.stringify(fresh));
+  return { id: fresh.id, isNew: true };
+}
+
+// ../tracking-core/src/events/page-view.ts
+import { z } from "zod";
+var pageViewMetadataSchema = z.object({
+  page: z.object({
+    title: z.string().nullable(),
+    path: z.string(),
+    search: z.string(),
+    hash: z.string()
+  }).strict(),
+  referrer: z.string().nullable(),
+  // `.nullable().optional()` — absent (undefined) OR explicit null OR a
+  // real viewport object. Mirrors Pydantic's `_Viewport | None = None`
+  // on the backend side so the drift test stays clean.
+  viewport: z.object({
+    w: z.number(),
+    h: z.number()
+  }).strict().nullable().optional()
+}).strict();
+var pageViewConfigSchema = z.object({}).strict();
+
+// ../tracking-core/src/page-view.ts
+var LAST_FIRED_URL_STORAGE_KEY = "aranova_tracking_last_fired_url";
+var lastFiredUrl = null;
+var lastFiredUrlHydrated = false;
+function readSessionStorage(key) {
+  try {
+    if (typeof window === "undefined") return null;
+    return window.sessionStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+function writeSessionStorage(key, value) {
+  try {
+    if (typeof window === "undefined") return;
+    window.sessionStorage.setItem(key, value);
+  } catch {
+  }
+}
+function getLastFiredUrl() {
+  if (!lastFiredUrlHydrated) {
+    lastFiredUrlHydrated = true;
+    const stored = readSessionStorage(LAST_FIRED_URL_STORAGE_KEY);
+    if (stored !== null) lastFiredUrl = stored;
+  }
+  return lastFiredUrl;
+}
+function setLastFiredUrl(url) {
+  lastFiredUrl = url;
+  lastFiredUrlHydrated = true;
+  writeSessionStorage(LAST_FIRED_URL_STORAGE_KEY, url);
+}
+function buildPageViewMetadata(referrerOverride) {
+  if (typeof window === "undefined" || typeof document === "undefined") return null;
+  return pageViewMetadataSchema.parse({
+    page: {
+      title: document.title || null,
+      path: window.location.pathname,
+      search: window.location.search,
+      hash: window.location.hash
+    },
+    referrer: referrerOverride !== void 0 ? referrerOverride : document.referrer || null,
+    viewport: { w: window.innerWidth, h: window.innerHeight }
+  });
+}
+function fireManualPageView(client) {
+  if (typeof window === "undefined") return;
+  const currentHref = window.location.href;
+  const previousFiredUrl = getLastFiredUrl();
+  const internalReferrer = previousFiredUrl !== null && previousFiredUrl !== currentHref ? previousFiredUrl : null;
+  const externalReferrer = typeof document !== "undefined" ? document.referrer || null : null;
+  const referrer = internalReferrer ?? externalReferrer;
+  const metadata = buildPageViewMetadata(referrer);
+  client.trackEvent({
+    eventType: "page_view",
+    pageUrl: currentHref,
+    metadata
+  });
+  if (currentHref !== previousFiredUrl) {
+    setLastFiredUrl(currentHref);
+  }
+}
+function attachBfcacheRestore(client) {
+  if (typeof window === "undefined") return () => {
+  };
+  function handlePageShow(event) {
+    if (!event.persisted) return;
+    fireManualPageView(client);
+  }
+  window.addEventListener("pageshow", handlePageShow);
+  return () => {
+    window.removeEventListener("pageshow", handlePageShow);
+  };
+}
+
+// ../tracking-core/src/heartbeat.ts
+function serializeValue(value) {
+  if (value instanceof RegExp) return value.source;
+  if (Array.isArray(value)) return value.map(serializeValue);
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = serializeValue(v);
+    }
+    return out;
+  }
+  return value;
+}
+function buildHeartbeatMetadata(surface, sdkVersion, packageName, triggers, gtagIds = null) {
+  const automaticNames = triggers ? Object.keys(triggers.automatic) : [];
+  const manualNames = triggers?.manual ? Object.keys(triggers.manual) : [];
+  let triggerConfig = null;
+  if (triggers) {
+    const cfg = {};
+    for (const [name, config] of Object.entries(triggers.automatic)) {
+      const serialized = serializeValue(config);
+      if (Object.keys(serialized).length > 0) {
+        cfg[name] = serialized;
+      }
+    }
+    if (triggers.manual) {
+      for (const [name, config] of Object.entries(triggers.manual)) {
+        if (config === void 0) continue;
+        const serialized = serializeValue(config);
+        if (Object.keys(serialized).length > 0) {
+          cfg[name] = serialized;
+        }
+      }
+    }
+    if (Object.keys(cfg).length > 0) {
+      triggerConfig = cfg;
+    }
+  }
+  return {
+    sdk_version: sdkVersion ?? "unknown",
+    package_name: packageName,
+    surface,
+    triggers: {
+      automatic: automaticNames,
+      manual: manualNames
+    },
+    trigger_config: triggerConfig,
+    configured_gtag_ids: gtagIds
+  };
+}
+
+// ../tracking-core/src/ingest.ts
+var DEFAULT_FLUSH_INTERVAL_MS = 2e3;
+var DEFAULT_MAX_QUEUE_SIZE = 10;
+var HARD_MAX_BATCH = 50;
+var MAX_RETRY_BACKOFF_MS = 6e4;
+var MAX_BUFFERED_EVENTS2 = 200;
+var RETRY_BUFFER_KEY_PREFIX = "aranova_tracking_pending_v1";
+var API_KEY_HEADER = "X-Aranova-Api-Key";
+var SDK_VERSION_HEADER = "X-Aranova-Sdk-Version";
+var SDK_PACKAGE_HEADER = "X-Aranova-Sdk-Package";
+var SDK_SURFACE_HEADER = "X-Aranova-Sdk-Surface";
+var SDK_ENVIRONMENT_HEADER = "X-Aranova-Sdk-Environment";
+function buildContext(surface, sdkVersion, packageName, environment, activeGtagIds) {
+  return {
+    surface,
+    sdk_version: sdkVersion,
+    package_name: packageName,
+    site_origin: typeof window === "undefined" ? null : window.location.origin,
+    page_title: typeof document === "undefined" ? null : document.title || null,
+    referrer: typeof document === "undefined" ? null : document.referrer || null,
+    environment,
+    active_gtag_ids: activeGtagIds,
+    // Rebuilt per flush (this runs inside the payload builder), so a client
+    // constructed later on a deeper route still gets reported.
+    capabilities: getRegisteredCapabilities()
+  };
+}
+function readTrackingParams() {
+  if (typeof window === "undefined") return createEmptyTrackingParams();
+  try {
+    captureTrackingParamsFromLocation();
+  } catch {
+  }
+  return getTrackingParamsFromCookieReader(getCookieValueFromDocument);
+}
+function consentSnapshot() {
+  try {
+    const choice = getConsentChoice();
+    return {
+      state: choice.state,
+      source: choice.source,
+      updated_at: choice.updatedAt,
+      expires_at: choice.expiresAt
+    };
+  } catch {
+    return null;
+  }
+}
+async function postWithFetch(url, body, apiKey, identity, keepalive) {
+  if (typeof fetch !== "function") return "drop";
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        [API_KEY_HEADER]: apiKey,
+        [SDK_VERSION_HEADER]: identity.sdkVersion,
+        [SDK_PACKAGE_HEADER]: identity.packageName,
+        [SDK_SURFACE_HEADER]: identity.surface,
+        [SDK_ENVIRONMENT_HEADER]: identity.environment
+      },
+      body,
+      keepalive,
+      // CORS is open on the tracking endpoint; never send cookies.
+      credentials: "omit",
+      mode: "cors"
+    });
+    if (response.ok) return "ok";
+    if (response.status === 408 || response.status === 429 || response.status >= 500) {
+      return "retry";
+    }
+    return "drop";
+  } catch {
+    return "retry";
+  }
+}
+function retryBufferKey(apiKey, endpoint) {
+  return `${RETRY_BUFFER_KEY_PREFIX}:${apiKey}:${endpoint}`;
+}
+function readPendingBatches(key) {
+  if (typeof window === "undefined") return [];
+  try {
+    const raw = window.localStorage.getItem(key);
+    if (!raw) return [];
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(
+      (entry) => typeof entry === "object" && entry !== null && "session" in entry && Array.isArray(entry.events)
+    );
+  } catch {
+    return [];
+  }
+}
+function writePendingBatches(key, batches) {
+  if (typeof window === "undefined") return;
+  try {
+    if (batches.length === 0) window.localStorage.removeItem(key);
+    else window.localStorage.setItem(key, JSON.stringify(batches));
+  } catch {
+  }
+}
+function trimToBufferCap(batches) {
+  let total = batches.reduce((sum, batch) => sum + batch.events.length, 0);
+  const trimmed = batches.slice();
+  while (total > MAX_BUFFERED_EVENTS2 && trimmed.length > 1) {
+    const dropped = trimmed.shift();
+    total -= dropped ? dropped.events.length : 0;
+  }
+  return trimmed;
+}
+var globalClient = null;
+var globalClientKey = null;
+function clientConfigKey(config) {
+  return `${config.apiKey}@${config.endpoint}#${config.surface}`;
+}
+function getOrCreateTrackingClient(config) {
+  const key = clientConfigKey(config);
+  if (globalClient !== null && globalClientKey === key) {
+    return globalClient;
+  }
+  if (globalClient !== null) {
+    globalClient.destroy();
+  }
+  globalClient = createTrackingClient(config);
+  globalClientKey = key;
+  return globalClient;
+}
+var clientCaptureRegistry = /* @__PURE__ */ new WeakMap();
+function attachClientCapturesOnce(client, build) {
+  let entry = clientCaptureRegistry.get(client);
+  if (entry === void 0) {
+    entry = { detach: build(), refCount: 0 };
+    clientCaptureRegistry.set(client, entry);
+  }
+  entry.refCount += 1;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    const current = clientCaptureRegistry.get(client);
+    if (current === void 0) return;
+    current.refCount -= 1;
+    if (current.refCount <= 0) {
+      current.detach();
+      clientCaptureRegistry.delete(client);
+    }
+  };
+}
+function createTrackingClient(config) {
+  const flushIntervalMs = config.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
+  const maxQueueSize = Math.min(config.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE, HARD_MAX_BATCH);
+  const sdkVersion = config.sdkVersion ?? null;
+  const packageName = config.packageName ?? null;
+  const environment = config.environment ?? "production";
+  const activeGtagIds = config.activeGtagIds ?? null;
+  const endpointBase = config.endpoint.replace(/\/$/, "");
+  const eventsUrl = `${endpointBase}/events`;
+  const identityHeaders = {
+    sdkVersion: sdkVersion ?? "",
+    packageName: packageName ?? "",
+    surface: config.surface,
+    environment
+  };
+  let queue = [];
+  let flushTimer = null;
+  const bufferKey = retryBufferKey(config.apiKey, endpointBase);
+  let pending = readPendingBatches(bufferKey);
+  let flushChain = Promise.resolve();
+  let retryAttempt = 0;
+  let firstPage = null;
+  let initialParams = createEmptyTrackingParams();
+  let destroyed = false;
+  const visitorId = getVisitorId();
+  const initialSession = getOrRotateSessionId();
+  let sessionId = initialSession.id;
+  if (typeof window !== "undefined") {
+    firstPage = window.location.href;
+    try {
+      initialParams = captureTrackingParamsFromLocation();
+    } catch {
+    }
+    getOrCaptureLandingParams(sessionId);
+    try {
+      captureFbc();
+    } catch {
+    }
+  }
+  function enqueueHeartbeat() {
+    const metadata = buildHeartbeatMetadata(
+      config.surface,
+      sdkVersion,
+      packageName,
+      config.triggers ?? null,
+      activeGtagIds
+    );
+    queue.push({
+      event_type: "sdk_heartbeat",
+      page_url: typeof window === "undefined" ? null : window.location.href,
+      metadata,
+      occurred_at: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  if (initialSession.isNew) {
+    enqueueHeartbeat();
+  }
+  if (pending.length > 0) {
+    scheduleFlush();
+  }
+  function buildSessionPayload() {
+    const rotated = getOrRotateSessionId();
+    if (rotated.isNew && rotated.id !== sessionId) {
+      enqueueHeartbeat();
+    }
+    sessionId = rotated.id;
+    const params = mergeTrackingParams(readTrackingParams(), initialParams);
+    const context = buildContext(
+      config.surface,
+      sdkVersion,
+      packageName,
+      environment,
+      activeGtagIds
+    );
+    return {
+      session_id: sessionId,
+      visitor_id: visitorId,
+      gclid: params.gclid,
+      wbraid: params.wbraid,
+      gbraid: params.gbraid,
+      ylpcid: params.ylpcid,
+      fbclid: params.fbclid,
+      fbc: getFbcCookie(),
+      fbp: getFbpCookie(),
+      utm_source: params.utm_source,
+      utm_medium: params.utm_medium,
+      utm_campaign: params.utm_campaign,
+      utm_term: params.utm_term,
+      utm_content: params.utm_content,
+      // Landing params for the CURRENT session id — captured on the spot when
+      // the session just rotated (the current URL is the rotated session's
+      // landing), reused from the stored record otherwise. Keys are omitted
+      // entirely when the landing isn't observable (SSR).
+      ...buildLandingPayloadFields(sessionId),
+      first_page: firstPage,
+      consent_state: consentSnapshot(),
+      context
+    };
+  }
+  function scheduleFlush(delayMs = flushIntervalMs) {
+    if (flushTimer !== null || destroyed) return;
+    flushTimer = setTimeout(() => {
+      flushTimer = null;
+      void flush();
+    }, delayMs);
+  }
+  function clearScheduledFlush() {
+    if (flushTimer !== null) {
+      clearTimeout(flushTimer);
+      flushTimer = null;
+    }
+  }
+  function bufferQueued() {
+    if (queue.length === 0) return;
+    const events = queue.slice(0, HARD_MAX_BATCH);
+    queue = queue.slice(events.length);
+    pending = trimToBufferCap([...pending, { session: buildSessionPayload(), events }]);
+    writePendingBatches(bufferKey, pending);
+  }
+  function flush() {
+    flushChain = flushChain.then(runFlush).catch(() => {
+    });
+    return flushChain;
+  }
+  async function runFlush() {
+    if (destroyed) return;
+    clearScheduledFlush();
+    bufferQueued();
+    if (pending.length === 0) return;
+    try {
+      while (pending.length > 0) {
+        const batch = pending[0];
+        const body = { session: batch.session, events: batch.events };
+        const outcome = await postWithFetch(
+          eventsUrl,
+          JSON.stringify(body),
+          config.apiKey,
+          identityHeaders,
+          false
+        );
+        if (outcome === "retry") {
+          retryAttempt += 1;
+          return;
+        }
+        pending = pending.slice(1);
+        writePendingBatches(bufferKey, pending);
+        retryAttempt = 0;
+      }
+    } finally {
+      if (pending.length > 0) {
+        const backoff = Math.min(flushIntervalMs * 2 ** retryAttempt, MAX_RETRY_BACKOFF_MS);
+        scheduleFlush(backoff);
+      } else if (queue.length > 0) {
+        scheduleFlush();
+      }
+    }
+  }
+  function trackEvent(input) {
+    if (destroyed) return;
+    if (!input || typeof input.eventType !== "string" || input.eventType.length === 0) return;
+    if (input.eventType === "form_submit" && getConsentState() !== "denied") {
+      try {
+        const fields = input.metadata?.form?.fields;
+        if (fields) stashUserDataFromFormFields(fields, config.phone?.defaultCountry);
+      } catch {
+      }
+    }
+    const occurredAt = input.occurredAt instanceof Date ? input.occurredAt.toISOString() : typeof input.occurredAt === "string" ? input.occurredAt : (/* @__PURE__ */ new Date()).toISOString();
+    queue.push({
+      event_type: input.eventType,
+      page_url: input.pageUrl ?? (typeof window === "undefined" ? null : window.location.href),
+      metadata: input.metadata ?? null,
+      occurred_at: occurredAt
+    });
+    if (queue.length >= maxQueueSize) {
+      void flush();
+    } else {
+      scheduleFlush();
+    }
+  }
+  function flushOnUnload() {
+    bufferQueued();
+    clearScheduledFlush();
+    if (pending.length === 0) return;
+    const batch = pending[0];
+    pending = pending.slice(1);
+    writePendingBatches(bufferKey, pending);
+    const body = { session: batch.session, events: batch.events };
+    void postWithFetch(eventsUrl, JSON.stringify(body), config.apiKey, identityHeaders, true);
+  }
+  if (typeof window !== "undefined") {
+    window.addEventListener("pagehide", flushOnUnload);
+    window.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "hidden") flushOnUnload();
+    });
+  }
+  return {
+    trackEvent,
+    flush,
+    flushBeacon: flushOnUnload,
+    getSessionId: () => sessionId,
+    getVisitorId: () => visitorId,
+    destroy: () => {
+      destroyed = true;
+      if (queue.length > 0) {
+        flushOnUnload();
+      }
+      clearScheduledFlush();
+      queue = [];
+      if (typeof window !== "undefined") {
+        window.removeEventListener("pagehide", flushOnUnload);
+      }
+    }
+  };
+}
+
+// ../tracking-core/src/events/cta-click.ts
+import { z as z2 } from "zod";
+var ctaClickMetadataSchema = z2.object({
+  cta_name: z2.string(),
+  page: z2.object({
+    path: z2.string()
+  }).strict(),
+  section: z2.string().nullable().optional(),
+  destination_url: z2.string().nullable().optional(),
+  // Set by auto-capture (and available to manual callers): the link target
+  // and a short element descriptor (tag#id) for tying clicks to specific UI.
+  href: z2.string().nullable().optional(),
+  element: z2.string().nullable().optional()
+}).strict();
+var ctaClickConfigSchema = z2.object({
+  autoCapture: z2.object({
+    selector: z2.string().optional()
+  }).strict().optional()
+}).strict();
+
+// ../tracking-core/src/events/sdk-heartbeat.ts
+import { z as z3 } from "zod";
+var sdkHeartbeatTriggersSchema = z3.object({
+  automatic: z3.array(z3.string()),
+  manual: z3.array(z3.string())
+}).strict();
+var sdkHeartbeatMetadataSchema = z3.object({
+  sdk_version: z3.string(),
+  package_name: z3.string().nullable(),
+  surface: z3.enum(["next", "react", "script"]),
+  triggers: sdkHeartbeatTriggersSchema,
+  trigger_config: z3.record(z3.string(), z3.record(z3.string(), z3.unknown())).nullable().optional(),
+  configured_gtag_ids: z3.record(z3.string(), z3.string()).nullable().optional()
+}).strict();
+var sdkHeartbeatConfigSchema = z3.object({}).strict();
+
+// ../tracking-core/src/events/form-start.ts
+import { z as z4 } from "zod";
+var formStartMetadataSchema = z4.object({
+  form: z4.object({
+    id: z4.string(),
+    action: z4.string().nullable()
+  }).strict(),
+  page: z4.object({
+    path: z4.string()
+  }).strict()
+}).strict();
+var formStartConfigSchema = z4.object({
+  selector: z4.string().optional()
+}).strict();
+
+// ../tracking-core/src/events/form-submit.ts
+import { z as z5 } from "zod";
+var jsonValueSchema = z5.lazy(
+  () => z5.union([
+    z5.string(),
+    z5.number().finite(),
+    z5.boolean(),
+    z5.null(),
+    z5.array(jsonValueSchema),
+    z5.record(jsonValueSchema)
+  ])
+);
+var formSubmitMetadataSchema = z5.object({
+  form: z5.object({
+    id: z5.string(),
+    action: z5.string().nullable(),
+    fields: z5.array(
+      z5.object({
+        name: z5.string(),
+        type: z5.string(),
+        label: z5.string().nullable(),
+        value: jsonValueSchema
+      }).strict()
+    ).optional()
+  }).strict(),
+  page: z5.object({
+    path: z5.string()
+  }).strict()
+}).strict();
+var formSubmitConfigSchema = z5.object({}).strict();
+
+// ../tracking-core/src/events/multi-page-session.ts
+import { z as z6 } from "zod";
+var multiPageSessionMetadataSchema = z6.object({
+  page_count: z6.number().int().min(2),
+  page: z6.object({
+    path: z6.string()
+  }).strict()
+}).strict();
+var multiPageSessionConfigSchema = z6.object({
+  pageThreshold: z6.number().int().min(2)
+}).strict();
+
+// ../tracking-core/src/events/page-exit.ts
+import { z as z7 } from "zod";
+var pageExitMetadataSchema = z7.object({
+  dwell_ms: z7.number().int().min(0),
+  // null = left without any scroll signal; floor is 0 so a valid 0% is never
+  // rejected (a single bad field 422s the whole keepalive beacon batch).
+  max_scroll_percent: z7.number().int().min(0).max(100).nullable(),
+  // The gating baseline: the fraction of the page visible at load with
+  // zero scrolling — or, for pages that grew after the post-paint snapshot
+  // (skeleton/streaming renders), the first-scroll position that
+  // established it. null = page had no scrollable range, or the segment
+  // ended before the snapshot. `.optional()` is load-bearing: SDK builds
+  // predating this field keep POSTing page_exit without the key —
+  // requiring it would 422 whole keepalive beacon batches.
+  scroll_baseline_percent: z7.number().int().min(0).max(100).nullable().optional(),
+  page: z7.object({
+    path: z7.string()
+  }).strict()
+}).strict();
+var pageExitConfigSchema = z7.object({}).strict();
+
+// ../tracking-core/src/events/phone-click.ts
+import { z as z8 } from "zod";
+var phoneClickMetadataSchema = z8.object({
+  phone_number: z8.string(),
+  page: z8.object({
+    path: z8.string()
+  }).strict(),
+  section: z8.string().nullable().optional()
+}).strict();
+var phoneClickConfigSchema = z8.object({
+  autoCapture: z8.object({
+    selector: z8.string().optional()
+  }).strict().optional()
+}).strict();
+
+// ../tracking-core/src/events/scroll-depth.ts
+import { z as z9 } from "zod";
+var scrollDepthMetadataSchema = z9.object({
+  depth_percent: z9.number().int().min(1).max(100),
+  page: z9.object({
+    path: z9.string()
+  }).strict()
+}).strict();
+var scrollDepthConfigSchema = z9.object({
+  thresholds: z9.array(z9.number().int().min(1).max(100)).min(1)
+}).strict();
+
+// ../tracking-core/src/events/specific-page-visit.ts
+import { z as z10 } from "zod";
+var PAGE_IDENTITY_MAX_LENGTH = 64;
+var PAGE_IDENTITY_PATTERN = /^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/;
+var pageIdentitySchema = z10.string().max(PAGE_IDENTITY_MAX_LENGTH).regex(PAGE_IDENTITY_PATTERN, {
+  message: "page identity must be lowercase snake_case, start with a letter, and contain at most 64 characters"
+});
+var specificPageNameSchema = pageIdentitySchema;
+var specificPageVisitMetadataSchema = z10.object({
+  page_name: specificPageNameSchema,
+  page: z10.object({
+    path: z10.string()
+  }).strict()
+}).strict();
+var specificPageVisitConfigSchema = z10.object({
+  pages: z10.array(
+    z10.object({
+      name: specificPageNameSchema,
+      pathPattern: z10.custom((value) => value instanceof RegExp, {
+        message: "pathPattern must be a RegExp"
+      })
+    }).strict()
+  ).min(1)
+}).strict();
+
+// ../tracking-core/src/events/time-on-site.ts
+import { z as z11 } from "zod";
+var timeOnSiteMetadataSchema = z11.object({
+  duration_ms: z11.number().int().nonnegative(),
+  page: z11.object({
+    path: z11.string()
+  }).strict()
+}).strict();
+var timeOnSiteConfigSchema = z11.object({
+  thresholdSeconds: z11.number().int().positive()
+}).strict();
+
+// ../tracking-core/src/events/semantics.ts
+var EVENT_SEMANTICS = {
+  page_view: {
+    label: "Page view",
+    category: "page",
+    outcomeRole: "navigation",
+    clientVisibility: "simple"
+  },
+  time_on_site: {
+    label: "Time on site",
+    category: "engagement",
+    outcomeRole: "engagement",
+    clientVisibility: "detailed"
+  },
+  specific_page_visit: {
+    label: "Key page visit",
+    category: "engagement",
+    outcomeRole: "engagement",
+    clientVisibility: "detailed"
+  },
+  scroll_depth: {
+    label: "Scroll depth",
+    category: "engagement",
+    outcomeRole: "engagement",
+    clientVisibility: "detailed"
+  },
+  multi_page_session: {
+    label: "Multi-page session",
+    category: "engagement",
+    outcomeRole: "engagement",
+    clientVisibility: "detailed"
+  },
+  form_start: {
+    label: "Form started",
+    category: "engagement",
+    outcomeRole: "engagement",
+    clientVisibility: "simple"
+  },
+  sdk_heartbeat: {
+    label: "SDK heartbeat",
+    category: "system",
+    outcomeRole: "diagnostic",
+    clientVisibility: "hidden"
+  },
+  page_exit: {
+    label: "Page exit",
+    category: "engagement",
+    outcomeRole: "diagnostic",
+    clientVisibility: "detailed"
+  },
+  form_submit: {
+    label: "Form submitted",
+    category: "lead",
+    outcomeRole: "lead",
+    clientVisibility: "simple"
+  },
+  phone_click: {
+    label: "Phone click",
+    category: "lead",
+    outcomeRole: "lead",
+    clientVisibility: "simple"
+  },
+  cta_click: {
+    label: "CTA click",
+    category: "engagement",
+    outcomeRole: "engagement",
+    clientVisibility: "simple"
+  }
+};
+
+// ../tracking-core/src/events/registry.ts
+var EVENT_REGISTRY = {
+  // --- automatic triggers ---
+  page_view: {
+    kind: "automatic",
+    semantics: EVENT_SEMANTICS.page_view,
+    metadataSchema: pageViewMetadataSchema,
+    configSchema: pageViewConfigSchema
+  },
+  time_on_site: {
+    kind: "automatic",
+    semantics: EVENT_SEMANTICS.time_on_site,
+    metadataSchema: timeOnSiteMetadataSchema,
+    configSchema: timeOnSiteConfigSchema
+  },
+  specific_page_visit: {
+    kind: "automatic",
+    semantics: EVENT_SEMANTICS.specific_page_visit,
+    metadataSchema: specificPageVisitMetadataSchema,
+    configSchema: specificPageVisitConfigSchema
+  },
+  scroll_depth: {
+    kind: "automatic",
+    semantics: EVENT_SEMANTICS.scroll_depth,
+    metadataSchema: scrollDepthMetadataSchema,
+    configSchema: scrollDepthConfigSchema
+  },
+  multi_page_session: {
+    kind: "automatic",
+    semantics: EVENT_SEMANTICS.multi_page_session,
+    metadataSchema: multiPageSessionMetadataSchema,
+    configSchema: multiPageSessionConfigSchema
+  },
+  form_start: {
+    kind: "automatic",
+    semantics: EVENT_SEMANTICS.form_start,
+    metadataSchema: formStartMetadataSchema,
+    configSchema: formStartConfigSchema
+  },
+  // --- SDK-internal automatic (not consumer-configurable) ---
+  sdk_heartbeat: {
+    kind: "automatic",
+    semantics: EVENT_SEMANTICS.sdk_heartbeat,
+    metadataSchema: sdkHeartbeatMetadataSchema,
+    configSchema: sdkHeartbeatConfigSchema
+  },
+  page_exit: {
+    kind: "automatic",
+    semantics: EVENT_SEMANTICS.page_exit,
+    metadataSchema: pageExitMetadataSchema,
+    configSchema: pageExitConfigSchema
+  },
+  // --- manual triggers ---
+  form_submit: {
+    kind: "manual",
+    semantics: EVENT_SEMANTICS.form_submit,
+    metadataSchema: formSubmitMetadataSchema,
+    configSchema: formSubmitConfigSchema
+  },
+  phone_click: {
+    kind: "manual",
+    semantics: EVENT_SEMANTICS.phone_click,
+    metadataSchema: phoneClickMetadataSchema,
+    configSchema: phoneClickConfigSchema
+  },
+  cta_click: {
+    kind: "manual",
+    semantics: EVENT_SEMANTICS.cta_click,
+    metadataSchema: ctaClickMetadataSchema,
+    configSchema: ctaClickConfigSchema
+  }
+};
+var ALL_AUTOMATIC_EVENT_NAMES = Object.entries(EVENT_REGISTRY).filter(([, def]) => def.kind === "automatic").map(([name]) => name);
+var ALL_MANUAL_EVENT_NAMES = Object.entries(EVENT_REGISTRY).filter(([, def]) => def.kind === "manual").map(([name]) => name);
+var ALL_LEAD_EVENT_NAMES = Object.entries(EVENT_REGISTRY).filter(([, def]) => def.semantics.outcomeRole === "lead").map(([name]) => name);
+function getEventDefinition(name) {
+  return EVENT_REGISTRY[name];
+}
+
+// ../tracking-core/src/ingest-typed.ts
+function createTypedClient(raw, registry, options = {}) {
+  const debug = options.debug ?? false;
+  if (registry.manual?.form_submit) registerCapability("form_capture");
+  return {
+    trackEvent(eventType, metadata, opts) {
+      if (debug) {
+        const def = getEventDefinition(eventType);
+        def.metadataSchema.parse(metadata);
+      }
+      raw.trackEvent({
+        eventType,
+        metadata,
+        pageUrl: opts?.pageUrl ?? null,
+        occurredAt: opts?.occurredAt ?? null
+      });
+    },
+    flush: raw.flush.bind(raw),
+    getSessionId: raw.getSessionId.bind(raw),
+    getVisitorId: raw.getVisitorId.bind(raw)
+  };
+}
+
+// ../tracking-core/src/triggers/time-on-site.ts
+function attachTimeOnSite(client, config) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return () => {
+    };
+  }
+  const thresholdMs = config.thresholdSeconds * 1e3;
+  let accumulatedMs = 0;
+  let activeSince = document.visibilityState === "visible" ? Date.now() : null;
+  let timer = null;
+  let fired = false;
+  function fire() {
+    if (fired) return;
+    fired = true;
+    client.trackEvent({
+      eventType: "time_on_site",
+      metadata: {
+        duration_ms: thresholdMs,
+        page: { path: window.location.pathname }
+      },
+      pageUrl: window.location.href,
+      occurredAt: null
+    });
+  }
+  function scheduleNext() {
+    if (fired || activeSince === null) return;
+    const remaining = thresholdMs - accumulatedMs;
+    if (remaining <= 0) {
+      fire();
+      return;
+    }
+    timer = setTimeout(fire, remaining);
+  }
+  function clearTimer() {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  }
+  function onVisibilityChange() {
+    if (fired) return;
+    if (document.visibilityState === "hidden") {
+      if (activeSince !== null) {
+        accumulatedMs += Date.now() - activeSince;
+        activeSince = null;
+      }
+      clearTimer();
+    } else {
+      activeSince = Date.now();
+      scheduleNext();
+    }
+  }
+  document.addEventListener("visibilitychange", onVisibilityChange);
+  scheduleNext();
+  return () => {
+    clearTimer();
+    document.removeEventListener("visibilitychange", onVisibilityChange);
+  };
+}
+
+// ../tracking-core/src/triggers/navigation.ts
+var listeners = /* @__PURE__ */ new Set();
+var restorePatch = null;
+function notify() {
+  for (const listener of listeners) listener();
+}
+function notifyDeferred() {
+  setTimeout(notify, 0);
+}
+function installPatch() {
+  const originalPushState = history.pushState;
+  const originalReplaceState = history.replaceState;
+  function patchedPushState(...args) {
+    originalPushState.apply(this, args);
+    notifyDeferred();
+  }
+  function patchedReplaceState(...args) {
+    originalReplaceState.apply(this, args);
+    notifyDeferred();
+  }
+  history.pushState = patchedPushState;
+  history.replaceState = patchedReplaceState;
+  window.addEventListener("popstate", notify);
+  restorePatch = () => {
+    history.pushState = originalPushState;
+    history.replaceState = originalReplaceState;
+    window.removeEventListener("popstate", notify);
+    restorePatch = null;
+  };
+}
+function onHistoryChange(listener) {
+  if (listeners.size === 0) installPatch();
+  listeners.add(listener);
+  return () => {
+    if (!listeners.delete(listener)) return;
+    if (listeners.size === 0) restorePatch?.();
+  };
+}
+
+// ../tracking-core/src/triggers/scroll-measurement.ts
+var BOTTOM_EPSILON_PX = 2;
+function measureScrollPercent() {
+  const root = document.scrollingElement ?? document.documentElement;
+  const scrollHeight = root.scrollHeight;
+  const clientHeight = root.clientHeight;
+  if (scrollHeight <= 0 || clientHeight <= 0) return null;
+  if (scrollHeight <= clientHeight + BOTTOM_EPSILON_PX) return null;
+  const maxTop = scrollHeight - clientHeight;
+  const scrollTop = Math.min(Math.max(root.scrollTop, 0), maxTop);
+  if (scrollTop + clientHeight >= scrollHeight - BOTTOM_EPSILON_PX) return 100;
+  return Math.max(1, Math.min(100, Math.round((scrollTop + clientHeight) / scrollHeight * 100)));
+}
+function scheduleBaselineSnapshot(onSnapshot) {
+  let rafId = requestAnimationFrame(() => {
+    rafId = requestAnimationFrame(() => {
+      onSnapshot(measureScrollPercent());
+    });
+  });
+  return () => cancelAnimationFrame(rafId);
+}
+function createBaselineGate() {
+  let baselinePercent = null;
+  let ready = false;
+  let cancelSnapshot = null;
+  return {
+    rebaseline() {
+      cancelSnapshot?.();
+      ready = false;
+      baselinePercent = null;
+      cancelSnapshot = scheduleBaselineSnapshot((b) => {
+        baselinePercent = b;
+        ready = true;
+      });
+    },
+    cancel() {
+      cancelSnapshot?.();
+    },
+    baseline() {
+      return ready ? baselinePercent : null;
+    },
+    sample() {
+      if (!ready) return null;
+      if (baselinePercent === null) {
+        baselinePercent = measureScrollPercent();
+        return null;
+      }
+      return measureScrollPercent();
+    }
+  };
+}
+
+// ../tracking-core/src/triggers/scroll-depth.ts
+function attachScrollDepth(client, config) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return () => {
+    };
+  }
+  const thresholds = new Set(config.thresholds);
+  let firedForPath = /* @__PURE__ */ new Set();
+  let currentPath2 = window.location.pathname;
+  let rafId = null;
+  const gate = createBaselineGate();
+  function checkThresholds() {
+    const percent = gate.sample();
+    if (percent === null) return;
+    const baseline = gate.baseline();
+    if (baseline === null) return;
+    for (const threshold of thresholds) {
+      if (threshold <= baseline) continue;
+      if (percent >= threshold && !firedForPath.has(threshold)) {
+        firedForPath.add(threshold);
+        client.trackEvent({
+          eventType: "scroll_depth",
+          metadata: {
+            depth_percent: threshold,
+            page: { path: currentPath2 }
+          },
+          pageUrl: window.location.href,
+          occurredAt: null
+        });
+      }
+    }
+  }
+  function onScroll() {
+    if (rafId !== null) return;
+    rafId = requestAnimationFrame(() => {
+      rafId = null;
+      checkThresholds();
+    });
+  }
+  function resetIfPathChanged() {
+    const newPath = window.location.pathname;
+    if (newPath === currentPath2) return;
+    currentPath2 = newPath;
+    firedForPath = /* @__PURE__ */ new Set();
+    gate.rebaseline();
+  }
+  const unsubscribeNav = onHistoryChange(resetIfPathChanged);
+  window.addEventListener("scroll", onScroll, { passive: true });
+  gate.rebaseline();
+  return () => {
+    if (rafId !== null) cancelAnimationFrame(rafId);
+    gate.cancel();
+    unsubscribeNav();
+    window.removeEventListener("scroll", onScroll);
+  };
+}
+
+// ../tracking-core/src/triggers/form-start.ts
+function attachFormStart(client, config) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return () => {
+    };
+  }
+  const selector = config.selector ?? "form";
+  let firedForms = /* @__PURE__ */ new Set();
+  let currentPath2 = window.location.pathname;
+  function getFormKey(form) {
+    if (form.id) return `id:${form.id}`;
+    const explicitAction = form.getAttribute("action");
+    if (explicitAction) return `action:${explicitAction}`;
+    const forms = Array.from(document.querySelectorAll(selector));
+    return `index:${forms.indexOf(form)}`;
+  }
+  function onFocusIn(event) {
+    const target = event.target;
+    if (!(target instanceof HTMLElement)) return;
+    const form = target.closest(selector);
+    if (!form || form.tagName !== "FORM") return;
+    const key = getFormKey(form);
+    if (firedForms.has(key)) return;
+    firedForms.add(key);
+    client.trackEvent({
+      eventType: "form_start",
+      metadata: {
+        form: {
+          id: form.id || "",
+          action: form.getAttribute("action") ?? null
+        },
+        page: { path: window.location.pathname }
+      },
+      pageUrl: window.location.href,
+      occurredAt: null
+    });
+  }
+  function resetIfPathChanged() {
+    const newPath = window.location.pathname;
+    if (newPath === currentPath2) return;
+    currentPath2 = newPath;
+    firedForms = /* @__PURE__ */ new Set();
+  }
+  const originalPushState = history.pushState.bind(history);
+  const originalReplaceState = history.replaceState.bind(history);
+  function patchedPushState(...args) {
+    originalPushState(...args);
+    setTimeout(resetIfPathChanged, 0);
+  }
+  function patchedReplaceState(...args) {
+    originalReplaceState(...args);
+    setTimeout(resetIfPathChanged, 0);
+  }
+  history.pushState = patchedPushState;
+  history.replaceState = patchedReplaceState;
+  window.addEventListener("popstate", resetIfPathChanged);
+  document.addEventListener("focusin", onFocusIn);
+  return () => {
+    history.pushState = originalPushState;
+    history.replaceState = originalReplaceState;
+    window.removeEventListener("popstate", resetIfPathChanged);
+    document.removeEventListener("focusin", onFocusIn);
+  };
+}
+
+// ../tracking-core/src/triggers/page-exit.ts
+var MIN_SEGMENT_MS = 50;
+function attachPageExit(client) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return () => {
+    };
+  }
+  let currentPath2 = window.location.pathname;
+  let activeSince = document.visibilityState === "visible" ? Date.now() : null;
+  let accumulatedMs = 0;
+  let maxScrollPercent = null;
+  let rafId = null;
+  const gate = createBaselineGate();
+  function onScroll() {
+    if (rafId !== null) return;
+    rafId = requestAnimationFrame(() => {
+      rafId = null;
+      const percent = gate.sample();
+      if (percent !== null && (maxScrollPercent === null || percent > maxScrollPercent)) {
+        maxScrollPercent = percent;
+      }
+    });
+  }
+  function settledDwellMs() {
+    let total = accumulatedMs;
+    if (activeSince !== null) {
+      total += Date.now() - activeSince;
+    }
+    return Math.max(0, Math.round(total));
+  }
+  function emitSegment(path, flush) {
+    const dwell = settledDwellMs();
+    if (dwell < MIN_SEGMENT_MS) return;
+    client.trackEvent({
+      eventType: "page_exit",
+      metadata: {
+        dwell_ms: dwell,
+        max_scroll_percent: maxScrollPercent,
+        // Lets the backend tell "scrolled to the bottom" apart from "the page
+        // was barely scrollable". null = unscrollable page or the segment
+        // ended before the post-paint snapshot landed. For pages that grew
+        // after the snapshot this is the first-scroll position, not the
+        // at-load fraction (see BaselineGate.baseline).
+        scroll_baseline_percent: gate.baseline(),
+        page: { path }
+      },
+      pageUrl: window.location.href,
+      occurredAt: null
+    });
+    if (flush) {
+      client.flushBeacon();
+    }
+    accumulatedMs = 0;
+    activeSince = null;
+  }
+  function onNavigate() {
+    const newPath = window.location.pathname;
+    if (newPath === currentPath2) return;
+    emitSegment(currentPath2, false);
+    currentPath2 = newPath;
+    maxScrollPercent = null;
+    gate.rebaseline();
+    accumulatedMs = 0;
+    activeSince = document.visibilityState === "visible" ? Date.now() : null;
+  }
+  function onVisibilityChange() {
+    if (document.visibilityState === "hidden") {
+      emitSegment(currentPath2, true);
+    } else {
+      activeSince = Date.now();
+    }
+  }
+  function onPageHide() {
+    emitSegment(currentPath2, true);
+  }
+  const unsubscribeNav = onHistoryChange(onNavigate);
+  window.addEventListener("scroll", onScroll, { passive: true });
+  document.addEventListener("visibilitychange", onVisibilityChange);
+  window.addEventListener("pagehide", onPageHide);
+  gate.rebaseline();
+  return () => {
+    if (rafId !== null) cancelAnimationFrame(rafId);
+    gate.cancel();
+    unsubscribeNav();
+    window.removeEventListener("scroll", onScroll);
+    document.removeEventListener("visibilitychange", onVisibilityChange);
+    window.removeEventListener("pagehide", onPageHide);
+  };
+}
+
+// ../tracking-core/src/triggers/cta-click-capture.ts
+var DEFAULT_CTA_SELECTOR = "[data-aranova-cta]";
+var CTA_NAME_MAX_LENGTH = 120;
+function describeElement(el) {
+  const tag = el.tagName.toLowerCase();
+  return el.id ? `${tag}#${el.id}` : tag;
+}
+function resolveCtaName(el) {
+  const explicit = el.getAttribute("data-aranova-cta");
+  if (explicit && explicit.trim().length > 0) return explicit.trim();
+  const text = (el.textContent ?? "").trim().replaceAll(/\s+/g, " ");
+  if (text.length > 0) return text.slice(0, CTA_NAME_MAX_LENGTH);
+  return describeElement(el);
+}
+function attachCtaClickCapture(client, config) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return () => {
+    };
+  }
+  const autoCapture = config.autoCapture;
+  if (!autoCapture) {
+    return () => {
+    };
+  }
+  registerCapability("cta_click_capture");
+  const selector = autoCapture.selector ?? DEFAULT_CTA_SELECTOR;
+  function onClick(event) {
+    const target = event.target;
+    if (!(target instanceof Element)) return;
+    let matched = null;
+    try {
+      matched = target.closest(selector);
+    } catch {
+      return;
+    }
+    if (matched === null) return;
+    const href = matched instanceof HTMLAnchorElement ? matched.href || null : matched.getAttribute("href");
+    client.trackEvent({
+      eventType: "cta_click",
+      metadata: {
+        cta_name: resolveCtaName(matched),
+        page: { path: window.location.pathname },
+        section: matched.getAttribute("data-aranova-section"),
+        destination_url: href,
+        href,
+        element: describeElement(matched)
+      },
+      pageUrl: window.location.href,
+      occurredAt: null
+    });
+  }
+  document.addEventListener("click", onClick, true);
+  return () => {
+    document.removeEventListener("click", onClick, true);
+  };
+}
+
+// ../tracking-core/src/triggers/phone-click-capture.ts
+var DEFAULT_TEL_SELECTOR = 'a[href^="tel:"]';
+function safeDecodeURIComponent(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function resolvePhoneNumber(el) {
+  const href = el instanceof HTMLAnchorElement ? el.href : el.getAttribute("href") ?? "";
+  const raw = safeDecodeURIComponent(href.replace(/^tel:/i, "").split(";")[0]).trim();
+  return toE164(raw) ?? raw;
+}
+function attachPhoneClickCapture(client, config) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return () => {
+    };
+  }
+  const autoCapture = config.autoCapture;
+  if (!autoCapture) {
+    return () => {
+    };
+  }
+  registerCapability("phone_click_capture");
+  const selector = autoCapture.selector ?? DEFAULT_TEL_SELECTOR;
+  function onClick(event) {
+    const target = event.target;
+    if (!(target instanceof Element)) return;
+    let matched = null;
+    try {
+      matched = target.closest(selector);
+    } catch {
+      return;
+    }
+    if (matched === null) return;
+    const metadata = {
+      phone_number: resolvePhoneNumber(matched),
+      page: { path: window.location.pathname },
+      section: matched.getAttribute("data-aranova-section")
+    };
+    client.trackEvent({
+      eventType: "phone_click",
+      metadata,
+      pageUrl: window.location.href,
+      occurredAt: null
+    });
+  }
+  document.addEventListener("click", onClick, true);
+  return () => {
+    document.removeEventListener("click", onClick, true);
+  };
+}
+
+// ../tracking-core/src/resources/sales/schema.ts
+import { z as z12 } from "zod";
+var SUPPORTED_CURRENCIES = ["USD", "CAD"];
+var TRACKING_ENVIRONMENTS = ["production", "development"];
+var currencySchema = z12.enum(SUPPORTED_CURRENCIES);
+var centsSchema = z12.number().int().nonnegative();
+var quantitySchema = z12.string().regex(/^\d+(\.\d{1,3})?$/);
+var metadataSchema = z12.record(z12.unknown());
+var saleItemSchema = z12.object({
+  external_item_id: z12.string().nullable().optional(),
+  name: z12.string().nullable().optional(),
+  category: z12.string().nullable().optional(),
+  quantity: quantitySchema,
+  unit_price_cents: centsSchema,
+  // Non-negativity validated on the wire — same contract as the other cents
+  // fields — and backstopped by the DB CHECK.
+  unit_cost_cents: centsSchema.nullable().optional()
+}).strict();
+var saleServiceSchema = z12.object({
+  service: z12.string(),
+  amount_cents: centsSchema
+}).strict();
+var customerNameSchema = z12.string().max(200);
+var customerPhoneSchema = z12.string().max(64);
+var customerEmailSchema = z12.string().max(320).email();
+function refineServiceXor(val, ctx, { requireAmount }) {
+  if (val.services != null) {
+    if (val.service != null) {
+      ctx.addIssue({
+        code: z12.ZodIssueCode.custom,
+        message: "pass either `service` or `services`, not both",
+        path: ["services"]
+      });
+    }
+    if (val.services.length === 0) {
+      ctx.addIssue({
+        code: z12.ZodIssueCode.custom,
+        message: "`services` must not be empty",
+        path: ["services"]
+      });
+    }
+    const keys = val.services.map((s) => s.service);
+    if (new Set(keys).size !== keys.length) {
+      ctx.addIssue({
+        code: z12.ZodIssueCode.custom,
+        message: "`services` must not list the same service more than once",
+        path: ["services"]
+      });
+    }
+    if (val.amount_total_cents != null) {
+      const sum = val.services.reduce((acc, s) => acc + s.amount_cents, 0);
+      if (val.amount_total_cents !== sum) {
+        ctx.addIssue({
+          code: z12.ZodIssueCode.custom,
+          message: "amount_total_cents must equal the sum of the services amounts (omit it to derive it automatically)",
+          path: ["amount_total_cents"]
+        });
+      }
+    }
+  } else if (requireAmount && val.amount_total_cents == null) {
+    ctx.addIssue({
+      code: z12.ZodIssueCode.custom,
+      message: "amount_total_cents is required unless `services` is provided",
+      path: ["amount_total_cents"]
+    });
+  }
+}
+var saleCreateSchema = z12.object({
+  external_id: z12.string().nullable().optional(),
+  description: z12.string().nullable().optional(),
+  service: z12.string().nullable().optional(),
+  services: z12.array(saleServiceSchema).nullable().optional(),
+  currency: currencySchema,
+  // Optional only because the plural `services` form derives it from the sum
+  // (see refineServiceXor); the singular/serviceless path still requires it.
+  amount_total_cents: centsSchema.nullable().optional(),
+  occurred_at: z12.string().datetime(),
+  environment: z12.enum(TRACKING_ENVIRONMENTS).default("production"),
+  items: z12.array(saleItemSchema).default([]),
+  metadata: metadataSchema.nullable().optional(),
+  customer_name: customerNameSchema.nullable().optional(),
+  customer_phone: customerPhoneSchema.nullable().optional(),
+  customer_email: customerEmailSchema.nullable().optional(),
+  // CASL consent attestation: the customer agreed to receive SMS. Recorded
+  // with a timestamp server-side; every SMS send path gates on it.
+  //
+  // Tri-state: omit it (or send null) to let the server apply the business's
+  // configured default-opt-in policy, honouring a returning customer's
+  // remembered preference. Send an explicit boolean to assert consent state
+  // yourself — `false` records a deliberate opt-out.
+  sms_consent: z12.boolean().nullable().optional()
+}).strict().superRefine((val, ctx) => refineServiceXor(val, ctx, { requireAmount: true }));
+var saleUpdateSchema = z12.object({
+  description: z12.string().nullable().optional(),
+  service: z12.string().nullable().optional(),
+  services: z12.array(saleServiceSchema).nullable().optional(),
+  currency: currencySchema.optional(),
+  amount_total_cents: centsSchema.optional(),
+  occurred_at: z12.string().datetime().optional(),
+  items: z12.array(saleItemSchema).optional(),
+  metadata: metadataSchema.nullable().optional(),
+  customer_name: customerNameSchema.nullable().optional(),
+  // Re-attest when changing a filler-looking name; the server clears the
+  // prior attestation whenever `customer_name` changes.
+  customer_name_placeholder_confirmed: z12.boolean().optional(),
+  customer_phone: customerPhoneSchema.nullable().optional(),
+  customer_email: customerEmailSchema.nullable().optional(),
+  // NOT NULL server-side: omit to leave unchanged (explicit null is rejected).
+  sms_consent: z12.boolean().optional()
+}).strict().superRefine((val, ctx) => refineServiceXor(val, ctx, { requireAmount: false }));
+
+// src/hooks.ts
+function useGclid() {
+  const [gclid, setGclid] = useState(null);
+  useEffect(() => {
+    setGclid(getCookieValueFromDocument("gclid"));
+  }, []);
+  return gclid;
+}
+function useTrackingParams() {
+  const [trackingParams, setTrackingParams] = useState(createEmptyTrackingParams());
+  useEffect(() => {
+    setTrackingParams(getTrackingParamsFromCookieReader(getCookieValueFromDocument));
+  }, []);
+  return trackingParams;
+}
+var DEFAULT_CHOICE2 = {
+  state: "granted",
+  source: "default",
+  updatedAt: null,
+  expiresAt: null
+};
+function useCookiePreferences(options) {
+  registerCapability("consent_controls");
+  const [choice, setChoice] = useState(DEFAULT_CHOICE2);
+  const ttlDays = options?.declineTtlDays;
+  useEffect(() => {
+    const sync = () => setChoice(getConsentChoice());
+    sync();
+    const handleStorage = (event) => {
+      if (event.key === null || event.key === CONSENT_STATE_KEY || event.key === CONSENT_EXPIRES_AT_KEY || event.key === CONSENT_TIMESTAMP_KEY)
+        sync();
+    };
+    window.addEventListener("storage", handleStorage);
+    const unsubscribe = onConsentChange(sync);
+    return () => {
+      window.removeEventListener("storage", handleStorage);
+      unsubscribe();
+    };
+  }, []);
+  const optOutAction = useCallback(() => {
+    optOut(ttlDays != null ? { declineTtlDays: ttlDays } : void 0);
+  }, [ttlDays]);
+  const optInAction = useCallback(() => {
+    optIn();
+  }, []);
+  const reset = useCallback(() => {
+    resetConsent();
+  }, []);
+  return {
+    state: choice.state,
+    source: choice.source,
+    isDefault: choice.source === "default",
+    isGranted: choice.state === "granted",
+    isDenied: choice.state === "denied",
+    updatedAt: choice.updatedAt,
+    expiresAt: choice.expiresAt,
+    optOut: optOutAction,
+    optIn: optInAction,
+    reset
+  };
+}
+function useConsentState() {
+  return useConsent().state;
+}
+function useConsent() {
+  const {
+    state,
+    isGranted,
+    isDenied,
+    optIn: accept,
+    optOut: decline,
+    reset
+  } = useCookiePreferences();
+  return {
+    state,
+    isPending: false,
+    isGranted,
+    isDenied,
+    accept,
+    decline,
+    reset
+  };
+}
+
+// src/ConsentBanner.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var LIGHT_THEME = {
+  background: "#ffffff",
+  border: "#e5e7eb",
+  text: "#111827",
+  mutedText: "#4b5563",
+  acceptBg: "#111827",
+  acceptText: "#ffffff",
+  declineBg: "transparent",
+  declineText: "#111827",
+  declineBorder: "#d1d5db",
+  shadow: "0 -4px 16px -2px rgba(15, 23, 42, 0.08), 0 -2px 6px -1px rgba(15, 23, 42, 0.04)",
+  linkColor: "#1f2937"
+};
+var DARK_THEME = {
+  background: "#0f172a",
+  border: "#1e293b",
+  text: "#f1f5f9",
+  mutedText: "#cbd5e1",
+  acceptBg: "#f1f5f9",
+  acceptText: "#0f172a",
+  declineBg: "transparent",
+  declineText: "#f1f5f9",
+  declineBorder: "#334155",
+  shadow: "0 -4px 16px -2px rgba(0, 0, 0, 0.5), 0 -2px 6px -1px rgba(0, 0, 0, 0.3)",
+  linkColor: "#e2e8f0"
+};
+function useResolvedTheme(theme) {
+  const [prefersDark, setPrefersDark] = useState2(false);
+  useEffect2(() => {
+    if (theme !== "auto" || typeof window === "undefined" || !window.matchMedia) return;
+    const mql = window.matchMedia("(prefers-color-scheme: dark)");
+    setPrefersDark(mql.matches);
+    const onChange = (e) => setPrefersDark(e.matches);
+    mql.addEventListener("change", onChange);
+    return () => mql.removeEventListener("change", onChange);
+  }, [theme]);
+  if (theme === "dark") return DARK_THEME;
+  if (theme === "auto" && prefersDark) return DARK_THEME;
+  return LIGHT_THEME;
+}
+var DEFAULT_MESSAGE = "We use cookies to understand ad performance and improve how our marketing works across visits. You can accept or decline this tracking.";
+function ConsentBanner({
+  message,
+  title,
+  acceptLabel = "Accept",
+  declineLabel = "Decline",
+  policyHref,
+  policyLabel = "Learn more",
+  onAccept,
+  onDecline,
+  position = "bottom",
+  theme = "light",
+  className,
+  style
+} = {}) {
+  const { isPending, accept, decline } = useConsent();
+  const tokens = useResolvedTheme(theme);
+  const [hasMounted, setHasMounted] = useState2(false);
+  useEffect2(() => {
+    setHasMounted(true);
+  }, []);
+  if (!hasMounted || !isPending) return null;
+  const wrapperStyle = {
+    position: "fixed",
+    left: 0,
+    right: 0,
+    [position]: 0,
+    zIndex: 2147483640,
+    background: tokens.background,
+    color: tokens.text,
+    borderTop: position === "bottom" ? `1px solid ${tokens.border}` : "none",
+    borderBottom: position === "top" ? `1px solid ${tokens.border}` : "none",
+    boxShadow: tokens.shadow,
+    padding: "16px 20px",
+    boxSizing: "border-box",
+    animation: `${ANIMATION_NAME}-${position} 200ms ease-out`,
+    fontFamily: 'system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif',
+    ...style
+  };
+  const innerStyle = {
+    maxWidth: 1100,
+    margin: "0 auto",
+    display: "flex",
+    flexWrap: "wrap",
+    gap: 16,
+    alignItems: "center",
+    justifyContent: "space-between"
+  };
+  const messageStyle = {
+    flex: "1 1 320px",
+    margin: 0,
+    fontSize: 14,
+    lineHeight: 1.5,
+    color: tokens.mutedText
+  };
+  const titleStyle = {
+    margin: "0 0 4px 0",
+    fontSize: 14,
+    fontWeight: 600,
+    color: tokens.text
+  };
+  const actionsStyle = {
+    display: "flex",
+    gap: 8,
+    flexShrink: 0
+  };
+  const buttonBase = {
+    appearance: "none",
+    fontFamily: "inherit",
+    fontSize: 14,
+    fontWeight: 500,
+    padding: "8px 16px",
+    borderRadius: 6,
+    cursor: "pointer",
+    border: "1px solid transparent",
+    transition: "opacity 120ms ease"
+  };
+  const declineStyle = {
+    ...buttonBase,
+    background: tokens.declineBg,
+    color: tokens.declineText,
+    borderColor: tokens.declineBorder
+  };
+  const acceptStyle = {
+    ...buttonBase,
+    background: tokens.acceptBg,
+    color: tokens.acceptText
+  };
+  const linkStyle = {
+    color: tokens.linkColor,
+    textDecoration: "underline",
+    textUnderlineOffset: 2
+  };
+  const handleAccept = () => {
+    accept();
+    onAccept?.();
+  };
+  const handleDecline = () => {
+    decline();
+    onDecline?.();
+  };
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("style", { children: ANIMATION_KEYFRAMES }),
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        role: "dialog",
+        "aria-live": "polite",
+        "aria-label": "Cookie consent",
+        className,
+        style: wrapperStyle,
+        children: /* @__PURE__ */ jsxs("div", { style: innerStyle, children: [
+          /* @__PURE__ */ jsxs("div", { style: { flex: "1 1 320px" }, children: [
+            title ? /* @__PURE__ */ jsx("p", { style: titleStyle, children: title }) : null,
+            /* @__PURE__ */ jsxs("p", { style: messageStyle, children: [
+              message ?? DEFAULT_MESSAGE,
+              policyHref ? /* @__PURE__ */ jsxs(Fragment, { children: [
+                " ",
+                /* @__PURE__ */ jsx("a", { href: policyHref, style: linkStyle, children: policyLabel })
+              ] }) : null
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { style: actionsStyle, children: [
+            /* @__PURE__ */ jsx("button", { type: "button", onClick: handleDecline, style: declineStyle, children: declineLabel }),
+            /* @__PURE__ */ jsx("button", { type: "button", onClick: handleAccept, style: acceptStyle, children: acceptLabel })
+          ] })
+        ] })
+      }
+    )
+  ] });
+}
+var ANIMATION_NAME = "aranova-consent-banner";
+var ANIMATION_KEYFRAMES = `
+@keyframes ${ANIMATION_NAME}-bottom {
+  from { transform: translateY(100%); opacity: 0; }
+  to   { transform: translateY(0);    opacity: 1; }
+}
+@keyframes ${ANIMATION_NAME}-top {
+  from { transform: translateY(-100%); opacity: 0; }
+  to   { transform: translateY(0);     opacity: 1; }
+}
+`;
+
+// src/AdPlatformTracking.tsx
+import Script from "next/script";
+import { useEffect as useEffect3 } from "react";
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function AdPlatformTracking({
+  gtagId,
+  gtagIds,
+  trackingConfig,
+  standalonePageView = false,
+  metaPixelId,
+  metaPixelIds
+}) {
+  const trackingConfigKey2 = trackingConfig ? `${resolveTrackingConfigUrl(trackingConfig)}:${trackingConfig.businessId}:${trackingConfig.environment}` : "";
+  useEffect3(() => {
+    if (!trackingConfig) return;
+    const runtime = getTrackingConfigRuntime(trackingConfig);
+    if (standalonePageView) runtime.queuePageView();
+    else runtime.start();
+  }, [trackingConfigKey2, standalonePageView]);
+  const gtagAll = trackingConfig ? [] : gtagIds ? Object.values(gtagIds).filter((id) => id != null) : gtagId ? [gtagId] : [];
+  const metaAll = metaPixelIds ? Object.values(metaPixelIds).filter((id) => id != null) : metaPixelId ? [metaPixelId] : [];
+  if (trackingConfig || gtagAll.length > 0) registerCapability("ad_tags_google");
+  if (metaAll.length > 0) registerCapability("ad_tags_meta");
+  const gtagLoaderId = gtagAll[0];
+  const gtagInitScript = gtagAll.length === 1 ? createGtagInitScript(gtagAll[0]) : createGtagInitScriptMulti(gtagAll);
+  const metaInitScript = metaAll.length === 1 ? createMetaPixelInitScript(metaAll[0]) : createMetaPixelInitScriptMulti(metaAll);
+  return /* @__PURE__ */ jsxs2(Fragment2, { children: [
+    gtagLoaderId ? /* @__PURE__ */ jsxs2(Fragment2, { children: [
+      /* @__PURE__ */ jsx2(Script, { id: "consent-default", strategy: "beforeInteractive", children: createConsentDefaultScript() }),
+      /* @__PURE__ */ jsx2(
+        Script,
+        {
+          src: `https://www.googletagmanager.com/gtag/js?id=${encodeURIComponent(gtagLoaderId)}`,
+          strategy: "afterInteractive"
+        }
+      ),
+      /* @__PURE__ */ jsx2(Script, { id: "gtag-init", strategy: "afterInteractive", children: gtagInitScript })
+    ] }) : null,
+    metaAll.length > 0 ? /* @__PURE__ */ jsxs2(Fragment2, { children: [
+      /* @__PURE__ */ jsx2(Script, { id: "meta-pixel-base", strategy: "afterInteractive", children: createMetaConsentDefaultScript() }),
+      /* @__PURE__ */ jsx2(Script, { id: "meta-pixel-init", strategy: "afterInteractive", children: metaInitScript })
+    ] }) : null
+  ] });
+}
+
+// src/GoogleAdsTracking.tsx
+import Script2 from "next/script";
+import { Fragment as Fragment3, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function GoogleAdsTracking(props) {
+  const { gtagId, gtagIds } = props;
+  const allIds = gtagIds ? Object.values(gtagIds).filter((id) => id != null) : gtagId ? [gtagId] : [];
+  if (allIds.length === 0) return null;
+  const loaderId = allIds[0];
+  const initScript = allIds.length === 1 ? createGtagInitScript(loaderId) : createGtagInitScriptMulti(allIds);
+  return /* @__PURE__ */ jsxs3(Fragment3, { children: [
+    /* @__PURE__ */ jsx3(Script2, { id: "consent-default", strategy: "beforeInteractive", children: createConsentDefaultScript() }),
+    /* @__PURE__ */ jsx3(
+      Script2,
+      {
+        src: `https://www.googletagmanager.com/gtag/js?id=${encodeURIComponent(loaderId)}`,
+        strategy: "afterInteractive"
+      }
+    ),
+    /* @__PURE__ */ jsx3(Script2, { id: "gtag-init", strategy: "afterInteractive", children: initScript })
+  ] });
+}
+
+// src/factory.tsx
+import { usePathname, useSearchParams } from "next/navigation";
+
+// package.json
+var version = "0.25.0";
+
+// src/factory.tsx
+import {
+  createContext as createContext2,
+  Suspense,
+  useCallback as useCallback3,
+  useContext as useContext2,
+  useEffect as useEffect4,
+  useMemo as useMemo2,
+  useRef
+} from "react";
+
+// ../tracking-core/src/phone-react.tsx
+import {
+  createContext,
+  forwardRef,
+  useCallback as useCallback2,
+  useContext,
+  useMemo,
+  useState as useState3
+} from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var _phoneConfigContext;
+function phoneConfigContext() {
+  return _phoneConfigContext ?? (_phoneConfigContext = createContext(null));
+}
+function PhoneConfigProvider({
+  value,
+  children
+}) {
+  const Ctx = phoneConfigContext();
+  return /* @__PURE__ */ jsx4(Ctx.Provider, { value, children });
+}
+function usePhoneConfig() {
+  const ctx = useContext(phoneConfigContext());
+  return {
+    defaultCountry: ctx?.defaultCountry ?? DEFAULT_PHONE_COUNTRY,
+    display: ctx?.display ?? "national"
+  };
+}
+function usePhoneField(opts = {}) {
+  registerCapability("phone_fields");
+  const cfg = usePhoneConfig();
+  const country = opts.country ?? cfg.defaultCountry;
+  const display = opts.display ?? cfg.display;
+  const { onValueChange } = opts;
+  const [value, setValue] = useState3(() => formatPhoneAsTyped(opts.defaultValue ?? "", country));
+  const [touched, setTouched] = useState3(false);
+  const parsed = useMemo(() => parsePhone(value, country), [value, country]);
+  const onChange = useCallback2(
+    (event) => {
+      const next = formatPhoneAsTyped(event.target.value, country);
+      setValue(next);
+      onValueChange?.(parsePhone(next, country).e164);
+    },
+    [country, onValueChange]
+  );
+  const onBlur = useCallback2(
+    (_event) => {
+      setTouched(true);
+      setValue((current) => {
+        const p = parsePhone(current, country);
+        return p.isValid ? formatPhone(current, display, country) : current;
+      });
+    },
+    [country, display]
+  );
+  const error = touched && value.length > 0 && !parsed.isValid ? "Enter a valid phone number" : null;
+  return {
+    value,
+    e164: parsed.e164,
+    isValid: parsed.isValid,
+    error,
+    parsed,
+    inputProps: { value, onChange, onBlur, type: "tel", inputMode: "tel", autoComplete: "tel" }
+  };
+}
+var PhoneField = forwardRef(function PhoneField2({ country, value, defaultValue, onChange, onE164Change, ...rest }, ref) {
+  const cfg = usePhoneConfig();
+  const resolvedCountry = country ?? cfg.defaultCountry;
+  const isControlled = value !== void 0;
+  const [internal, setInternal] = useState3(
+    () => formatPhoneAsTyped(defaultValue ?? "", resolvedCountry)
+  );
+  const handleChange = (event) => {
+    const formatted = formatPhoneAsTyped(event.target.value, resolvedCountry);
+    event.target.value = formatted;
+    onE164Change?.(parsePhone(formatted, resolvedCountry).e164);
+    if (!isControlled) setInternal(formatted);
+    onChange?.(event);
+  };
+  const shown = isControlled ? formatPhoneAsTyped(value, resolvedCountry) : internal;
+  return /* @__PURE__ */ jsx4(
+    "input",
+    {
+      ...rest,
+      ref,
+      type: "tel",
+      inputMode: "tel",
+      autoComplete: "tel",
+      value: shown,
+      onChange: handleChange
+    }
+  );
+});
+
+// src/factory.tsx
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+function PageViewTracker({ fire }) {
+  const pathname = usePathname();
+  const searchParams = useSearchParams();
+  useEffect4(() => {
+    fire();
+  }, [pathname, searchParams, fire]);
+  return null;
+}
+function createTracking(options) {
+  const {
+    apiKey,
+    endpoint,
+    triggers,
+    environment,
+    gtagIds,
+    debug,
+    phone,
+    conversionConfig,
+    trackingConfig
+  } = options;
+  registerCapability("base_tracking");
+  if (trackingConfig) registerCapability("conversion_goals_auto");
+  if (!apiKey || !endpoint) {
+    if (apiKey || endpoint) {
+      console.warn(
+        "[AranovaTracking] createTracking() requires both `apiKey` and `endpoint`. Tracking is disabled for this session."
+      );
+    }
+    const noopClient = {
+      trackEvent: () => {
+      },
+      flush: async () => {
+      },
+      getSessionId: () => "",
+      getVisitorId: () => ""
+    };
+    return {
+      TrackingProvider: ({ children }) => /* @__PURE__ */ jsx5(PhoneConfigProvider, { value: phone ?? null, children }),
+      useTracking: () => noopClient
+    };
+  }
+  const TrackingContext = createContext2(null);
+  const specificPageVisitConfig = triggers.automatic.specific_page_visit ?? null;
+  const timeOnSiteConfig = triggers.automatic.time_on_site ?? null;
+  function TrackingProvider({ children }) {
+    const pathname = usePathname();
+    const rawClient = useMemo2(
+      () => getOrCreateTrackingClient({
+        apiKey,
+        endpoint,
+        surface: "next",
+        packageName: "@aranova/tracking-next",
+        sdkVersion: version,
+        triggers,
+        environment,
+        activeGtagIds: gtagIds,
+        debug
+      }),
+      []
+    );
+    const conversionStore = useMemo2(
+      () => trackingConfig ? getTrackingConfigRuntime(trackingConfig) : conversionConfig ? resolveConversionConfig({
+        cdnUrl: conversionConfig.cdnUrl,
+        baked: conversionConfig.baked
+      }) : null,
+      []
+    );
+    const wrapClient = useMemo2(() => {
+      const autoFire = conversionStore ? createConversionAutoFire(conversionStore) : null;
+      return (c) => autoFire ? withConversionAutoFire(c, autoFire) : c;
+    }, [conversionStore]);
+    const client = useMemo2(
+      () => createTypedClient(wrapClient(rawClient), triggers, { debug }),
+      [rawClient, wrapClient]
+    );
+    useEffect4(() => {
+      if (trackingConfig && conversionStore && "start" in conversionStore) {
+        conversionStore.start();
+      }
+    }, [conversionStore]);
+    const firePageView = useCallback3(() => {
+      fireManualPageView(wrapClient(rawClient));
+      if (trackingConfig) getTrackingConfigRuntime(trackingConfig).queuePageView();
+    }, [rawClient, wrapClient]);
+    const firedPagesRef = useRef(/* @__PURE__ */ new Set());
+    useEffect4(() => {
+      if (!specificPageVisitConfig || pathname === null) return;
+      const detectorClient = wrapClient(rawClient);
+      for (const { name, pathPattern } of specificPageVisitConfig.pages) {
+        if (!pathPattern.test(pathname)) continue;
+        const key = `${name}:${pathname}`;
+        if (firedPagesRef.current.has(key)) continue;
+        firedPagesRef.current.add(key);
+        detectorClient.trackEvent({
+          eventType: "specific_page_visit",
+          metadata: {
+            page_name: name,
+            page: { path: pathname }
+          },
+          pageUrl: null,
+          occurredAt: null
+        });
+      }
+    }, [pathname, rawClient, wrapClient]);
+    const multiPageSessionConfig = triggers.automatic.multi_page_session ?? null;
+    const mpsLastPathRef = useRef(null);
+    useEffect4(() => {
+      if (!multiPageSessionConfig || pathname === null) return;
+      if (pathname === mpsLastPathRef.current) return;
+      mpsLastPathRef.current = pathname;
+      const MPS_PATHS_KEY = "aranova_tracking_mps_paths";
+      const MPS_SESSION_KEY = "aranova_tracking_mps_session";
+      const MPS_FIRED_KEY = "aranova_tracking_mps_fired";
+      try {
+        const store = window.sessionStorage;
+        const currentSession = getOrRotateSessionId().id;
+        const storedSession = store.getItem(MPS_SESSION_KEY);
+        if (storedSession !== currentSession) {
+          store.setItem(MPS_SESSION_KEY, currentSession);
+          store.removeItem(MPS_PATHS_KEY);
+          store.removeItem(MPS_FIRED_KEY);
+        }
+        if (store.getItem(MPS_FIRED_KEY) === "1") return;
+        const raw = store.getItem(MPS_PATHS_KEY);
+        const paths = raw ? new Set(JSON.parse(raw)) : /* @__PURE__ */ new Set();
+        paths.add(pathname);
+        store.setItem(MPS_PATHS_KEY, JSON.stringify([...paths]));
+        if (paths.size >= multiPageSessionConfig.pageThreshold) {
+          store.setItem(MPS_FIRED_KEY, "1");
+          wrapClient(rawClient).trackEvent({
+            eventType: "multi_page_session",
+            metadata: {
+              page_count: paths.size,
+              page: { path: pathname }
+            },
+            pageUrl: null,
+            occurredAt: null
+          });
+        }
+      } catch {
+      }
+    }, [multiPageSessionConfig, pathname, rawClient, wrapClient]);
+    useEffect4(() => {
+      return attachClientCapturesOnce(rawClient, () => {
+        const detachers = [];
+        const detectorClient = wrapClient(rawClient);
+        detachers.push(attachPageExit(detectorClient));
+        detachers.push(attachBfcacheRestore(detectorClient));
+        if (timeOnSiteConfig) {
+          detachers.push(attachTimeOnSite(detectorClient, timeOnSiteConfig));
+        }
+        const scrollDepth = triggers.automatic.scroll_depth;
+        if (scrollDepth) {
+          detachers.push(attachScrollDepth(detectorClient, scrollDepth));
+        }
+        const formStart = triggers.automatic.form_start;
+        if (formStart) {
+          detachers.push(attachFormStart(detectorClient, formStart));
+        }
+        const ctaClick = triggers.manual?.cta_click;
+        if (ctaClick) {
+          detachers.push(attachCtaClickCapture(detectorClient, ctaClick));
+        }
+        const phoneClick = triggers.manual?.phone_click;
+        if (phoneClick) {
+          detachers.push(attachPhoneClickCapture(detectorClient, phoneClick));
+        }
+        return () => {
+          for (let i = detachers.length - 1; i >= 0; i--) {
+            detachers[i]();
+          }
+        };
+      });
+    }, [rawClient, wrapClient]);
+    return /* @__PURE__ */ jsxs4(TrackingContext.Provider, { value: client, children: [
+      /* @__PURE__ */ jsx5(Suspense, { fallback: null, children: /* @__PURE__ */ jsx5(PageViewTracker, { fire: firePageView }) }),
+      /* @__PURE__ */ jsx5(PhoneConfigProvider, { value: phone ?? null, children })
+    ] });
+  }
+  function useTracking() {
+    const client = useContext2(TrackingContext);
+    if (client === null) {
+      throw new Error(
+        "useTracking must be called inside a <TrackingProvider> returned by createTracking()"
+      );
+    }
+    return client;
+  }
+  return { TrackingProvider, useTracking };
+}
+export {
+  AdPlatformTracking,
+  ConsentBanner,
+  GoogleAdsTracking,
+  PhoneField,
+  createTracking,
+  useConsent,
+  useConsentState,
+  useCookiePreferences,
+  useGclid,
+  usePhoneConfig,
+  usePhoneField,
+  useTrackingParams
+};
+//# sourceMappingURL=client.mjs.map