@aranova/tracking-react 1.0.0 → 1.2.0

package/dist/client.js

@@ -294,6 +294,7 @@ var TRACKING_CAPABILITIES = [
   "consent_controls",
   "conversion_goals_auto",
   "conversion_goals_manual",
+  "cross_site_linker",
   "cta_click_capture",
   "form_capture",
   "phone_click_capture",
@@ -320,6 +321,9 @@ function readDomMarkers() {
   return found;
 }
 
+// ../tracking-core/src/cross-site-link.ts
+var z = __toESM(require("zod/mini"));
+
 // ../tracking-core/src/tracking.ts
 var TRACKING_COOKIE_MAX_AGE_SECONDS = 7776e3;
 var TRACKING_PARAM_KEYS = [
@@ -687,6 +691,244 @@ function buildLandingPayloadFields(sessionId, override) {
   };
 }
 
+// ../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 adoptVisitorId(visitorId) {
+  if (typeof window === "undefined" || visitorId.length === 0) return false;
+  const existing = readLocalStorage(VISITOR_STORAGE_KEY);
+  if (existing && existing.length > 0) return false;
+  writeLocalStorage(VISITOR_STORAGE_KEY, visitorId);
+  return readLocalStorage(VISITOR_STORAGE_KEY) === visitorId;
+}
+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/cross-site-link.ts
+var LINK_PARAM = "_arv";
+var LINK_TOKEN_VERSION = "1";
+var LINK_TOKEN_TTL_MS = 5 * 60 * 1e3;
+var FUTURE_SKEW_MS = 60 * 1e3;
+var CARRIED_KEYS = {
+  g: "gclid",
+  w: "wbraid",
+  gb: "gbraid",
+  f: "fbclid",
+  y: "ylpcid"
+};
+var CARRIED_ENTRIES = Object.entries(CARRIED_KEYS);
+var identifier = z.string().check(z.minLength(1), z.maxLength(128));
+var optionalIdentifier = z.optional(identifier);
+var linkTokenSchema = z.object({
+  v: identifier,
+  s: identifier,
+  // Epoch ms in base36.
+  t: z.string().check(z.regex(/^[0-9a-z]{1,12}$/)),
+  g: optionalIdentifier,
+  w: optionalIdentifier,
+  gb: optionalIdentifier,
+  f: optionalIdentifier,
+  fc: optionalIdentifier,
+  y: optionalIdentifier
+});
+function toBase64Url(input) {
+  const bytes = new TextEncoder().encode(input);
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromBase64Url(input) {
+  try {
+    const padded = input.replace(/-/g, "+").replace(/_/g, "/");
+    const binary = atob(padded + "=".repeat((4 - padded.length % 4) % 4));
+    const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+    return new TextDecoder().decode(bytes);
+  } catch {
+    return null;
+  }
+}
+function encodeLinkToken(payload) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(payload)) {
+    if (typeof value === "string" && value.length > 0) params.set(key, value);
+  }
+  return `${LINK_TOKEN_VERSION}.${toBase64Url(params.toString())}`;
+}
+function decodeLinkToken(raw) {
+  const dot = raw.indexOf(".");
+  if (dot <= 0 || raw.slice(0, dot) !== LINK_TOKEN_VERSION) return null;
+  const decoded = fromBase64Url(raw.slice(dot + 1));
+  if (decoded === null) return null;
+  const params = new URLSearchParams(decoded);
+  const candidate = {};
+  params.forEach((value, key) => {
+    candidate[key] = value;
+  });
+  const result = linkTokenSchema.safeParse(candidate);
+  return result.success ? result.data : null;
+}
+function payloadToLink(payload) {
+  const carried = {};
+  for (const [wire, param] of CARRIED_ENTRIES) {
+    const value = payload[wire];
+    if (value) carried[param] = value;
+  }
+  return {
+    visitorId: payload.v,
+    sessionId: payload.s,
+    linkedAt: Number.parseInt(payload.t, 36),
+    carried,
+    fbc: payload.fc ?? null
+  };
+}
+function stripWww(hostname) {
+  return hostname.toLowerCase().replace(/^www\./, "");
+}
+function isSiblingHost(hostname, sibling) {
+  const host = stripWww(hostname);
+  const target = stripWww(sibling);
+  return host === target || host.endsWith(`.${target}`);
+}
+function resolveCrossSiteLink(url, linkedHostnames, now = Date.now()) {
+  if (typeof window === "undefined" || linkedHostnames.length === 0) return null;
+  let target;
+  try {
+    target = new URL(url, window.location.href);
+  } catch {
+    return null;
+  }
+  if (target.protocol !== "http:" && target.protocol !== "https:") return null;
+  const here = window.location.hostname;
+  if (here && isSiblingHost(target.hostname, here)) return null;
+  const hostname = linkedHostnames.find((sibling) => isSiblingHost(target.hostname, sibling));
+  if (hostname === void 0) return null;
+  const consent = getConsentChoice();
+  if (consent.state === "denied" && consent.source === "explicit") {
+    return { hostname, decorated: url };
+  }
+  target.searchParams.set(LINK_PARAM, buildOutboundLinkToken(now));
+  return { hostname, decorated: target.href };
+}
+function stripLinkParam(url) {
+  try {
+    const parsed = new URL(url, typeof window === "undefined" ? void 0 : window.location.href);
+    if (!parsed.searchParams.has(LINK_PARAM)) return url;
+    parsed.searchParams.delete(LINK_PARAM);
+    return parsed.href;
+  } catch {
+    return url;
+  }
+}
+function stripLinkParamFromSearch(search) {
+  if (!search.includes(LINK_PARAM)) return search;
+  const params = new URLSearchParams(search);
+  if (!params.has(LINK_PARAM)) return search;
+  params.delete(LINK_PARAM);
+  const rest = params.toString();
+  return rest.length > 0 ? `?${rest}` : "";
+}
+function readCarried() {
+  const out = {};
+  for (const [wire, param] of CARRIED_ENTRIES) {
+    const value = readCookieValue(param);
+    if (value) out[wire] = value;
+  }
+  return out;
+}
+function buildOutboundLinkToken(now = Date.now()) {
+  const fbc = getFbcCookie();
+  return encodeLinkToken({
+    v: getVisitorId(),
+    s: getOrRotateSessionId(now).id,
+    t: now.toString(36),
+    ...readCarried(),
+    ...fbc ? { fc: fbc } : {}
+  });
+}
+function decorateCrossSiteUrl(url, linkedHostnames, now = Date.now()) {
+  return resolveCrossSiteLink(url, linkedHostnames, now)?.decorated ?? url;
+}
+function consumeInboundLink(href = typeof window === "undefined" ? "" : window.location.href, now = Date.now()) {
+  if (typeof window === "undefined" || !href) return null;
+  let raw;
+  try {
+    raw = new URL(href, window.location.href).searchParams.get(LINK_PARAM);
+  } catch {
+    return null;
+  }
+  if (!raw) return null;
+  const payload = decodeLinkToken(raw);
+  if (payload === null) return { outcome: "invalid", link: null, adoptedVisitor: false };
+  const link = payloadToLink(payload);
+  const age = now - link.linkedAt;
+  if (!Number.isFinite(age) || age < -FUTURE_SKEW_MS) {
+    return { outcome: "invalid", link: null, adoptedVisitor: false };
+  }
+  if (age > LINK_TOKEN_TTL_MS) {
+    return { outcome: "stale", link: null, adoptedVisitor: false };
+  }
+  const adoptedVisitor = adoptVisitorId(link.visitorId);
+  for (const [param, value] of Object.entries(link.carried)) {
+    if (!readCookieValue(param)) setTrackingCookie(param, value);
+  }
+  if (link.fbc && !getFbcCookie()) persistCookieValue(FBC_COOKIE, link.fbc);
+  return { outcome: "linked", link, adoptedVisitor };
+}
+function stripLinkParamFromLocation() {
+  if (typeof window === "undefined" || typeof history === "undefined") return;
+  const clean = stripLinkParam(window.location.href);
+  if (clean === window.location.href) return;
+  try {
+    history.replaceState(null, "", clean);
+  } catch {
+  }
+}
+
 // ../tracking-core/src/resources/conversion-firing.ts
 var DEDUP_PREFIX = "_aranova_conv_";
 function dedupKey(input) {
@@ -793,7 +1035,8 @@ function parseConversionConfig(raw) {
     gtag_ids: isStringMap(obj.gtag_ids) ? obj.gtag_ids : {},
     meta_pixel_ids: isStringMap(obj.meta_pixel_ids) ? obj.meta_pixel_ids : {},
     services,
-    goals
+    goals,
+    linked_hostnames: Array.isArray(obj.linked_hostnames) ? obj.linked_hostnames.filter((h) => typeof h === "string" && h.length > 0) : []
   };
 }
 var CACHE_PREFIX = "_aranova_cfg_";
@@ -877,6 +1120,7 @@ function resolveConversionConfig(options) {
     getFiring: (key) => goalsByKey.get(key)?.firing ?? null,
     getGoal: (key) => goalsByKey.get(key) ?? null,
     listGoals: () => [...goalsByKey.values()],
+    linkedHostnames: () => current?.linked_hostnames ?? [],
     current: () => current,
     isReady: () => current !== null,
     onResolve: (listener) => {
@@ -1061,7 +1305,7 @@ function validateConfig(config, ref) {
 function pageViewSnapshot() {
   if (typeof window === "undefined" || typeof document === "undefined") return null;
   return {
-    href: window.location.href,
+    href: stripLinkParam(window.location.href),
     title: document.title || null,
     referrer: document.referrer || null
   };
@@ -1212,6 +1456,10 @@ var TrackingConfigRuntime = class {
   listGoals() {
     return this.current?.goals ?? [];
   }
+  /** Sibling hostnames for the linker — read from the cached object even while unconfirmed. */
+  linkedHostnames() {
+    return this.current?.linked_hostnames ?? [];
+  }
   async revalidateNow() {
     try {
       const headers = {};
@@ -1449,83 +1697,32 @@ function withConversionAutoFire(client, autoFire) {
   };
 }
 
-// ../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/page-view.ts
 var import_mini = require("zod/mini");
 
 // ../tracking-core/src/events/page-view.ts
-var z = __toESM(require("zod/mini"));
-var pageViewMetadataSchema = z.strictObject({
-  page: z.strictObject({
-    title: z.nullable(z.string()),
-    path: z.string(),
-    search: z.string(),
-    hash: z.string()
+var z2 = __toESM(require("zod/mini"));
+var pageViewMetadataSchema = z2.strictObject({
+  page: z2.strictObject({
+    title: z2.nullable(z2.string()),
+    path: z2.string(),
+    search: z2.string(),
+    hash: z2.string()
   }),
-  referrer: z.nullable(z.string()),
+  referrer: z2.nullable(z2.string()),
   // Optional + nullable — 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.optional(
-    z.nullable(
-      z.strictObject({
-        w: z.number(),
-        h: z.number()
+  viewport: z2.optional(
+    z2.nullable(
+      z2.strictObject({
+        w: z2.number(),
+        h: z2.number()
       })
     )
   )
 });
-var pageViewConfigSchema = z.strictObject({});
+var pageViewConfigSchema = z2.strictObject({});
 
 // ../tracking-core/src/page-view.ts
 var LAST_FIRED_URL_STORAGE_KEY = "aranova_tracking_last_fired_url";
@@ -1565,7 +1762,7 @@ function buildPageViewMetadata(referrerOverride) {
     page: {
       title: document.title || null,
       path: window.location.pathname,
-      search: window.location.search,
+      search: stripLinkParamFromSearch(window.location.search),
       hash: window.location.hash
     },
     referrer: referrerOverride !== void 0 ? referrerOverride : document.referrer || null,
@@ -1864,11 +2061,19 @@ function createTrackingClient(config) {
   let firstPage = null;
   let initialParams = createEmptyTrackingParams();
   let destroyed = false;
+  let inboundLink = null;
+  if (typeof window !== "undefined") {
+    try {
+      inboundLink = consumeInboundLink();
+    } catch {
+    }
+  }
+  let originLink = inboundLink?.link ?? null;
   const visitorId = getVisitorId();
   const initialSession = getOrRotateSessionId();
   let sessionId = initialSession.id;
   if (typeof window !== "undefined") {
-    firstPage = window.location.href;
+    firstPage = stripLinkParam(window.location.href);
     try {
       initialParams = captureTrackingParamsFromLocation();
     } catch {
@@ -1879,25 +2084,50 @@ function createTrackingClient(config) {
     } catch {
     }
   }
-  function enqueueHeartbeat() {
-    const metadata = buildHeartbeatMetadata(
-      config.surface,
-      sdkVersion,
-      packageName,
-      config.triggers ?? null,
-      activeGtagIds,
-      config.configSiteId ?? null
-    );
+  function currentPageUrl() {
+    return typeof window === "undefined" ? null : stripLinkParam(window.location.href);
+  }
+  function enqueueInternal(eventType, metadata, pageUrl) {
     queue.push({
-      event_type: "sdk_heartbeat",
-      page_url: typeof window === "undefined" ? null : window.location.href,
+      event_type: eventType,
+      page_url: pageUrl,
       metadata,
       occurred_at: (/* @__PURE__ */ new Date()).toISOString()
     });
   }
+  function enqueueHeartbeat() {
+    enqueueInternal(
+      "sdk_heartbeat",
+      buildHeartbeatMetadata(
+        config.surface,
+        sdkVersion,
+        packageName,
+        config.triggers ?? null,
+        activeGtagIds,
+        config.configSiteId ?? null
+      ),
+      currentPageUrl()
+    );
+  }
   if (initialSession.isNew) {
     enqueueHeartbeat();
   }
+  if (inboundLink !== null && typeof window !== "undefined") {
+    const link = inboundLink.link;
+    enqueueInternal(
+      "site_link_arrival",
+      {
+        outcome: inboundLink.outcome,
+        origin_session_id: link?.sessionId ?? null,
+        origin_visitor_id: link?.visitorId ?? null,
+        transit_ms: link ? Math.max(0, Date.now() - link.linkedAt) : null,
+        adopted_visitor: inboundLink.adoptedVisitor,
+        page: { path: window.location.pathname }
+      },
+      firstPage
+    );
+    scheduleFlush();
+  }
   if (pending.length > 0) {
     scheduleFlush();
   }
@@ -1905,6 +2135,7 @@ function createTrackingClient(config) {
     const rotated = getOrRotateSessionId();
     if (rotated.isNew && rotated.id !== sessionId) {
       enqueueHeartbeat();
+      originLink = null;
     }
     sessionId = rotated.id;
     const params = mergeTrackingParams(readTrackingParams(), initialParams);
@@ -1935,6 +2166,11 @@ function createTrackingClient(config) {
       // landing), reused from the stored record otherwise. Keys are omitted
       // entirely when the landing isn't observable (SSR).
       ...buildLandingPayloadFields(sessionId),
+      ...originLink ? {
+        origin_session_id: originLink.sessionId,
+        origin_visitor_id: originLink.visitorId,
+        origin_linked_at: new Date(originLink.linkedAt).toISOString()
+      } : {},
       first_page: firstPage,
       consent_state: consentSnapshot(),
       context
@@ -2011,7 +2247,8 @@ function createTrackingClient(config) {
     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),
+      // A caller's href still carries `_arv` until the surface strips it after hydration.
+      page_url: input.pageUrl != null ? stripLinkParam(input.pageUrl) : currentPageUrl(),
       metadata: input.metadata ?? null,
       occurred_at: occurredAt
     });
@@ -2061,112 +2298,112 @@ function createTrackingClient(config) {
 var import_mini2 = require("zod/mini");
 
 // ../tracking-core/src/events/cta-click.ts
-var z2 = __toESM(require("zod/mini"));
-var ctaClickMetadataSchema = z2.strictObject({
-  cta_name: z2.string(),
-  page: z2.strictObject({
-    path: z2.string()
+var z3 = __toESM(require("zod/mini"));
+var ctaClickMetadataSchema = z3.strictObject({
+  cta_name: z3.string(),
+  page: z3.strictObject({
+    path: z3.string()
   }),
-  section: z2.optional(z2.nullable(z2.string())),
-  destination_url: z2.optional(z2.nullable(z2.string())),
+  section: z3.optional(z3.nullable(z3.string())),
+  destination_url: z3.optional(z3.nullable(z3.string())),
   // 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.optional(z2.nullable(z2.string())),
-  element: z2.optional(z2.nullable(z2.string()))
+  href: z3.optional(z3.nullable(z3.string())),
+  element: z3.optional(z3.nullable(z3.string()))
 });
-var ctaClickConfigSchema = z2.strictObject({
-  autoCapture: z2.optional(
-    z2.strictObject({
-      selector: z2.optional(z2.string())
+var ctaClickConfigSchema = z3.strictObject({
+  autoCapture: z3.optional(
+    z3.strictObject({
+      selector: z3.optional(z3.string())
     })
   )
 });
 
 // ../tracking-core/src/events/sdk-heartbeat.ts
-var z3 = __toESM(require("zod/mini"));
-var sdkHeartbeatTriggersSchema = z3.strictObject({
-  automatic: z3.array(z3.string()),
-  manual: z3.array(z3.string())
+var z4 = __toESM(require("zod/mini"));
+var sdkHeartbeatTriggersSchema = z4.strictObject({
+  automatic: z4.array(z4.string()),
+  manual: z4.array(z4.string())
 });
-var sdkHeartbeatMetadataSchema = z3.strictObject({
-  sdk_version: z3.string(),
-  package_name: z3.nullable(z3.string()),
-  surface: z3.enum(["next", "react", "script"]),
+var sdkHeartbeatMetadataSchema = z4.strictObject({
+  sdk_version: z4.string(),
+  package_name: z4.nullable(z4.string()),
+  surface: z4.enum(["next", "react", "script"]),
   triggers: sdkHeartbeatTriggersSchema,
-  trigger_config: z3.optional(z3.nullable(z3.record(z3.string(), z3.record(z3.string(), z3.unknown())))),
-  configured_gtag_ids: z3.optional(z3.nullable(z3.record(z3.string(), z3.string()))),
+  trigger_config: z4.optional(z4.nullable(z4.record(z4.string(), z4.record(z4.string(), z4.unknown())))),
+  configured_gtag_ids: z4.optional(z4.nullable(z4.record(z4.string(), z4.string()))),
   // Site whose config object the SDK resolves; null on a legacy business ref.
-  config_site_id: z3.optional(z3.nullable(z3.uuid()))
+  config_site_id: z4.optional(z4.nullable(z4.uuid()))
 });
-var sdkHeartbeatConfigSchema = z3.strictObject({});
+var sdkHeartbeatConfigSchema = z4.strictObject({});
 
 // ../tracking-core/src/events/form-start.ts
-var z4 = __toESM(require("zod/mini"));
-var formStartMetadataSchema = z4.strictObject({
-  form: z4.strictObject({
-    id: z4.string(),
-    action: z4.nullable(z4.string())
+var z5 = __toESM(require("zod/mini"));
+var formStartMetadataSchema = z5.strictObject({
+  form: z5.strictObject({
+    id: z5.string(),
+    action: z5.nullable(z5.string())
   }),
-  page: z4.strictObject({
-    path: z4.string()
+  page: z5.strictObject({
+    path: z5.string()
   })
 });
-var formStartConfigSchema = z4.strictObject({
-  selector: z4.optional(z4.string())
+var formStartConfigSchema = z5.strictObject({
+  selector: z5.optional(z5.string())
 });
 
 // ../tracking-core/src/events/form-submit.ts
-var z5 = __toESM(require("zod/mini"));
-var jsonValueSchema = z5.lazy(
-  () => z5.union([
-    z5.string(),
-    z5.number(),
-    z5.boolean(),
-    z5.null(),
-    z5.array(jsonValueSchema),
-    z5.record(z5.string(), jsonValueSchema)
+var z6 = __toESM(require("zod/mini"));
+var jsonValueSchema = z6.lazy(
+  () => z6.union([
+    z6.string(),
+    z6.number(),
+    z6.boolean(),
+    z6.null(),
+    z6.array(jsonValueSchema),
+    z6.record(z6.string(), jsonValueSchema)
   ])
-).register(z5.globalRegistry, { id: "JsonSerializableValue" });
-var formSubmitMetadataSchema = z5.strictObject({
-  form: z5.strictObject({
-    id: z5.string(),
-    action: z5.nullable(z5.string()),
-    fields: z5.optional(
-      z5.array(
-        z5.strictObject({
-          name: z5.string(),
-          type: z5.string(),
-          label: z5.nullable(z5.string()),
+).register(z6.globalRegistry, { id: "JsonSerializableValue" });
+var formSubmitMetadataSchema = z6.strictObject({
+  form: z6.strictObject({
+    id: z6.string(),
+    action: z6.nullable(z6.string()),
+    fields: z6.optional(
+      z6.array(
+        z6.strictObject({
+          name: z6.string(),
+          type: z6.string(),
+          label: z6.nullable(z6.string()),
           value: jsonValueSchema
         })
       )
     )
   }),
-  page: z5.strictObject({
-    path: z5.string()
+  page: z6.strictObject({
+    path: z6.string()
   })
 });
-var formSubmitConfigSchema = z5.strictObject({});
+var formSubmitConfigSchema = z6.strictObject({});
 
 // ../tracking-core/src/events/multi-page-session.ts
-var z6 = __toESM(require("zod/mini"));
-var multiPageSessionMetadataSchema = z6.strictObject({
-  page_count: z6.int().check(z6.gte(2)),
-  page: z6.strictObject({
-    path: z6.string()
+var z7 = __toESM(require("zod/mini"));
+var multiPageSessionMetadataSchema = z7.strictObject({
+  page_count: z7.int().check(z7.gte(2)),
+  page: z7.strictObject({
+    path: z7.string()
   })
 });
-var multiPageSessionConfigSchema = z6.strictObject({
-  pageThreshold: z6.int().check(z6.gte(2))
+var multiPageSessionConfigSchema = z7.strictObject({
+  pageThreshold: z7.int().check(z7.gte(2))
 });
 
 // ../tracking-core/src/events/page-exit.ts
-var z7 = __toESM(require("zod/mini"));
-var pageExitMetadataSchema = z7.strictObject({
-  dwell_ms: z7.int().check(z7.gte(0)),
+var z8 = __toESM(require("zod/mini"));
+var pageExitMetadataSchema = z8.strictObject({
+  dwell_ms: z8.int().check(z8.gte(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.nullable(z7.int().check(z7.gte(0), z7.lte(100))),
+  max_scroll_percent: z8.nullable(z8.int().check(z8.gte(0), z8.lte(100))),
   // 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
@@ -2174,80 +2411,104 @@ var pageExitMetadataSchema = z7.strictObject({
   // ended before the snapshot. Optionality 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.optional(z7.nullable(z7.int().check(z7.gte(0), z7.lte(100)))),
-  page: z7.strictObject({
-    path: z7.string()
+  scroll_baseline_percent: z8.optional(z8.nullable(z8.int().check(z8.gte(0), z8.lte(100)))),
+  page: z8.strictObject({
+    path: z8.string()
   })
 });
-var pageExitConfigSchema = z7.strictObject({});
+var pageExitConfigSchema = z8.strictObject({});
 
 // ../tracking-core/src/events/phone-click.ts
-var z8 = __toESM(require("zod/mini"));
-var phoneClickMetadataSchema = z8.strictObject({
-  phone_number: z8.string(),
-  page: z8.strictObject({
-    path: z8.string()
+var z9 = __toESM(require("zod/mini"));
+var phoneClickMetadataSchema = z9.strictObject({
+  phone_number: z9.string(),
+  page: z9.strictObject({
+    path: z9.string()
   }),
-  section: z8.optional(z8.nullable(z8.string()))
+  section: z9.optional(z9.nullable(z9.string()))
 });
-var phoneClickConfigSchema = z8.strictObject({
-  autoCapture: z8.optional(
-    z8.strictObject({
-      selector: z8.optional(z8.string())
+var phoneClickConfigSchema = z9.strictObject({
+  autoCapture: z9.optional(
+    z9.strictObject({
+      selector: z9.optional(z9.string())
     })
   )
 });
 
 // ../tracking-core/src/events/scroll-depth.ts
-var z9 = __toESM(require("zod/mini"));
-var scrollDepthMetadataSchema = z9.strictObject({
-  depth_percent: z9.int().check(z9.gte(1), z9.lte(100)),
-  page: z9.strictObject({
-    path: z9.string()
+var z10 = __toESM(require("zod/mini"));
+var scrollDepthMetadataSchema = z10.strictObject({
+  depth_percent: z10.int().check(z10.gte(1), z10.lte(100)),
+  page: z10.strictObject({
+    path: z10.string()
   })
 });
-var scrollDepthConfigSchema = z9.strictObject({
-  thresholds: z9.array(z9.int().check(z9.gte(1), z9.lte(100))).check(z9.minLength(1))
+var scrollDepthConfigSchema = z10.strictObject({
+  thresholds: z10.array(z10.int().check(z10.gte(1), z10.lte(100))).check(z10.minLength(1))
 });
 
 // ../tracking-core/src/events/specific-page-visit.ts
-var z10 = __toESM(require("zod/mini"));
+var z11 = __toESM(require("zod/mini"));
 var PAGE_IDENTITY_MAX_LENGTH = 64;
 var PAGE_IDENTITY_PATTERN = /^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/;
-var pageIdentitySchema = z10.string().check(
-  z10.maxLength(PAGE_IDENTITY_MAX_LENGTH),
-  z10.regex(PAGE_IDENTITY_PATTERN, {
+var pageIdentitySchema = z11.string().check(
+  z11.maxLength(PAGE_IDENTITY_MAX_LENGTH),
+  z11.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.strictObject({
+var specificPageVisitMetadataSchema = z11.strictObject({
   page_name: specificPageNameSchema,
-  page: z10.strictObject({
-    path: z10.string()
+  page: z11.strictObject({
+    path: z11.string()
   })
 });
-var specificPageVisitConfigSchema = z10.strictObject({
-  pages: z10.array(
-    z10.strictObject({
+var specificPageVisitConfigSchema = z11.strictObject({
+  pages: z11.array(
+    z11.strictObject({
       name: specificPageNameSchema,
-      pathPattern: z10.custom((value) => value instanceof RegExp, {
+      pathPattern: z11.custom((value) => value instanceof RegExp, {
         message: "pathPattern must be a RegExp"
       })
     })
-  ).check(z10.minLength(1))
+  ).check(z11.minLength(1))
 });
 
+// ../tracking-core/src/events/site-link.ts
+var z12 = __toESM(require("zod/mini"));
+var siteLinkClickMetadataSchema = z12.strictObject({
+  destination_host: z12.string(),
+  destination_url: z12.string(),
+  page: z12.strictObject({
+    path: z12.string()
+  })
+});
+var siteLinkClickConfigSchema = z12.strictObject({});
+var siteLinkArrivalMetadataSchema = z12.strictObject({
+  outcome: z12.enum(["linked", "stale", "invalid"]),
+  origin_session_id: z12.optional(z12.nullable(z12.string())),
+  origin_visitor_id: z12.optional(z12.nullable(z12.string())),
+  // Milliseconds between the origin click and this page load.
+  transit_ms: z12.optional(z12.nullable(z12.number())),
+  // True when this browser had no visitor id and took the origin's.
+  adopted_visitor: z12.boolean(),
+  page: z12.strictObject({
+    path: z12.string()
+  })
+});
+var siteLinkArrivalConfigSchema = z12.strictObject({});
+
 // ../tracking-core/src/events/time-on-site.ts
-var z11 = __toESM(require("zod/mini"));
-var timeOnSiteMetadataSchema = z11.strictObject({
-  duration_ms: z11.int().check(z11.nonnegative()),
-  page: z11.strictObject({
-    path: z11.string()
+var z13 = __toESM(require("zod/mini"));
+var timeOnSiteMetadataSchema = z13.strictObject({
+  duration_ms: z13.int().check(z13.nonnegative()),
+  page: z13.strictObject({
+    path: z13.string()
   })
 });
-var timeOnSiteConfigSchema = z11.strictObject({
-  thresholdSeconds: z11.int().check(z11.positive())
+var timeOnSiteConfigSchema = z13.strictObject({
+  thresholdSeconds: z13.int().check(z13.positive())
 });
 
 // ../tracking-core/src/events/semantics.ts
@@ -2317,6 +2578,18 @@ var EVENT_SEMANTICS = {
     category: "engagement",
     outcomeRole: "engagement",
     clientVisibility: "simple"
+  },
+  site_link_click: {
+    label: "Left for sibling site",
+    category: "page",
+    outcomeRole: "navigation",
+    clientVisibility: "detailed"
+  },
+  site_link_arrival: {
+    label: "Arrived from sibling site",
+    category: "page",
+    outcomeRole: "navigation",
+    clientVisibility: "simple"
   }
 };
 
@@ -2372,6 +2645,20 @@ var EVENT_REGISTRY = {
     metadataSchema: pageExitMetadataSchema,
     configSchema: pageExitConfigSchema
   },
+  // Cross-site linkage: emitted by the linker (roster comes from the site
+  // config, not the trigger registry), so neither is consumer-configurable.
+  site_link_click: {
+    kind: "automatic",
+    semantics: EVENT_SEMANTICS.site_link_click,
+    metadataSchema: siteLinkClickMetadataSchema,
+    configSchema: siteLinkClickConfigSchema
+  },
+  site_link_arrival: {
+    kind: "automatic",
+    semantics: EVENT_SEMANTICS.site_link_arrival,
+    metadataSchema: siteLinkArrivalMetadataSchema,
+    configSchema: siteLinkArrivalConfigSchema
+  },
   // --- manual triggers ---
   form_submit: {
     kind: "manual",
@@ -2977,6 +3264,57 @@ function attachCtaClickCapture(client, config) {
   };
 }
 
+// ../tracking-core/src/triggers/site-link-capture.ts
+function anchorFrom(target) {
+  if (!(target instanceof Element)) return null;
+  const anchor = target.closest("a[href]");
+  return anchor instanceof HTMLAnchorElement ? anchor : null;
+}
+function opensTheLink(event) {
+  return event.button === 0 || event.button === 1;
+}
+function attachSiteLinkCapture(client, options) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return () => {
+    };
+  }
+  registerCapability("cross_site_linker");
+  function hopFrom(event) {
+    const anchor = anchorFrom(event.target);
+    if (anchor === null) return null;
+    const link = resolveCrossSiteLink(anchor.href, options.linkedHostnames());
+    return link === null ? null : { anchor, link };
+  }
+  function onPointerDown(event) {
+    if (!opensTheLink(event)) return;
+    const hop = hopFrom(event);
+    if (hop !== null) hop.anchor.href = hop.link.decorated;
+  }
+  function onClick(event) {
+    if (!opensTheLink(event)) return;
+    const hop = hopFrom(event);
+    if (hop === null) return;
+    hop.anchor.href = hop.link.decorated;
+    client.trackEvent({
+      eventType: "site_link_click",
+      metadata: {
+        destination_host: hop.anchor.hostname,
+        destination_url: stripLinkParam(hop.anchor.href),
+        page: { path: window.location.pathname }
+      },
+      pageUrl: window.location.href,
+      occurredAt: null
+    });
+    client.flushBeacon();
+  }
+  document.addEventListener("pointerdown", onPointerDown, true);
+  document.addEventListener("click", onClick, true);
+  return () => {
+    document.removeEventListener("pointerdown", onPointerDown, true);
+    document.removeEventListener("click", onClick, true);
+  };
+}
+
 // ../tracking-core/src/triggers/phone-click-capture.ts
 var DEFAULT_TEL_SELECTOR = 'a[href^="tel:"]';
 function safeDecodeURIComponent(value) {
@@ -3362,7 +3700,7 @@ function GoogleAdsTracking(props) {
 var import_react6 = require("react");
 
 // package.json
-var version = "1.0.0";
+var version = "1.2.0";
 
 // ../tracking-core/src/phone-react.tsx
 var import_react5 = require("react");
@@ -3485,7 +3823,8 @@ function createTracking(options) {
       // Still publish phone config so usePhoneField/<PhoneField> work even when
       // tracking is disabled (missing apiKey/endpoint).
       TrackingProvider: ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(PhoneConfigProvider, { value: phone ?? null, children }),
-      useTracking: () => noopTyped
+      useTracking: () => noopTyped,
+      decorateUrl: (url) => url
     };
   }
   const TrackingContext = (0, import_react6.createContext)(null);
@@ -3504,8 +3843,8 @@ function createTracking(options) {
       // eslint-disable-next-line react-hooks/exhaustive-deps -- gtagIdsKey is stable proxy
       [gtagId, gtagIdsKey]
     );
-    const rawClient = (0, import_react6.useMemo)(
-      () => getOrCreateTrackingClient({
+    const rawClient = (0, import_react6.useMemo)(() => {
+      const created = getOrCreateTrackingClient({
         apiKey,
         endpoint,
         surface: "react",
@@ -3516,9 +3855,10 @@ function createTracking(options) {
         activeGtagIds: resolvedGtagIds,
         configSiteId: trackingConfig?.siteId ?? null,
         debug
-      }),
-      [resolvedGtagIds]
-    );
+      });
+      stripLinkParamFromLocation();
+      return created;
+    }, [resolvedGtagIds]);
     const conversionStore = (0, import_react6.useMemo)(
       () => trackingConfig ? getTrackingConfigRuntime(trackingConfig) : conversionConfig ? resolveConversionConfig({
         cdnUrl: conversionConfig.cdnUrl,
@@ -3572,6 +3912,11 @@ function createTracking(options) {
         if (timeOnSite) {
           detachers.push(attachTimeOnSite(detectorClient, timeOnSite));
         }
+        detachers.push(
+          attachSiteLinkCapture(detectorClient, {
+            linkedHostnames: () => conversionStore?.linkedHostnames() ?? []
+          })
+        );
         const specificPageVisit = triggers.automatic.specific_page_visit;
         if (specificPageVisit) {
           detachers.push(attachSpecificPageVisit(detectorClient, specificPageVisit));
@@ -3614,7 +3959,14 @@ function createTracking(options) {
     }
     return client;
   }
-  return { TrackingProvider, useTracking };
+  return {
+    TrackingProvider,
+    useTracking,
+    decorateUrl: (url) => decorateCrossSiteUrl(
+      url,
+      trackingConfig ? getTrackingConfigRuntime(trackingConfig).linkedHostnames() : []
+    )
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {