@aranova/tracking-react 1.14.0 → 1.15.0

package/dist/sales.mjs

@@ -89,6 +89,14 @@ var DEFAULT_CHOICE = {
   updatedAt: null,
   expiresAt: null
 };
+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 {
@@ -117,6 +125,24 @@ function getConsentState() {
 }
 
 // ../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 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);
@@ -135,6 +161,27 @@ function fireGtagConversion(input) {
     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);
+}
 
 // ../tracking-core/src/resources/conversion-firing.ts
 var DEDUP_PREFIX = "_aranova_conv_";
@@ -170,6 +217,77 @@ function fireConversionWithConsent(input, options) {
   }
 }
 
+// ../tracking-core/src/events/form-submit.ts
+import * as z from "zod/mini";
+var jsonValueSchema = z.lazy(
+  () => z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.null(),
+    z.array(jsonValueSchema),
+    z.record(z.string(), jsonValueSchema)
+  ])
+).register(z.globalRegistry, { id: "JsonSerializableValue" });
+var contractNameSchema = z.string().check(z.regex(/^[a-z][a-z0-9_]{0,47}(:[a-z0-9_-]{1,48})?$/));
+var contractName = contractNameSchema;
+var violationRole = z.string().check(
+  z.maxLength(200),
+  z.regex(
+    /^[a-z][a-z0-9_]{0,47}(:[a-z0-9_-]{1,48})?(\|[a-z][a-z0-9_]{0,47}(:[a-z0-9_-]{1,48})?)*$/
+  )
+);
+var MAX_CONTRACT_VIOLATIONS = 50;
+var contractViolationSchema = z.strictObject({
+  role: z.nullable(violationRole),
+  rule: z.string().check(z.regex(/^[a-z][a-z_]{0,47}$/))
+});
+var formSubmitMetadataSchema = z.strictObject({
+  form: z.strictObject({
+    id: z.string(),
+    action: z.nullable(z.string()),
+    fields: z.optional(
+      z.array(
+        z.strictObject({
+          name: z.string(),
+          type: z.string(),
+          label: z.nullable(z.string()),
+          value: jsonValueSchema,
+          role: z.optional(z.nullable(contractName))
+        })
+      )
+    ),
+    kind: z.optional(z.nullable(contractName)),
+    contract_version: z.optional(z.nullable(z.int().check(z.gte(1)))),
+    contract_hash: z.optional(z.nullable(z.string().check(z.maxLength(64)))),
+    extra: z.optional(
+      z.nullable(
+        z.array(
+          z.strictObject({
+            key: z.string().check(z.maxLength(64)),
+            label: z.string().check(z.maxLength(200)),
+            value: jsonValueSchema
+          })
+        ).check(z.maxLength(20))
+      )
+    ),
+    contract_violations: z.optional(
+      z.nullable(z.array(contractViolationSchema).check(z.maxLength(MAX_CONTRACT_VIOLATIONS)))
+    )
+  }),
+  page: z.strictObject({
+    path: z.string()
+  })
+});
+var formSubmitConfigSchema = z.strictObject({});
+
+// ../tracking-core/src/ingest-typed.ts
+import { parse, safeParse } from "zod/mini";
+var clientSettings = /* @__PURE__ */ new WeakMap();
+function typedClientSettings(client) {
+  return clientSettings.get(client) ?? {};
+}
+
 // ../../contracts/autoleap-booking-links.json
 var autoleap_booking_links_default = {
   hosts: ["myalp.io"]
@@ -242,8 +360,108 @@ function nationalDigits(phone) {
 }
 
 // ../tracking-core/src/lead-forms/lead-forms.gen.ts
-import * as z from "zod/mini";
+import * as z2 from "zod/mini";
 var LEAD_FORM_REGISTRY_VERSION = 2;
+var LEAD_FORM_ROLES = [
+  "given_name",
+  "family_name",
+  "phone",
+  "email",
+  "service",
+  "preferred_date",
+  "preferred_time",
+  "note",
+  "visit",
+  "intent",
+  "vehicle",
+  "drop_off",
+  "address",
+  "patient_type",
+  "matter",
+  "language",
+  "products",
+  "goal",
+  "business_type",
+  "lead_volume",
+  "attribution"
+];
+var leadFormPrimitiveSchemas = /* @__PURE__ */ (() => ({
+  string: z2.string().check(z2.maxLength(120)),
+  text: z2.string().check(z2.maxLength(2e3)),
+  enum: z2.string().check(z2.regex(/^[a-z0-9-]{1,48}$/)),
+  multi_enum: z2.array(z2.string().check(z2.regex(/^[a-z0-9-]{1,48}$/))).check(z2.maxLength(10)),
+  bool: z2.boolean(),
+  date: z2.string().check(z2.regex(/^\d{4}-\d{2}-\d{2}$/)),
+  time_window: z2.strictObject({
+    start: z2.string().check(z2.regex(/^([01]\d|2[0-3]):[0-5]\d$/)),
+    end: z2.nullable(z2.string().check(z2.regex(/^([01]\d|2[0-3]):[0-5]\d$/))),
+    label: z2.optional(z2.string().check(z2.maxLength(60)))
+  }),
+  phone: z2.string().check(z2.regex(/^\+[1-9]\d{6,14}$/)),
+  email: z2.string().check(z2.maxLength(320), z2.regex(/^[^\s@]+@[^\s@]+$/)),
+  address: z2.strictObject({
+    line1: z2.string().check(z2.maxLength(120)),
+    line2: z2.optional(z2.string().check(z2.maxLength(120))),
+    city: z2.optional(z2.string().check(z2.maxLength(120))),
+    region: z2.optional(z2.string().check(z2.maxLength(120))),
+    postal_code: z2.optional(z2.string().check(z2.maxLength(120))),
+    country: z2.optional(z2.string().check(z2.maxLength(120)))
+  }),
+  number: z2.number()
+}))();
+var LEAD_FORM_ROLE_SPECS = {
+  given_name: { primitive: "string", smsLabel: "", contactIdentity: true },
+  family_name: { primitive: "string", smsLabel: "", contactIdentity: true },
+  phone: { primitive: "phone", smsLabel: "", contactIdentity: true },
+  email: { primitive: "email", smsLabel: "", contactIdentity: true },
+  service: { primitive: "multi_enum", smsLabel: "Service" },
+  preferred_date: { primitive: "date", smsLabel: "Date" },
+  preferred_time: { primitive: "time_window", smsLabel: "Time" },
+  note: { primitive: "text", smsLabel: "Note" },
+  visit: {
+    primitive: "enum",
+    smsLabel: "Visit",
+    options: [
+      { key: "in-shop", label: "In shop" },
+      { key: "in-home", label: "In home" },
+      { key: "remote", label: "Remote" },
+      { key: "on-site", label: "On site" }
+    ]
+  },
+  intent: {
+    primitive: "enum",
+    smsLabel: "Wants",
+    options: [
+      { key: "book", label: "Book" },
+      { key: "quote", label: "Quote" }
+    ]
+  },
+  vehicle: { primitive: "string", smsLabel: "Vehicle" },
+  drop_off: {
+    primitive: "enum",
+    smsLabel: "Drop-off",
+    options: [
+      { key: "wait-for-it", label: "Waiting" },
+      { key: "drop-off", label: "Dropping off" }
+    ]
+  },
+  address: { primitive: "address", smsLabel: "Address" },
+  patient_type: { primitive: "enum", smsLabel: "Patient" },
+  matter: { primitive: "enum", smsLabel: "Matter" },
+  language: { primitive: "enum", smsLabel: "Language" },
+  products: { primitive: "multi_enum", smsLabel: "Products" },
+  goal: { primitive: "enum", smsLabel: "Goal" },
+  business_type: { primitive: "enum", smsLabel: "Business" },
+  lead_volume: { primitive: "enum", smsLabel: "Lead volume" },
+  add_on: { primitive: "bool", smsLabel: "" },
+  attribution: { primitive: "enum", smsLabel: "", uninteresting: true }
+};
+
+// ../tracking-core/src/lead-forms/submit.ts
+import { safeParse as safeParse2 } from "zod/mini";
+
+// ../tracking-core/src/cross-site-link.ts
+import * as z3 from "zod/mini";
 
 // ../tracking-core/src/uuid.ts
 function uuidV4() {
@@ -281,17 +499,348 @@ function peekSessionId(now = Date.now()) {
   }
 }
 
-// ../tracking-core/src/resources/http/errors.ts
-var AranovaApiError = class extends Error {
-  constructor(message, options) {
-    super(message);
-    this.name = "AranovaApiError";
-    this.status = options.status;
-    this.code = options.code;
-    this.requestId = options.requestId;
-    this.context = options.context;
-  }
+// ../tracking-core/src/cross-site-link.ts
+var LINK_PARAM = "_arv";
+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 = z3.string().check(z3.minLength(1), z3.maxLength(128));
+var optionalIdentifier = z3.optional(identifier);
+var linkTokenSchema = z3.object({
+  v: identifier,
+  s: identifier,
+  // Epoch ms in base36.
+  t: z3.string().check(z3.regex(/^[0-9a-z]{1,12}$/)),
+  g: optionalIdentifier,
+  w: optionalIdentifier,
+  gb: optionalIdentifier,
+  f: optionalIdentifier,
+  fc: optionalIdentifier,
+  y: optionalIdentifier
+});
+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;
+  }
+}
+
+// ../tracking-core/src/resources/conversion-config.ts
+var BOOKING_MODES = ["live", "test", "simulated"];
+function isBookingMode(value) {
+  return BOOKING_MODES.includes(value);
+}
+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 isNumberList(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === "number");
+}
+function isStringList(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string");
+}
+function parseWindowsMap(value) {
+  const windowsByKey = {};
+  if (!value || typeof value !== "object") return windowsByKey;
+  for (const [key, windows] of Object.entries(value)) {
+    if (!windows || typeof windows !== "object") continue;
+    const w = windows;
+    windowsByKey[key] = {
+      morning: isNumberList(w.morning) ? w.morning : [],
+      afternoon: isNumberList(w.afternoon) ? w.afternoon : []
+    };
+  }
+  return windowsByKey;
+}
+function parseBookingRules(value) {
+  if (!value || typeof value !== "object") return null;
+  const r = value;
+  if (typeof r.min_days_ahead !== "number" || typeof r.max_days_ahead !== "number") return null;
+  if (!r.hours || typeof r.hours !== "object") return null;
+  const hours = parseWindowsMap(r.hours);
+  return {
+    min_days_ahead: r.min_days_ahead,
+    max_days_ahead: r.max_days_ahead,
+    hours,
+    closed_dates: isStringList(r.closed_dates) ? r.closed_dates : [],
+    special_hours: parseWindowsMap(r.special_hours),
+    vehicle_required: r.vehicle_required === true,
+    vehicle_deferred: r.vehicle_deferred === true,
+    drop_off_options: isStringList(r.drop_off_options) ? r.drop_off_options : []
+  };
+}
+function parseBookingOption(value) {
+  if (!value || typeof value !== "object") return [];
+  const o = value;
+  if (typeof o.key !== "string" || !o.key || typeof o.label !== "string") return [];
+  return [
+    {
+      key: o.key,
+      label: o.label,
+      group: typeof o.group === "string" && o.group ? o.group : null,
+      description: typeof o.description === "string" && o.description ? o.description : null
+    }
+  ];
+}
+function parseIntegrations(value) {
+  if (!value || typeof value !== "object") return {};
+  const autoleap = value.autoleap;
+  if (!autoleap || typeof autoleap !== "object") return {};
+  const booking = autoleap.booking;
+  if (!booking || typeof booking !== "object") return {};
+  const b = booking;
+  if (typeof b.fallback_url !== "string" || !b.fallback_url) return {};
+  return {
+    autoleap: {
+      booking: {
+        enabled: b.enabled === true,
+        fallback_url: b.fallback_url,
+        timezone: typeof b.timezone === "string" ? b.timezone : "UTC",
+        config_version: typeof b.config_version === "number" ? b.config_version : null,
+        accepts_bookings: b.accepts_bookings === true,
+        rules: parseBookingRules(b.rules),
+        options: Array.isArray(b.options) ? b.options.flatMap(parseBookingOption) : [],
+        ...isBookingMode(b.mode) ? { mode: b.mode } : {}
+      }
+    }
+  };
+}
+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,
+    linked_hostnames: Array.isArray(obj.linked_hostnames) ? obj.linked_hostnames.filter((h) => typeof h === "string" && h.length > 0) : [],
+    integrations: parseIntegrations(obj.integrations),
+    lead_forms: parseLeadForms(obj.lead_forms)
+  };
+}
+function parseLeadForms(value) {
+  if (!isRecord(value) || typeof value.registry_version !== "number") return null;
+  return {
+    registry_version: value.registry_version,
+    contracts: records(value.contracts).flatMap(
+      (c) => typeof c.form_kind === "string" && typeof c.contract_hash === "string" ? [
+        {
+          form_kind: c.form_kind,
+          requires: records(c.requires).flatMap(
+            (r) => typeof r.role === "string" ? [
+              {
+                role: r.role,
+                required_when: parseCondition(r.required_when),
+                waived: r.waived === true
+              }
+            ] : []
+          ),
+          requires_any: records(c.requires_any).map((g) => ({
+            roles: strings(g.roles),
+            waived: g.waived === true
+          })),
+          options: records(c.options).flatMap(
+            (o) => typeof o.role === "string" ? [{ role: o.role, options: records(o.options).flatMap(parseContractOption) }] : []
+          ),
+          contract_hash: c.contract_hash
+        }
+      ] : []
+    )
+  };
+}
+function parseCondition(value) {
+  if (!isRecord(value) || typeof value.role !== "string") return null;
+  return { role: value.role, any_of: strings(value.any_of) };
+}
+function parseContractOption(value) {
+  if (typeof value.key !== "string" || typeof value.label !== "string") return [];
+  return [
+    {
+      key: value.key,
+      label: value.label,
+      is_non_answer: value.is_non_answer === true,
+      deprecated: value.deprecated === true
+    }
+  ];
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function records(value) {
+  return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+function strings(value) {
+  return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+}
+
+// ../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/intl/date.ts
 function formatDateInTz(iso3, timeZone, opts, locale) {
@@ -340,7 +889,482 @@ function resolveTrackingConfigUrl(ref) {
   const base = (configured || DEFAULT_CDN_BASE_URL).replace(/\/+$/, "");
   return `${base}/${trackingConfigKey(ref)}`;
 }
+var CACHE_PREFIX = "_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 cacheKey(url) {
+  return `${CACHE_PREFIX}${url}`;
+}
+function pushBounded(queue, item) {
+  queue.push(item);
+  if (queue.length > MAX_QUEUE_LENGTH) queue.splice(0, queue.length - MAX_QUEUE_LENGTH);
+}
+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 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: stripLinkParam(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 = readCache(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 ?? [];
+  }
+  /** Sibling hostnames for the linker — read from the cached object even while unconfirmed. */
+  linkedHostnames() {
+    return this.current?.linked_hostnames ?? [];
+  }
+  /**
+   * Integration blocks, from the cached object even while unconfirmed: the booking fallback
+   * link is safe to show stale. Same reference until the next adopt, for `useSyncExternalStore`.
+   */
+  integrations() {
+    return this.current?.integrations ?? null;
+  }
+  /** The lead-form contracts, from the cached object like `integrations()`. */
+  leadForms() {
+    return this.current?.lead_forms ?? null;
+  }
+  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";
+    writeCache(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/lead-forms/submit.ts
+var KNOWN_ROLES = new Set(LEAD_FORM_ROLES);
+var ROLE_ORDER = new Map(LEAD_FORM_ROLES.map((role, index) => [role, index]));
+var ADD_ON = /^add_on:[a-z0-9_-]{1,48}$/;
+var CONTRACT_NAME = /^[a-z][a-z0-9_]{0,47}(:[a-z0-9_-]{1,48})?$/;
+function judgeLeadForm(kind, formId, fields, contracts, settings) {
+  const generated = contracts?.contracts[kind];
+  const live = liveContract(settings.trackingConfig, kind);
+  const violations = check(live === void 0 ? generated : fromLive(live), fields);
+  const liveHash = live === void 0 ? void 0 : live?.contract_hash ?? null;
+  if (contracts && (liveHash !== void 0 && (generated?.hash ?? null) !== liveHash || contracts.registryVersion !== LEAD_FORM_REGISTRY_VERSION)) {
+    violations.push({ role: null, rule: "contract_behind" });
+  }
+  if (violations.length > 0 && (settings.debug || settings.environment === "development")) {
+    const message = `[AranovaTracking] lead form "${formId}" (${kind}) breaks its contract: ${violations.map((v) => `${v.rule}${v.role ? ` (${v.role})` : ""}`).join(", ")}`;
+    console.error(message);
+    if (settings.debug) throw new Error(message);
+  }
+  return {
+    violations,
+    hash: liveHash === void 0 ? generated?.hash ?? null : liveHash
+  };
+}
+function liveContract(ref, kind) {
+  const leadForms = ref ? getTrackingConfigRuntime(ref).leadForms() : null;
+  if (!leadForms) return void 0;
+  return leadForms.contracts.find((c) => c.form_kind === kind) ?? null;
+}
+function fromLive(live) {
+  if (!live) return void 0;
+  return {
+    requires: live.requires.map((r) => ({
+      role: r.role,
+      requiredWhen: r.required_when ? { role: r.required_when.role, anyOf: r.required_when.any_of } : null
+    })),
+    requiresAny: live.requires_any.map((g) => g.roles),
+    // Deprecated keys still resolve: a cached form may send them (ADR-0024 §7).
+    options: Object.fromEntries(live.options.map((o) => [o.role, o.options.map((x) => x.key)]))
+  };
+}
+function check(contract, fields) {
+  const answered = new Map(fields);
+  const violations = [];
+  for (const [role, value] of fields) {
+    const primitive = primitiveOf(role);
+    if (!primitive) {
+      violations.push({ role: CONTRACT_NAME.test(role) ? role : null, rule: "unknown_role" });
+      continue;
+    }
+    if (!safeParse2(leadFormPrimitiveSchemas[primitive], value).success) {
+      violations.push({ role, rule: "invalid_value" });
+      continue;
+    }
+    const allowed = contract?.options[role] ?? registryOptions(role);
+    if (allowed?.length && optionKeys(value).some((key) => !allowed.includes(key))) {
+      violations.push({ role, rule: "unknown_option" });
+    }
+  }
+  for (const { role, requiredWhen } of contract?.requires ?? []) {
+    const owing = requiredWhen === null || optionKeys(answered.get(requiredWhen.role)).some((key) => requiredWhen.anyOf.includes(key));
+    if (owing && !answered.has(role)) violations.push({ role, rule: "missing_required" });
+  }
+  for (const group of contract?.requiresAny ?? []) {
+    if (!group.some((role) => answered.has(role))) {
+      violations.push({ role: group.join("|"), rule: "missing_any_of" });
+    }
+  }
+  return violations;
+}
+function primitiveOf(role) {
+  if (ADD_ON.test(role)) return "bool";
+  return KNOWN_ROLES.has(role) ? LEAD_FORM_ROLE_SPECS[role].primitive : null;
+}
+function registryOptions(role) {
+  const spec = KNOWN_ROLES.has(role) ? LEAD_FORM_ROLE_SPECS[role] : void 0;
+  return spec && "options" in spec ? spec.options.map((o) => o.key) : void 0;
+}
+function optionKeys(value) {
+  if (typeof value === "string") return [value];
+  return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+}
+
+// ../tracking-core/src/resources/http/errors.ts
+var AranovaApiError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = "AranovaApiError";
+    this.status = options.status;
+    this.code = options.code;
+    this.requestId = options.requestId;
+    this.context = options.context;
+  }
+};
 
 // ../tracking-core/src/ingest.ts
 var API_KEY_HEADER = "X-Aranova-Api-Key";
@@ -376,11 +1400,11 @@ async function apiRequest(config, method, path, body, extraHeaders) {
     try {
       const parsed = await response.json();
       if (parsed && typeof parsed === "object") {
-        const record3 = parsed;
-        if (typeof record3.detail === "string") detail = record3.detail;
-        if (typeof record3.code === "string") code = record3.code;
-        if (record3.context && typeof record3.context === "object") {
-          context = record3.context;
+        const record4 = parsed;
+        if (typeof record4.detail === "string") detail = record4.detail;
+        if (typeof record4.code === "string") code = record4.code;
+        if (record4.context && typeof record4.context === "object") {
+          context = record4.context;
         }
       }
     } catch {
@@ -434,7 +1458,7 @@ var DROP_OFF_KEYS = {
   waitForIt: "wait-for-it",
   dropOff: "drop-off"
 };
-function formSubmitPayload(input, formSubmit, contractHash) {
+function formSubmitPayload(input, formSubmit, runtime) {
   const field = (role, name, type, label, value) => ({ name, type, label, value, role });
   const text = (value) => value?.trim() || void 0;
   const { vehicle, dropOff } = input;
@@ -444,7 +1468,7 @@ function formSubmitPayload(input, formSubmit, contractHash) {
     // E.164 on the wire: it keys the customer and enhanced-conversion matching.
     field("phone", "phone", "tel", "Phone", toE164(input.phone) ?? input.phone),
     field("email", "email", "email", "Email", text(input.email)),
-    field("service", "service", "select", "Service", input.services),
+    field("service", "service", "select", "Service", [...input.services]),
     field(
       "vehicle",
       "vehicle",
@@ -469,6 +1493,14 @@ function formSubmitPayload(input, formSubmit, contractHash) {
   const reported = new Set(entries.map((item) => item.name));
   const fields = entries.filter((item) => item.value !== void 0);
   const extra = (formSubmit.extraFields ?? []).filter((item) => !reported.has(item.name));
+  const settings = typedClientSettings(formSubmit.tracking);
+  const { violations, hash } = judgeLeadForm(
+    "booking",
+    formSubmit.formId,
+    fields.map((item) => [item.role, item.value]),
+    formSubmit.contracts,
+    { ...settings, trackingConfig: settings.trackingConfig ?? runtime?.ref }
+  );
   return {
     form: {
       id: formSubmit.formId,
@@ -476,7 +1508,8 @@ function formSubmitPayload(input, formSubmit, contractHash) {
       fields: [...fields, ...extra],
       kind: "booking",
       contract_version: LEAD_FORM_REGISTRY_VERSION,
-      ...contractHash ? { contract_hash: contractHash } : {}
+      ...hash ? { contract_hash: hash } : {},
+      ...violations.length > 0 ? { contract_violations: violations.slice(0, MAX_CONTRACT_VIOLATIONS) } : {}
     },
     page: { path: typeof window === "undefined" ? "/" : window.location.pathname }
   };
@@ -575,10 +1608,9 @@ function createSalesBookingsClient(config, firing) {
       }
       if (formSubmit && !submittedForms.has(attemptKey)) {
         submittedForms.add(attemptKey);
-        const contract = runtime?.leadForms()?.contracts.find((c) => c.form_kind === "booking");
         formSubmit.tracking.trackEvent(
           "form_submit",
-          formSubmitPayload(input, formSubmit, contract?.contract_hash ?? null)
+          formSubmitPayload(input, formSubmit, runtime)
         );
       }
       const body = {
@@ -594,7 +1626,7 @@ function createSalesBookingsClient(config, firing) {
         email: input.email?.trim() || null,
         vehicle: input.vehicle ?? null,
         drop_off: input.dropOff ?? null,
-        services: input.services,
+        services: [...input.services],
         notes: input.notes?.trim() || null,
         marketing_sms_consent: input.marketingSmsConsent === true,
         page_path: typeof window === "undefined" ? null : window.location.pathname
@@ -681,7 +1713,7 @@ function fireRecordedConversions(firing, input, recorded, sale, currency) {
 }
 function createSalesClient(config) {
   if (config.firing) registerCapability("conversion_goals_manual");
-  async function record3(input) {
+  async function record4(input) {
     const currency = input.currency ?? config.defaultCurrency;
     if (!currency) {
       throw new Error(
@@ -707,9 +1739,9 @@ function createSalesClient(config) {
     return sale;
   }
   return {
-    record: record3,
+    record: record4,
     // recordSale is the intent-revealing alias — same behavior, clearer call site.
-    recordSale: record3,
+    recordSale: record4,
     trackConversion(key, options) {
       if (config.firing && "fireConversion" in config.firing) {
         if (options?.userData && getConsentState() !== "denied") stashUserData(options.userData);
@@ -829,17 +1861,17 @@ function createSalesClient(config) {
 }
 
 // ../tracking-core/src/resources/sales/schema.ts
-import * as z3 from "zod/mini";
+import * as z5 from "zod/mini";
 
 // ../tracking-core/src/resources/sales/generated/zod.gen.ts
-import * as z2 from "zod/mini";
-var zAutoLeapSaleFacts = z2.object({
-  first_order: z2.boolean(),
-  fleet_customer: z2.boolean(),
-  invoice_code: z2.string(),
-  invoice_id: z2.string()
+import * as z4 from "zod/mini";
+var zAutoLeapSaleFacts = z4.object({
+  first_order: z4.boolean(),
+  fleet_customer: z4.boolean(),
+  invoice_code: z4.string(),
+  invoice_id: z4.string()
 });
-var zErrorCode = z2.enum([
+var zErrorCode = z4.enum([
   "missing_credentials",
   "invalid_api_key",
   "not_authenticated",
@@ -883,37 +1915,37 @@ var zErrorCode = z2.enum([
   "rate_limited",
   "internal_error"
 ]);
-var zSaleItemEntitySchema = z2.object({
-  category: z2.nullable(z2.string()),
-  external_item_id: z2.nullable(z2.string()),
-  id: z2.uuid(),
-  name: z2.nullable(z2.string()),
-  quantity: z2.string().check(z2.regex(/^(?!^[-+.]*$)[+-]?0*\d*\.?\d*$/)),
-  unit_cost_cents: z2.nullable(z2.int()),
-  unit_price_cents: z2.int()
+var zSaleItemEntitySchema = z4.object({
+  category: z4.nullable(z4.string()),
+  external_item_id: z4.nullable(z4.string()),
+  id: z4.uuid(),
+  name: z4.nullable(z4.string()),
+  quantity: z4.string().check(z4.regex(/^(?!^[-+.]*$)[+-]?0*\d*\.?\d*$/)),
+  unit_cost_cents: z4.nullable(z4.int()),
+  unit_price_cents: z4.int()
 });
-var zSaleItemInputSchema = z2.strictObject({
-  category: z2.nullish(z2.string()),
-  external_item_id: z2.nullish(z2.string()),
-  name: z2.nullish(z2.string()),
-  quantity: z2.string().check(z2.regex(/^\d+(\.\d{1,3})?$/)),
-  unit_cost_cents: z2.nullish(z2.int().check(z2.gte(0))),
-  unit_price_cents: z2.int().check(z2.gte(0))
+var zSaleItemInputSchema = z4.strictObject({
+  category: z4.nullish(z4.string()),
+  external_item_id: z4.nullish(z4.string()),
+  name: z4.nullish(z4.string()),
+  quantity: z4.string().check(z4.regex(/^\d+(\.\d{1,3})?$/)),
+  unit_cost_cents: z4.nullish(z4.int().check(z4.gte(0))),
+  unit_price_cents: z4.int().check(z4.gte(0))
 });
-var zSaleServiceEntitySchema = z2.object({
-  amount_cents: z2.int(),
-  id: z2.uuid(),
-  mapped: z2.nullable(z2.boolean()),
-  service_id: z2.uuid(),
-  service_key: z2.string(),
-  service_label: z2.string()
+var zSaleServiceEntitySchema = z4.object({
+  amount_cents: z4.int(),
+  id: z4.uuid(),
+  mapped: z4.nullable(z4.boolean()),
+  service_id: z4.uuid(),
+  service_key: z4.string(),
+  service_label: z4.string()
 });
-var zSaleServiceInputSchema = z2.strictObject({
-  amount_cents: z2.int().check(z2.gte(0)),
-  service: z2.string()
+var zSaleServiceInputSchema = z4.strictObject({
+  amount_cents: z4.int().check(z4.gte(0)),
+  service: z4.string()
 });
-var zSaleSource = z2.enum(["api", "admin", "autoleap"]);
-var zSmsAutomationState = z2.enum([
+var zSaleSource = z4.enum(["api", "admin", "autoleap"]);
+var zSmsAutomationState = z4.enum([
   "needs_check",
   "failed",
   "undelivered",
@@ -925,7 +1957,7 @@ var zSmsAutomationState = z2.enum([
   "eligible",
   "not_applicable"
 ]);
-var zSmsWithheldReason = z2.enum([
+var zSmsWithheldReason = z4.enum([
   "automation_disabled",
   "sms_disabled",
   "no_phone",
@@ -951,77 +1983,80 @@ var zSmsWithheldReason = z2.enum([
   "confirmed_by_integration",
   "test_or_bot_session",
   "invalid_phone",
-  "recently_texted"
+  "recently_texted",
+  "do_not_contact",
+  "do_not_text_tag",
+  "missing_value"
 ]);
-var zSaleSmsStatusSchema = z2.object({
-  can_send_now: z2._default(z2.boolean(), false),
-  last_message_at: z2.nullable(z2.iso.datetime({ offset: true })),
-  reason_detail: z2.nullable(z2.string()),
+var zSaleSmsStatusSchema = z4.object({
+  can_send_now: z4._default(z4.boolean(), false),
+  last_message_at: z4.nullable(z4.iso.datetime({ offset: true })),
+  reason_detail: z4.nullable(z4.string()),
   state: zSmsAutomationState,
-  suppressed_by_other_sale: z2._default(z2.boolean(), false),
-  withheld_reason: z2.nullable(zSmsWithheldReason)
+  suppressed_by_other_sale: z4._default(z4.boolean(), false),
+  withheld_reason: z4.nullable(zSmsWithheldReason)
 });
-var zSupportedCurrency = z2.enum(["USD", "CAD"]);
-var zTrackingEnvironment = z2.enum(["production", "development"]);
-var zSaleCreateSchema = z2.strictObject({
-  amount_total_cents: z2.nullish(z2.int().check(z2.gte(0))),
+var zSupportedCurrency = z4.enum(["USD", "CAD"]);
+var zTrackingEnvironment = z4.enum(["production", "development"]);
+var zSaleCreateSchema = z4.strictObject({
+  amount_total_cents: z4.nullish(z4.int().check(z4.gte(0))),
   currency: zSupportedCurrency,
-  customer_email: z2.nullish(z2.email().check(z2.maxLength(320))),
-  customer_name: z2.nullish(z2.string().check(z2.maxLength(200))),
-  customer_phone: z2.nullish(z2.string().check(z2.maxLength(64))),
-  description: z2.nullish(z2.string()),
-  environment: z2._default(z2.optional(zTrackingEnvironment), "production"),
-  external_id: z2.nullish(z2.string()),
-  items: z2.optional(z2.array(zSaleItemInputSchema)),
-  metadata: z2.nullish(z2.record(z2.string(), z2.unknown())),
-  occurred_at: z2.iso.datetime({ offset: true }),
-  service: z2.nullish(z2.string()),
-  services: z2.nullish(z2.array(zSaleServiceInputSchema)),
-  sms_consent: z2.nullish(z2.boolean())
+  customer_email: z4.nullish(z4.email().check(z4.maxLength(320))),
+  customer_name: z4.nullish(z4.string().check(z4.maxLength(200))),
+  customer_phone: z4.nullish(z4.string().check(z4.maxLength(64))),
+  description: z4.nullish(z4.string()),
+  environment: z4._default(z4.optional(zTrackingEnvironment), "production"),
+  external_id: z4.nullish(z4.string()),
+  items: z4.optional(z4.array(zSaleItemInputSchema)),
+  metadata: z4.nullish(z4.record(z4.string(), z4.unknown())),
+  occurred_at: z4.iso.datetime({ offset: true }),
+  service: z4.nullish(z4.string()),
+  services: z4.nullish(z4.array(zSaleServiceInputSchema)),
+  sms_consent: z4.nullish(z4.boolean())
 });
-var zValidationError = z2.object({
-  ctx: z2.optional(z2.record(z2.string(), z2.unknown())),
-  input: z2.optional(z2.unknown()),
-  loc: z2.array(z2.union([z2.string(), z2.int()])),
-  msg: z2.string(),
-  type: z2.string()
+var zValidationError = z4.object({
+  ctx: z4.optional(z4.record(z4.string(), z4.unknown())),
+  input: z4.optional(z4.unknown()),
+  loc: z4.array(z4.union([z4.string(), z4.int()])),
+  msg: z4.string(),
+  type: z4.string()
 });
-var zHttpValidationError = z2.object({
-  detail: z2.optional(z2.array(zValidationError))
+var zHttpValidationError = z4.object({
+  detail: z4.optional(z4.array(zValidationError))
 });
-var zValidationErrorItem = z2.object({
-  loc: z2.array(z2.union([z2.string(), z2.int()])),
-  msg: z2.string(),
-  type: z2.string()
+var zValidationErrorItem = z4.object({
+  loc: z4.array(z4.union([z4.string(), z4.int()])),
+  msg: z4.string(),
+  type: z4.string()
 });
-var zApiErrorSchema = z2.object({
+var zApiErrorSchema = z4.object({
   code: zErrorCode,
-  context: z2._default(z2.nullish(z2.record(z2.string(), z2.unknown())), null),
-  detail: z2.string(),
-  errors: z2._default(z2.nullish(z2.array(zValidationErrorItem)), null),
-  request_id: z2._default(z2.nullish(z2.string()), null)
+  context: z4._default(z4.nullish(z4.record(z4.string(), z4.unknown())), null),
+  detail: z4.string(),
+  errors: z4._default(z4.nullish(z4.array(zValidationErrorItem)), null),
+  request_id: z4._default(z4.nullish(z4.string()), null)
 });
-var zWritebackEmailSource = z2.enum(["NONE", "SALE", "CUSTOMER", "HARVESTED"]);
-var zWritebackEnrichmentStatus = z2.enum(["NONE", "MATCHED", "AMBIGUOUS"]);
-var zWritebackSaleUploadCounts = z2.object({
-  failed: z2._default(z2.int(), 0),
-  pending: z2._default(z2.int(), 0),
-  skipped: z2._default(z2.int(), 0),
-  submitted: z2._default(z2.int(), 0),
-  total: z2._default(z2.int(), 0),
-  uploaded: z2._default(z2.int(), 0)
+var zWritebackEmailSource = z4.enum(["NONE", "SALE", "CUSTOMER", "HARVESTED"]);
+var zWritebackEnrichmentStatus = z4.enum(["NONE", "MATCHED", "AMBIGUOUS"]);
+var zWritebackSaleUploadCounts = z4.object({
+  failed: z4._default(z4.int(), 0),
+  pending: z4._default(z4.int(), 0),
+  skipped: z4._default(z4.int(), 0),
+  submitted: z4._default(z4.int(), 0),
+  total: z4._default(z4.int(), 0),
+  uploaded: z4._default(z4.int(), 0)
 });
-var zSaleWritebackStatusSchema = z2.object({
-  blocked_reason: z2.nullable(z2.string()),
-  can_dispatch: z2._default(z2.boolean(), false),
-  email_source: z2.nullable(zWritebackEmailSource),
-  enrichment_status: z2.nullable(zWritebackEnrichmentStatus),
-  gclid_attached: z2._default(z2.boolean(), false),
-  identifiers_sent: z2.nullable(z2.string()),
-  mapped_service_ids: z2.array(z2.uuid()),
-  matched_submit_count: z2.nullable(z2.int()),
-  needs_force: z2._default(z2.boolean(), false),
-  rollup: z2.enum([
+var zSaleWritebackStatusSchema = z4.object({
+  blocked_reason: z4.nullable(z4.string()),
+  can_dispatch: z4._default(z4.boolean(), false),
+  email_source: z4.nullable(zWritebackEmailSource),
+  enrichment_status: z4.nullable(zWritebackEnrichmentStatus),
+  gclid_attached: z4._default(z4.boolean(), false),
+  identifiers_sent: z4.nullable(z4.string()),
+  mapped_service_ids: z4.array(z4.uuid()),
+  matched_submit_count: z4.nullable(z4.int()),
+  needs_force: z4._default(z4.boolean(), false),
+  rollup: z4.enum([
     "failed",
     "skipped",
     "pending",
@@ -1031,39 +2066,39 @@ var zSaleWritebackStatusSchema = z2.object({
     "out_of_window",
     "blocked"
   ]),
-  stale: z2._default(z2.boolean(), false),
-  uncovered_service_ids: z2.array(z2.uuid()),
+  stale: z4._default(z4.boolean(), false),
+  uncovered_service_ids: z4.array(z4.uuid()),
   uploads: zWritebackSaleUploadCounts
 });
-var zSaleEntitySchema = z2.object({
-  amount_total_cents: z2.int(),
-  business_id: z2.uuid(),
-  business_name: z2.nullable(z2.string()),
-  created_at: z2.iso.datetime({ offset: true }),
-  currency: z2.string(),
-  customer_email: z2.nullable(z2.string()),
-  customer_name: z2.nullable(z2.string()),
-  customer_name_placeholder_confirmed: z2._default(z2.boolean(), false),
-  customer_name_placeholder_confirmed_at: z2.nullable(z2.iso.datetime({ offset: true })),
-  customer_phone: z2.nullable(z2.string()),
-  description: z2.nullable(z2.string()),
+var zSaleEntitySchema = z4.object({
+  amount_total_cents: z4.int(),
+  business_id: z4.uuid(),
+  business_name: z4.nullable(z4.string()),
+  created_at: z4.iso.datetime({ offset: true }),
+  currency: z4.string(),
+  customer_email: z4.nullable(z4.string()),
+  customer_name: z4.nullable(z4.string()),
+  customer_name_placeholder_confirmed: z4._default(z4.boolean(), false),
+  customer_name_placeholder_confirmed_at: z4.nullable(z4.iso.datetime({ offset: true })),
+  customer_phone: z4.nullable(z4.string()),
+  description: z4.nullable(z4.string()),
   environment: zTrackingEnvironment,
-  external_id: z2.nullable(z2.string()),
-  id: z2.uuid(),
-  items: z2.array(zSaleItemEntitySchema),
-  metadata: z2.nullable(z2.record(z2.string(), z2.unknown())),
-  occurred_at: z2.iso.datetime({ offset: true }),
-  service_id: z2.nullable(z2.uuid()),
-  service_key: z2.nullable(z2.string()),
-  service_label: z2.nullable(z2.string()),
-  services: z2.array(zSaleServiceEntitySchema),
-  sms_automation: z2.nullable(zSaleSmsStatusSchema),
-  sms_consent: z2._default(z2.boolean(), false),
-  sms_consent_granted_at: z2.nullable(z2.iso.datetime({ offset: true })),
+  external_id: z4.nullable(z4.string()),
+  id: z4.uuid(),
+  items: z4.array(zSaleItemEntitySchema),
+  metadata: z4.nullable(z4.record(z4.string(), z4.unknown())),
+  occurred_at: z4.iso.datetime({ offset: true }),
+  service_id: z4.nullable(z4.uuid()),
+  service_key: z4.nullable(z4.string()),
+  service_label: z4.nullable(z4.string()),
+  services: z4.array(zSaleServiceEntitySchema),
+  sms_automation: z4.nullable(zSaleSmsStatusSchema),
+  sms_consent: z4._default(z4.boolean(), false),
+  sms_consent_granted_at: z4.nullable(z4.iso.datetime({ offset: true })),
   source: zSaleSource,
-  source_facts: z2.nullable(zAutoLeapSaleFacts),
-  updated_at: z2.iso.datetime({ offset: true }),
-  writeback: z2.nullable(zSaleWritebackStatusSchema)
+  source_facts: z4.nullable(zAutoLeapSaleFacts),
+  updated_at: z4.iso.datetime({ offset: true }),
+  writeback: z4.nullable(zSaleWritebackStatusSchema)
 });
 
 // ../tracking-core/src/resources/sales/schema.ts
@@ -1072,11 +2107,11 @@ var saleServiceSchema = zSaleServiceInputSchema;
 var currencySchema = zSupportedCurrency;
 var SUPPORTED_CURRENCIES = currencySchema.options;
 var SALE_SOURCES = zSaleSource.options;
-var centsSchema = z3.int().check(z3.gte(0));
-var metadataSchema = z3.record(z3.string(), z3.unknown());
-var customerNameSchema = z3.string().check(z3.maxLength(200));
-var customerPhoneSchema = z3.string().check(z3.maxLength(64));
-var customerEmailSchema = z3.email().check(z3.maxLength(320));
+var centsSchema = z5.int().check(z5.gte(0));
+var metadataSchema = z5.record(z5.string(), z5.unknown());
+var customerNameSchema = z5.string().check(z5.maxLength(200));
+var customerPhoneSchema = z5.string().check(z5.maxLength(64));
+var customerEmailSchema = z5.email().check(z5.maxLength(320));
 function addIssue(ctx, path, message) {
   ctx.issues.push({ code: "custom", input: ctx.value, path, message });
 }
@@ -1110,24 +2145,24 @@ function refineServiceXor(val, ctx, { requireAmount }) {
     );
   }
 }
-var saleCreateSchema = z3.extend(zSaleCreateSchema, { items: z3._default(z3.array(saleItemSchema), []) }).check((ctx) => refineServiceXor(ctx.value, ctx, { requireAmount: true }));
-var saleUpdateSchema = z3.strictObject({
-  description: z3.nullish(z3.string()),
-  service: z3.nullish(z3.string()),
-  services: z3.nullish(z3.array(saleServiceSchema)),
-  currency: z3.optional(currencySchema),
-  amount_total_cents: z3.optional(centsSchema),
-  occurred_at: z3.optional(z3.iso.datetime()),
-  items: z3.optional(z3.array(saleItemSchema)),
-  metadata: z3.nullish(metadataSchema),
-  customer_name: z3.nullish(customerNameSchema),
+var saleCreateSchema = z5.extend(zSaleCreateSchema, { items: z5._default(z5.array(saleItemSchema), []) }).check((ctx) => refineServiceXor(ctx.value, ctx, { requireAmount: true }));
+var saleUpdateSchema = z5.strictObject({
+  description: z5.nullish(z5.string()),
+  service: z5.nullish(z5.string()),
+  services: z5.nullish(z5.array(saleServiceSchema)),
+  currency: z5.optional(currencySchema),
+  amount_total_cents: z5.optional(centsSchema),
+  occurred_at: z5.optional(z5.iso.datetime()),
+  items: z5.optional(z5.array(saleItemSchema)),
+  metadata: z5.nullish(metadataSchema),
+  customer_name: z5.nullish(customerNameSchema),
   // Re-attest when changing a filler-looking name; the server clears the
   // prior attestation whenever `customer_name` changes.
-  customer_name_placeholder_confirmed: z3.optional(z3.boolean()),
-  customer_phone: z3.nullish(customerPhoneSchema),
-  customer_email: z3.nullish(customerEmailSchema),
+  customer_name_placeholder_confirmed: z5.optional(z5.boolean()),
+  customer_phone: z5.nullish(customerPhoneSchema),
+  customer_email: z5.nullish(customerEmailSchema),
   // NOT NULL server-side: omit to leave unchanged (explicit null is rejected).
-  sms_consent: z3.optional(z3.boolean())
+  sms_consent: z5.optional(z5.boolean())
 }).check((ctx) => refineServiceXor(ctx.value, ctx, { requireAmount: false }));
 var TRACKING_RANGES = ["24h", "7d", "30d"];
 var NAMED_RANGES = [