@aranova/tracking-react 0.26.0 → 1.0.0

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -39,6 +49,7 @@ __export(src_exports, {
   createTrackingClientContext: () => createTrackingClientContext,
   createTrackingEventCreatePayload: () => createTrackingEventCreatePayload,
   createTrackingSessionUpsertPayload: () => createTrackingSessionUpsertPayload,
+  currencySchema: () => currencySchema,
   fetchServices: () => fetchServices,
   formatDateInTz: () => formatDateInTz,
   formatMoney: () => formatMoney,
@@ -126,7 +137,7 @@ function normalizeEmail(raw) {
   return EMAIL_SHAPE.test(cleaned) ? cleaned : null;
 }
 function stashUserData(data, country) {
-  const email = normalizeEmail(data.email);
+  const email3 = normalizeEmail(data.email);
   let phoneNumber = null;
   if (typeof data.phone === "string" && data.phone.length > 0) {
     try {
@@ -136,7 +147,7 @@ function stashUserData(data, country) {
     }
   }
   stash = {
-    email: email ?? stash.email,
+    email: email3 ?? stash.email,
     phoneNumber: phoneNumber ?? stash.phoneNumber
   };
 }
@@ -145,11 +156,11 @@ function clearStashedUserData() {
 }
 function applyUserDataForConversion(explicit, country) {
   if (typeof window === "undefined" || typeof window.gtag !== "function") return false;
-  let email = stash.email;
+  let email3 = stash.email;
   let phoneNumber = stash.phoneNumber;
   if (explicit) {
     const normalizedEmail = normalizeEmail(explicit.email);
-    if (normalizedEmail) email = normalizedEmail;
+    if (normalizedEmail) email3 = normalizedEmail;
     if (typeof explicit.phone === "string" && explicit.phone.length > 0) {
       try {
         phoneNumber = toE164(explicit.phone, country) ?? phoneNumber;
@@ -157,10 +168,10 @@ function applyUserDataForConversion(explicit, country) {
       }
     }
   }
-  if (email === null && phoneNumber === null) return false;
+  if (email3 === null && phoneNumber === null) return false;
   try {
     window.gtag("set", "user_data", {
-      ...email !== null ? { email } : {},
+      ...email3 !== null ? { email: email3 } : {},
       ...phoneNumber !== null ? { phone_number: phoneNumber } : {}
     });
     return true;
@@ -516,10 +527,10 @@ function readStoredRecord() {
     return null;
   }
 }
-function writeRecord(record) {
-  memoryRecord = record;
+function writeRecord(record3) {
+  memoryRecord = record3;
   try {
-    window.localStorage.setItem(LANDING_STORAGE_KEY, JSON.stringify(record));
+    window.localStorage.setItem(LANDING_STORAGE_KEY, JSON.stringify(record3));
   } catch {
   }
 }
@@ -541,9 +552,9 @@ function getOrCaptureLandingParams(sessionId, url) {
   if (memoryRecord && memoryRecord.session_id === sessionId) {
     return memoryRecord.params;
   }
-  const record = { session_id: sessionId, params: captureFromUrl(url) };
-  writeRecord(record);
-  return record.params;
+  const record3 = { session_id: sessionId, params: captureFromUrl(url) };
+  writeRecord(record3);
+  return record3.params;
 }
 function buildLandingPayloadFields(sessionId, override) {
   const params = override ?? (typeof window === "undefined" ? null : getOrCaptureLandingParams(sessionId));
@@ -920,9 +931,9 @@ function automaticThresholdMet(goal, eventType, metadata) {
 }
 
 // ../tracking-core/src/resources/intl/date.ts
-function formatDateInTz(iso, timeZone, opts, locale) {
-  const date = new Date(iso);
-  if (Number.isNaN(date.getTime())) return iso;
+function formatDateInTz(iso3, timeZone, opts, locale) {
+  const date = new Date(iso3);
+  if (Number.isNaN(date.getTime())) return iso3;
   return new Intl.DateTimeFormat(locale, {
     year: "numeric",
     month: "short",
@@ -956,14 +967,15 @@ function formatMoney(cents, currency, locale) {
 
 // ../tracking-core/src/resources/tracking-config-runtime.ts
 var DEFAULT_CDN_BASE_URL = "https://demos.aranova.io";
-function trackingConfigKey(businessId, environment) {
-  return `tracking-config/v1/${businessId}-${environment}.json`;
+function trackingConfigKey(ref) {
+  if (ref.siteId) return `tracking-config/v1/sites/${ref.siteId}-${ref.environment}.json`;
+  return `tracking-config/v1/${ref.businessId}-${ref.environment}.json`;
 }
 function resolveTrackingConfigUrl(ref) {
   if (ref.cdnUrl) return ref.cdnUrl;
   const configured = ref.cdnBaseUrl?.trim();
   const base = (configured || DEFAULT_CDN_BASE_URL).replace(/\/+$/, "");
-  return `${base}/${trackingConfigKey(ref.businessId, ref.environment)}`;
+  return `${base}/${trackingConfigKey(ref)}`;
 }
 var CACHE_PREFIX2 = "_aranova_cfg_runtime_";
 var AUTHORITY_TTL_MS = 6e4;
@@ -1333,29 +1345,6 @@ function getTrackingConfigRuntime(ref, fetchImpl) {
   return runtime;
 }
 
-// ../tracking-core/src/session.ts
-var SESSION_IDLE_MS = 30 * 60 * 1e3;
-
-// ../tracking-core/src/events/page-view.ts
-var import_zod = require("zod");
-var pageViewMetadataSchema = import_zod.z.object({
-  page: import_zod.z.object({
-    title: import_zod.z.string().nullable(),
-    path: import_zod.z.string(),
-    search: import_zod.z.string(),
-    hash: import_zod.z.string()
-  }).strict(),
-  referrer: import_zod.z.string().nullable(),
-  // `.nullable().optional()` — absent (undefined) OR explicit null OR a
-  // real viewport object. Mirrors Pydantic's `_Viewport | None = None`
-  // on the backend side so the drift test stays clean.
-  viewport: import_zod.z.object({
-    w: import_zod.z.number(),
-    h: import_zod.z.number()
-  }).strict().nullable().optional()
-}).strict();
-var pageViewConfigSchema = import_zod.z.object({}).strict();
-
 // ../tracking-core/src/ingest.ts
 var API_KEY_HEADER = "X-Aranova-Api-Key";
 var SDK_VERSION_HEADER = "X-Aranova-Sdk-Version";
@@ -1363,185 +1352,6 @@ var SDK_PACKAGE_HEADER = "X-Aranova-Sdk-Package";
 var SDK_SURFACE_HEADER = "X-Aranova-Sdk-Surface";
 var SDK_ENVIRONMENT_HEADER = "X-Aranova-Sdk-Environment";
 
-// ../tracking-core/src/events/cta-click.ts
-var import_zod2 = require("zod");
-var ctaClickMetadataSchema = import_zod2.z.object({
-  cta_name: import_zod2.z.string(),
-  page: import_zod2.z.object({
-    path: import_zod2.z.string()
-  }).strict(),
-  section: import_zod2.z.string().nullable().optional(),
-  destination_url: import_zod2.z.string().nullable().optional(),
-  // Set by auto-capture (and available to manual callers): the link target
-  // and a short element descriptor (tag#id) for tying clicks to specific UI.
-  href: import_zod2.z.string().nullable().optional(),
-  element: import_zod2.z.string().nullable().optional()
-}).strict();
-var ctaClickConfigSchema = import_zod2.z.object({
-  autoCapture: import_zod2.z.object({
-    selector: import_zod2.z.string().optional()
-  }).strict().optional()
-}).strict();
-
-// ../tracking-core/src/events/sdk-heartbeat.ts
-var import_zod3 = require("zod");
-var sdkHeartbeatTriggersSchema = import_zod3.z.object({
-  automatic: import_zod3.z.array(import_zod3.z.string()),
-  manual: import_zod3.z.array(import_zod3.z.string())
-}).strict();
-var sdkHeartbeatMetadataSchema = import_zod3.z.object({
-  sdk_version: import_zod3.z.string(),
-  package_name: import_zod3.z.string().nullable(),
-  surface: import_zod3.z.enum(["next", "react", "script"]),
-  triggers: sdkHeartbeatTriggersSchema,
-  trigger_config: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.record(import_zod3.z.string(), import_zod3.z.unknown())).nullable().optional(),
-  configured_gtag_ids: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string()).nullable().optional()
-}).strict();
-var sdkHeartbeatConfigSchema = import_zod3.z.object({}).strict();
-
-// ../tracking-core/src/events/form-start.ts
-var import_zod4 = require("zod");
-var formStartMetadataSchema = import_zod4.z.object({
-  form: import_zod4.z.object({
-    id: import_zod4.z.string(),
-    action: import_zod4.z.string().nullable()
-  }).strict(),
-  page: import_zod4.z.object({
-    path: import_zod4.z.string()
-  }).strict()
-}).strict();
-var formStartConfigSchema = import_zod4.z.object({
-  selector: import_zod4.z.string().optional()
-}).strict();
-
-// ../tracking-core/src/events/form-submit.ts
-var import_zod5 = require("zod");
-var jsonValueSchema = import_zod5.z.lazy(
-  () => import_zod5.z.union([
-    import_zod5.z.string(),
-    import_zod5.z.number().finite(),
-    import_zod5.z.boolean(),
-    import_zod5.z.null(),
-    import_zod5.z.array(jsonValueSchema),
-    import_zod5.z.record(jsonValueSchema)
-  ])
-);
-var formSubmitMetadataSchema = import_zod5.z.object({
-  form: import_zod5.z.object({
-    id: import_zod5.z.string(),
-    action: import_zod5.z.string().nullable(),
-    fields: import_zod5.z.array(
-      import_zod5.z.object({
-        name: import_zod5.z.string(),
-        type: import_zod5.z.string(),
-        label: import_zod5.z.string().nullable(),
-        value: jsonValueSchema
-      }).strict()
-    ).optional()
-  }).strict(),
-  page: import_zod5.z.object({
-    path: import_zod5.z.string()
-  }).strict()
-}).strict();
-var formSubmitConfigSchema = import_zod5.z.object({}).strict();
-
-// ../tracking-core/src/events/multi-page-session.ts
-var import_zod6 = require("zod");
-var multiPageSessionMetadataSchema = import_zod6.z.object({
-  page_count: import_zod6.z.number().int().min(2),
-  page: import_zod6.z.object({
-    path: import_zod6.z.string()
-  }).strict()
-}).strict();
-var multiPageSessionConfigSchema = import_zod6.z.object({
-  pageThreshold: import_zod6.z.number().int().min(2)
-}).strict();
-
-// ../tracking-core/src/events/page-exit.ts
-var import_zod7 = require("zod");
-var pageExitMetadataSchema = import_zod7.z.object({
-  dwell_ms: import_zod7.z.number().int().min(0),
-  // null = left without any scroll signal; floor is 0 so a valid 0% is never
-  // rejected (a single bad field 422s the whole keepalive beacon batch).
-  max_scroll_percent: import_zod7.z.number().int().min(0).max(100).nullable(),
-  // The gating baseline: the fraction of the page visible at load with
-  // zero scrolling — or, for pages that grew after the post-paint snapshot
-  // (skeleton/streaming renders), the first-scroll position that
-  // established it. null = page had no scrollable range, or the segment
-  // ended before the snapshot. `.optional()` is load-bearing: SDK builds
-  // predating this field keep POSTing page_exit without the key —
-  // requiring it would 422 whole keepalive beacon batches.
-  scroll_baseline_percent: import_zod7.z.number().int().min(0).max(100).nullable().optional(),
-  page: import_zod7.z.object({
-    path: import_zod7.z.string()
-  }).strict()
-}).strict();
-var pageExitConfigSchema = import_zod7.z.object({}).strict();
-
-// ../tracking-core/src/events/phone-click.ts
-var import_zod8 = require("zod");
-var phoneClickMetadataSchema = import_zod8.z.object({
-  phone_number: import_zod8.z.string(),
-  page: import_zod8.z.object({
-    path: import_zod8.z.string()
-  }).strict(),
-  section: import_zod8.z.string().nullable().optional()
-}).strict();
-var phoneClickConfigSchema = import_zod8.z.object({
-  autoCapture: import_zod8.z.object({
-    selector: import_zod8.z.string().optional()
-  }).strict().optional()
-}).strict();
-
-// ../tracking-core/src/events/scroll-depth.ts
-var import_zod9 = require("zod");
-var scrollDepthMetadataSchema = import_zod9.z.object({
-  depth_percent: import_zod9.z.number().int().min(1).max(100),
-  page: import_zod9.z.object({
-    path: import_zod9.z.string()
-  }).strict()
-}).strict();
-var scrollDepthConfigSchema = import_zod9.z.object({
-  thresholds: import_zod9.z.array(import_zod9.z.number().int().min(1).max(100)).min(1)
-}).strict();
-
-// ../tracking-core/src/events/specific-page-visit.ts
-var import_zod10 = require("zod");
-var PAGE_IDENTITY_MAX_LENGTH = 64;
-var PAGE_IDENTITY_PATTERN = /^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/;
-var pageIdentitySchema = import_zod10.z.string().max(PAGE_IDENTITY_MAX_LENGTH).regex(PAGE_IDENTITY_PATTERN, {
-  message: "page identity must be lowercase snake_case, start with a letter, and contain at most 64 characters"
-});
-var specificPageNameSchema = pageIdentitySchema;
-var specificPageVisitMetadataSchema = import_zod10.z.object({
-  page_name: specificPageNameSchema,
-  page: import_zod10.z.object({
-    path: import_zod10.z.string()
-  }).strict()
-}).strict();
-var specificPageVisitConfigSchema = import_zod10.z.object({
-  pages: import_zod10.z.array(
-    import_zod10.z.object({
-      name: specificPageNameSchema,
-      pathPattern: import_zod10.z.custom((value) => value instanceof RegExp, {
-        message: "pathPattern must be a RegExp"
-      })
-    }).strict()
-  ).min(1)
-}).strict();
-
-// ../tracking-core/src/events/time-on-site.ts
-var import_zod11 = require("zod");
-var timeOnSiteMetadataSchema = import_zod11.z.object({
-  duration_ms: import_zod11.z.number().int().nonnegative(),
-  page: import_zod11.z.object({
-    path: import_zod11.z.string()
-  }).strict()
-}).strict();
-var timeOnSiteConfigSchema = import_zod11.z.object({
-  thresholdSeconds: import_zod11.z.number().int().positive()
-}).strict();
-
 // ../tracking-core/src/events/semantics.ts
 var EVENT_SEMANTICS = {
   page_view: {
@@ -1615,82 +1425,6 @@ function getEventSemantics(eventName) {
   return eventName in EVENT_SEMANTICS ? EVENT_SEMANTICS[eventName] : null;
 }
 
-// ../tracking-core/src/events/registry.ts
-var EVENT_REGISTRY = {
-  // --- automatic triggers ---
-  page_view: {
-    kind: "automatic",
-    semantics: EVENT_SEMANTICS.page_view,
-    metadataSchema: pageViewMetadataSchema,
-    configSchema: pageViewConfigSchema
-  },
-  time_on_site: {
-    kind: "automatic",
-    semantics: EVENT_SEMANTICS.time_on_site,
-    metadataSchema: timeOnSiteMetadataSchema,
-    configSchema: timeOnSiteConfigSchema
-  },
-  specific_page_visit: {
-    kind: "automatic",
-    semantics: EVENT_SEMANTICS.specific_page_visit,
-    metadataSchema: specificPageVisitMetadataSchema,
-    configSchema: specificPageVisitConfigSchema
-  },
-  scroll_depth: {
-    kind: "automatic",
-    semantics: EVENT_SEMANTICS.scroll_depth,
-    metadataSchema: scrollDepthMetadataSchema,
-    configSchema: scrollDepthConfigSchema
-  },
-  multi_page_session: {
-    kind: "automatic",
-    semantics: EVENT_SEMANTICS.multi_page_session,
-    metadataSchema: multiPageSessionMetadataSchema,
-    configSchema: multiPageSessionConfigSchema
-  },
-  form_start: {
-    kind: "automatic",
-    semantics: EVENT_SEMANTICS.form_start,
-    metadataSchema: formStartMetadataSchema,
-    configSchema: formStartConfigSchema
-  },
-  // --- SDK-internal automatic (not consumer-configurable) ---
-  sdk_heartbeat: {
-    kind: "automatic",
-    semantics: EVENT_SEMANTICS.sdk_heartbeat,
-    metadataSchema: sdkHeartbeatMetadataSchema,
-    configSchema: sdkHeartbeatConfigSchema
-  },
-  page_exit: {
-    kind: "automatic",
-    semantics: EVENT_SEMANTICS.page_exit,
-    metadataSchema: pageExitMetadataSchema,
-    configSchema: pageExitConfigSchema
-  },
-  // --- manual triggers ---
-  form_submit: {
-    kind: "manual",
-    semantics: EVENT_SEMANTICS.form_submit,
-    metadataSchema: formSubmitMetadataSchema,
-    configSchema: formSubmitConfigSchema
-  },
-  phone_click: {
-    kind: "manual",
-    semantics: EVENT_SEMANTICS.phone_click,
-    metadataSchema: phoneClickMetadataSchema,
-    configSchema: phoneClickConfigSchema
-  },
-  cta_click: {
-    kind: "manual",
-    semantics: EVENT_SEMANTICS.cta_click,
-    metadataSchema: ctaClickMetadataSchema,
-    configSchema: ctaClickConfigSchema
-  }
-};
-var ALL_AUTOMATIC_EVENT_NAMES = Object.entries(EVENT_REGISTRY).filter(([, def]) => def.kind === "automatic").map(([name]) => name);
-var ALL_MANUAL_EVENT_NAMES = Object.entries(EVENT_REGISTRY).filter(([, def]) => def.kind === "manual").map(([name]) => name);
-var ALL_LEAD_EVENT_NAMES = Object.entries(EVENT_REGISTRY).filter(([, def]) => def.semantics.outcomeRole === "lead").map(([name]) => name);
-
 // ../tracking-core/src/resources/http/errors.ts
 var AranovaApiError = class extends Error {
   constructor(message, options) {
@@ -1728,9 +1462,9 @@ async function apiRequest(config, method, path, body, extraHeaders) {
     try {
       const parsed = await response.json();
       if (parsed && typeof parsed === "object") {
-        const record = parsed;
-        if (typeof record.detail === "string") detail = record.detail;
-        if (typeof record.code === "string") code = record.code;
+        const record3 = parsed;
+        if (typeof record3.detail === "string") detail = record3.detail;
+        if (typeof record3.code === "string") code = record3.code;
       }
     } catch {
     }
@@ -1779,7 +1513,7 @@ function fireRecordedConversions(firing, input, recorded, sale, currency) {
 }
 function createSalesClient(config) {
   if (config.firing) registerCapability("conversion_goals_manual");
-  async function record(input) {
+  async function record3(input) {
     const currency = input.currency ?? config.defaultCurrency;
     if (!currency) {
       throw new Error(
@@ -1805,9 +1539,9 @@ function createSalesClient(config) {
     return sale;
   }
   return {
-    record,
+    record: record3,
     // recordSale is the intent-revealing alias — same behavior, clearer call site.
-    recordSale: record,
+    recordSale: record3,
     trackConversion(key, options) {
       if (config.firing && "fireConversion" in config.firing) {
         if (options?.userData && getConsentState() !== "denied") stashUserData(options.userData);
@@ -1926,115 +1660,264 @@ function createSalesClient(config) {
 }
 
 // ../tracking-core/src/resources/sales/schema.ts
-var import_zod12 = require("zod");
-var SUPPORTED_CURRENCIES = ["USD", "CAD"];
-var TRACKING_ENVIRONMENTS = ["production", "development"];
-var currencySchema = import_zod12.z.enum(SUPPORTED_CURRENCIES);
-var centsSchema = import_zod12.z.number().int().nonnegative();
-var quantitySchema = import_zod12.z.string().regex(/^\d+(\.\d{1,3})?$/);
-var metadataSchema = import_zod12.z.record(import_zod12.z.unknown());
-var saleItemSchema = import_zod12.z.object({
-  external_item_id: import_zod12.z.string().nullable().optional(),
-  name: import_zod12.z.string().nullable().optional(),
-  category: import_zod12.z.string().nullable().optional(),
-  quantity: quantitySchema,
-  unit_price_cents: centsSchema,
-  // Non-negativity validated on the wire — same contract as the other cents
-  // fields — and backstopped by the DB CHECK.
-  unit_cost_cents: centsSchema.nullable().optional()
-}).strict();
-var saleServiceSchema = import_zod12.z.object({
-  service: import_zod12.z.string(),
-  amount_cents: centsSchema
-}).strict();
-var customerNameSchema = import_zod12.z.string().max(200);
-var customerPhoneSchema = import_zod12.z.string().max(64);
-var customerEmailSchema = import_zod12.z.string().max(320).email();
+var z2 = __toESM(require("zod/mini"));
+
+// ../tracking-core/src/resources/sales/generated/zod.gen.ts
+var z = __toESM(require("zod/mini"));
+var zErrorCode = z.enum([
+  "missing_credentials",
+  "invalid_api_key",
+  "not_authenticated",
+  "wrong_key_type",
+  "origin_missing",
+  "origin_not_allowed",
+  "capability_denied",
+  "session_required",
+  "operator_only",
+  "cross_tenant",
+  "business_id_required",
+  "bad_request",
+  "not_found",
+  "conflict",
+  "incompatible_payload",
+  "repeat_confirmation_required",
+  "idempotency_conflict",
+  "validation_error",
+  "unknown_service",
+  "invalid_sale_properties",
+  "invalid_cursor",
+  "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 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 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 zSaleServiceInputSchema = z.strictObject({
+  amount_cents: z.int().check(z.gte(0)),
+  service: z.string()
+});
+var zSmsAutomationState = z.enum([
+  "needs_check",
+  "failed",
+  "undelivered",
+  "blocked_opted_out",
+  "withheld",
+  "queued",
+  "sent",
+  "delivered",
+  "eligible",
+  "not_applicable"
+]);
+var zSmsWithheldReason = z.enum([
+  "automation_disabled",
+  "sms_disabled",
+  "no_phone",
+  "no_consent",
+  "no_customer_identity",
+  "missing_customer_name",
+  "placeholder_customer_name",
+  "opted_out",
+  "already_messaged",
+  "sender_not_ready",
+  "missing_review_url",
+  "no_handler",
+  "dispatch_already_recorded"
+]);
+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()),
+  state: zSmsAutomationState,
+  suppressed_by_other_sale: z._default(z.boolean(), false),
+  withheld_reason: z.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))),
+  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())
+});
+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 zHttpValidationError = z.object({
+  detail: z.optional(z.array(zValidationError))
+});
+var zValidationErrorItem = z.object({
+  loc: z.array(z.union([z.string(), z.int()])),
+  msg: z.string(),
+  type: z.string()
+});
+var zApiErrorSchema = z.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)
+});
+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 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([
+    "failed",
+    "skipped",
+    "pending",
+    "submitted",
+    "uploaded",
+    "not_uploaded",
+    "out_of_window",
+    "blocked"
+  ]),
+  stale: z._default(z.boolean(), false),
+  uncovered_service_ids: z.array(z.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()),
+  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)
+});
+
+// ../tracking-core/src/resources/sales/schema.ts
+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));
+function addIssue(ctx, path, message) {
+  ctx.issues.push({ code: "custom", input: ctx.value, path, message });
+}
 function refineServiceXor(val, ctx, { requireAmount }) {
   if (val.services != null) {
     if (val.service != null) {
-      ctx.addIssue({
-        code: import_zod12.z.ZodIssueCode.custom,
-        message: "pass either `service` or `services`, not both",
-        path: ["services"]
-      });
+      addIssue(ctx, ["services"], "pass either `service` or `services`, not both");
     }
     if (val.services.length === 0) {
-      ctx.addIssue({
-        code: import_zod12.z.ZodIssueCode.custom,
-        message: "`services` must not be empty",
-        path: ["services"]
-      });
+      addIssue(ctx, ["services"], "`services` must not be empty");
     }
     const keys = val.services.map((s) => s.service);
     if (new Set(keys).size !== keys.length) {
-      ctx.addIssue({
-        code: import_zod12.z.ZodIssueCode.custom,
-        message: "`services` must not list the same service more than once",
-        path: ["services"]
-      });
+      addIssue(ctx, ["services"], "`services` must not list the same service more than once");
     }
     if (val.amount_total_cents != null) {
       const sum = val.services.reduce((acc, s) => acc + s.amount_cents, 0);
       if (val.amount_total_cents !== sum) {
-        ctx.addIssue({
-          code: import_zod12.z.ZodIssueCode.custom,
-          message: "amount_total_cents must equal the sum of the services amounts (omit it to derive it automatically)",
-          path: ["amount_total_cents"]
-        });
+        addIssue(
+          ctx,
+          ["amount_total_cents"],
+          "amount_total_cents must equal the sum of the services amounts (omit it to derive it automatically)"
+        );
       }
     }
   } else if (requireAmount && val.amount_total_cents == null) {
-    ctx.addIssue({
-      code: import_zod12.z.ZodIssueCode.custom,
-      message: "amount_total_cents is required unless `services` is provided",
-      path: ["amount_total_cents"]
-    });
+    addIssue(
+      ctx,
+      ["amount_total_cents"],
+      "amount_total_cents is required unless `services` is provided"
+    );
   }
 }
-var saleCreateSchema = import_zod12.z.object({
-  external_id: import_zod12.z.string().nullable().optional(),
-  description: import_zod12.z.string().nullable().optional(),
-  service: import_zod12.z.string().nullable().optional(),
-  services: import_zod12.z.array(saleServiceSchema).nullable().optional(),
-  currency: currencySchema,
-  // Optional only because the plural `services` form derives it from the sum
-  // (see refineServiceXor); the singular/serviceless path still requires it.
-  amount_total_cents: centsSchema.nullable().optional(),
-  occurred_at: import_zod12.z.string().datetime(),
-  environment: import_zod12.z.enum(TRACKING_ENVIRONMENTS).default("production"),
-  items: import_zod12.z.array(saleItemSchema).default([]),
-  metadata: metadataSchema.nullable().optional(),
-  customer_name: customerNameSchema.nullable().optional(),
-  customer_phone: customerPhoneSchema.nullable().optional(),
-  customer_email: customerEmailSchema.nullable().optional(),
-  // CASL consent attestation: the customer agreed to receive SMS. Recorded
-  // with a timestamp server-side; every SMS send path gates on it.
-  //
-  // Tri-state: omit it (or send null) to let the server apply the business's
-  // configured default-opt-in policy, honouring a returning customer's
-  // remembered preference. Send an explicit boolean to assert consent state
-  // yourself — `false` records a deliberate opt-out.
-  sms_consent: import_zod12.z.boolean().nullable().optional()
-}).strict().superRefine((val, ctx) => refineServiceXor(val, ctx, { requireAmount: true }));
-var saleUpdateSchema = import_zod12.z.object({
-  description: import_zod12.z.string().nullable().optional(),
-  service: import_zod12.z.string().nullable().optional(),
-  services: import_zod12.z.array(saleServiceSchema).nullable().optional(),
-  currency: currencySchema.optional(),
-  amount_total_cents: centsSchema.optional(),
-  occurred_at: import_zod12.z.string().datetime().optional(),
-  items: import_zod12.z.array(saleItemSchema).optional(),
-  metadata: metadataSchema.nullable().optional(),
-  customer_name: customerNameSchema.nullable().optional(),
+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),
   // Re-attest when changing a filler-looking name; the server clears the
   // prior attestation whenever `customer_name` changes.
-  customer_name_placeholder_confirmed: import_zod12.z.boolean().optional(),
-  customer_phone: customerPhoneSchema.nullable().optional(),
-  customer_email: customerEmailSchema.nullable().optional(),
+  customer_name_placeholder_confirmed: z2.optional(z2.boolean()),
+  customer_phone: z2.nullish(customerPhoneSchema),
+  customer_email: z2.nullish(customerEmailSchema),
   // NOT NULL server-side: omit to leave unchanged (explicit null is rejected).
-  sms_consent: import_zod12.z.boolean().optional()
-}).strict().superRefine((val, ctx) => refineServiceXor(val, ctx, { requireAmount: false }));
+  sms_consent: z2.optional(z2.boolean())
+}).check((ctx) => refineServiceXor(ctx.value, ctx, { requireAmount: false }));
 var TRACKING_RANGES = ["24h", "7d", "30d"];
 var NAMED_RANGES = [
   "today",
@@ -2083,6 +1966,7 @@ var import_client2 = require("@aranova/tracking-react/client");
   createTrackingClientContext,
   createTrackingEventCreatePayload,
   createTrackingSessionUpsertPayload,
+  currencySchema,
   fetchServices,
   formatDateInTz,
   formatMoney,