@aranova/tracking-react 1.14.0 → 1.14.1

package/dist/index.js

@@ -555,10 +555,10 @@ function readStoredRecord() {
     return null;
   }
 }
-function writeRecord(record3) {
-  memoryRecord = record3;
+function writeRecord(record4) {
+  memoryRecord = record4;
   try {
-    window.localStorage.setItem(LANDING_STORAGE_KEY, JSON.stringify(record3));
+    window.localStorage.setItem(LANDING_STORAGE_KEY, JSON.stringify(record4));
   } catch {
   }
 }
@@ -580,9 +580,9 @@ function getOrCaptureLandingParams(sessionId, url) {
   if (memoryRecord && memoryRecord.session_id === sessionId) {
     return memoryRecord.params;
   }
-  const record3 = { session_id: sessionId, params: captureFromUrl(url) };
-  writeRecord(record3);
-  return record3.params;
+  const record4 = { session_id: sessionId, params: captureFromUrl(url) };
+  writeRecord(record4);
+  return record4.params;
 }
 function buildLandingPayloadFields(sessionId, override) {
   const params = override ?? (typeof window === "undefined" ? null : getOrCaptureLandingParams(sessionId));
@@ -1809,8 +1809,81 @@ 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/lead-forms/lead-forms.gen.ts
+// ../tracking-core/src/ingest-typed.ts
+var import_mini = require("zod/mini");
+
+// ../tracking-core/src/events/form-submit.ts
 var z2 = __toESM(require("zod/mini"));
+var jsonValueSchema = z2.lazy(
+  () => z2.union([
+    z2.string(),
+    z2.number(),
+    z2.boolean(),
+    z2.null(),
+    z2.array(jsonValueSchema),
+    z2.record(z2.string(), jsonValueSchema)
+  ])
+).register(z2.globalRegistry, { id: "JsonSerializableValue" });
+var contractNameSchema = z2.string().check(z2.regex(/^[a-z][a-z0-9_]{0,47}(:[a-z0-9_-]{1,48})?$/));
+var contractName = contractNameSchema;
+var violationRole = z2.string().check(
+  z2.maxLength(200),
+  z2.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 = z2.strictObject({
+  role: z2.nullable(violationRole),
+  rule: z2.string().check(z2.regex(/^[a-z][a-z_]{0,47}$/))
+});
+var formSubmitMetadataSchema = z2.strictObject({
+  form: z2.strictObject({
+    id: z2.string(),
+    action: z2.nullable(z2.string()),
+    fields: z2.optional(
+      z2.array(
+        z2.strictObject({
+          name: z2.string(),
+          type: z2.string(),
+          label: z2.nullable(z2.string()),
+          value: jsonValueSchema,
+          role: z2.optional(z2.nullable(contractName))
+        })
+      )
+    ),
+    kind: z2.optional(z2.nullable(contractName)),
+    contract_version: z2.optional(z2.nullable(z2.int().check(z2.gte(1)))),
+    contract_hash: z2.optional(z2.nullable(z2.string().check(z2.maxLength(64)))),
+    extra: z2.optional(
+      z2.nullable(
+        z2.array(
+          z2.strictObject({
+            key: z2.string().check(z2.maxLength(64)),
+            label: z2.string().check(z2.maxLength(200)),
+            value: jsonValueSchema
+          })
+        ).check(z2.maxLength(20))
+      )
+    ),
+    contract_violations: z2.optional(
+      z2.nullable(z2.array(contractViolationSchema).check(z2.maxLength(MAX_CONTRACT_VIOLATIONS)))
+    )
+  }),
+  page: z2.strictObject({
+    path: z2.string()
+  })
+});
+var formSubmitConfigSchema = z2.strictObject({});
+
+// ../tracking-core/src/ingest-typed.ts
+var clientSettings = /* @__PURE__ */ new WeakMap();
+function typedClientSettings(client) {
+  return clientSettings.get(client) ?? {};
+}
+
+// ../tracking-core/src/lead-forms/lead-forms.gen.ts
+var z3 = __toESM(require("zod/mini"));
 var LEAD_FORM_REGISTRY_VERSION = 2;
 var LEAD_FORM_KINDS = ["booking", "quote", "contact", "consult", "callback"];
 var LEAD_FORM_ROLES = [
@@ -1850,28 +1923,28 @@ var LEAD_FORM_PRIMITIVES = [
   "number"
 ];
 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)))
+  string: z3.string().check(z3.maxLength(120)),
+  text: z3.string().check(z3.maxLength(2e3)),
+  enum: z3.string().check(z3.regex(/^[a-z0-9-]{1,48}$/)),
+  multi_enum: z3.array(z3.string().check(z3.regex(/^[a-z0-9-]{1,48}$/))).check(z3.maxLength(10)),
+  bool: z3.boolean(),
+  date: z3.string().check(z3.regex(/^\d{4}-\d{2}-\d{2}$/)),
+  time_window: z3.strictObject({
+    start: z3.string().check(z3.regex(/^([01]\d|2[0-3]):[0-5]\d$/)),
+    end: z3.nullable(z3.string().check(z3.regex(/^([01]\d|2[0-3]):[0-5]\d$/))),
+    label: z3.optional(z3.string().check(z3.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)))
+  phone: z3.string().check(z3.regex(/^\+[1-9]\d{6,14}$/)),
+  email: z3.string().check(z3.maxLength(320), z3.regex(/^[^\s@]+@[^\s@]+$/)),
+  address: z3.strictObject({
+    line1: z3.string().check(z3.maxLength(120)),
+    line2: z3.optional(z3.string().check(z3.maxLength(120))),
+    city: z3.optional(z3.string().check(z3.maxLength(120))),
+    region: z3.optional(z3.string().check(z3.maxLength(120))),
+    postal_code: z3.optional(z3.string().check(z3.maxLength(120))),
+    country: z3.optional(z3.string().check(z3.maxLength(120)))
   }),
-  number: z2.number()
+  number: z3.number()
 }))();
 var LEAD_FORM_ROLE_SPECS = {
   given_name: { primitive: "string", smsLabel: "", contactIdentity: true },
@@ -1921,6 +1994,101 @@ var LEAD_FORM_ROLE_SPECS = {
   attribution: { primitive: "enum", smsLabel: "", uninteresting: true }
 };
 
+// ../tracking-core/src/lead-forms/submit.ts
+var import_mini2 = require("zod/mini");
+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 (!(0, import_mini2.safeParse)(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") : [];
+}
+function slotFields(dateTime) {
+  const written = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2})(?::\d{2}(?:\.\d+)?)?$/.exec(dateTime);
+  if (!written) {
+    throw new TypeError(
+      `slotFields needs the slot's wall time without an offset ("2026-10-13T09:30"), got "${dateTime}"`
+    );
+  }
+  return { preferred_date: written[1], preferred_time: { start: written[2], end: null } };
+}
+function timeWindow(start, end, label) {
+  return { start, end: end ?? null, ...label ? { label } : {} };
+}
+
 // ../tracking-core/src/resources/http/errors.ts
 var AranovaApiError = class extends Error {
   constructor(message, options) {
@@ -1960,11 +2128,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 {
@@ -2018,7 +2186,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;
@@ -2028,7 +2196,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",
@@ -2053,6 +2221,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,
@@ -2060,7 +2236,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 }
   };
@@ -2159,10 +2336,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 = {
@@ -2178,7 +2354,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
@@ -2265,7 +2441,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(
@@ -2291,9 +2467,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);
@@ -2413,17 +2589,17 @@ function createSalesClient(config) {
 }
 
 // ../tracking-core/src/resources/sales/schema.ts
-var z4 = __toESM(require("zod/mini"));
+var z5 = __toESM(require("zod/mini"));
 
 // ../tracking-core/src/resources/sales/generated/zod.gen.ts
-var z3 = __toESM(require("zod/mini"));
-var zAutoLeapSaleFacts = z3.object({
-  first_order: z3.boolean(),
-  fleet_customer: z3.boolean(),
-  invoice_code: z3.string(),
-  invoice_id: z3.string()
+var z4 = __toESM(require("zod/mini"));
+var zAutoLeapSaleFacts = z4.object({
+  first_order: z4.boolean(),
+  fleet_customer: z4.boolean(),
+  invoice_code: z4.string(),
+  invoice_id: z4.string()
 });
-var zErrorCode = z3.enum([
+var zErrorCode = z4.enum([
   "missing_credentials",
   "invalid_api_key",
   "not_authenticated",
@@ -2467,37 +2643,37 @@ var zErrorCode = z3.enum([
   "rate_limited",
   "internal_error"
 ]);
-var zSaleItemEntitySchema = z3.object({
-  category: z3.nullable(z3.string()),
-  external_item_id: z3.nullable(z3.string()),
-  id: z3.uuid(),
-  name: z3.nullable(z3.string()),
-  quantity: z3.string().check(z3.regex(/^(?!^[-+.]*$)[+-]?0*\d*\.?\d*$/)),
-  unit_cost_cents: z3.nullable(z3.int()),
-  unit_price_cents: z3.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 = z3.strictObject({
-  category: z3.nullish(z3.string()),
-  external_item_id: z3.nullish(z3.string()),
-  name: z3.nullish(z3.string()),
-  quantity: z3.string().check(z3.regex(/^\d+(\.\d{1,3})?$/)),
-  unit_cost_cents: z3.nullish(z3.int().check(z3.gte(0))),
-  unit_price_cents: z3.int().check(z3.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 = z3.object({
-  amount_cents: z3.int(),
-  id: z3.uuid(),
-  mapped: z3.nullable(z3.boolean()),
-  service_id: z3.uuid(),
-  service_key: z3.string(),
-  service_label: z3.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 = z3.strictObject({
-  amount_cents: z3.int().check(z3.gte(0)),
-  service: z3.string()
+var zSaleServiceInputSchema = z4.strictObject({
+  amount_cents: z4.int().check(z4.gte(0)),
+  service: z4.string()
 });
-var zSaleSource = z3.enum(["api", "admin", "autoleap"]);
-var zSmsAutomationState = z3.enum([
+var zSaleSource = z4.enum(["api", "admin", "autoleap"]);
+var zSmsAutomationState = z4.enum([
   "needs_check",
   "failed",
   "undelivered",
@@ -2509,7 +2685,7 @@ var zSmsAutomationState = z3.enum([
   "eligible",
   "not_applicable"
 ]);
-var zSmsWithheldReason = z3.enum([
+var zSmsWithheldReason = z4.enum([
   "automation_disabled",
   "sms_disabled",
   "no_phone",
@@ -2535,77 +2711,79 @@ var zSmsWithheldReason = z3.enum([
   "confirmed_by_integration",
   "test_or_bot_session",
   "invalid_phone",
-  "recently_texted"
+  "recently_texted",
+  "do_not_contact",
+  "do_not_text_tag"
 ]);
-var zSaleSmsStatusSchema = z3.object({
-  can_send_now: z3._default(z3.boolean(), false),
-  last_message_at: z3.nullable(z3.iso.datetime({ offset: true })),
-  reason_detail: z3.nullable(z3.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: z3._default(z3.boolean(), false),
-  withheld_reason: z3.nullable(zSmsWithheldReason)
+  suppressed_by_other_sale: z4._default(z4.boolean(), false),
+  withheld_reason: z4.nullable(zSmsWithheldReason)
 });
-var zSupportedCurrency = z3.enum(["USD", "CAD"]);
-var zTrackingEnvironment = z3.enum(["production", "development"]);
-var zSaleCreateSchema = z3.strictObject({
-  amount_total_cents: z3.nullish(z3.int().check(z3.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: z3.nullish(z3.email().check(z3.maxLength(320))),
-  customer_name: z3.nullish(z3.string().check(z3.maxLength(200))),
-  customer_phone: z3.nullish(z3.string().check(z3.maxLength(64))),
-  description: z3.nullish(z3.string()),
-  environment: z3._default(z3.optional(zTrackingEnvironment), "production"),
-  external_id: z3.nullish(z3.string()),
-  items: z3.optional(z3.array(zSaleItemInputSchema)),
-  metadata: z3.nullish(z3.record(z3.string(), z3.unknown())),
-  occurred_at: z3.iso.datetime({ offset: true }),
-  service: z3.nullish(z3.string()),
-  services: z3.nullish(z3.array(zSaleServiceInputSchema)),
-  sms_consent: z3.nullish(z3.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 = 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 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 = z3.object({
-  detail: z3.optional(z3.array(zValidationError))
+var zHttpValidationError = z4.object({
+  detail: z4.optional(z4.array(zValidationError))
 });
-var zValidationErrorItem = z3.object({
-  loc: z3.array(z3.union([z3.string(), z3.int()])),
-  msg: z3.string(),
-  type: z3.string()
+var zValidationErrorItem = z4.object({
+  loc: z4.array(z4.union([z4.string(), z4.int()])),
+  msg: z4.string(),
+  type: z4.string()
 });
-var zApiErrorSchema = z3.object({
+var zApiErrorSchema = z4.object({
   code: zErrorCode,
-  context: z3._default(z3.nullish(z3.record(z3.string(), z3.unknown())), null),
-  detail: z3.string(),
-  errors: z3._default(z3.nullish(z3.array(zValidationErrorItem)), 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(zValidationErrorItem)), null),
+  request_id: z4._default(z4.nullish(z4.string()), null)
 });
-var zWritebackEmailSource = z3.enum(["NONE", "SALE", "CUSTOMER", "HARVESTED"]);
-var zWritebackEnrichmentStatus = z3.enum(["NONE", "MATCHED", "AMBIGUOUS"]);
-var zWritebackSaleUploadCounts = z3.object({
-  failed: z3._default(z3.int(), 0),
-  pending: z3._default(z3.int(), 0),
-  skipped: z3._default(z3.int(), 0),
-  submitted: z3._default(z3.int(), 0),
-  total: z3._default(z3.int(), 0),
-  uploaded: z3._default(z3.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 = z3.object({
-  blocked_reason: z3.nullable(z3.string()),
-  can_dispatch: z3._default(z3.boolean(), false),
-  email_source: z3.nullable(zWritebackEmailSource),
-  enrichment_status: z3.nullable(zWritebackEnrichmentStatus),
-  gclid_attached: z3._default(z3.boolean(), false),
-  identifiers_sent: z3.nullable(z3.string()),
-  mapped_service_ids: z3.array(z3.uuid()),
-  matched_submit_count: z3.nullable(z3.int()),
-  needs_force: z3._default(z3.boolean(), false),
-  rollup: z3.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",
@@ -2615,39 +2793,39 @@ var zSaleWritebackStatusSchema = z3.object({
     "out_of_window",
     "blocked"
   ]),
-  stale: z3._default(z3.boolean(), false),
-  uncovered_service_ids: z3.array(z3.uuid()),
+  stale: z4._default(z4.boolean(), false),
+  uncovered_service_ids: z4.array(z4.uuid()),
   uploads: zWritebackSaleUploadCounts
 });
-var zSaleEntitySchema = z3.object({
-  amount_total_cents: z3.int(),
-  business_id: z3.uuid(),
-  business_name: z3.nullable(z3.string()),
-  created_at: z3.iso.datetime({ offset: true }),
-  currency: z3.string(),
-  customer_email: z3.nullable(z3.string()),
-  customer_name: z3.nullable(z3.string()),
-  customer_name_placeholder_confirmed: z3._default(z3.boolean(), false),
-  customer_name_placeholder_confirmed_at: z3.nullable(z3.iso.datetime({ offset: true })),
-  customer_phone: z3.nullable(z3.string()),
-  description: z3.nullable(z3.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: z3.nullable(z3.string()),
-  id: z3.uuid(),
-  items: z3.array(zSaleItemEntitySchema),
-  metadata: z3.nullable(z3.record(z3.string(), z3.unknown())),
-  occurred_at: z3.iso.datetime({ offset: true }),
-  service_id: z3.nullable(z3.uuid()),
-  service_key: z3.nullable(z3.string()),
-  service_label: z3.nullable(z3.string()),
-  services: z3.array(zSaleServiceEntitySchema),
-  sms_automation: z3.nullable(zSaleSmsStatusSchema),
-  sms_consent: z3._default(z3.boolean(), false),
-  sms_consent_granted_at: z3.nullable(z3.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: z3.nullable(zAutoLeapSaleFacts),
-  updated_at: z3.iso.datetime({ offset: true }),
-  writeback: z3.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
@@ -2656,11 +2834,11 @@ var saleServiceSchema = zSaleServiceInputSchema;
 var currencySchema = zSupportedCurrency;
 var SUPPORTED_CURRENCIES = currencySchema.options;
 var SALE_SOURCES = zSaleSource.options;
-var centsSchema = z4.int().check(z4.gte(0));
-var metadataSchema = z4.record(z4.string(), z4.unknown());
-var customerNameSchema = z4.string().check(z4.maxLength(200));
-var customerPhoneSchema = z4.string().check(z4.maxLength(64));
-var customerEmailSchema = z4.email().check(z4.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 });
 }
@@ -2694,24 +2872,24 @@ function refineServiceXor(val, ctx, { requireAmount }) {
     );
   }
 }
-var saleCreateSchema = z4.extend(zSaleCreateSchema, { items: z4._default(z4.array(saleItemSchema), []) }).check((ctx) => refineServiceXor(ctx.value, ctx, { requireAmount: true }));
-var saleUpdateSchema = z4.strictObject({
-  description: z4.nullish(z4.string()),
-  service: z4.nullish(z4.string()),
-  services: z4.nullish(z4.array(saleServiceSchema)),
-  currency: z4.optional(currencySchema),
-  amount_total_cents: z4.optional(centsSchema),
-  occurred_at: z4.optional(z4.iso.datetime()),
-  items: z4.optional(z4.array(saleItemSchema)),
-  metadata: z4.nullish(metadataSchema),
-  customer_name: z4.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: z4.optional(z4.boolean()),
-  customer_phone: z4.nullish(customerPhoneSchema),
-  customer_email: z4.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: z4.optional(z4.boolean())
+  sms_consent: z5.optional(z5.boolean())
 }).check((ctx) => refineServiceXor(ctx.value, ctx, { requireAmount: false }));
 var TRACKING_RANGES = ["24h", "7d", "30d"];
 var NAMED_RANGES = [
@@ -2738,23 +2916,6 @@ function phoneField(name, raw, country, label = null) {
   return { name, type: "phone", label, value: toE164(raw, country) };
 }
 
-// ../tracking-core/src/lead-forms/submit.ts
-var import_mini = require("zod/mini");
-var KNOWN_ROLES = new Set(LEAD_FORM_ROLES);
-var ROLE_ORDER = new Map(LEAD_FORM_ROLES.map((role, index) => [role, index]));
-function slotFields(dateTime) {
-  const written = /^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2})(?::\d{2}(?:\.\d+)?)?$/.exec(dateTime);
-  if (!written) {
-    throw new TypeError(
-      `slotFields needs the slot's wall time without an offset ("2026-10-13T09:30"), got "${dateTime}"`
-    );
-  }
-  return { preferred_date: written[1], preferred_time: { start: written[2], end: null } };
-}
-function timeWindow(start, end, label) {
-  return { start, end: end ?? null, ...label ? { label } : {} };
-}
-
 // src/index.ts
 var import_client2 = require("@aranova/tracking-react/client");
 var import_client3 = require("@aranova/tracking-react/client");