@aranova/tracking-next 1.0.0 → 1.2.0

package/dist/index.mjs

@@ -213,6 +213,7 @@ var TRACKING_CAPABILITIES = [
   "consent_controls",
   "conversion_goals_auto",
   "conversion_goals_manual",
+  "cross_site_linker",
   "cta_click_capture",
   "form_capture",
   "phone_click_capture",
@@ -239,6 +240,9 @@ function readDomMarkers() {
   return found;
 }
 
+// ../tracking-core/src/cross-site-link.ts
+import * as z from "zod/mini";
+
 // ../tracking-core/src/tracking.ts
 var TRACKING_COOKIE_MAX_AGE_SECONDS = 7776e3;
 var TRACKING_PARAM_KEYS = [
@@ -483,6 +487,72 @@ 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 readLocalStorage(key) {
+  try {
+    return window.localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+function peekVisitorId() {
+  if (typeof window === "undefined") return null;
+  const existing = readLocalStorage(VISITOR_STORAGE_KEY);
+  return existing && existing.length > 0 ? existing : null;
+}
+function peekSessionId(now = Date.now()) {
+  if (typeof window === "undefined") return null;
+  const raw = readLocalStorage(SESSION_STORAGE_KEY);
+  if (!raw) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.id !== "string" || typeof parsed.last_event_at !== "number") return null;
+    return now - parsed.last_event_at <= SESSION_IDLE_MS ? parsed.id : null;
+  } catch {
+    return null;
+  }
+}
+
+// ../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 = 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 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/payloads.ts
 function createTrackingClientContext(surface, input = {}) {
   return {
@@ -522,6 +592,7 @@ function createTrackingSessionUpsertPayload(trackingParams, input, context) {
   };
 }
 function createTrackingEventCreatePayload(trackingParams, input, context) {
+  const pageUrl = input.pageUrl ?? (typeof window === "undefined" ? null : window.location.href);
   return {
     session_id: input.sessionId,
     event_type: input.eventType,
@@ -532,7 +603,7 @@ function createTrackingEventCreatePayload(trackingParams, input, context) {
     fbclid: trackingParams.fbclid,
     fbc: getFbcCookie(),
     fbp: getFbpCookie(),
-    page_url: input.pageUrl ?? (typeof window === "undefined" ? null : window.location.href),
+    page_url: pageUrl === null ? null : stripLinkParam(pageUrl),
     metadata: input.metadata ?? null,
     context
   };
@@ -644,7 +715,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_";
@@ -728,6 +800,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) => {
@@ -935,7 +1008,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
   };
@@ -1086,6 +1159,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 = {};
@@ -1329,6 +1406,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"
   }
 };
 function getEventSemantics(eventName) {
@@ -1570,11 +1659,11 @@ function createSalesClient(config) {
 }
 
 // ../tracking-core/src/resources/sales/schema.ts
-import * as z2 from "zod/mini";
+import * as z3 from "zod/mini";
 
 // ../tracking-core/src/resources/sales/generated/zod.gen.ts
-import * as z from "zod/mini";
-var zErrorCode = z.enum([
+import * as z2 from "zod/mini";
+var zErrorCode = z2.enum([
   "missing_credentials",
   "invalid_api_key",
   "not_authenticated",
@@ -1589,9 +1678,19 @@ var zErrorCode = z.enum([
   "bad_request",
   "not_found",
   "conflict",
+  "gone",
   "incompatible_payload",
   "repeat_confirmation_required",
   "idempotency_conflict",
+  "slot_unavailable",
+  "calendar_not_connected",
+  "calendar_disconnected",
+  "booking_not_found",
+  "booking_not_cancellable",
+  "booking_not_reschedulable",
+  "manage_token_invalid",
+  "google_error",
+  "calendar_not_owned",
   "validation_error",
   "unknown_service",
   "invalid_sale_properties",
@@ -1599,36 +1698,36 @@ var zErrorCode = z.enum([
   "rate_limited",
   "internal_error"
 ]);
-var zSaleItemEntitySchema = z.object({
-  category: z.nullable(z.string()),
-  external_item_id: z.nullable(z.string()),
-  id: z.uuid(),
-  name: z.nullable(z.string()),
-  quantity: z.string().check(z.regex(/^(?!^[-+.]*$)[+-]?0*\d*\.?\d*$/)),
-  unit_cost_cents: z.nullable(z.int()),
-  unit_price_cents: z.int()
+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 zSaleItemInputSchema = z.strictObject({
-  category: z.nullish(z.string()),
-  external_item_id: z.nullish(z.string()),
-  name: z.nullish(z.string()),
-  quantity: z.string().check(z.regex(/^\d+(\.\d{1,3})?$/)),
-  unit_cost_cents: z.nullish(z.int().check(z.gte(0))),
-  unit_price_cents: z.int().check(z.gte(0))
+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 zSaleServiceEntitySchema = z.object({
-  amount_cents: z.int(),
-  id: z.uuid(),
-  mapped: z.nullable(z.boolean()),
-  service_id: z.uuid(),
-  service_key: z.string(),
-  service_label: z.string()
+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 zSaleServiceInputSchema = z.strictObject({
-  amount_cents: z.int().check(z.gte(0)),
-  service: z.string()
+var zSaleServiceInputSchema = z2.strictObject({
+  amount_cents: z2.int().check(z2.gte(0)),
+  service: z2.string()
 });
-var zSmsAutomationState = z.enum([
+var zSmsAutomationState = z2.enum([
   "needs_check",
   "failed",
   "undelivered",
@@ -1640,7 +1739,7 @@ var zSmsAutomationState = z.enum([
   "eligible",
   "not_applicable"
 ]);
-var zSmsWithheldReason = z.enum([
+var zSmsWithheldReason = z2.enum([
   "automation_disabled",
   "sms_disabled",
   "no_phone",
@@ -1653,77 +1752,83 @@ var zSmsWithheldReason = z.enum([
   "sender_not_ready",
   "missing_review_url",
   "no_handler",
-  "dispatch_already_recorded"
+  "dispatch_already_recorded",
+  "text_back_disabled",
+  "number_text_back_disabled",
+  "number_not_active",
+  "a2p_registration_required",
+  "alert_recipient_cannot_receive_sms",
+  "line_type_unresolved"
 ]);
-var zSaleSmsStatusSchema = z.object({
-  can_send_now: z._default(z.boolean(), false),
-  last_message_at: z.nullable(z.iso.datetime({ offset: true })),
-  reason_detail: z.nullable(z.string()),
+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()),
   state: zSmsAutomationState,
-  suppressed_by_other_sale: z._default(z.boolean(), false),
-  withheld_reason: z.nullable(zSmsWithheldReason)
+  suppressed_by_other_sale: z2._default(z2.boolean(), false),
+  withheld_reason: z2.nullable(zSmsWithheldReason)
 });
-var zSupportedCurrency = z.enum(["USD", "CAD"]);
-var zTrackingEnvironment = z.enum(["production", "development"]);
-var zSaleCreateSchema = z.strictObject({
-  amount_total_cents: z.nullish(z.int().check(z.gte(0))),
+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))),
   currency: zSupportedCurrency,
-  customer_email: z.nullish(z.email().check(z.maxLength(320))),
-  customer_name: z.nullish(z.string().check(z.maxLength(200))),
-  customer_phone: z.nullish(z.string().check(z.maxLength(64))),
-  description: z.nullish(z.string()),
-  environment: z._default(z.optional(zTrackingEnvironment), "production"),
-  external_id: z.nullish(z.string()),
-  items: z.optional(z.array(zSaleItemInputSchema)),
-  metadata: z.nullish(z.record(z.string(), z.unknown())),
-  occurred_at: z.iso.datetime({ offset: true }),
-  service: z.nullish(z.string()),
-  services: z.nullish(z.array(zSaleServiceInputSchema)),
-  sms_consent: z.nullish(z.boolean())
+  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())
 });
-var zValidationError = z.object({
-  ctx: z.optional(z.record(z.string(), z.unknown())),
-  input: z.optional(z.unknown()),
-  loc: z.array(z.union([z.string(), z.int()])),
-  msg: z.string(),
-  type: z.string()
+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 zHttpValidationError = z.object({
-  detail: z.optional(z.array(zValidationError))
+var zHttpValidationError = z2.object({
+  detail: z2.optional(z2.array(zValidationError))
 });
-var zValidationErrorItem = z.object({
-  loc: z.array(z.union([z.string(), z.int()])),
-  msg: z.string(),
-  type: z.string()
+var zValidationErrorItem = z2.object({
+  loc: z2.array(z2.union([z2.string(), z2.int()])),
+  msg: z2.string(),
+  type: z2.string()
 });
-var zApiErrorSchema = z.object({
+var zApiErrorSchema = z2.object({
   code: zErrorCode,
-  context: z._default(z.nullish(z.record(z.string(), z.unknown())), null),
-  detail: z.string(),
-  errors: z._default(z.nullish(z.array(zValidationErrorItem)), null),
-  request_id: z._default(z.nullish(z.string()), null)
+  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)
 });
-var zWritebackEmailSource = z.enum(["NONE", "SALE", "CUSTOMER", "HARVESTED"]);
-var zWritebackEnrichmentStatus = z.enum(["NONE", "MATCHED", "AMBIGUOUS"]);
-var zWritebackSaleUploadCounts = z.object({
-  failed: z._default(z.int(), 0),
-  pending: z._default(z.int(), 0),
-  skipped: z._default(z.int(), 0),
-  submitted: z._default(z.int(), 0),
-  total: z._default(z.int(), 0),
-  uploaded: z._default(z.int(), 0)
+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 zSaleWritebackStatusSchema = z.object({
-  blocked_reason: z.nullable(z.string()),
-  can_dispatch: z._default(z.boolean(), false),
-  email_source: z.nullable(zWritebackEmailSource),
-  enrichment_status: z.nullable(zWritebackEnrichmentStatus),
-  gclid_attached: z._default(z.boolean(), false),
-  identifiers_sent: z.nullable(z.string()),
-  mapped_service_ids: z.array(z.uuid()),
-  matched_submit_count: z.nullable(z.int()),
-  needs_force: z._default(z.boolean(), false),
-  rollup: z.enum([
+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([
     "failed",
     "skipped",
     "pending",
@@ -1733,37 +1838,37 @@ var zSaleWritebackStatusSchema = z.object({
     "out_of_window",
     "blocked"
   ]),
-  stale: z._default(z.boolean(), false),
-  uncovered_service_ids: z.array(z.uuid()),
+  stale: z2._default(z2.boolean(), false),
+  uncovered_service_ids: z2.array(z2.uuid()),
   uploads: zWritebackSaleUploadCounts
 });
-var zSaleEntitySchema = z.object({
-  amount_total_cents: z.int(),
-  business_id: z.uuid(),
-  business_name: z.nullable(z.string()),
-  created_at: z.iso.datetime({ offset: true }),
-  currency: z.string(),
-  customer_email: z.nullable(z.string()),
-  customer_name: z.nullable(z.string()),
-  customer_name_placeholder_confirmed: z._default(z.boolean(), false),
-  customer_name_placeholder_confirmed_at: z.nullable(z.iso.datetime({ offset: true })),
-  customer_phone: z.nullable(z.string()),
-  description: z.nullable(z.string()),
+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()),
   environment: zTrackingEnvironment,
-  external_id: z.nullable(z.string()),
-  id: z.uuid(),
-  items: z.array(zSaleItemEntitySchema),
-  metadata: z.nullable(z.record(z.string(), z.unknown())),
-  occurred_at: z.iso.datetime({ offset: true }),
-  service_id: z.nullable(z.uuid()),
-  service_key: z.nullable(z.string()),
-  service_label: z.nullable(z.string()),
-  services: z.array(zSaleServiceEntitySchema),
-  sms_automation: z.nullable(zSaleSmsStatusSchema),
-  sms_consent: z._default(z.boolean(), false),
-  sms_consent_granted_at: z.nullable(z.iso.datetime({ offset: true })),
-  updated_at: z.iso.datetime({ offset: true }),
-  writeback: z.nullable(zSaleWritebackStatusSchema)
+  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 })),
+  updated_at: z2.iso.datetime({ offset: true }),
+  writeback: z2.nullable(zSaleWritebackStatusSchema)
 });
 
 // ../tracking-core/src/resources/sales/schema.ts
@@ -1771,11 +1876,11 @@ var saleItemSchema = zSaleItemInputSchema;
 var saleServiceSchema = zSaleServiceInputSchema;
 var currencySchema = zSupportedCurrency;
 var SUPPORTED_CURRENCIES = currencySchema.options;
-var centsSchema = z2.int().check(z2.gte(0));
-var metadataSchema = z2.record(z2.string(), z2.unknown());
-var customerNameSchema = z2.string().check(z2.maxLength(200));
-var customerPhoneSchema = z2.string().check(z2.maxLength(64));
-var customerEmailSchema = z2.email().check(z2.maxLength(320));
+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));
 function addIssue(ctx, path, message) {
   ctx.issues.push({ code: "custom", input: ctx.value, path, message });
 }
@@ -1809,24 +1914,24 @@ function refineServiceXor(val, ctx, { requireAmount }) {
     );
   }
 }
-var saleCreateSchema = z2.extend(zSaleCreateSchema, { items: z2._default(z2.array(saleItemSchema), []) }).check((ctx) => refineServiceXor(ctx.value, ctx, { requireAmount: true }));
-var saleUpdateSchema = z2.strictObject({
-  description: z2.nullish(z2.string()),
-  service: z2.nullish(z2.string()),
-  services: z2.nullish(z2.array(saleServiceSchema)),
-  currency: z2.optional(currencySchema),
-  amount_total_cents: z2.optional(centsSchema),
-  occurred_at: z2.optional(z2.iso.datetime()),
-  items: z2.optional(z2.array(saleItemSchema)),
-  metadata: z2.nullish(metadataSchema),
-  customer_name: z2.nullish(customerNameSchema),
+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),
   // Re-attest when changing a filler-looking name; the server clears the
   // prior attestation whenever `customer_name` changes.
-  customer_name_placeholder_confirmed: z2.optional(z2.boolean()),
-  customer_phone: z2.nullish(customerPhoneSchema),
-  customer_email: z2.nullish(customerEmailSchema),
+  customer_name_placeholder_confirmed: z3.optional(z3.boolean()),
+  customer_phone: z3.nullish(customerPhoneSchema),
+  customer_email: z3.nullish(customerEmailSchema),
   // NOT NULL server-side: omit to leave unchanged (explicit null is rejected).
-  sms_consent: z2.optional(z2.boolean())
+  sms_consent: z3.optional(z3.boolean())
 }).check((ctx) => refineServiceXor(ctx.value, ctx, { requireAmount: false }));
 var TRACKING_RANGES = ["24h", "7d", "30d"];
 var NAMED_RANGES = [
@@ -1866,6 +1971,40 @@ import {
   useTrackingParams
 } from "@aranova/tracking-next/client";
 
+// ../tracking-core/src/resources/calendar/attribution.ts
+var LIMITS = {
+  session_id: 64,
+  visitor_id: 64,
+  gclid: 256,
+  fbclid: 256,
+  utm_source: 128,
+  utm_medium: 128,
+  utm_campaign: 128,
+  utm_term: 128,
+  utm_content: 128
+};
+function getBookingAttribution() {
+  if (typeof window === "undefined") return {};
+  const params = getTrackingParamsFromCookieReader(getCookieValueFromDocument);
+  const values = {
+    session_id: peekSessionId(),
+    visitor_id: peekVisitorId(),
+    gclid: params.gclid,
+    fbclid: params.fbclid,
+    utm_source: params.utm_source,
+    utm_medium: params.utm_medium,
+    utm_campaign: params.utm_campaign,
+    utm_term: params.utm_term,
+    utm_content: params.utm_content
+  };
+  const attribution = {};
+  for (const key of Object.keys(LIMITS)) {
+    const value = values[key];
+    if (value) attribution[key] = value.slice(0, LIMITS[key]);
+  }
+  return attribution;
+}
+
 // ../tracking-core/src/resources/calendar/transport.ts
 async function calendarRequest(config, method, path, body) {
   return apiRequest(config, method, `/calendar${path}`, body);
@@ -1964,80 +2103,119 @@ function isCalendarError(error, code) {
 }
 
 // ../tracking-core/src/resources/calendar/schema.ts
-import * as z4 from "zod/mini";
+import * as z5 from "zod/mini";
 
 // ../tracking-core/src/resources/calendar/generated/zod.gen.ts
-import * as z3 from "zod/mini";
-var zBookingAttendee = z3.strictObject({
-  display_name: z3.nullish(z3.string().check(z3.maxLength(200))),
-  email: z3.email().check(z3.maxLength(320)),
-  optional: z3._default(z3.optional(z3.boolean()), false)
+import * as z4 from "zod/mini";
+var zBookingAttendee = z4.strictObject({
+  display_name: z4.nullish(z4.string().check(z4.maxLength(200))),
+  email: z4.email().check(z4.maxLength(320)),
+  optional: z4._default(z4.optional(z4.boolean()), false)
 });
-var zBookingCancelSchema = z3.strictObject({
-  notify_attendees: z3._default(z3.optional(z3.boolean()), true),
-  reason: z3.nullish(z3.string().check(z3.maxLength(500)))
+var zBookingCancelSchema = z4.strictObject({
+  notify_attendees: z4._default(z4.optional(z4.boolean()), true),
+  reason: z4.nullish(z4.string().check(z4.maxLength(500)))
 });
-var zBookingCustomerInput = z3.strictObject({
-  email: z3.email().check(z3.maxLength(320)),
-  name: z3.nullish(z3.string().check(z3.maxLength(200))),
-  phone: z3.nullish(z3.string().check(z3.maxLength(64))),
-  sms_consent: z3._default(z3.optional(z3.boolean()), false)
+var zBookingCustomerInput = z4.strictObject({
+  email: z4.email().check(z4.maxLength(320)),
+  name: z4.nullish(z4.string().check(z4.maxLength(200))),
+  phone: z4.nullish(z4.string().check(z4.maxLength(64))),
+  sms_consent: z4._default(z4.optional(z4.boolean()), false)
 });
-var zBookingCustomerOutput = z3.strictObject({
-  email: z3.email().check(z3.maxLength(320)),
-  name: z3.nullable(z3.string().check(z3.maxLength(200))),
-  phone: z3.nullable(z3.string().check(z3.maxLength(64))),
-  sms_consent: z3._default(z3.boolean(), false)
+var zBookingCustomerOutput = z4.strictObject({
+  email: z4.email().check(z4.maxLength(320)),
+  name: z4.nullable(z4.string().check(z4.maxLength(200))),
+  phone: z4.nullable(z4.string().check(z4.maxLength(64))),
+  sms_consent: z4._default(z4.boolean(), false)
 });
-var zBookingRescheduleSchema = z3.strictObject({
-  duration_minutes: z3.nullish(z3.int().check(z3.gt(0), z3.lte(1440))),
-  end_at: z3.nullish(z3.iso.datetime({ offset: true })),
-  notify_attendees: z3._default(z3.optional(z3.boolean()), true),
-  reason: z3.nullish(z3.string().check(z3.maxLength(500))),
-  start_at: z3.iso.datetime({ offset: true }),
-  time_zone: z3.string().check(z3.minLength(1), z3.maxLength(64), z3.regex(/^[A-Za-z0-9_+\-\/]+$/))
+var zBookingRescheduleSchema = z4.strictObject({
+  duration_minutes: z4.nullish(z4.int().check(z4.gt(0), z4.lte(1440))),
+  end_at: z4.nullish(z4.iso.datetime({ offset: true })),
+  notify_attendees: z4._default(z4.optional(z4.boolean()), true),
+  reason: z4.nullish(z4.string().check(z4.maxLength(500))),
+  start_at: z4.iso.datetime({ offset: true }),
+  time_zone: z4.string().check(z4.minLength(1), z4.maxLength(64), z4.regex(/^[A-Za-z0-9_+\-\/]+$/))
 });
-var zBookingResponse = z3.strictObject({
-  appointment_type: z3.nullable(z3.string()),
-  calendar_key: z3.string(),
+var zBookingResponse = z4.strictObject({
+  all_day: z4.boolean(),
+  appointment_type: z4.nullable(z4.string()),
+  calendar_key: z4.string(),
+  created_at: z4.iso.datetime({ offset: true }),
   customer: zBookingCustomerOutput,
-  end_at: z3.iso.datetime({ offset: true }),
-  google_html_link: z3.nullable(z3.string()),
-  google_sync_state: z3.string(),
-  id: z3.string(),
-  manage_token: z3.nullable(z3.string()),
-  meet_url: z3.nullable(z3.string()),
-  start_at: z3.iso.datetime({ offset: true }),
-  status: z3.string(),
-  time_zone: z3.string(),
-  title: z3.string()
+  end_at: z4.iso.datetime({ offset: true }),
+  google_event_id: z4.nullable(z4.string()),
+  google_html_link: z4.nullable(z4.string()),
+  google_sync_state: z4.enum(["queued", "synced", "uncertain", "failed", "drifted"]),
+  ical_uid: z4.nullable(z4.string()),
+  id: z4.string(),
+  manage_token: z4.nullable(z4.string()),
+  meet_url: z4.nullable(z4.string()),
+  organizer_email: z4.nullable(z4.string()),
+  start_at: z4.iso.datetime({ offset: true }),
+  status: z4.enum(["pending", "confirmed", "cancelled", "no_show"]),
+  time_zone: z4.string(),
+  title: z4.string()
 });
-var zBookingSource = z3.enum(["website", "phone", "walk_in", "import", "operator"]);
-var zBookingMetadata = z3.strictObject({
-  custom: z3.nullish(
-    z3.record(z3.string(), z3.nullable(z3.union([z3.string(), z3.int(), z3.number(), z3.boolean()])))
+var zBookingSource = z4.enum(["website", "phone", "walk_in", "import", "operator"]);
+var zBookingMetadataInput = z4.strictObject({
+  custom: z4.nullish(
+    z4.record(z4.string(), z4.nullable(z4.union([z4.string(), z4.int(), z4.number(), z4.boolean()])))
   ),
-  fbclid: z3.nullish(z3.string().check(z3.maxLength(256))),
-  gclid: z3.nullish(z3.string().check(z3.maxLength(256))),
-  landing_page: z3.nullish(z3.string().check(z3.maxLength(2048))),
-  notes: z3.nullish(z3.string().check(z3.maxLength(2e3))),
-  referrer: z3.nullish(z3.string().check(z3.maxLength(2048))),
-  schema_version: z3._default(z3.optional(z3.int()), 1),
-  service: z3.nullish(z3.string().check(z3.maxLength(64))),
-  session_id: z3.nullish(z3.string().check(z3.maxLength(64))),
-  source: z3.nullish(zBookingSource),
-  utm_campaign: z3.nullish(z3.string().check(z3.maxLength(128))),
-  utm_content: z3.nullish(z3.string().check(z3.maxLength(128))),
-  utm_medium: z3.nullish(z3.string().check(z3.maxLength(128))),
-  utm_source: z3.nullish(z3.string().check(z3.maxLength(128))),
-  utm_term: z3.nullish(z3.string().check(z3.maxLength(128))),
-  visitor_id: z3.nullish(z3.string().check(z3.maxLength(64)))
+  fbclid: z4.nullish(z4.string().check(z4.maxLength(256))),
+  gclid: z4.nullish(z4.string().check(z4.maxLength(256))),
+  landing_page: z4.nullish(z4.string().check(z4.maxLength(2048))),
+  notes: z4.nullish(z4.string().check(z4.maxLength(2e3))),
+  referrer: z4.nullish(z4.string().check(z4.maxLength(2048))),
+  schema_version: z4._default(z4.optional(z4.int()), 1),
+  service: z4.nullish(z4.string().check(z4.maxLength(64))),
+  session_id: z4.nullish(z4.string().check(z4.maxLength(64))),
+  source: z4.nullish(zBookingSource),
+  utm_campaign: z4.nullish(z4.string().check(z4.maxLength(128))),
+  utm_content: z4.nullish(z4.string().check(z4.maxLength(128))),
+  utm_medium: z4.nullish(z4.string().check(z4.maxLength(128))),
+  utm_source: z4.nullish(z4.string().check(z4.maxLength(128))),
+  utm_term: z4.nullish(z4.string().check(z4.maxLength(128))),
+  visitor_id: z4.nullish(z4.string().check(z4.maxLength(64)))
 });
-var zCustomLocation = z3.strictObject({
-  kind: z3.literal("custom"),
-  text: z3.string().check(z3.maxLength(1024))
+var zBusySource = z4.enum(["google", "booking"]);
+var zBusyInterval = z4.strictObject({
+  end_at: z4.iso.datetime({ offset: true }),
+  source: zBusySource,
+  start_at: z4.iso.datetime({ offset: true })
 });
-var zErrorCode2 = z3.enum([
+var zBusyWindow = z4.strictObject({
+  since: z4.iso.datetime({ offset: true }),
+  until: z4.iso.datetime({ offset: true })
+});
+var zBusyResponse = z4.strictObject({
+  busy: z4.array(zBusyInterval),
+  calendar_key: z4.string(),
+  generated_at: z4.iso.datetime({ offset: true }),
+  time_zone: z4.string(),
+  window: zBusyWindow
+});
+var zCalendarSummary = z4.strictObject({
+  allow_overlaps: z4.boolean(),
+  calendar_key: z4.string(),
+  connected_at: z4.nullable(z4.iso.datetime({ offset: true })),
+  google_account_email: z4.nullable(z4.string()),
+  granted_scopes: z4.nullable(z4.array(z4.string())),
+  label: z4.string(),
+  status: z4.enum([
+    "pending_invite",
+    "awaiting_calendar_selection",
+    "connected",
+    "needs_reconnect",
+    "revoked",
+    "disabled"
+  ]),
+  time_zone: z4.string()
+});
+var zCustomLocation = z4.strictObject({
+  kind: z4.literal("custom"),
+  text: z4.string().check(z4.maxLength(1024))
+});
+var zErrorCode2 = z4.enum([
   "missing_credentials",
   "invalid_api_key",
   "not_authenticated",
@@ -2052,9 +2230,19 @@ var zErrorCode2 = z3.enum([
   "bad_request",
   "not_found",
   "conflict",
+  "gone",
   "incompatible_payload",
   "repeat_confirmation_required",
   "idempotency_conflict",
+  "slot_unavailable",
+  "calendar_not_connected",
+  "calendar_disconnected",
+  "booking_not_found",
+  "booking_not_cancellable",
+  "booking_not_reschedulable",
+  "manage_token_invalid",
+  "google_error",
+  "calendar_not_owned",
   "validation_error",
   "unknown_service",
   "invalid_sale_properties",
@@ -2062,66 +2250,67 @@ var zErrorCode2 = z3.enum([
   "rate_limited",
   "internal_error"
 ]);
-var zMeetLocation = z3.strictObject({
-  kind: z3.literal("google_meet")
+var zMeetLocation = z4.strictObject({
+  kind: z4.literal("google_meet")
 });
-var zPhoneLocation = z3.strictObject({
-  kind: z3.literal("phone"),
-  phone: z3.string().check(z3.maxLength(64))
+var zPhoneLocation = z4.strictObject({
+  kind: z4.literal("phone"),
+  phone: z4.string().check(z4.maxLength(64))
 });
-var zPhysicalLocation = z3.strictObject({
-  address: z3.string().check(z3.maxLength(1024)),
-  kind: z3.literal("physical")
+var zPhysicalLocation = z4.strictObject({
+  address: z4.string().check(z4.maxLength(1024)),
+  kind: z4.literal("physical")
 });
-var zReminderMethod = z3.enum(["email", "popup"]);
-var zBookingReminder = z3.strictObject({
+var zReminderMethod = z4.enum(["email", "popup"]);
+var zBookingReminder = z4.strictObject({
   method: zReminderMethod,
-  minutes_before: z3.int().check(z3.gte(0), z3.lte(40320))
+  minutes_before: z4.int().check(z4.gte(0), z4.lte(40320))
 });
-var zBookingReminders = z3.strictObject({
-  overrides: z3.optional(z3.array(zBookingReminder).check(z3.maxLength(5))),
-  use_calendar_defaults: z3._default(z3.optional(z3.boolean()), true)
+var zBookingReminders = z4.strictObject({
+  overrides: z4.optional(z4.array(zBookingReminder).check(z4.maxLength(5))),
+  use_calendar_defaults: z4._default(z4.optional(z4.boolean()), true)
 });
-var zBookingCreateSchema = z3.strictObject({
-  appointment_type: z3.nullish(z3.string().check(z3.maxLength(64))),
-  attendees: z3.optional(z3.array(zBookingAttendee).check(z3.maxLength(20))),
-  buffer_after_minutes: z3._default(z3.optional(z3.int().check(z3.gte(0), z3.lte(1440))), 0),
-  buffer_before_minutes: z3._default(z3.optional(z3.int().check(z3.gte(0), z3.lte(1440))), 0),
-  calendar_key: z3.string().check(z3.minLength(1), z3.maxLength(64)),
+var zBookingCreateSchema = z4.strictObject({
+  appointment_type: z4.nullish(z4.string().check(z4.maxLength(64))),
+  attendees: z4.optional(z4.array(zBookingAttendee).check(z4.maxLength(20))),
+  buffer_after_minutes: z4._default(z4.optional(z4.int().check(z4.gte(0), z4.lte(1440))), 0),
+  buffer_before_minutes: z4._default(z4.optional(z4.int().check(z4.gte(0), z4.lte(1440))), 0),
+  calendar_key: z4.string().check(z4.minLength(1), z4.maxLength(64)),
   customer: zBookingCustomerInput,
-  description: z3.nullish(z3.string().check(z3.maxLength(8e3))),
-  duration_minutes: z3.nullish(z3.int().check(z3.gt(0), z3.lte(1440))),
-  end_at: z3.nullish(z3.iso.datetime({ offset: true })),
-  idempotency_key: z3.nullish(z3.string().check(z3.maxLength(128))),
-  location: z3.nullish(z3.union([zMeetLocation, zPhysicalLocation, zPhoneLocation, zCustomLocation])),
-  metadata: z3.nullish(zBookingMetadata),
-  reminders: z3.nullish(zBookingReminders),
-  send_invites: z3._default(z3.optional(z3.boolean()), true),
-  start_at: z3.iso.datetime({ offset: true }),
-  time_zone: z3.string().check(z3.minLength(1), z3.maxLength(64), z3.regex(/^[A-Za-z0-9_+\-\/]+$/)),
-  title: z3.nullish(z3.string().check(z3.maxLength(300)))
+  date: z4.nullish(z4.iso.date()),
+  description: z4.nullish(z4.string().check(z4.maxLength(8e3))),
+  duration_minutes: z4.nullish(z4.int().check(z4.gt(0), z4.lte(1440))),
+  end_at: z4.nullish(z4.iso.datetime({ offset: true })),
+  idempotency_key: z4.nullish(z4.string().check(z4.maxLength(128))),
+  location: z4.nullish(z4.union([zMeetLocation, zPhysicalLocation, zPhoneLocation, zCustomLocation])),
+  metadata: z4.nullish(zBookingMetadataInput),
+  reminders: z4.nullish(zBookingReminders),
+  send_invites: z4._default(z4.optional(z4.boolean()), true),
+  start_at: z4.nullish(z4.iso.datetime({ offset: true })),
+  time_zone: z4.string().check(z4.minLength(1), z4.maxLength(64), z4.regex(/^[A-Za-z0-9_+\-\/]+$/)),
+  title: z4.nullish(z4.string().check(z4.maxLength(300)))
 });
-var zValidationError2 = z3.object({
-  ctx: z3.optional(z3.record(z3.string(), z3.unknown())),
-  input: z3.optional(z3.unknown()),
-  loc: z3.array(z3.union([z3.string(), z3.int()])),
-  msg: z3.string(),
-  type: z3.string()
+var zValidationError2 = 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 zHttpValidationError2 = z3.object({
-  detail: z3.optional(z3.array(zValidationError2))
+var zHttpValidationError2 = z4.object({
+  detail: z4.optional(z4.array(zValidationError2))
 });
-var zValidationErrorItem2 = z3.object({
-  loc: z3.array(z3.union([z3.string(), z3.int()])),
-  msg: z3.string(),
-  type: z3.string()
+var zValidationErrorItem2 = z4.object({
+  loc: z4.array(z4.union([z4.string(), z4.int()])),
+  msg: z4.string(),
+  type: z4.string()
 });
-var zApiErrorSchema2 = z3.object({
+var zApiErrorSchema2 = z4.object({
   code: zErrorCode2,
-  context: z3._default(z3.nullish(z3.record(z3.string(), z3.unknown())), null),
-  detail: z3.string(),
-  errors: z3._default(z3.nullish(z3.array(zValidationErrorItem2)), null),
-  request_id: z3._default(z3.nullish(z3.string()), null)
+  context: z4._default(z4.nullish(z4.record(z4.string(), z4.unknown())), null),
+  detail: z4.string(),
+  errors: z4._default(z4.nullish(z4.array(zValidationErrorItem2)), null),
+  request_id: z4._default(z4.nullish(z4.string()), null)
 });
 
 // ../tracking-core/src/resources/calendar/schema.ts
@@ -2131,22 +2320,17 @@ var MAX_REMINDER_OVERRIDES = 5;
 var MAX_REMINDER_MINUTES = 40320;
 var MAX_BOOKING_MINUTES = 1440;
 var BOOKING_SOURCES = ["website", "phone", "walk_in", "import", "operator"];
-var BOOKING_STATUSES = ["pending", "confirmed", "cancelled", "no_show"];
-var GOOGLE_SYNC_STATES = ["queued", "synced", "uncertain", "failed", "drifted"];
-var CALENDAR_SYNC_STATUSES = [
-  "pending_invite",
-  "awaiting_calendar_selection",
-  "connected",
-  "needs_reconnect",
-  "revoked",
-  "disabled"
-];
+var BOOKING_STATUSES = zBookingResponse.shape.status.options;
+var GOOGLE_SYNC_STATES = zBookingResponse.shape.google_sync_state.options;
+var CALENDAR_SYNC_STATUSES = zCalendarSummary.shape.status.options;
 var CALENDAR_ERROR_CODES = [
   "slot_unavailable",
   "calendar_not_connected",
   "calendar_disconnected",
   "booking_not_found",
-  "outside_booking_window",
+  "booking_not_cancellable",
+  "booking_not_reschedulable",
+  "manage_token_invalid",
   "rate_limited",
   "google_error"
 ];
@@ -2158,29 +2342,29 @@ function isKnownTimeZone(timeZone) {
     return false;
   }
 }
-var ianaTz = z4.string().check(
-  z4.minLength(1),
-  z4.maxLength(64),
-  z4.regex(/^[A-Za-z0-9_+\-/]+$/),
-  z4.refine(isKnownTimeZone, { error: "unknown IANA time zone" })
+var ianaTz = z5.string().check(
+  z5.minLength(1),
+  z5.maxLength(64),
+  z5.regex(/^[A-Za-z0-9_+\-/]+$/),
+  z5.refine(isKnownTimeZone, { error: "unknown IANA time zone" })
 );
 var bookingAttendeeSchema = zBookingAttendee;
 var bookingReminderSchema = zBookingReminder;
 var bookingCustomerSchema = zBookingCustomerInput;
-var bookingMetadataSchema = z4.extend(zBookingMetadata, {
-  custom: z4.nullish(
-    z4.record(z4.string(), z4.union([z4.string(), z4.int(), z4.number(), z4.boolean(), z4.null()]))
+var bookingMetadataSchema = z5.extend(zBookingMetadataInput, {
+  custom: z5.nullish(
+    z5.record(z5.string(), z5.union([z5.string(), z5.int(), z5.number(), z5.boolean(), z5.null()]))
   )
 });
-var bookingLocationSchema = z4.union([
+var bookingLocationSchema = z5.union([
   zMeetLocation,
   zPhysicalLocation,
   zPhoneLocation,
   zCustomLocation
 ]);
-var bookingLocationNullableSchema = z4.union([
+var bookingLocationNullableSchema = z5.union([
   ...bookingLocationSchema.def.options,
-  z4.null()
+  z5.null()
 ]);
 function addIssue2(ctx, path, message) {
   ctx.issues.push({ code: "custom", input: ctx.value, path, message });
@@ -2196,26 +2380,44 @@ function refineEndXor(value, ctx) {
     addIssue2(ctx, ["end_at"], "end_at must be after start_at");
   }
 }
-var bookingRemindersSchema = z4.extend(zBookingReminders, {
-  overrides: z4._default(
-    z4.array(bookingReminderSchema).check(z4.maxLength(MAX_REMINDER_OVERRIDES)),
+function refineStartXor(value, ctx) {
+  const hasStart = value.start_at !== void 0 && value.start_at !== null;
+  const hasDate = value.date !== void 0 && value.date !== null;
+  if (hasStart === hasDate) {
+    addIssue2(ctx, ["start_at"], "provide exactly one of start_at or date");
+    return;
+  }
+  if (hasStart) {
+    refineEndXor(value, ctx);
+    return;
+  }
+  if (value.end_at != null || value.duration_minutes != null) {
+    addIssue2(ctx, ["date"], "an all-day booking (date) takes no end_at or duration_minutes");
+  }
+  if (value.buffer_before_minutes || value.buffer_after_minutes) {
+    addIssue2(ctx, ["date"], "an all-day booking (date) takes no buffers");
+  }
+}
+var bookingRemindersSchema = z5.extend(zBookingReminders, {
+  overrides: z5._default(
+    z5.array(bookingReminderSchema).check(z5.maxLength(MAX_REMINDER_OVERRIDES)),
     []
   )
 });
-var bookingCreateSchema = z4.extend(zBookingCreateSchema, {
+var bookingCreateSchema = z5.extend(zBookingCreateSchema, {
   time_zone: ianaTz,
   // The generated field is `z.union([...variants]).nullish()`, which nests one
   // `anyOf` inside another; Pydantic's `BookingLocation | None` flattens to a
   // single list and the drift snapshot compares structure. Override with the
   // flattened union.
-  location: z4.optional(bookingLocationNullableSchema),
-  attendees: z4._default(z4.array(bookingAttendeeSchema).check(z4.maxLength(MAX_ATTENDEES)), []),
+  location: z5.optional(bookingLocationNullableSchema),
+  attendees: z5._default(z5.array(bookingAttendeeSchema).check(z5.maxLength(MAX_ATTENDEES)), []),
   // These reference the un-composed generated schemas; generation can't nest
   // our compositions into its own output.
-  reminders: z4.nullish(bookingRemindersSchema),
-  metadata: z4.nullish(bookingMetadataSchema)
-}).check((ctx) => refineEndXor(ctx.value, ctx));
-var bookingRescheduleSchema = z4.extend(zBookingRescheduleSchema, { time_zone: ianaTz }).check((ctx) => refineEndXor(ctx.value, ctx));
+  reminders: z5.nullish(bookingRemindersSchema),
+  metadata: z5.nullish(bookingMetadataSchema)
+}).check((ctx) => refineStartXor(ctx.value, ctx));
+var bookingRescheduleSchema = z5.extend(zBookingRescheduleSchema, { time_zone: ianaTz }).check((ctx) => refineEndXor(ctx.value, ctx));
 var bookingCancelSchema = zBookingCancelSchema;
 
 // ../tracking-core/src/resources/calendar/slots.ts
@@ -2373,7 +2575,10 @@ function useBookingForm(options = {}) {
         const response = await fetch(endpoint, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(input)
+          body: JSON.stringify({
+            ...input,
+            metadata: { ...getBookingAttribution(), ...input.metadata }
+          })
         });
         const body = await response.json().catch(() => null);
         if (!response.ok) {
@@ -2457,6 +2662,7 @@ export {
   formatPhoneAsTyped,
   formatSlotRange,
   fromMinor,
+  getBookingAttribution,
   getConsentChoice,
   getConsentState,
   getEventSemantics,