@aranova/tracking-react 0.27.0 → 1.1.0

package/dist/client.js

@@ -1,8 +1,10 @@
 "use strict";
 "use client";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -16,6 +18,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/client.ts
@@ -284,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",
@@ -310,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 = [
@@ -631,10 +645,10 @@ function readStoredRecord() {
     return null;
   }
 }
-function writeRecord(record) {
-  memoryRecord = record;
+function writeRecord(record3) {
+  memoryRecord = record3;
   try {
-    window.localStorage.setItem(LANDING_STORAGE_KEY, JSON.stringify(record));
+    window.localStorage.setItem(LANDING_STORAGE_KEY, JSON.stringify(record3));
   } catch {
   }
 }
@@ -656,9 +670,9 @@ function getOrCaptureLandingParams(sessionId, url) {
   if (memoryRecord && memoryRecord.session_id === sessionId) {
     return memoryRecord.params;
   }
-  const record = { session_id: sessionId, params: captureFromUrl(url) };
-  writeRecord(record);
-  return record.params;
+  const record3 = { session_id: sessionId, params: captureFromUrl(url) };
+  writeRecord(record3);
+  return record3.params;
 }
 function buildLandingPayloadFields(sessionId, override) {
   const params = override ?? (typeof window === "undefined" ? null : getOrCaptureLandingParams(sessionId));
@@ -677,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) {
@@ -783,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_";
@@ -867,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) => {
@@ -1051,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
   };
@@ -1202,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 = {};
@@ -1439,76 +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 import_zod = require("zod");
-var pageViewMetadataSchema = import_zod.z.object({
-  page: import_zod.z.object({
-    title: import_zod.z.string().nullable(),
-    path: import_zod.z.string(),
-    search: import_zod.z.string(),
-    hash: import_zod.z.string()
-  }).strict(),
-  referrer: import_zod.z.string().nullable(),
-  // `.nullable().optional()` — absent (undefined) OR explicit null OR a
+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: 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: import_zod.z.object({
-    w: import_zod.z.number(),
-    h: import_zod.z.number()
-  }).strict().nullable().optional()
-}).strict();
-var pageViewConfigSchema = import_zod.z.object({}).strict();
+  viewport: z2.optional(
+    z2.nullable(
+      z2.strictObject({
+        w: z2.number(),
+        h: z2.number()
+      })
+    )
+  )
+});
+var pageViewConfigSchema = z2.strictObject({});
 
 // ../tracking-core/src/page-view.ts
 var LAST_FIRED_URL_STORAGE_KEY = "aranova_tracking_last_fired_url";
@@ -1544,11 +1758,11 @@ function setLastFiredUrl(url) {
 }
 function buildPageViewMetadata(referrerOverride) {
   if (typeof window === "undefined" || typeof document === "undefined") return null;
-  return pageViewMetadataSchema.parse({
+  return (0, import_mini.parse)(pageViewMetadataSchema, {
     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,
@@ -1847,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 {
@@ -1862,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();
   }
@@ -1888,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);
@@ -1918,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
@@ -1994,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
     });
@@ -2040,186 +2294,222 @@ function createTrackingClient(config) {
   };
 }
 
+// ../tracking-core/src/ingest-typed.ts
+var import_mini2 = require("zod/mini");
+
 // ../tracking-core/src/events/cta-click.ts
-var import_zod2 = require("zod");
-var ctaClickMetadataSchema = import_zod2.z.object({
-  cta_name: import_zod2.z.string(),
-  page: import_zod2.z.object({
-    path: import_zod2.z.string()
-  }).strict(),
-  section: import_zod2.z.string().nullable().optional(),
-  destination_url: import_zod2.z.string().nullable().optional(),
+var z3 = __toESM(require("zod/mini"));
+var ctaClickMetadataSchema = z3.strictObject({
+  cta_name: z3.string(),
+  page: z3.strictObject({
+    path: z3.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: import_zod2.z.string().nullable().optional(),
-  element: import_zod2.z.string().nullable().optional()
-}).strict();
-var ctaClickConfigSchema = import_zod2.z.object({
-  autoCapture: import_zod2.z.object({
-    selector: import_zod2.z.string().optional()
-  }).strict().optional()
-}).strict();
+  href: z3.optional(z3.nullable(z3.string())),
+  element: z3.optional(z3.nullable(z3.string()))
+});
+var ctaClickConfigSchema = z3.strictObject({
+  autoCapture: z3.optional(
+    z3.strictObject({
+      selector: z3.optional(z3.string())
+    })
+  )
+});
 
 // ../tracking-core/src/events/sdk-heartbeat.ts
-var import_zod3 = require("zod");
-var sdkHeartbeatTriggersSchema = import_zod3.z.object({
-  automatic: import_zod3.z.array(import_zod3.z.string()),
-  manual: import_zod3.z.array(import_zod3.z.string())
-}).strict();
-var sdkHeartbeatMetadataSchema = import_zod3.z.object({
-  sdk_version: import_zod3.z.string(),
-  package_name: import_zod3.z.string().nullable(),
-  surface: import_zod3.z.enum(["next", "react", "script"]),
+var z4 = __toESM(require("zod/mini"));
+var sdkHeartbeatTriggersSchema = z4.strictObject({
+  automatic: z4.array(z4.string()),
+  manual: z4.array(z4.string())
+});
+var sdkHeartbeatMetadataSchema = z4.strictObject({
+  sdk_version: z4.string(),
+  package_name: z4.nullable(z4.string()),
+  surface: z4.enum(["next", "react", "script"]),
   triggers: sdkHeartbeatTriggersSchema,
-  trigger_config: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown())).nullable().optional(),
-  configured_gtag_ids: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).nullable().optional(),
+  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: import_zod3.z.string().uuid().nullable().optional()
-}).strict();
-var sdkHeartbeatConfigSchema = import_zod3.z.object({}).strict();
+  config_site_id: z4.optional(z4.nullable(z4.uuid()))
+});
+var sdkHeartbeatConfigSchema = z4.strictObject({});
 
 // ../tracking-core/src/events/form-start.ts
-var import_zod4 = require("zod");
-var formStartMetadataSchema = import_zod4.z.object({
-  form: import_zod4.z.object({
-    id: import_zod4.z.string(),
-    action: import_zod4.z.string().nullable()
-  }).strict(),
-  page: import_zod4.z.object({
-    path: import_zod4.z.string()
-  }).strict()
-}).strict();
-var formStartConfigSchema = import_zod4.z.object({
-  selector: import_zod4.z.string().optional()
-}).strict();
+var z5 = __toESM(require("zod/mini"));
+var formStartMetadataSchema = z5.strictObject({
+  form: z5.strictObject({
+    id: z5.string(),
+    action: z5.nullable(z5.string())
+  }),
+  page: z5.strictObject({
+    path: z5.string()
+  })
+});
+var formStartConfigSchema = z5.strictObject({
+  selector: z5.optional(z5.string())
+});
 
 // ../tracking-core/src/events/form-submit.ts
-var import_zod5 = require("zod");
-var jsonValueSchema = import_zod5.z.lazy(
-  () => import_zod5.z.union([
-    import_zod5.z.string(),
-    import_zod5.z.number().finite(),
-    import_zod5.z.boolean(),
-    import_zod5.z.null(),
-    import_zod5.z.array(jsonValueSchema),
-    import_zod5.z.record(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)
   ])
-);
-var formSubmitMetadataSchema = import_zod5.z.object({
-  form: import_zod5.z.object({
-    id: import_zod5.z.string(),
-    action: import_zod5.z.string().nullable(),
-    fields: import_zod5.z.array(
-      import_zod5.z.object({
-        name: import_zod5.z.string(),
-        type: import_zod5.z.string(),
-        label: import_zod5.z.string().nullable(),
-        value: jsonValueSchema
-      }).strict()
-    ).optional()
-  }).strict(),
-  page: import_zod5.z.object({
-    path: import_zod5.z.string()
-  }).strict()
-}).strict();
-var formSubmitConfigSchema = import_zod5.z.object({}).strict();
+).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: z6.strictObject({
+    path: z6.string()
+  })
+});
+var formSubmitConfigSchema = z6.strictObject({});
 
 // ../tracking-core/src/events/multi-page-session.ts
-var import_zod6 = require("zod");
-var multiPageSessionMetadataSchema = import_zod6.z.object({
-  page_count: import_zod6.z.number().int().min(2),
-  page: import_zod6.z.object({
-    path: import_zod6.z.string()
-  }).strict()
-}).strict();
-var multiPageSessionConfigSchema = import_zod6.z.object({
-  pageThreshold: import_zod6.z.number().int().min(2)
-}).strict();
+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 = z7.strictObject({
+  pageThreshold: z7.int().check(z7.gte(2))
+});
 
 // ../tracking-core/src/events/page-exit.ts
-var import_zod7 = require("zod");
-var pageExitMetadataSchema = import_zod7.z.object({
-  dwell_ms: import_zod7.z.number().int().min(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: import_zod7.z.number().int().min(0).max(100).nullable(),
+  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
   // established it. null = page had no scrollable range, or the segment
-  // ended before the snapshot. `.optional()` is load-bearing: SDK builds
+  // 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: import_zod7.z.number().int().min(0).max(100).nullable().optional(),
-  page: import_zod7.z.object({
-    path: import_zod7.z.string()
-  }).strict()
-}).strict();
-var pageExitConfigSchema = import_zod7.z.object({}).strict();
+  scroll_baseline_percent: z8.optional(z8.nullable(z8.int().check(z8.gte(0), z8.lte(100)))),
+  page: z8.strictObject({
+    path: z8.string()
+  })
+});
+var pageExitConfigSchema = z8.strictObject({});
 
 // ../tracking-core/src/events/phone-click.ts
-var import_zod8 = require("zod");
-var phoneClickMetadataSchema = import_zod8.z.object({
-  phone_number: import_zod8.z.string(),
-  page: import_zod8.z.object({
-    path: import_zod8.z.string()
-  }).strict(),
-  section: import_zod8.z.string().nullable().optional()
-}).strict();
-var phoneClickConfigSchema = import_zod8.z.object({
-  autoCapture: import_zod8.z.object({
-    selector: import_zod8.z.string().optional()
-  }).strict().optional()
-}).strict();
+var z9 = __toESM(require("zod/mini"));
+var phoneClickMetadataSchema = z9.strictObject({
+  phone_number: z9.string(),
+  page: z9.strictObject({
+    path: z9.string()
+  }),
+  section: z9.optional(z9.nullable(z9.string()))
+});
+var phoneClickConfigSchema = z9.strictObject({
+  autoCapture: z9.optional(
+    z9.strictObject({
+      selector: z9.optional(z9.string())
+    })
+  )
+});
 
 // ../tracking-core/src/events/scroll-depth.ts
-var import_zod9 = require("zod");
-var scrollDepthMetadataSchema = import_zod9.z.object({
-  depth_percent: import_zod9.z.number().int().min(1).max(100),
-  page: import_zod9.z.object({
-    path: import_zod9.z.string()
-  }).strict()
-}).strict();
-var scrollDepthConfigSchema = import_zod9.z.object({
-  thresholds: import_zod9.z.array(import_zod9.z.number().int().min(1).max(100)).min(1)
-}).strict();
+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 = 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 import_zod10 = require("zod");
+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 = import_zod10.z.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 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 = import_zod10.z.object({
+var specificPageVisitMetadataSchema = z11.strictObject({
   page_name: specificPageNameSchema,
-  page: import_zod10.z.object({
-    path: import_zod10.z.string()
-  }).strict()
-}).strict();
-var specificPageVisitConfigSchema = import_zod10.z.object({
-  pages: import_zod10.z.array(
-    import_zod10.z.object({
+  page: z11.strictObject({
+    path: z11.string()
+  })
+});
+var specificPageVisitConfigSchema = z11.strictObject({
+  pages: z11.array(
+    z11.strictObject({
       name: specificPageNameSchema,
-      pathPattern: import_zod10.z.custom((value) => value instanceof RegExp, {
+      pathPattern: z11.custom((value) => value instanceof RegExp, {
         message: "pathPattern must be a RegExp"
       })
-    }).strict()
-  ).min(1)
-}).strict();
+    })
+  ).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 import_zod11 = require("zod");
-var timeOnSiteMetadataSchema = import_zod11.z.object({
-  duration_ms: import_zod11.z.number().int().nonnegative(),
-  page: import_zod11.z.object({
-    path: import_zod11.z.string()
-  }).strict()
-}).strict();
-var timeOnSiteConfigSchema = import_zod11.z.object({
-  thresholdSeconds: import_zod11.z.number().int().positive()
-}).strict();
+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 = z13.strictObject({
+  thresholdSeconds: z13.int().check(z13.positive())
+});
 
 // ../tracking-core/src/events/semantics.ts
 var EVENT_SEMANTICS = {
@@ -2288,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"
   }
 };
 
@@ -2343,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",
@@ -2378,7 +2694,7 @@ function createTypedClient(raw, registry, options = {}) {
     trackEvent(eventType, metadata, opts) {
       if (debug) {
         const def = getEventDefinition(eventType);
-        def.metadataSchema.parse(metadata);
+        (0, import_mini2.parse)(def.metadataSchema, metadata);
       }
       raw.trackEvent({
         eventType,
@@ -2948,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) {
@@ -3002,117 +3369,6 @@ function attachPhoneClickCapture(client, config) {
   };
 }
 
-// ../tracking-core/src/resources/sales/schema.ts
-var import_zod12 = require("zod");
-var SUPPORTED_CURRENCIES = ["USD", "CAD"];
-var TRACKING_ENVIRONMENTS = ["production", "development"];
-var currencySchema = import_zod12.z.enum(SUPPORTED_CURRENCIES);
-var centsSchema = import_zod12.z.number().int().nonnegative();
-var quantitySchema = import_zod12.z.string().regex(/^\d+(\.\d{1,3})?$/);
-var metadataSchema = import_zod12.z.record(import_zod12.z.unknown());
-var saleItemSchema = import_zod12.z.object({
-  external_item_id: import_zod12.z.string().nullable().optional(),
-  name: import_zod12.z.string().nullable().optional(),
-  category: import_zod12.z.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 = import_zod12.z.object({
-  service: import_zod12.z.string(),
-  amount_cents: centsSchema
-}).strict();
-var customerNameSchema = import_zod12.z.string().max(200);
-var customerPhoneSchema = import_zod12.z.string().max(64);
-var customerEmailSchema = import_zod12.z.string().max(320).email();
-function refineServiceXor(val, ctx, { requireAmount }) {
-  if (val.services != null) {
-    if (val.service != null) {
-      ctx.addIssue({
-        code: import_zod12.z.ZodIssueCode.custom,
-        message: "pass either `service` or `services`, not both",
-        path: ["services"]
-      });
-    }
-    if (val.services.length === 0) {
-      ctx.addIssue({
-        code: import_zod12.z.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: import_zod12.z.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: import_zod12.z.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: import_zod12.z.ZodIssueCode.custom,
-      message: "amount_total_cents is required unless `services` is provided",
-      path: ["amount_total_cents"]
-    });
-  }
-}
-var saleCreateSchema = import_zod12.z.object({
-  external_id: import_zod12.z.string().nullable().optional(),
-  description: import_zod12.z.string().nullable().optional(),
-  service: import_zod12.z.string().nullable().optional(),
-  services: import_zod12.z.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: import_zod12.z.string().datetime(),
-  environment: import_zod12.z.enum(TRACKING_ENVIRONMENTS).default("production"),
-  items: import_zod12.z.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: import_zod12.z.boolean().nullable().optional()
-}).strict().superRefine((val, ctx) => refineServiceXor(val, ctx, { requireAmount: true }));
-var saleUpdateSchema = import_zod12.z.object({
-  description: import_zod12.z.string().nullable().optional(),
-  service: import_zod12.z.string().nullable().optional(),
-  services: import_zod12.z.array(saleServiceSchema).nullable().optional(),
-  currency: currencySchema.optional(),
-  amount_total_cents: centsSchema.optional(),
-  occurred_at: import_zod12.z.string().datetime().optional(),
-  items: import_zod12.z.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: import_zod12.z.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: import_zod12.z.boolean().optional()
-}).strict().superRefine((val, ctx) => refineServiceXor(val, ctx, { requireAmount: false }));
-
 // src/hooks.ts
 function useGclid() {
   const [gclid, setGclid] = (0, import_react.useState)(null);
@@ -3444,7 +3700,7 @@ function GoogleAdsTracking(props) {
 var import_react6 = require("react");
 
 // package.json
-var version = "0.27.0";
+var version = "1.1.0";
 
 // ../tracking-core/src/phone-react.tsx
 var import_react5 = require("react");
@@ -3567,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);
@@ -3586,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",
@@ -3598,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,
@@ -3654,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));
@@ -3696,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 = {