@parag.more.withsurface.com/forms-sdk 0.1.4

package/dist/index.mjs

@@ -0,0 +1,2714 @@
+// src/core/events/viewDetection.ts
+var observeFormView = (element, onViewed) => {
+  if (typeof IntersectionObserver === "undefined") {
+    onViewed();
+    return () => void 0;
+  }
+  let viewed = false;
+  const observer = new IntersectionObserver((entries) => {
+    const [entry] = entries;
+    if (!entry?.isIntersecting || viewed) return;
+    viewed = true;
+    observer.disconnect();
+    onViewed();
+  });
+  observer.observe(element);
+  return () => observer.disconnect();
+};
+
+// src/bind/bindForm.ts
+var fieldSelector = "input, select, textarea";
+var resolveFields = (element) => {
+  if (element.matches(fieldSelector)) {
+    return [element];
+  }
+  return Array.from(element.querySelectorAll(fieldSelector)).filter(
+    (field) => field.closest("[data-question-id]") === element
+  );
+};
+var fieldNameFor = (element, field, questionType) => {
+  const explicit = element.getAttribute("data-field-name") ?? field.getAttribute("data-field-name");
+  if (explicit) return explicit;
+  if (questionType === "Dropdown" && field instanceof HTMLSelectElement) return "selected";
+  if (field instanceof HTMLInputElement && field.type === "email") return "email";
+  return "input";
+};
+var questionTypeFor = (element, field) => {
+  const explicit = element.getAttribute("data-question-type") ?? field.getAttribute("data-question-type");
+  if (explicit) return explicit;
+  if (field instanceof HTMLInputElement && field.type === "email") return "EmailForm";
+  return "ShortInput";
+};
+var fieldValue = (field) => {
+  if (field instanceof HTMLInputElement && (field.type === "checkbox" || field.type === "radio")) {
+    return field.type === "checkbox" ? field.checked : field.value;
+  }
+  return field.value;
+};
+var isChoiceControl = (field) => field instanceof HTMLInputElement && (field.type === "radio" || field.type === "checkbox");
+var selectedValueAndIndex = (options) => {
+  const index = options.findIndex((option) => option.checked);
+  return { value: index === -1 ? "" : options[index].value, index };
+};
+var CHOICE_ANSWER_BUILDERS = {
+  MultipleOptionsQuestion: (options) => ({
+    choices: options.map((option, index) => ({ key: option.value, value: option.checked, index }))
+  }),
+  MultipleChoiceQuestion: (options) => ({
+    choices: options.map((option) => ({ key: option.value, value: option.checked }))
+  }),
+  MMChoiceQuestion: (options) => ({
+    choices: options.map((option) => ({ key: option.value, value: option.checked }))
+  }),
+  GraphicOptions: selectedValueAndIndex,
+  MultipleChoiceSingleAnswer: selectedValueAndIndex
+};
+var bindForm = ({ engine, root, expectedQuestionIds }) => {
+  const teardowns = [];
+  const boundQuestionIds = /* @__PURE__ */ new Set();
+  const listen = (target, type, handler) => {
+    target.addEventListener(type, handler);
+    teardowns.push(() => target.removeEventListener(type, handler));
+  };
+  for (const element of Array.from(root.querySelectorAll("[data-question-id]"))) {
+    const questionId = element.getAttribute("data-question-id");
+    const fields = resolveFields(element);
+    if (fields.length === 0) continue;
+    boundQuestionIds.add(questionId);
+    const groupType = questionTypeFor(element, fields[0]);
+    const buildChoiceAnswer = CHOICE_ANSWER_BUILDERS[groupType];
+    const choiceControls = fields.filter(isChoiceControl);
+    if (buildChoiceAnswer && choiceControls.length > 0) {
+      const apply = () => engine.setAnswer(questionId, { type: groupType, ...buildChoiceAnswer(choiceControls) });
+      for (const control of choiceControls) {
+        listen(control, "change", apply);
+      }
+      if (choiceControls.some((control) => control.checked)) apply();
+      continue;
+    }
+    for (const field of fields) {
+      const type = questionTypeFor(element, field);
+      const fieldName = fieldNameFor(element, field, type);
+      const apply = () => engine.setAnswer(questionId, { type, [fieldName]: fieldValue(field) });
+      listen(field, "input", apply);
+      listen(field, "change", apply);
+      const initial = fieldValue(field);
+      if (initial !== "" && initial !== false) apply();
+    }
+  }
+  const unbound = (expectedQuestionIds ?? []).filter((id) => !boundQuestionIds.has(id));
+  if (unbound.length > 0) {
+    console.warn(
+      `Surface SDK: form record declares questionIds with no bound element: ${unbound.join(", ")}. Answers for these will never be captured \u2014 check data-question-id attributes (validate_form_html catches this at authoring time).`
+    );
+  }
+  const navigationMarkerSelector = "[data-surface-goto-step], .surface-disqualify-button, .surface-submit-button, .surface-next-button";
+  for (const button of Array.from(root.querySelectorAll(navigationMarkerSelector))) {
+    const gotoStepId = button.getAttribute("data-surface-goto-step");
+    const markers = [
+      gotoStepId != null ? "goto" : null,
+      button.classList.contains("surface-disqualify-button") ? "disqualify" : null,
+      button.classList.contains("surface-submit-button") ? "submit" : null,
+      button.classList.contains("surface-next-button") ? "next" : null
+    ].filter((marker) => marker != null);
+    const action = markers[0];
+    if (markers.length > 1) {
+      console.warn(
+        `Surface SDK: element carries multiple navigation markers (${markers.join(
+          ", "
+        )}); only "${action}" is bound.`
+      );
+    }
+    listen(button, "click", (event) => {
+      event.preventDefault();
+      if (action === "goto") {
+        void engine.goToStep(gotoStepId).catch((error) => console.warn(`Surface SDK: ${String(error)}`));
+      } else if (action === "disqualify") {
+        void engine.disqualify();
+      } else if (action === "submit") {
+        void engine.submit();
+      } else {
+        void engine.next();
+      }
+    });
+  }
+  if (root instanceof HTMLFormElement) {
+    listen(root, "submit", (event) => {
+      event.preventDefault();
+      void engine.submit();
+    });
+  }
+  const stepContainers = Array.from(root.querySelectorAll("[data-step-id]"));
+  const showCurrentStep = () => {
+    const { currentStepId } = engine.state();
+    for (const container of stepContainers) {
+      container.hidden = container.getAttribute("data-step-id") !== currentStepId;
+    }
+  };
+  if (stepContainers.length > 0) {
+    showCurrentStep();
+    teardowns.push(engine.on("stepChanged", showCurrentStep));
+  }
+  teardowns.push(observeFormView(root, () => engine.markViewed()));
+  return () => teardowns.forEach((teardown) => teardown());
+};
+
+// src/bind/bookingWidget.ts
+var currentMonth = () => {
+  const now = /* @__PURE__ */ new Date();
+  return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}`;
+};
+var monthLabel = (month) => {
+  const [year, monthNum] = month.split("-").map(Number);
+  return new Date(year, monthNum - 1, 1).toLocaleDateString(void 0, { month: "long", year: "numeric" });
+};
+var dateLabel = (date) => {
+  const [year, monthNum, day] = date.split("-").map(Number);
+  return new Date(year, monthNum - 1, day).toLocaleDateString(void 0, {
+    weekday: "short",
+    month: "short",
+    day: "numeric"
+  });
+};
+var shiftMonth = (month, delta) => {
+  const [year, monthNum] = month.split("-").map(Number);
+  const shifted = new Date(year, monthNum - 1 + delta, 1);
+  return `${shifted.getFullYear()}-${String(shifted.getMonth() + 1).padStart(2, "0")}`;
+};
+var mountBookingWidget = ({
+  container,
+  scheduler,
+  eventTypeId,
+  timezone = Intl.DateTimeFormat().resolvedOptions().timeZone,
+  duration,
+  prefill,
+  identity,
+  formatters,
+  onComplete
+}) => {
+  const formatMonth = formatters?.month ?? monthLabel;
+  const formatDate = formatters?.date ?? dateLabel;
+  const formatTime = formatters?.time ?? ((slot) => new Date(slot.start).toLocaleTimeString(void 0, {
+    hour: "numeric",
+    minute: "2-digit",
+    timeZone: timezone
+  }));
+  const root = document.createElement("div");
+  root.className = "surface-booking";
+  container.appendChild(root);
+  let month = currentMonth();
+  let dates = [];
+  let selectedDate = null;
+  let selectedSlot = null;
+  let destroyed = false;
+  let generation = 0;
+  const el = (tag, className, text) => {
+    const node = document.createElement(tag);
+    node.className = className;
+    if (text != null) node.textContent = text;
+    return node;
+  };
+  const render = (children) => {
+    if (destroyed) return;
+    root.replaceChildren(...children);
+  };
+  const renderError = (message, retry) => {
+    const error = el("p", "surface-booking-error", message);
+    const retryButton = el("button", "surface-booking-retry", "Try again");
+    retryButton.type = "button";
+    retryButton.addEventListener("click", retry);
+    render([error, retryButton]);
+  };
+  const renderDates = async () => {
+    const requestedMonth = month;
+    const gen = ++generation;
+    render([el("p", "surface-booking-loading", "Loading availability\u2026")]);
+    const result = await scheduler.getMonthAvailability({
+      eventTypeId,
+      month: requestedMonth,
+      timezone,
+      duration
+    });
+    if (destroyed || gen !== generation) return;
+    if (!result.ok) {
+      renderError("Unable to load availability.", () => void renderDates());
+      return;
+    }
+    dates = result.data.data?.dates ?? [];
+    const heading = el("p", "surface-booking-month", formatMonth(requestedMonth));
+    heading.dataset.value = requestedMonth;
+    const nav = el("div", "surface-booking-month-nav");
+    for (const [label, delta] of [
+      ["Previous month", -1],
+      ["Next month", 1]
+    ]) {
+      const button = el("button", "surface-booking-month-button", label);
+      button.type = "button";
+      button.addEventListener("click", () => {
+        month = shiftMonth(month, delta);
+        void renderDates();
+      });
+      nav.appendChild(button);
+    }
+    const list = el("ul", "surface-booking-dates");
+    for (const date of dates.filter((d) => d.slots && d.slots.length > 0)) {
+      const item = el("li", "surface-booking-date");
+      const button = el("button", "surface-booking-date-button", formatDate(date.date));
+      button.dataset.value = date.date;
+      button.type = "button";
+      button.addEventListener("click", () => {
+        selectedDate = date;
+        void renderSlots();
+      });
+      item.appendChild(button);
+      list.appendChild(item);
+    }
+    if (list.childElementCount === 0) {
+      list.appendChild(el("li", "surface-booking-no-dates", "No availability this month."));
+    }
+    render([heading, nav, list]);
+  };
+  const renderSlots = async () => {
+    if (!selectedDate) return;
+    const gen = ++generation;
+    let slots = selectedDate.slots ?? [];
+    if (slots.length === 0) {
+      const result = await scheduler.getSlots({ eventTypeId, date: selectedDate.date, timezone, duration });
+      if (destroyed || gen !== generation) return;
+      if (!result.ok) {
+        renderError("Unable to load times.", () => void renderSlots());
+        return;
+      }
+      slots = result.data.data?.slots ?? [];
+    }
+    const heading = el("p", "surface-booking-day", formatDate(selectedDate.date));
+    heading.dataset.value = selectedDate.date;
+    const back = el("button", "surface-booking-back", "Back");
+    back.type = "button";
+    back.addEventListener("click", () => void renderDates());
+    const list = el("ul", "surface-booking-slots");
+    for (const slot of slots) {
+      const item = el("li", "surface-booking-slot");
+      const button = el("button", "surface-booking-slot-button", formatTime(slot));
+      button.dataset.value = slot.start;
+      button.type = "button";
+      button.addEventListener("click", () => {
+        selectedSlot = slot;
+        renderForm();
+      });
+      item.appendChild(button);
+      list.appendChild(item);
+    }
+    render([heading, back, list]);
+  };
+  const renderForm = (errorMessage) => {
+    if (!selectedSlot) return;
+    const form = el("form", "surface-booking-form");
+    const name = el("input", "surface-booking-name");
+    name.name = "name";
+    name.placeholder = "Name";
+    name.value = prefill?.name ?? "";
+    const email = el("input", "surface-booking-email");
+    email.type = "email";
+    email.name = "email";
+    email.placeholder = "Email";
+    email.value = prefill?.email ?? "";
+    const submit = el("button", "surface-booking-submit", "Book");
+    submit.type = "submit";
+    form.append(name, email, submit);
+    if (errorMessage) form.appendChild(el("p", "surface-booking-error", errorMessage));
+    form.addEventListener("submit", (event) => {
+      event.preventDefault();
+      void (async () => {
+        submit.disabled = true;
+        const result = await scheduler.book({
+          eventTypeId,
+          startTime: selectedSlot.start,
+          endTime: selectedSlot.end,
+          timezone,
+          inviteeName: name.value,
+          inviteeEmail: email.value,
+          duration,
+          ...identity
+        });
+        if (destroyed) return;
+        if (!result.ok) {
+          renderForm("Booking failed. Please try again.");
+          return;
+        }
+        render([el("p", "surface-booking-booked", "Booked!")]);
+        onComplete(result.data);
+      })();
+    });
+    render([form]);
+  };
+  void renderDates();
+  return () => {
+    destroyed = true;
+    root.remove();
+  };
+};
+
+// src/core/client/emailValidation.ts
+var VALIDATION_PATH = "/api/v1/edge/emailValidation";
+var failOpenResult = (email) => ({
+  email,
+  isValid: true,
+  status: "unknown",
+  reason: "validation_failed",
+  failed: true
+});
+var resultOf = (email, row) => {
+  if (!row || typeof row.isValid !== "boolean") return failOpenResult(email);
+  return {
+    email,
+    isValid: row.isValid,
+    status: row.status,
+    reason: row.reason,
+    ...row.blacklistEntryIds?.length ? { blacklistEntryIds: row.blacklistEntryIds } : {},
+    ...row.validationSuccessfullyRan === false ? { failed: true } : {}
+  };
+};
+var createEmailValidator = ({
+  transport,
+  environmentId,
+  preview = false
+}) => {
+  const cache = /* @__PURE__ */ new Map();
+  const validateBatch = (emails) => {
+    const normalized = [...new Set(emails.map((email) => email.trim()).filter((email) => email !== ""))];
+    if (preview) {
+      for (const email of normalized) {
+        if (!cache.has(email)) {
+          cache.set(email, Promise.resolve({ email, isValid: true, status: "preview" }));
+        }
+      }
+    }
+    const pending = normalized.filter((email) => !cache.has(email));
+    if (pending.length > 0) {
+      const request = transport.post(VALIDATION_PATH, { emails: pending, environmentId }).then((result) => result.ok ? result.data.data ?? {} : {}).catch(() => ({}));
+      for (const email of pending) {
+        cache.set(
+          email,
+          request.then((rows) => resultOf(email, rows[email]))
+        );
+      }
+    }
+    return Promise.all(normalized.map((email) => cache.get(email)));
+  };
+  return {
+    validateBatch,
+    validate: async (email) => {
+      const [result] = await validateBatch([email]);
+      return result ?? failOpenResult(email.trim());
+    }
+  };
+};
+
+// src/core/client/responses.ts
+var CREATE_PATH = "/api/v1/responses/";
+var UPDATE_PATH = "/api/v1/responses/update";
+var GET_PATH = "/api/v1/responses/getResponse";
+var submitResponse = async (transport, payload) => {
+  const result = await transport.post(CREATE_PATH, payload, { credentials: true });
+  if (!result.ok) return result;
+  const id = result.data.data?.id;
+  if (!id) {
+    return { ok: false, error: { kind: "http", status: 200, body: result.data } };
+  }
+  return {
+    ok: true,
+    data: {
+      responseId: id,
+      leadId: result.data.data?.meta?.leadId ?? null,
+      resumeToken: result.data.data?.resumeToken ?? null
+    }
+  };
+};
+var updateResponse = (transport, payload) => {
+  transport.beacon(UPDATE_PATH, payload);
+};
+var updateResponseConfirmed = (transport, payload) => transport.post(UPDATE_PATH, payload, { keepalive: true, credentials: true });
+var isAnswerRow = (row) => typeof row?.questionId === "string" && typeof row?.response === "object" && row.response !== null;
+var fetchStoredResponse = async (transport, { responseId, resumeToken }) => {
+  const result = await transport.get(
+    `${GET_PATH}?rid=${encodeURIComponent(responseId)}&rt=${encodeURIComponent(resumeToken)}`
+  );
+  if (!result.ok) return result;
+  const rows = Array.isArray(result.data.data?.data) ? result.data.data.data : [];
+  return {
+    ok: true,
+    data: { answers: rows.filter(isAnswerRow).filter((row) => row.response.type !== "URL_DATA") }
+  };
+};
+
+// src/core/client/runtimeConfig.ts
+var fetchRuntimeConfig = (transport, formId, { preview = false, previewToken } = {}) => transport.get(
+  `/api/v1/public/forms/${formId}/runtime-config${// The signed token (from the create_form / get_sdk_binding_map replies)
+  // unlocks the DRAFT config of a never-published form; without it the
+  // server serves the published config.
+  preview ? `?preview=1${previewToken ? `&pt=${encodeURIComponent(previewToken)}` : ""}` : ""}`
+);
+var flatComponentsOf = (step) => {
+  const components = step.components;
+  if (Array.isArray(components)) return components;
+  const layout = components?.layout;
+  if (!Array.isArray(layout)) return [];
+  return layout.flatMap((layoutRow) => {
+    const row = layoutRow.row;
+    if (!Array.isArray(row)) return [];
+    return row.map(
+      (item) => item.type === "GridLayoutRowItem" ? item.component : item
+    );
+  });
+};
+var stepsOf = (config) => (config.steps ?? []).map((step) => ({
+  id: step.id,
+  ...step.endStepKind !== void 0 && { endStepKind: step.endStepKind }
+}));
+var statefulQuestionsOf = (config) => (config.steps ?? []).flatMap(flatComponentsOf).flatMap((component) => {
+  const typed = component;
+  if (typeof typed?.state?.questionId !== "string") return [];
+  return [
+    {
+      questionId: typed.state.questionId,
+      ...typeof typed.type === "string" && { componentType: typed.type }
+    }
+  ];
+});
+var statefulQuestionIdsOf = (config) => statefulQuestionsOf(config).map((question) => question.questionId);
+var enrichmentSourcesOf = (config) => (config.steps ?? []).flatMap(flatComponentsOf).flatMap((component) => {
+  const typed = component;
+  if (typeof typed?.state?.questionId !== "string") return [];
+  if (typed.type === "IdentityInfo") {
+    const source = typeof typed.content?.enrichmentSourceField === "string" ? typed.content.enrichmentSourceField : "emailAddress";
+    return [{ questionId: typed.state.questionId, fieldNames: [.../* @__PURE__ */ new Set([source, "websiteUrl"])] }];
+  }
+  if (typed.type === "EmailForm") {
+    return [{ questionId: typed.state.questionId, fieldNames: ["email"] }];
+  }
+  return [];
+});
+var hasDeclaredEnrichmentSource = (config) => (config.steps ?? []).flatMap(flatComponentsOf).some(
+  (component) => typeof component?.content?.enrichmentSourceField === "string"
+);
+var hasEnabledEnrichmentProvider = (settings) => {
+  const enrichment = settings?.enrichment;
+  if (enrichment?.version !== 2 || !Array.isArray(enrichment.providers)) return false;
+  return enrichment.providers.some(
+    (provider) => provider?.enabled === true && Array.isArray(provider.enabledFields) && provider.enabledFields.length > 0
+  );
+};
+
+// src/core/client/scheduler.ts
+var toParams = (entries) => new URLSearchParams(
+  Object.fromEntries(Object.entries(entries).filter(([, value]) => value != null))
+);
+var createSchedulerClient = ({
+  transport,
+  preview = false
+}) => {
+  const previewParam = preview ? "true" : void 0;
+  const unwrapBooking = (result) => {
+    if (!result.ok) return result;
+    const booking = result.data.data;
+    if (!booking?.id) return { ok: false, error: { kind: "http", status: 200, body: result.data } };
+    return { ok: true, data: booking };
+  };
+  return {
+    getPublicEventType: (eventTypeId) => transport.get(`/api/v1/scheduler/event-types/${eventTypeId}/public`),
+    getAvailabilitySummary: ({ eventTypeId, timezone }) => {
+      const params = new URLSearchParams({
+        eventTypeId,
+        timezone: timezone ?? Intl.DateTimeFormat().resolvedOptions().timeZone
+      });
+      return transport.get(`/api/v1/scheduler/availability-summary?${params}`);
+    },
+    getMonthAvailability: ({ eventTypeId, month, timezone, duration, hostId, ownerEmail }) => {
+      const [year, monthNum] = month.split("-").map(Number);
+      const params = toParams({
+        eventTypeId,
+        month: String(monthNum),
+        year: String(year),
+        timezone,
+        duration: duration ? String(duration) : void 0,
+        preview: previewParam,
+        hostId,
+        ownerEmail
+      });
+      return transport.get(`/api/v1/scheduler/availability?${params}`);
+    },
+    getSlots: ({ eventTypeId, date, timezone, duration, hostId, ownerEmail }) => {
+      const params = toParams({
+        eventTypeId,
+        date,
+        timezone,
+        duration: duration ? String(duration) : void 0,
+        preview: previewParam,
+        hostId,
+        ownerEmail
+      });
+      return transport.get(`/api/v1/scheduler/slots?${params}`);
+    },
+    book: async ({
+      eventTypeId,
+      startTime,
+      endTime,
+      timezone,
+      inviteeName,
+      inviteeEmail,
+      duration,
+      intakeResponses,
+      guestEmails,
+      captchaToken,
+      responseId,
+      leadSessionId,
+      fingerprint,
+      hostRouting
+    }) => {
+      if (preview) {
+        return {
+          ok: true,
+          data: {
+            id: "preview-booking-" + Date.now(),
+            startTime,
+            // Native fabricates from the selected slot (BookingForm: slot.end).
+            endTime,
+            timezone,
+            inviteeName: inviteeName || "Test User",
+            inviteeEmail: inviteeEmail || "test@example.com",
+            meetingJoinLink: null,
+            cancelToken: "preview-cancel-" + Date.now(),
+            rescheduleToken: "preview-reschedule-" + Date.now(),
+            attendees: [{ name: "Host", email: "host@example.com", isHost: true }]
+          }
+        };
+      }
+      const result = await transport.post("/api/v1/scheduler/book", {
+        eventTypeId,
+        startTime,
+        timezone,
+        inviteeName,
+        inviteeEmail: inviteeEmail.trim(),
+        ...duration ? { duration } : {},
+        ...intakeResponses && Object.keys(intakeResponses).length > 0 ? { intakeResponses } : {},
+        ...guestEmails && guestEmails.length > 0 ? { guestEmails } : {},
+        ...captchaToken ? { captchaToken } : {},
+        meta: {
+          source: "form",
+          ...responseId ? { responseId } : {},
+          ...leadSessionId ? { leadSessionId } : {},
+          ...fingerprint ? { fingerprint } : {},
+          ...hostRouting ? { hostRouting } : {}
+        }
+      });
+      return unwrapBooking(result);
+    },
+    reschedule: async ({ bookingId, rescheduleToken, newStartTime, timezone }) => {
+      const result = await transport.post(
+        `/api/v1/scheduler/bookings/${bookingId}/reschedule`,
+        { rescheduleToken, newStartTime, timezone }
+      );
+      return unwrapBooking(result);
+    }
+  };
+};
+var toSchedulerAnswerState = (booking) => {
+  const hostAttendee = booking.attendees?.find((attendee) => attendee.isHost);
+  return {
+    type: "DynamicScheduler",
+    eventScheduled: true,
+    uri: booking.id,
+    meetingTime: booking.startTime,
+    meetingEndTime: booking.endTime,
+    ownerEmails: hostAttendee?.email ?? "",
+    guestEmails: booking.inviteeEmail,
+    inviteeName: booking.inviteeName,
+    googleMeetLink: booking.meetingJoinLink ?? ""
+  };
+};
+
+// src/core/client/transport.ts
+var DEFAULT_API_BASE_URL = "https://forms.withsurface.com";
+var SDK_VERSION = "0.1.0";
+var versionedHeaders = (headers = {}) => ({
+  ...headers,
+  "X-Surface-Sdk-Version": SDK_VERSION
+});
+var versionedUrl = (url) => `${url}${url.includes("?") ? "&" : "?"}sdv=${SDK_VERSION}`;
+var createTransport = ({
+  apiBaseUrl = DEFAULT_API_BASE_URL
+} = {}) => {
+  const baseUrl = apiBaseUrl.replace(/\/$/, "");
+  const toUrl = (path) => `${baseUrl}${path}`;
+  const get = async (path) => {
+    try {
+      const response = await fetch(toUrl(path), { headers: versionedHeaders() });
+      if (!response.ok) {
+        const body = await response.json().catch(() => void 0);
+        return { ok: false, error: { kind: "http", status: response.status, body } };
+      }
+      return { ok: true, data: await response.json() };
+    } catch (cause) {
+      return { ok: false, error: { kind: "network", cause } };
+    }
+  };
+  const post = async (path, payload, opts) => {
+    try {
+      const response = await fetch(toUrl(path), {
+        method: "POST",
+        headers: versionedHeaders({ "Content-Type": "application/json" }),
+        body: JSON.stringify(payload),
+        ...opts?.keepalive ? { keepalive: true } : {},
+        // The `${formId}_pa` person-attributes cookie (repeat-visitor signals)
+        // lives on the API origin; only credentialed requests carry it from a
+        // customer-hosted page (Decisions #12 — the endpoints echo the origin).
+        ...opts?.credentials ? { credentials: "include" } : {}
+      });
+      if (!response.ok) {
+        const body = await response.json().catch(() => void 0);
+        return { ok: false, error: { kind: "http", status: response.status, body } };
+      }
+      return { ok: true, data: await response.json() };
+    } catch (cause) {
+      return { ok: false, error: { kind: "network", cause } };
+    }
+  };
+  const beacon = (path, payload) => {
+    let serialized;
+    try {
+      serialized = JSON.stringify(payload);
+    } catch {
+      return false;
+    }
+    const url = versionedUrl(toUrl(path));
+    try {
+      if (typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function") {
+        const queued = navigator.sendBeacon(url, new Blob([serialized], { type: "application/json" }));
+        if (queued) return true;
+      }
+    } catch {
+    }
+    try {
+      void fetch(url, {
+        method: "POST",
+        keepalive: true,
+        // sendBeacon always sends credentials; the fallback must match, or the
+        // update path's `${formId}_pa` cookie round-trip depends on which
+        // delivery won.
+        credentials: "include",
+        headers: versionedHeaders({ "Content-Type": "application/json" }),
+        body: serialized
+      }).catch(() => void 0);
+    } catch {
+    }
+    return false;
+  };
+  return { get, post, beacon };
+};
+
+// src/core/engine/answerStates.ts
+var IDENTITY_INFO_ANSWER_KEYS = [
+  "firstName",
+  "lastName",
+  "fullName",
+  "emailAddress",
+  "workEmailAddress",
+  "phoneNumber",
+  "companyName",
+  "numberOfEmployees",
+  "websiteUrl",
+  "title",
+  "streetAddress",
+  "aptSuiteEtc",
+  "city",
+  "state",
+  "country",
+  "zipCode",
+  "companyRevenue",
+  "profilePictureUrl"
+];
+
+// src/core/events/emitter.ts
+var createEmitter = () => {
+  const handlers = /* @__PURE__ */ new Map();
+  return {
+    on: (event, handler) => {
+      const existing = handlers.get(event) ?? /* @__PURE__ */ new Set();
+      existing.add(handler);
+      handlers.set(event, existing);
+      return () => {
+        existing.delete(handler);
+      };
+    },
+    emit: (event, payload) => {
+      handlers.get(event)?.forEach((handler) => {
+        try {
+          handler(payload);
+        } catch (error) {
+          console.error(`Surface SDK: "${String(event)}" handler threw`, error);
+        }
+      });
+    }
+  };
+};
+
+// src/core/events/pushEvents.ts
+var PUSH_EVENT_PATH = "/api/v1/pushEvent";
+var KNOWN_BOT_UA = /bot|crawl|spider|slurp|baidu|bingpreview|googlebot|yandex|duckduck|ahrefs|semrush|facebookexternalhit|embedly|quora link preview|pinterest|twitterbot|linkedinbot|whatsapp|telegram|discord|headless|lighthouse|pagespeed/i;
+var isLikelyBot = () => {
+  const ua = navigator.userAgent;
+  if (!ua) return false;
+  return KNOWN_BOT_UA.test(ua);
+};
+var hasRequiredFields = (event) => Boolean(event?.type && event?.entityType && event?.entityId);
+var buildStepTransitionEventBatch = ({
+  sessionId,
+  formId,
+  currentStepId,
+  nextStepId,
+  stepCompletionTime
+}) => ({
+  events: [
+    {
+      type: "form_step_submitted",
+      entityType: "form_step",
+      entityId: formId,
+      stepId: currentStepId,
+      leadSessionId: sessionId,
+      properties: [{ key: "stepCompletionTime", value: stepCompletionTime }]
+    },
+    {
+      type: "form_step_viewed",
+      entityType: "form_step",
+      entityId: formId,
+      stepId: nextStepId,
+      leadSessionId: sessionId,
+      properties: []
+    }
+  ]
+});
+var createPushEventClient = ({
+  transport,
+  preview = false
+}) => ({
+  push: (request) => {
+    if (preview) return;
+    if (typeof navigator === "undefined") return;
+    const events = "events" in request ? request.events : [request];
+    if (isLikelyBot()) return;
+    if (events.some((event) => !hasRequiredFields(event))) return;
+    transport.beacon(PUSH_EVENT_PATH, request);
+  }
+});
+
+// src/core/events/startedDetection.ts
+var createStartedDetector = (initial) => {
+  const snapshot = deepClone(initial);
+  let started = false;
+  return (current) => {
+    if (started) return false;
+    if (deepEqual(snapshot, current)) return false;
+    started = true;
+    return true;
+  };
+};
+var deepClone = (value) => {
+  if (Array.isArray(value)) return value.map(deepClone);
+  if (value !== null && typeof value === "object") {
+    const clone = {};
+    for (const [key, entry] of Object.entries(value)) clone[key] = deepClone(entry);
+    return clone;
+  }
+  return value;
+};
+var deepEqual = (a, b) => {
+  if (Object.is(a, b)) return true;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((entry, index) => deepEqual(entry, b[index]));
+  }
+  if (a !== null && b !== null && typeof a === "object" && typeof b === "object") {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) return false;
+    return aKeys.every(
+      (key) => deepEqual(a[key], b[key])
+    );
+  }
+  return false;
+};
+
+// src/core/engine/responsePayload.ts
+var buildResponsesArray = (answers, externalStates) => {
+  const responses = [];
+  let enrichedFields = {};
+  let bookingId;
+  for (const step in answers) {
+    const stepState = answers[step];
+    for (const questionId in stepState) {
+      const entry = stepState[questionId];
+      if (!bookingId && entry?.eventScheduled === true && typeof entry.uri === "string" && entry.uri.length > 0 && !entry.uri.includes("calendly.com") && !entry.uri.includes("cal.com")) {
+        bookingId = entry.uri;
+      }
+      responses.push({ questionId, response: { ...stepState[questionId] } });
+    }
+  }
+  for (const stateId in externalStates) {
+    const externalState = externalStates[stateId];
+    if (externalState.type === "SCHEDULER_AVAILABILITY_DATA") continue;
+    responses.push({ questionId: stateId, response: { ...externalState } });
+    if (externalState.type === "APOLLO_EMAIL_ENRICHMENT" && externalState.processed) {
+      enrichedFields = externalState.data ?? {};
+    }
+  }
+  return { responses, enrichedFields, bookingId };
+};
+var buildBasePayload = ({
+  formId,
+  answers,
+  externalStates,
+  submittingOnStepId,
+  finished,
+  invalidResponse,
+  trackCookies,
+  meta = {},
+  personAttributeEnrichedFields,
+  fingerprint,
+  leadSessionId
+}) => {
+  const { responses, enrichedFields, bookingId } = buildResponsesArray(answers, externalStates);
+  const filteredMeta = trackCookies ? meta : Object.fromEntries(Object.entries(meta).filter(([key]) => key !== "cookies"));
+  return {
+    responses,
+    enrichedFields: personAttributeEnrichedFields ?? enrichedFields ?? {},
+    formId,
+    finished,
+    invalidResponse,
+    stepId: submittingOnStepId,
+    fingerprint,
+    leadSessionId,
+    meta: bookingId ? { ...filteredMeta, bookingId } : filteredMeta
+  };
+};
+var createSubmitResponsePayload = (options) => ({
+  ...buildBasePayload(options),
+  responseShapeVersion: "2.0"
+});
+var createUpdateResponsePayload = (options) => ({
+  ...buildBasePayload(options),
+  responseId: options.responseId
+});
+
+// src/core/engine/formEngine.ts
+var createFormEngine = ({
+  formId,
+  environmentId,
+  steps,
+  transport,
+  resolveNextStep,
+  trackPartialResponses = true,
+  trackCookies = false,
+  externalStates = {},
+  meta = {},
+  identity,
+  pushEvents,
+  formJourney,
+  preview = false,
+  resume
+}) => {
+  if (steps.length === 0) throw new Error("createFormEngine requires at least one step");
+  const resolve = resolveNextStep ?? ((currentStepId2) => {
+    const index = steps.findIndex((step) => step.id === currentStepId2);
+    const following = steps[index + 1];
+    return following ? { stepId: following.id, reason: "linear" } : "END";
+  });
+  const emitter = createEmitter();
+  const storeListeners = /* @__PURE__ */ new Set();
+  let snapshotDirty = true;
+  let snapshot;
+  const notify = () => {
+    snapshotDirty = true;
+    storeListeners.forEach((listener) => listener());
+  };
+  const currentIdentity = () => identity?.() ?? {};
+  const answers = {};
+  let currentStepId = steps[0].id;
+  let responseId = resume?.responseId ?? null;
+  let resumeToken = null;
+  if (resume?.answers) {
+    const seeded = {};
+    for (const [questionId, state] of Object.entries(resume.answers)) {
+      seeded[questionId] = { ...state };
+    }
+    answers[currentStepId] = seeded;
+  }
+  let finished = false;
+  let terminalWrite = null;
+  let viewed = false;
+  const createdAt = Date.now();
+  const history2 = [];
+  const hasStarted = createStartedDetector(answers);
+  formJourney?.setFormId(formId);
+  if (responseId != null) formJourney?.setResponseId(responseId);
+  formJourney?.recordEntry(currentStepId);
+  const write = async (submittingOnStepId, isFinished, invalid) => {
+    if (preview) return;
+    const payloadOptions = {
+      formId,
+      answers,
+      externalStates,
+      submittingOnStepId,
+      finished: isFinished,
+      invalidResponse: invalid,
+      trackCookies,
+      meta,
+      fingerprint: currentIdentity().fingerprint,
+      leadSessionId: currentIdentity().leadSessionId
+    };
+    if (responseId == null) {
+      const result = await submitResponse(transport, createSubmitResponsePayload(payloadOptions));
+      if (!result.ok) {
+        if (result.error.kind === "network") {
+          pushEvents?.push({
+            type: "response_submission_error",
+            entityType: "response",
+            entityId: formId,
+            stepId: submittingOnStepId,
+            leadSessionId: currentIdentity().leadSessionId,
+            properties: [{ key: "error", value: "network" }]
+          });
+        }
+        emitter.emit("error", { scope: "submit", error: result.error });
+        return;
+      }
+      responseId = result.data.responseId;
+      resumeToken = result.data.resumeToken;
+      formJourney?.setResponseId(responseId);
+      pushEvents?.push({
+        type: "response_submission_created",
+        entityType: "response",
+        entityId: formId,
+        stepId: submittingOnStepId,
+        leadSessionId: currentIdentity().leadSessionId,
+        properties: [{ key: "responseId", value: responseId }]
+      });
+    } else if (isFinished) {
+      const result = await updateResponseConfirmed(
+        transport,
+        createUpdateResponsePayload({ ...payloadOptions, responseId })
+      );
+      if (!result.ok) {
+        updateResponse(transport, createUpdateResponsePayload({ ...payloadOptions, responseId }));
+        emitter.emit("error", { scope: "submit", error: result.error });
+        return;
+      }
+    } else {
+      updateResponse(transport, createUpdateResponsePayload({ ...payloadOptions, responseId }));
+    }
+    notify();
+    emitter.emit("saved", { responseId, finished: isFinished, resumeToken });
+  };
+  let writeQueue = Promise.resolve();
+  const enqueueWrite = (task) => {
+    const run = writeQueue.then(() => finished ? void 0 : task());
+    writeQueue = run.catch(() => void 0);
+    return run;
+  };
+  const amendAfterFinish = () => {
+    if (!finished || terminalWrite == null) return;
+    const amend = terminalWrite;
+    writeQueue = writeQueue.then(() => {
+      if (responseId != null) return write(amend.stepId, true, amend.invalid);
+    }).catch(() => void 0);
+  };
+  let pendingAdvance = null;
+  const advance = (submitting) => {
+    if (finished) return Promise.resolve();
+    if (pendingAdvance) {
+      return submitting ? pendingAdvance.then(() => advance(true)) : pendingAdvance;
+    }
+    const tracked = enqueueWrite(() => advanceNow(submitting)).finally(() => {
+      if (pendingAdvance === tracked) pendingAdvance = null;
+    });
+    pendingAdvance = tracked;
+    return tracked;
+  };
+  const rewindTo = (targetStepId) => {
+    const from = currentStepId;
+    while (history2.length > 0 && currentStepId !== targetStepId) {
+      currentStepId = history2.pop();
+    }
+    notify();
+    formJourney?.recordTransition({ fromStepId: from, toStepId: currentStepId, reason: "back_nav" });
+    emitter.emit("stepChanged", { fromStepId: from, toStepId: currentStepId });
+  };
+  const goToStep = (targetStepId) => {
+    if (!steps.some((step) => step.id === targetStepId)) {
+      return Promise.reject(new Error(`goToStep: no step with id "${targetStepId}"`));
+    }
+    if (finished) return Promise.resolve();
+    if (pendingAdvance) {
+      return pendingAdvance.then(() => goToStep(targetStepId));
+    }
+    if (targetStepId === currentStepId) return Promise.resolve();
+    if (history2.includes(targetStepId)) {
+      rewindTo(targetStepId);
+      return Promise.resolve();
+    }
+    const tracked = enqueueWrite(async () => {
+      if (targetStepId === currentStepId) return;
+      emitter.emit("stepCompleted", { stepId: currentStepId });
+      await moveForwardNow({ stepId: targetStepId, reason: "conditional_match" });
+    }).finally(() => {
+      if (pendingAdvance === tracked) pendingAdvance = null;
+    });
+    pendingAdvance = tracked;
+    return tracked;
+  };
+  const disqualify = () => {
+    if (finished) return Promise.resolve();
+    if (pendingAdvance) {
+      return pendingAdvance.then(() => disqualify());
+    }
+    const tracked = enqueueWrite(() => finishNow(true)).finally(() => {
+      if (pendingAdvance === tracked) pendingAdvance = null;
+    });
+    pendingAdvance = tracked;
+    return tracked;
+  };
+  const moveForwardNow = async (target) => {
+    const leavingStepId = currentStepId;
+    pushEvents?.push(
+      buildStepTransitionEventBatch({
+        sessionId: currentIdentity().leadSessionId,
+        formId,
+        currentStepId: leavingStepId,
+        nextStepId: target.stepId,
+        stepCompletionTime: (Date.now() - createdAt) / 1e3
+      })
+    );
+    formJourney?.recordTransition({
+      fromStepId: leavingStepId,
+      toStepId: target.stepId,
+      reason: target.reason ?? "linear"
+    });
+    if (trackPartialResponses) await write(leavingStepId, false, false);
+    history2.push(leavingStepId);
+    currentStepId = target.stepId;
+    notify();
+    emitter.emit("stepChanged", { fromStepId: leavingStepId, toStepId: currentStepId });
+  };
+  const revealEndingStep = (kind) => {
+    const ending = steps.find((step) => step.endStepKind === kind);
+    if (!ending || ending.id === currentStepId) return;
+    const from = currentStepId;
+    history2.push(from);
+    currentStepId = ending.id;
+    notify();
+    emitter.emit("stepChanged", { fromStepId: from, toStepId: currentStepId });
+  };
+  const finishNow = async (invalid) => {
+    const leavingStepId = currentStepId;
+    finished = true;
+    terminalWrite = { stepId: leavingStepId, invalid };
+    await write(leavingStepId, true, invalid);
+    revealEndingStep(invalid ? "disqualified" : "thank_you");
+    if (invalid) {
+      formJourney?.recordTerminal({
+        outcome: "disqualified",
+        disqualification: { reason: "conditional_match", atStepId: leavingStepId }
+      });
+      emitter.emit("disqualified", { stepId: leavingStepId });
+    } else {
+      formJourney?.recordTerminal({ outcome: "completed" });
+      pushEvents?.push({
+        type: "form_completed",
+        entityType: "form",
+        entityId: formId,
+        stepId: null,
+        leadSessionId: currentIdentity().leadSessionId,
+        properties: [],
+        environmentId,
+        leadId: currentIdentity().leadId
+      });
+      emitter.emit("completed", { formId });
+    }
+    notify();
+  };
+  const advanceNow = async (submitting) => {
+    const resolved = resolve(currentStepId, answers);
+    const isFinished = submitting || resolved === "END" || resolved === "INVALID" || resolved == null;
+    emitter.emit("stepCompleted", { stepId: currentStepId });
+    if (!isFinished) {
+      await moveForwardNow(resolved);
+      return;
+    }
+    await finishNow(resolved === "INVALID");
+  };
+  return {
+    setAnswer: (questionId, state) => {
+      const stepState = answers[currentStepId] ?? (answers[currentStepId] = {});
+      stepState[questionId] = { ...stepState[questionId], ...state };
+      if (hasStarted(answers)) {
+        pushEvents?.push({
+          type: "form_started",
+          entityType: "form",
+          entityId: formId,
+          stepId: null,
+          leadSessionId: currentIdentity().leadSessionId,
+          properties: []
+        });
+        emitter.emit("started", { formId });
+      }
+      notify();
+    },
+    setExternalState: (id, state) => {
+      externalStates[id] = state;
+      notify();
+      amendAfterFinish();
+    },
+    mergeMeta: (partial) => {
+      Object.assign(meta, partial);
+      amendAfterFinish();
+    },
+    next: () => advance(false),
+    goToStep,
+    submit: () => advance(true),
+    disqualify,
+    back: () => {
+      const previous = history2.pop();
+      if (previous == null || finished) return;
+      const from = currentStepId;
+      currentStepId = previous;
+      notify();
+      formJourney?.recordTransition({ fromStepId: from, toStepId: previous, reason: "back_nav" });
+      emitter.emit("stepChanged", { fromStepId: from, toStepId: previous });
+    },
+    savePartial: () => {
+      const submittingOnStepId = currentStepId;
+      return enqueueWrite(() => write(submittingOnStepId, false, false));
+    },
+    // Reads the queue at call time (it grows via amendAfterFinish), so this
+    // settles after everything already queued — including post-finish amends.
+    flush: () => writeQueue.then(() => void 0),
+    markViewed: () => {
+      if (viewed) return;
+      viewed = true;
+      pushEvents?.push({
+        type: "form_viewed",
+        entityType: "form",
+        entityId: formId,
+        stepId: null,
+        leadSessionId: currentIdentity().leadSessionId,
+        properties: [],
+        environmentId,
+        leadId: currentIdentity().leadId
+      });
+      pushEvents?.push({
+        type: "form_step_viewed",
+        entityType: "form_step",
+        entityId: formId,
+        stepId: steps[0].id,
+        leadSessionId: currentIdentity().leadSessionId,
+        properties: []
+      });
+      emitter.emit("viewed", { formId });
+    },
+    on: emitter.on,
+    state: () => {
+      if (snapshotDirty) {
+        snapshot = { currentStepId, answers, externalStates, responseId, resumeToken, finished };
+        snapshotDirty = false;
+      }
+      return snapshot;
+    },
+    subscribe: (listener) => {
+      storeListeners.add(listener);
+      return () => storeListeners.delete(listener);
+    }
+  };
+};
+
+// src/core/engine/redirect.ts
+var DEFAULT_REDIRECT_TIMEOUT_MS = 400;
+var addProtocolToUrl = (url, protocol = "https") => {
+  if (!url) return url;
+  if (url.startsWith(protocol)) return url;
+  return `${protocol}://${url}`;
+};
+var buildRedirectUrl = (url, { leadId, sessionId } = {}) => {
+  if (!url || !url.trim()) return "";
+  try {
+    const redirectUrl = new URL(addProtocolToUrl(url));
+    if (leadId) redirectUrl.searchParams.set("leadId", leadId);
+    if (sessionId) redirectUrl.searchParams.set("sessionId", sessionId);
+    return redirectUrl.toString();
+  } catch {
+    return url;
+  }
+};
+var performRedirect = ({
+  url,
+  redirectType = "CurrentWindow",
+  leadId,
+  sessionId,
+  preview = false
+}) => {
+  if (!url || preview) return;
+  if (typeof window === "undefined") return;
+  const redirectUrl = buildRedirectUrl(url, { leadId, sessionId });
+  if (!redirectUrl) return;
+  if (redirectType === "CurrentWindow") {
+    window.location.href = redirectUrl;
+  } else if (redirectType === "NewTab") {
+    window.open(redirectUrl, "_blank");
+  }
+};
+
+// src/core/engine/urlData.ts
+var constructUrlParamsObject = (url) => {
+  const urlObj = new URL(url);
+  if (!urlObj.search) return {};
+  const paramsObject = {};
+  new URLSearchParams(urlObj.search).forEach((value, key) => {
+    paramsObject[key] = value;
+  });
+  return paramsObject;
+};
+var parseCookiesObject = (cookieString) => {
+  const cookies = {};
+  for (const cookie of cookieString.split(";")) {
+    const trimmed = cookie.trim();
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex <= 0) continue;
+    const value = trimmed.substring(eqIndex + 1);
+    try {
+      cookies[trimmed.substring(0, eqIndex)] = decodeURIComponent(value);
+    } catch {
+      cookies[trimmed.substring(0, eqIndex)] = value;
+    }
+  }
+  return cookies;
+};
+var buildUrlData = ({
+  defaultUrl,
+  trackCookies = false
+} = {}) => {
+  const inBrowser = typeof window !== "undefined";
+  const urlData = {
+    type: "URL_DATA",
+    fullUrl: defaultUrl ?? (inBrowser ? window.location.href : void 0),
+    referrer: inBrowser && typeof document !== "undefined" ? document.referrer || "" : void 0
+  };
+  if (urlData.fullUrl) {
+    try {
+      urlData.params = constructUrlParamsObject(urlData.fullUrl);
+    } catch {
+    }
+  }
+  if (trackCookies) {
+    urlData.cookies = inBrowser && typeof document !== "undefined" ? parseCookiesObject(document.cookie) : {};
+  } else {
+    urlData.cookies = {};
+  }
+  return urlData;
+};
+
+// src/core/engine/urlPrefill.ts
+var parseQuestionId = (input) => {
+  const firstUnderscore = input.indexOf("_");
+  return {
+    originalId: input,
+    questionId: firstUnderscore >= 0 ? input.slice(0, firstUnderscore).trim() : input,
+    fieldName: firstUnderscore >= 0 ? input.slice(firstUnderscore + 1).trim() : null
+  };
+};
+var RESERVED_PARAMS = /* @__PURE__ */ new Set(["url", "referrer", "cookies"]);
+var parsePrefillParams = (search) => {
+  const params = typeof search === "string" ? new URLSearchParams(search) : search;
+  let questionIds = null;
+  for (const id of params.keys()) {
+    if (RESERVED_PARAMS.has(id)) continue;
+    const { originalId, questionId, fieldName } = parseQuestionId(id);
+    if (fieldName == null) continue;
+    const prefill = { originalId, questionId, fieldName, value: params.get(id) };
+    questionIds ?? (questionIds = /* @__PURE__ */ Object.create(null));
+    questionIds[questionId] = [...questionIds[questionId] ?? [], prefill];
+  }
+  return questionIds;
+};
+
+// src/core/events/dropoffDetection.ts
+var observeDropoff = (pushEventClient, getState) => {
+  if (typeof window === "undefined") return () => void 0;
+  const handlePageHide = (event) => {
+    const { started, formId, stepId, sessionId } = getState();
+    if (!started || event.persisted) return;
+    pushEventClient.push({
+      type: "form_step_dropoff",
+      entityType: "form_step",
+      entityId: formId,
+      stepId,
+      leadSessionId: sessionId,
+      properties: []
+    });
+  };
+  window.addEventListener("pagehide", handlePageHide);
+  return () => window.removeEventListener("pagehide", handlePageHide);
+};
+
+// src/core/events/formJourneyTracker.ts
+var TRACK_PATH = "/api/v1/form-journey/track";
+var MAX_VISITS = 50;
+var TERMINAL_OUTCOMES = /* @__PURE__ */ new Set([
+  "completed",
+  "disqualified",
+  "dropped_off",
+  "partial"
+]);
+var createFormJourneyTracker = ({
+  transport,
+  preview = false
+}) => {
+  const state = {
+    responseId: null,
+    formId: null,
+    nextOrdinal: 1,
+    enteredAt: /* @__PURE__ */ new Map(),
+    pendingClose: null,
+    visits: [],
+    truncated: false,
+    terminal: {},
+    frozen: false,
+    flushScheduled: false
+  };
+  const flushNow = () => {
+    state.flushScheduled = false;
+    if (preview) return;
+    if (!state.responseId || !state.formId) return;
+    if (state.visits.length === 0 && !state.terminal.outcome) return;
+    transport.beacon(TRACK_PATH, {
+      responseId: state.responseId,
+      formId: state.formId,
+      events: state.visits,
+      ...state.terminal
+    });
+    state.terminal = {};
+  };
+  const flush = () => {
+    if (state.flushScheduled) return;
+    state.flushScheduled = true;
+    queueMicrotask(() => {
+      if (state.flushScheduled) flushNow();
+    });
+  };
+  const closePrevious = (nowIso) => {
+    if (!state.pendingClose) return;
+    const { ordinal, stepId } = state.pendingClose;
+    const entered = state.enteredAt.get(ordinal);
+    const existing = state.visits.find((visit) => visit.ordinal === ordinal);
+    const durationMs = entered ? Date.parse(nowIso) - Date.parse(entered) : null;
+    if (existing) {
+      existing.exitedAt = nowIso;
+      existing.durationMs = durationMs;
+    } else {
+      state.visits.push({
+        ordinal,
+        stepId,
+        enteredAt: entered ?? nowIso,
+        exitedAt: nowIso,
+        durationMs,
+        fromStepId: null,
+        transitionReason: "initial"
+      });
+    }
+    state.pendingClose = null;
+  };
+  const pushVisit = (visit) => {
+    if (state.visits.length >= MAX_VISITS) {
+      state.truncated = true;
+      return false;
+    }
+    state.visits.push(visit);
+    return true;
+  };
+  return {
+    hasRecordedTransition: () => state.nextOrdinal > 1,
+    setResponseId: (id) => {
+      state.responseId = id;
+      flush();
+    },
+    setFormId: (id) => {
+      state.formId = id;
+      flush();
+    },
+    recordEntry: (stepId) => {
+      if (state.frozen || state.truncated) return;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      if (state.nextOrdinal === 1) {
+        state.enteredAt.set(1, now);
+        state.pendingClose = { ordinal: 1, stepId };
+        state.nextOrdinal = 2;
+      }
+    },
+    recordTransition: ({ fromStepId, toStepId, reason, transitionMeta }) => {
+      if (state.frozen || state.truncated) return;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      closePrevious(now);
+      const ordinal = state.nextOrdinal++;
+      state.enteredAt.set(ordinal, now);
+      const pushed = pushVisit({
+        ordinal,
+        stepId: toStepId,
+        enteredAt: now,
+        exitedAt: null,
+        durationMs: null,
+        fromStepId,
+        transitionReason: reason,
+        transitionMeta: transitionMeta ?? null
+      });
+      state.pendingClose = pushed ? { ordinal, stepId: toStepId } : null;
+      flush();
+    },
+    recordTerminal: ({ outcome, disqualification }) => {
+      if (state.frozen) return;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      closePrevious(now);
+      state.terminal = {
+        outcome,
+        disqualification: disqualification ? { reason: disqualification.reason, matched: disqualification.matched } : void 0,
+        disqualifiedAtStepId: disqualification?.atStepId,
+        disqualifiedTriggerStepId: disqualification?.triggerStepId
+      };
+      if (TERMINAL_OUTCOMES.has(outcome)) state.frozen = true;
+      if (outcome === "in_progress") flushNow();
+      else flush();
+    }
+  };
+};
+
+// src/core/identity/browserFingerprint.ts
+async function getHash(input) {
+  const data = new TextEncoder().encode(input);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var getBrowserFingerprint = async (environmentId) => {
+  const userAgentData = navigator.userAgentData || {};
+  const fields = {
+    deviceType: /Mobi|Android/i.test(navigator.userAgent) ? "Mobile" : "Desktop",
+    screen: {
+      width: screen.width,
+      height: screen.height,
+      colorDepth: screen.colorDepth
+    },
+    userAgent: navigator.userAgent,
+    browser: userAgentData.brands || userAgentData.uaList || [{ brand: "unknown", version: "unknown" }],
+    os: userAgentData.platform || "unknown",
+    language: navigator.language,
+    ...navigator.plugins != null ? { plugins: Array.from(navigator.plugins).map((plugin) => plugin.name) } : {},
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    environmentId
+  };
+  return { ...fields, id: await getHash(JSON.stringify(fields)) };
+};
+
+// src/core/identity/identify.ts
+var IDENTIFY_PATH = "/api/v1/lead/identify";
+var buildIdentifyPayload = ({
+  environmentId,
+  fingerprintId,
+  pageUrl,
+  source = "sdkForm",
+  formId,
+  leadId = null,
+  sessionIdFromParams = null,
+  referrer
+}) => {
+  const url = new URL(pageUrl);
+  return {
+    environmentId,
+    source,
+    sourceURL: url.href.replace(/\/$/, ""),
+    sourceURLDomain: url.hostname,
+    sourceURLPath: url.pathname.replace(/\/$/, ""),
+    sourceUrlSearchParams: url.search,
+    fingerprint: fingerprintId,
+    formId,
+    leadId,
+    sessionIdFromParams,
+    ...referrer != null ? { referrer } : {}
+  };
+};
+var identifyLead = async (transport, payload) => {
+  const result = await transport.post(IDENTIFY_PATH, payload, {
+    keepalive: true,
+    credentials: true
+  });
+  if (!result.ok) return null;
+  const data = result.data.data?.data;
+  if (!data?.leadId || !data?.sessionId) return null;
+  return {
+    leadId: data.leadId,
+    sessionId: data.sessionId,
+    existing: data.existing,
+    leadHasExistingBookingAttr: data.leadHasExistingBookingAttr,
+    leadHasExistingEmailAttr: data.leadHasExistingEmailAttr
+  };
+};
+
+// src/core/identity/leadDataCache.ts
+var LEAD_DATA_STORAGE_KEY = "surfaceLeadData";
+var LEAD_DATA_TTL_MS = 10 * 60 * 1e3;
+var readLeadData = () => {
+  if (typeof localStorage === "undefined") return null;
+  try {
+    const raw = localStorage.getItem(LEAD_DATA_STORAGE_KEY);
+    if (!raw) return null;
+    const item = JSON.parse(raw);
+    if (Date.now() > (item.expiry ?? 0)) {
+      localStorage.removeItem(LEAD_DATA_STORAGE_KEY);
+      return null;
+    }
+    return {
+      leadId: item.leadId,
+      leadSessionId: item.leadSessionId,
+      fingerprint: item.fingerprint,
+      landingPageUrl: item.landingPageUrl,
+      expiry: item.expiry
+    };
+  } catch {
+    return null;
+  }
+};
+var writeLeadData = (data) => {
+  if (typeof localStorage === "undefined") return;
+  try {
+    localStorage.setItem(
+      LEAD_DATA_STORAGE_KEY,
+      JSON.stringify({ ...data, expiry: Date.now() + LEAD_DATA_TTL_MS })
+    );
+  } catch {
+  }
+};
+
+// src/core/identity/ensureIdentified.ts
+var ensureIdentified = async ({
+  transport,
+  environmentId,
+  formId,
+  pageUrl,
+  source,
+  preview = false
+}) => {
+  if (preview) return null;
+  if (typeof window === "undefined") return null;
+  const cached = readLeadData();
+  if (cached?.leadSessionId && cached?.fingerprint) {
+    return cached;
+  }
+  const landingPageUrl = pageUrl ?? window.location.href;
+  const fingerprint = await getBrowserFingerprint(environmentId);
+  const result = await identifyLead(
+    transport,
+    buildIdentifyPayload({
+      environmentId,
+      fingerprintId: fingerprint.id,
+      pageUrl: landingPageUrl,
+      formId,
+      source,
+      leadId: cached?.leadId ?? null,
+      sessionIdFromParams: cached?.leadSessionId ?? null
+    })
+  );
+  if (result == null) return null;
+  const leadData = {
+    leadId: result.leadId,
+    leadSessionId: result.sessionId,
+    fingerprint: fingerprint.id,
+    landingPageUrl
+  };
+  writeLeadData(leadData);
+  return leadData;
+};
+
+// src/core/identity/journey.ts
+var JOURNEY_COOKIE_NAME = "surface_journey_id";
+var RECENT_VISIT_COOKIE_NAME = "surface_recent_visit";
+var JOURNEY_COOKIE_MAX_AGE = 5184e3;
+var RECENT_VISIT_COOKIE_MAX_AGE = 86400;
+var TRACK_PATH2 = "/api/v1/lead/track";
+var getCookie = (name) => {
+  if (typeof document === "undefined") return null;
+  for (const cookie of document.cookie.split(";")) {
+    const trimmed = cookie.trim();
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    if (trimmed.substring(0, eqIndex) !== name) continue;
+    const value = trimmed.substring(eqIndex + 1);
+    try {
+      return decodeURIComponent(value);
+    } catch {
+      return value;
+    }
+  }
+  return null;
+};
+var setCookie = (name, value, maxAge, domain) => {
+  if (typeof document === "undefined") return;
+  const domainAttr = domain ? `; domain=${domain}` : "";
+  document.cookie = `${name}=${encodeURIComponent(
+    value
+  )}; path=/; max-age=${maxAge}; samesite=lax${domainAttr}`;
+};
+var getJourneyCookieDomain = () => {
+  const hostname = typeof window === "undefined" ? "" : window.location?.hostname ?? "";
+  if (!hostname || !hostname.includes(".")) return void 0;
+  const parts = hostname.split(".");
+  return "." + (parts.length === 2 ? hostname : parts.slice(1).join("."));
+};
+var createJourneyTracker = ({
+  transport,
+  environmentId
+}) => {
+  let journeyId = getCookie(JOURNEY_COOKIE_NAME);
+  const refreshJourneyCookie = () => {
+    if (!journeyId) return;
+    setCookie(JOURNEY_COOKIE_NAME, journeyId, JOURNEY_COOKIE_MAX_AGE, getJourneyCookieDomain());
+  };
+  const buildPayload = (url) => {
+    const leadData = readLeadData();
+    return {
+      ...journeyId ? { id: journeyId } : {},
+      data: {
+        type: "page_view",
+        payload: {
+          url,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          referrer: typeof document === "undefined" ? "" : document.referrer || ""
+        }
+      },
+      metadata: {
+        environmentId,
+        ...leadData ? {
+          ...leadData.leadId ? { leadId: leadData.leadId } : {},
+          ...leadData.leadSessionId ? { leadSessionId: leadData.leadSessionId } : {},
+          fingerprint: leadData.fingerprint,
+          ...leadData.landingPageUrl ? { landingPageUrl: leadData.landingPageUrl } : {}
+        } : {}
+      }
+    };
+  };
+  const trackPageView = async (url) => {
+    if (typeof window === "undefined") return;
+    const pageUrl = url ?? window.location.href;
+    if (getCookie(RECENT_VISIT_COOKIE_NAME) === pageUrl) return;
+    const payload = buildPayload(pageUrl);
+    if (journeyId && transport.beacon(TRACK_PATH2, payload)) {
+      refreshJourneyCookie();
+    } else {
+      const result = await transport.post(TRACK_PATH2, payload);
+      if (result.ok && result.data.data?.id) {
+        journeyId = result.data.data.id;
+      }
+      refreshJourneyCookie();
+    }
+    setCookie(RECENT_VISIT_COOKIE_NAME, pageUrl, RECENT_VISIT_COOKIE_MAX_AGE, getJourneyCookieDomain());
+  };
+  const observeRouteChanges = () => {
+    if (typeof window === "undefined") return () => void 0;
+    let currentUrl = window.location.href;
+    const notify = () => {
+      const newUrl = window.location.href;
+      if (newUrl === currentUrl) return;
+      currentUrl = newUrl;
+      void trackPageView(newUrl);
+    };
+    window.addEventListener("popstate", notify);
+    const originalPushState = history.pushState;
+    const originalReplaceState = history.replaceState;
+    history.pushState = function(...args) {
+      originalPushState.apply(history, args);
+      setTimeout(notify, 0);
+    };
+    history.replaceState = function(...args) {
+      originalReplaceState.apply(history, args);
+      setTimeout(notify, 0);
+    };
+    return () => {
+      window.removeEventListener("popstate", notify);
+      history.pushState = originalPushState;
+      history.replaceState = originalReplaceState;
+    };
+  };
+  const clear = () => {
+    const domain = getJourneyCookieDomain();
+    const domainAttr = domain ? `; domain=${domain}` : "";
+    if (typeof document === "undefined") return;
+    document.cookie = `${JOURNEY_COOKIE_NAME}=; path=/; max-age=0; samesite=lax${domainAttr}`;
+    document.cookie = `${RECENT_VISIT_COOKIE_NAME}=; path=/; max-age=0; samesite=lax${domainAttr}`;
+    journeyId = null;
+  };
+  return { trackPageView, observeRouteChanges, clear };
+};
+
+// src/enrichment/attachEnrichment.ts
+var ENRICHMENT_PATH = "/api/v1/services/enrichment/realtime";
+var ENRICHMENT_STATE_ID = "selfServeEnrichment";
+var DEBOUNCE_MS = 1e3;
+var EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/;
+var DOMAIN_PATTERN = /^(?:https?:\/\/)?(?:www\.)?([a-z0-9-]+(?:\.[a-z0-9-]+)+)/i;
+var enrichmentInputOf = (value) => {
+  const trimmed = value.trim();
+  if (EMAIL_PATTERN.test(trimmed)) return { email: trimmed };
+  const domain = trimmed.match(DOMAIN_PATTERN)?.[1];
+  return domain ? { domain } : null;
+};
+var attachEnrichment = ({
+  engine,
+  transport,
+  formId,
+  sources
+}) => {
+  const processed = /* @__PURE__ */ new Set();
+  const inFlight = /* @__PURE__ */ new Set();
+  let pendingTimer;
+  let pendingValue;
+  let detached = false;
+  const fire = async (value) => {
+    const input = enrichmentInputOf(value);
+    if (!input) return;
+    const key = input.email ?? input.domain;
+    if (processed.has(key) || inFlight.has(key)) return;
+    inFlight.add(key);
+    try {
+      const result = await transport.post(ENRICHMENT_PATH, {
+        formId,
+        ...input
+      });
+      if (detached || !result.ok) return;
+      const data = result.data.data ?? {};
+      if (Object.keys(data).length === 0) return;
+      processed.add(key);
+      const existing = engine.state().externalStates[ENRICHMENT_STATE_ID];
+      const existingData = existing?.type === "APOLLO_EMAIL_ENRICHMENT" ? existing.data ?? {} : {};
+      engine.setExternalState(ENRICHMENT_STATE_ID, {
+        type: "APOLLO_EMAIL_ENRICHMENT",
+        processed: true,
+        // existing keys win: a later trigger (e.g. a website after the email)
+        // only fills gaps, never overwrites resolved fields.
+        data: { ...data, ...existingData }
+      });
+    } finally {
+      inFlight.delete(key);
+    }
+  };
+  const candidateValues = () => {
+    const values = [];
+    const flat = {};
+    for (const stepAnswers of Object.values(engine.state().answers)) Object.assign(flat, stepAnswers);
+    for (const { questionId, fieldNames } of sources) {
+      const state = flat[questionId];
+      if (!state) continue;
+      for (const fieldName of fieldNames) {
+        const value = state[fieldName];
+        if (typeof value === "string" && value.trim().length > 0) values.push(value);
+      }
+    }
+    return values;
+  };
+  const scheduleLatest = () => {
+    const latest = candidateValues().find((value) => {
+      const input = enrichmentInputOf(value);
+      return input != null && !processed.has(input.email ?? input.domain);
+    });
+    if (latest === void 0 || latest === pendingValue) return;
+    pendingValue = latest;
+    clearTimeout(pendingTimer);
+    pendingTimer = setTimeout(() => {
+      pendingValue = void 0;
+      void fire(latest);
+    }, DEBOUNCE_MS);
+  };
+  const flushPending = () => {
+    if (pendingValue === void 0) return;
+    clearTimeout(pendingTimer);
+    const value = pendingValue;
+    pendingValue = void 0;
+    void fire(value);
+  };
+  const teardowns = [
+    engine.subscribe(scheduleLatest),
+    engine.on("stepCompleted", flushPending),
+    engine.on("completed", flushPending)
+  ];
+  return () => {
+    detached = true;
+    clearTimeout(pendingTimer);
+    teardowns.forEach((teardown) => teardown());
+  };
+};
+
+// src/core/engine/answerAudit.ts
+var CHOICE_LIST_TYPES = /* @__PURE__ */ new Set(["MultipleOptionsQuestion", "MultipleChoiceQuestion", "MMChoiceQuestion"]);
+var isValidChoiceEntry = (entry, needsIndex) => typeof entry === "object" && entry !== null && typeof entry.key === "string" && typeof entry.value === "boolean" && (!needsIndex || typeof entry.index === "number");
+var auditAnswer = ({
+  questions,
+  questionId,
+  merged
+}) => {
+  const prefix = `Surface SDK [debug]: setAnswer("${questionId}")`;
+  const expected = questions.size > 0 ? questions.get(questionId) : void 0;
+  if (questions.size > 0 && !expected) {
+    console.warn(`${prefix} \u2014 the record has no stateful question with this id; the answer will be dropped.`);
+    console.debug(`Surface SDK [debug]: answer ${questionId}`, merged);
+    return;
+  }
+  if (merged.type === void 0) {
+    console.warn(
+      `${prefix} \u2014 state has no "type" discriminator; the wire schema rejects untyped states. Include type: "${expected?.componentType ?? "<ComponentType>"}".`
+    );
+  } else if (expected?.componentType !== void 0 && merged.type !== expected.componentType) {
+    console.warn(
+      `${prefix} \u2014 state type "${String(merged.type)}" but the record's component is ${expected.componentType}.`
+    );
+  }
+  const effectiveType = expected?.componentType ?? merged.type;
+  if (typeof effectiveType === "string" && CHOICE_LIST_TYPES.has(effectiveType)) {
+    const needsIndex = effectiveType === "MultipleOptionsQuestion";
+    const malformed = !Array.isArray(merged.choices) || merged.choices.some((entry) => !isValidChoiceEntry(entry, needsIndex));
+    if (malformed) {
+      console.warn(
+        `${prefix} \u2014 ${effectiveType} answers need the ENTIRE option list under "choices" as {key, value${needsIndex ? ", index" : ""}} objects, not ${JSON.stringify(merged.choices ?? merged)}. See get_sdk_binding_map's answerShape.`
+      );
+    }
+  }
+  console.debug(`Surface SDK [debug]: answer ${questionId}`, merged);
+};
+
+// src/tracking/conversionRules.ts
+var DEFAULT_META_EVENT_NAME = "Lead";
+var DEFAULT_GA4_EVENT_NAME = "generate_lead";
+var DEFAULT_OPENAI_EVENT_NAME = "lead_created";
+var X_EVENT_ID_REGEX = /^tw-([a-z0-9]+)-([a-z0-9]+)$/i;
+var parseXPixelId = (eventId) => {
+  const match = eventId?.trim().match(X_EVENT_ID_REGEX);
+  return match ? match[1] : null;
+};
+var isNumericId = (value) => /^\d+$/.test(value?.trim() ?? "");
+var isRuleFireable = (rule) => {
+  if (rule.enabled === false) return false;
+  if ((rule.trigger ?? "reached_qualified") === "reached_step" && !rule.triggerStepId?.trim()) return false;
+  switch (rule.provider) {
+    case "x":
+      return X_EVENT_ID_REGEX.test(rule.eventId?.trim() ?? "");
+    case "meta":
+    case "openai":
+      return !!rule.pixelId?.trim();
+    case "ga4":
+      return !!rule.measurementId?.trim();
+    case "linkedin":
+      return isNumericId(rule.partnerId) && isNumericId(rule.conversionId);
+    default:
+      return false;
+  }
+};
+var getParamValue = (params, name) => {
+  const lowerName = name.toLowerCase();
+  for (const [key, value] of Object.entries(params)) {
+    if (key.toLowerCase() === lowerName) return value;
+  }
+  return void 0;
+};
+var matchesCondition = (condition, params) => {
+  const value = getParamValue(params, condition.param)?.trim() ?? "";
+  const values = condition.values ?? [];
+  switch (condition.operator) {
+    case "is_present":
+      return value.length > 0;
+    case "equals_any":
+      return values.some((v) => v.trim().toLowerCase() === value.toLowerCase());
+    case "contains":
+      return value.length > 0 && values.some((v) => value.toLowerCase().includes(v.trim().toLowerCase()));
+    default:
+      return false;
+  }
+};
+var matchesConditions = (conditions, params, operator = "and") => {
+  if (conditions.length === 0) return true;
+  return operator === "or" ? conditions.some((c) => matchesCondition(c, params)) : conditions.every((c) => matchesCondition(c, params));
+};
+var ruleToConversionEvent = (rule) => {
+  if (!isRuleFireable(rule)) return null;
+  switch (rule.provider) {
+    case "x": {
+      const pixelId = parseXPixelId(rule.eventId);
+      if (!pixelId) return null;
+      return { provider: "x", event: { event_id: rule.eventId.trim(), pixel_id: pixelId } };
+    }
+    case "meta":
+      return {
+        provider: "meta",
+        event: {
+          pixel_id: rule.pixelId.trim(),
+          event_name: rule.eventName?.trim() || DEFAULT_META_EVENT_NAME
+        }
+      };
+    case "openai":
+      return {
+        provider: "openai",
+        event: {
+          pixel_id: rule.pixelId.trim(),
+          event_name: rule.eventName?.trim() || DEFAULT_OPENAI_EVENT_NAME
+        }
+      };
+    case "ga4":
+      return {
+        provider: "ga4",
+        event: {
+          measurement_id: rule.measurementId.trim(),
+          event_name: rule.eventName?.trim() || DEFAULT_GA4_EVENT_NAME
+        }
+      };
+    case "linkedin":
+      return {
+        provider: "linkedin",
+        event: { partner_id: rule.partnerId.trim(), conversion_id: rule.conversionId.trim() }
+      };
+    default:
+      return null;
+  }
+};
+var selectFiringEvents = (rules, trigger, params, stepId) => {
+  const results = [];
+  for (const rule of rules) {
+    if ((rule.trigger ?? "reached_qualified") !== trigger) continue;
+    if (trigger === "reached_step" && (!stepId || rule.triggerStepId !== stepId)) continue;
+    if (!matchesConditions(rule.conditions ?? [], params, rule.conditionsOperator ?? "and")) continue;
+    const conversion = ruleToConversionEvent(rule);
+    if (conversion) results.push({ rule, conversion });
+  }
+  return results;
+};
+var ensureTwq = (win, pixelId) => {
+  if (!win.twq) {
+    const s = win.twq = function(...args) {
+      s.exe ? s.exe.apply(s, args) : s.queue.push(args);
+    };
+    s.version = "1.1";
+    s.queue = [];
+    const el = win.document.createElement("script");
+    el.async = true;
+    el.src = "https://static.ads-twitter.com/uwt.js";
+    win.document.head.appendChild(el);
+  }
+  win.twq("config", pixelId);
+};
+var ensureFbq = (win, pixelId) => {
+  if (!win.fbq) {
+    const n = win.fbq = function(...args) {
+      n.callMethod ? n.callMethod.apply(n, args) : n.queue.push(args);
+    };
+    if (!win._fbq) win._fbq = n;
+    n.push = n;
+    n.loaded = true;
+    n.version = "2.0";
+    n.queue = [];
+    const el = win.document.createElement("script");
+    el.async = true;
+    el.src = "https://connect.facebook.net/en_US/fbevents.js";
+    win.document.head.appendChild(el);
+  }
+  win.fbq("init", pixelId);
+};
+var ensureOaiq = (win, pixelId) => {
+  if (!win.oaiq) {
+    const q = win.oaiq = function(...args) {
+      q.q.push(args);
+    };
+    q.q = [];
+    const el = win.document.createElement("script");
+    el.async = true;
+    el.src = "https://bzrcdn.openai.com/sdk/oaiq.min.js";
+    win.document.head.appendChild(el);
+  }
+  win.oaiq("init", { pixelId });
+};
+var ensureGtag = (win, measurementId) => {
+  if (!win.gtag) {
+    win.dataLayer = win.dataLayer || [];
+    win.gtag = function(...args) {
+      win.dataLayer.push(args);
+    };
+    const el = win.document.createElement("script");
+    el.async = true;
+    el.src = `https://www.googletagmanager.com/gtag/js?id=${encodeURIComponent(measurementId)}`;
+    win.document.head.appendChild(el);
+    win.gtag("js", /* @__PURE__ */ new Date());
+  }
+  win.gtag("config", measurementId, { send_page_view: false });
+};
+var ensureLintrk = (win, partnerId) => {
+  if (!win.lintrk) {
+    win._linkedin_partner_id = partnerId;
+    const l = win.lintrk = function(a, b) {
+      l.q.push([a, b]);
+    };
+    l.q = [];
+    const el = win.document.createElement("script");
+    el.async = true;
+    el.src = "https://snap.licdn.com/li.lms-analytics/insight.min.js";
+    win.document.head.appendChild(el);
+  }
+  win._linkedin_data_partner_ids = win._linkedin_data_partner_ids || [];
+  if (!win._linkedin_data_partner_ids.includes(partnerId)) {
+    win._linkedin_data_partner_ids.push(partnerId);
+  }
+};
+var fireConversion = (win, conversion, ctx) => {
+  const w = win;
+  try {
+    switch (conversion.provider) {
+      case "x": {
+        ensureTwq(w, conversion.event.pixel_id);
+        w.twq("event", conversion.event.event_id, {
+          conversion_id: ctx.responseId,
+          ...ctx.twclid ? { twclid: ctx.twclid } : {},
+          ...ctx.email ? { email_address: ctx.email } : {}
+        });
+        return true;
+      }
+      case "meta": {
+        ensureFbq(w, conversion.event.pixel_id);
+        w.fbq("track", conversion.event.event_name, {}, { eventID: ctx.responseId });
+        return true;
+      }
+      case "openai": {
+        ensureOaiq(w, conversion.event.pixel_id);
+        w.oaiq(
+          "measure",
+          conversion.event.event_name,
+          { type: "customer_action" },
+          { event_id: ctx.responseId }
+        );
+        return true;
+      }
+      case "ga4": {
+        ensureGtag(w, conversion.event.measurement_id);
+        w.gtag("event", conversion.event.event_name, {
+          transaction_id: ctx.responseId,
+          send_to: conversion.event.measurement_id
+        });
+        return true;
+      }
+      case "linkedin": {
+        ensureLintrk(w, conversion.event.partner_id);
+        w.lintrk("track", { conversion_id: conversion.event.conversion_id });
+        return true;
+      }
+      default:
+        return false;
+    }
+  } catch {
+    return false;
+  }
+};
+
+// src/tracking/vendors.ts
+var scriptPresent = (win, src) => win.document.querySelector(`script[src="${src}"]`) != null;
+var injectScriptOnce = (win, src, parent, id) => {
+  if (scriptPresent(win, src)) return;
+  const el = win.document.createElement("script");
+  el.async = true;
+  el.src = src;
+  if (id) el.id = id;
+  win.document[parent].appendChild(el);
+};
+var initGtm = (win, gtmId) => {
+  const src = `https://www.googletagmanager.com/gtm.js?id=${encodeURIComponent(gtmId)}`;
+  if (scriptPresent(win, src)) return;
+  win.dataLayer = win.dataLayer || [];
+  win.dataLayer.push({ "gtm.start": (/* @__PURE__ */ new Date()).getTime(), event: "gtm.js" });
+  injectScriptOnce(win, src, "head");
+};
+var initGa4 = (win, measurementId) => {
+  const src = `https://www.googletagmanager.com/gtag/js?id=${encodeURIComponent(measurementId)}`;
+  if (scriptPresent(win, src)) return;
+  win.dataLayer = win.dataLayer || [];
+  if (!win.gtag) {
+    win.gtag = function() {
+      win.dataLayer.push(arguments);
+    };
+    win.gtag("js", /* @__PURE__ */ new Date());
+  }
+  injectScriptOnce(win, src, "head");
+  const isEmbeddedInIframe = win.self !== win.top;
+  win.gtag("config", measurementId, {
+    ...isEmbeddedInIframe && { cookie_flags: "SameSite=None;Secure;Partitioned" }
+  });
+};
+var initMetaPixel = (win, pixelId) => {
+  if (!win.fbq) {
+    const n = win.fbq = function(...args) {
+      n.callMethod ? n.callMethod.apply(n, args) : n.queue.push(args);
+    };
+    if (!win._fbq) win._fbq = n;
+    n.push = n;
+    n.loaded = true;
+    n.version = "2.0";
+    n.queue = [];
+    injectScriptOnce(win, "https://connect.facebook.net/en_US/fbevents.js", "head");
+  }
+  win.fbq("init", pixelId);
+};
+var initHubspot = (win, trackingId) => {
+  injectScriptOnce(win, `https://js.hs-scripts.com/${trackingId}.js`, "body", "hs-script-loader");
+};
+var createVendorTracker = (win, settings) => {
+  const w = win;
+  if (settings.gtmId) initGtm(w, settings.gtmId);
+  if (settings.gaMeasurementId) initGa4(w, settings.gaMeasurementId);
+  if (settings.metaPixelId) initMetaPixel(w, settings.metaPixelId);
+  if (settings.hubspotTracking?.trackingId) initHubspot(w, settings.hubspotTracking.trackingId);
+  const dataLayerPush = (event) => {
+    if (!settings.gtmId) return;
+    w.dataLayer = w.dataLayer || [];
+    w.dataLayer.push(event);
+  };
+  const gtagEvent = (name, params) => {
+    if (!settings.gaMeasurementId) return;
+    w.gtag?.("event", name, params);
+  };
+  const fbqTrackCustom = (name, data) => {
+    if (!settings.metaPixelId) return;
+    w.fbq?.("trackCustom", name, data);
+  };
+  return {
+    formStarted: (formId, urlData) => {
+      dataLayerPush({ event: "SurfaceFormStarted", formId, ...urlData });
+      fbqTrackCustom("SurfaceFormStarted", { formId, ...urlData });
+      gtagEvent("SurfaceFormStarted", { formId, ...urlData });
+    },
+    stepSubmitted: (payload) => {
+      dataLayerPush({ event: "SurfaceFormStepSubmitted", ...payload });
+      fbqTrackCustom("SurfaceFormStepSubmitted", payload);
+      gtagEvent("SurfaceFormStepSubmitted", payload);
+    },
+    formCompleted: (formId, urlData) => {
+      dataLayerPush({ event: "SurfaceFormSubmitEvent", formId, ...urlData });
+      fbqTrackCustom("SurfaceFormCompleted", { formId, ...urlData });
+      gtagEvent("SurfaceFormCompleted", { formId, ...urlData });
+    }
+  };
+};
+
+// src/tracking/attachTracking.ts
+var parseLocationParams = (win) => {
+  try {
+    return Object.fromEntries(new URLSearchParams(win.location.search).entries());
+  } catch {
+    return {};
+  }
+};
+var getParam = (params, name) => {
+  const lower = name.toLowerCase();
+  for (const [key, value] of Object.entries(params)) {
+    if (key.toLowerCase() === lower) return value?.trim() || void 0;
+  }
+  return void 0;
+};
+var pickClickIds = (params) => ({
+  twclid: getParam(params, "twclid"),
+  fbclid: getParam(params, "fbclid"),
+  gclid: getParam(params, "gclid"),
+  li_fat_id: getParam(params, "li_fat_id")
+});
+var EMAIL_ANSWER_KEYS = ["email", "emailAddress", "workEmailAddress"];
+var findEmail = (answers) => {
+  for (const state of Object.values(answers)) {
+    for (const key of EMAIL_ANSWER_KEYS) {
+      const value = state[key];
+      if (typeof value === "string" && value.trim().length > 0) return value.trim();
+    }
+  }
+  return void 0;
+};
+var hasBookedMeeting = (answers) => Object.values(answers).some((state) => state.eventScheduled === true);
+var flatAnswers = (engine) => {
+  const flat = {};
+  for (const stepAnswers of Object.values(engine.state().answers)) {
+    Object.assign(flat, stepAnswers);
+  }
+  return flat;
+};
+var attachTracking = ({ engine, formId, settings, win }) => {
+  const w = win ?? window;
+  const tracker = createVendorTracker(w, settings);
+  const rules = settings.adsConversions ?? [];
+  const params = parseLocationParams(w);
+  const urlData = { url: w.location.href, urlParams: params };
+  const firedRuleIds = /* @__PURE__ */ new Set();
+  const processedStepIds = /* @__PURE__ */ new Set();
+  const pendingStepIds = /* @__PURE__ */ new Set();
+  const pendingEventTriggers = /* @__PURE__ */ new Set();
+  let pendingTerminal = false;
+  let firedTerminal = false;
+  let firedStepSubmitted = false;
+  let firedEmail = false;
+  let firedMeeting = false;
+  const freshSession = engine.state().responseId == null;
+  let firedStarted = !freshSession;
+  const fire = (selected, responseId) => {
+    const fresh = selected.filter(({ rule }) => !firedRuleIds.has(rule.id));
+    if (fresh.length === 0) return;
+    fresh.forEach(({ rule }) => firedRuleIds.add(rule.id));
+    const ctx = { responseId, email: findEmail(flatAnswers(engine)), ...pickClickIds(params) };
+    fresh.forEach(({ conversion }) => fireConversion(w, conversion, ctx));
+  };
+  const fireTrigger = (trigger, responseId) => {
+    if (!responseId) {
+      pendingEventTriggers.add(trigger);
+      return;
+    }
+    fire(selectFiringEvents(rules, trigger, params), responseId);
+  };
+  const fireStep = (stepId, responseId) => {
+    if (!responseId) {
+      pendingStepIds.add(stepId);
+      return;
+    }
+    fire(selectFiringEvents(rules, "reached_step", params, stepId), responseId);
+  };
+  const fireTerminal = (responseId) => {
+    if (!responseId) {
+      pendingTerminal = true;
+      return;
+    }
+    firedTerminal = true;
+    pendingTerminal = false;
+    const byRule = /* @__PURE__ */ new Map();
+    for (const trigger of ["reached_qualified", "form_submitted"]) {
+      for (const hit of selectFiringEvents(rules, trigger, params)) {
+        byRule.set(hit.rule.id, hit);
+      }
+    }
+    fire(Array.from(byRule.values()), responseId);
+  };
+  const detectAnswerMoments = () => {
+    const answers = flatAnswers(engine);
+    if (!firedEmail && freshSession && findEmail(answers) !== void 0) {
+      firedEmail = true;
+      fireTrigger("email_provided", engine.state().responseId);
+    }
+    if (!firedMeeting && freshSession && hasBookedMeeting(answers)) {
+      firedMeeting = true;
+      fireTrigger("meeting_booked", engine.state().responseId);
+    }
+  };
+  const teardowns = [];
+  teardowns.push(
+    engine.on("started", () => {
+      tracker.formStarted(formId, urlData);
+    })
+  );
+  let pendingStepSubmitted;
+  teardowns.push(
+    engine.on("stepCompleted", ({ stepId }) => {
+      const answers = flatAnswers(engine);
+      pendingStepSubmitted = {
+        stepId,
+        formId,
+        emailProvided: findEmail(answers) !== void 0,
+        meetingBooked: hasBookedMeeting(answers),
+        ...urlData
+      };
+      if (!firedStepSubmitted && freshSession) {
+        firedStepSubmitted = true;
+        fireTrigger("step_submitted", engine.state().responseId);
+      }
+    })
+  );
+  teardowns.push(
+    engine.on("stepChanged", ({ toStepId }) => {
+      if (pendingStepSubmitted) {
+        if (!engine.state().finished) tracker.stepSubmitted(pendingStepSubmitted);
+        pendingStepSubmitted = void 0;
+      }
+      if (processedStepIds.has(toStepId)) return;
+      processedStepIds.add(toStepId);
+      fireStep(toStepId, engine.state().responseId);
+    })
+  );
+  teardowns.push(
+    engine.on("completed", () => {
+      pendingStepSubmitted = void 0;
+      tracker.formCompleted(formId, urlData);
+      if (!firedTerminal) fireTerminal(engine.state().responseId);
+    })
+  );
+  teardowns.push(
+    engine.on("saved", ({ responseId }) => {
+      if (!firedStarted) {
+        firedStarted = true;
+        fireTrigger("form_started", responseId);
+      }
+      if (pendingTerminal) fireTerminal(responseId);
+      if (pendingStepIds.size > 0) {
+        const stepIds = Array.from(pendingStepIds);
+        pendingStepIds.clear();
+        stepIds.forEach((stepId) => fireStep(stepId, responseId));
+      }
+      if (pendingEventTriggers.size > 0) {
+        const triggers = Array.from(pendingEventTriggers);
+        pendingEventTriggers.clear();
+        triggers.forEach((trigger) => fireTrigger(trigger, responseId));
+      }
+    })
+  );
+  teardowns.push(engine.subscribe(detectAnswerMoments));
+  const initialStepId = engine.state().currentStepId;
+  processedStepIds.add(initialStepId);
+  fireStep(initialStepId, engine.state().responseId);
+  detectAnswerMoments();
+  return () => teardowns.forEach((teardown) => teardown());
+};
+
+// src/validation/attachEmailValidation.ts
+var DEBOUNCE_MS2 = 300;
+var EMAIL_ANSWER_KEYS2 = ["email", "emailAddress", "workEmailAddress"];
+var EMAIL_PATTERN2 = /^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/;
+var attachEmailValidation = ({ engine, validator }) => {
+  const requested = /* @__PURE__ */ new Set();
+  const results = /* @__PURE__ */ new Map();
+  let pendingTimer;
+  let pendingScheduled = false;
+  let lastMetaKey;
+  let detached = false;
+  const candidateEmails = () => {
+    const emails = [];
+    for (const stepAnswers of Object.values(engine.state().answers)) {
+      for (const state of Object.values(stepAnswers)) {
+        for (const key of EMAIL_ANSWER_KEYS2) {
+          const value = state[key];
+          if (typeof value === "string" && EMAIL_PATTERN2.test(value.trim())) emails.push(value.trim());
+        }
+      }
+    }
+    return emails;
+  };
+  const writeMeta = () => {
+    const current = new Set(candidateEmails());
+    const verdicts = [...results.values()].filter((verdict) => current.has(verdict.email));
+    if (verdicts.length === 0) return;
+    const metaKey = JSON.stringify(verdicts.map((v) => [v.email, v.isValid, v.failed === true]));
+    if (metaKey === lastMetaKey) return;
+    lastMetaKey = metaKey;
+    const detailed = verdicts.find((verdict) => verdict.status && verdict.reason);
+    engine.mergeMeta({
+      isEmailValid: verdicts.some((verdict) => verdict.isValid),
+      emailValidation: detailed ? {
+        status: detailed.status,
+        reason: detailed.reason,
+        ...detailed.blacklistEntryIds?.length && { blacklistEntryIds: detailed.blacklistEntryIds }
+      } : void 0,
+      emailValidationFailed: verdicts.some((verdict) => verdict.failed === true)
+    });
+  };
+  const fire = async () => {
+    const fresh = candidateEmails().filter((email) => !requested.has(email));
+    if (fresh.length === 0) return;
+    fresh.forEach((email) => requested.add(email));
+    const verdicts = await validator.validateBatch(fresh);
+    if (detached) return;
+    verdicts.forEach((verdict) => results.set(verdict.email, verdict));
+    writeMeta();
+  };
+  const scheduleLatest = () => {
+    if (!candidateEmails().some((email) => !requested.has(email))) {
+      writeMeta();
+      return;
+    }
+    pendingScheduled = true;
+    clearTimeout(pendingTimer);
+    pendingTimer = setTimeout(() => {
+      pendingScheduled = false;
+      void fire();
+    }, DEBOUNCE_MS2);
+  };
+  const flushPending = () => {
+    if (!pendingScheduled) return;
+    pendingScheduled = false;
+    clearTimeout(pendingTimer);
+    void fire();
+  };
+  const teardowns = [
+    engine.subscribe(scheduleLatest),
+    engine.on("stepCompleted", flushPending),
+    engine.on("completed", flushPending)
+  ];
+  return () => {
+    detached = true;
+    clearTimeout(pendingTimer);
+    teardowns.forEach((teardown) => teardown());
+  };
+};
+
+// src/surfaceForms.ts
+var RESERVED_META_KEYS = /* @__PURE__ */ new Set([
+  "surfaceTagStatus",
+  "isEmailValid",
+  "emailValidation",
+  "emailValidationFailed"
+]);
+var SurfaceForms = {
+  init: async ({
+    environmentId,
+    formId,
+    steps,
+    settings = {},
+    apiBaseUrl,
+    container,
+    expectedQuestionIds,
+    resolveNextStep,
+    urlDataStateId,
+    source,
+    journey = false,
+    emailValidation = false,
+    preview = false,
+    previewToken,
+    debug = false,
+    resume,
+    meta
+  }) => {
+    const transport = createTransport({ apiBaseUrl });
+    let runtimeConfig;
+    if (!steps) {
+      const fetched = await fetchRuntimeConfig(transport, formId, { preview, previewToken });
+      if (!fetched.ok || !fetched.data.data) {
+        const baseUrl = (apiBaseUrl ?? DEFAULT_API_BASE_URL).replace(/\/$/, "");
+        const detail = !fetched.ok ? fetched.error.kind === "http" ? `HTTP ${fetched.error.status}` : "network error" : "empty response";
+        throw new Error(
+          `SurfaceForms.init: could not fetch runtime config for form "${formId}" (${detail} from ${baseUrl}/api/v1/public/forms/${formId}/runtime-config). If this environment is not served from ${DEFAULT_API_BASE_URL}, pass apiBaseUrl \u2014 the get_sdk_binding_map MCP tool returns the correct value.`
+        );
+      }
+      runtimeConfig = fetched.data.data;
+      steps = stepsOf(runtimeConfig.config);
+      expectedQuestionIds = expectedQuestionIds ?? statefulQuestionsOf(runtimeConfig.config).map((q) => q.questionId);
+      const fetchedSettings = runtimeConfig.settings ?? {};
+      settings = {
+        trackPartialResponses: fetchedSettings.trackPartialResponses,
+        trackCookies: fetchedSettings.trackCookie,
+        gtmId: fetchedSettings.gtmId,
+        gaMeasurementId: fetchedSettings.gaMeasurementId,
+        metaPixelId: fetchedSettings.metaPixelId,
+        hubspotTracking: fetchedSettings.hubspotTracking,
+        adsConversions: fetchedSettings.adsConversions,
+        ...settings
+      };
+    }
+    const trackCookies = settings.trackCookies ?? false;
+    let engineResume;
+    if (resume && !preview) {
+      const stored = await fetchStoredResponse(transport, resume);
+      if (stored.ok) {
+        engineResume = {
+          responseId: resume.responseId,
+          answers: Object.fromEntries(stored.data.answers.map((row) => [row.questionId, row.response]))
+        };
+      } else {
+        console.warn(
+          `Surface SDK: resume fetch for response "${resume.responseId}" failed \u2014 starting a fresh session.`
+        );
+      }
+    }
+    let identity = await ensureIdentified({ transport, environmentId, formId, source, preview });
+    const pushEvents = createPushEventClient({ transport, preview });
+    const formJourney = createFormJourneyTracker({ transport, preview });
+    const engine = createFormEngine({
+      formId,
+      environmentId,
+      steps,
+      transport,
+      resolveNextStep,
+      trackPartialResponses: settings.trackPartialResponses ?? true,
+      trackCookies,
+      externalStates: urlDataStateId ? { [urlDataStateId]: buildUrlData({ trackCookies }) } : {},
+      // Native forms report tag detection here; for the SDK the answer is static —
+      // the SDK IS the runtime — and it keys the responses-table "SDK" badge, so
+      // callers cannot override it (Decisions #8).
+      meta: { ...meta, surfaceTagStatus: "sdk" },
+      identity: () => ({
+        fingerprint: identity?.fingerprint,
+        leadSessionId: identity?.leadSessionId ?? void 0,
+        leadId: identity?.leadId ?? void 0
+      }),
+      pushEvents,
+      formJourney,
+      preview,
+      resume: engineResume
+    });
+    const teardowns = [];
+    let auditedEngine = engine;
+    if (debug) {
+      const questions = new Map(
+        (runtimeConfig ? statefulQuestionsOf(runtimeConfig.config) : []).map((q) => [q.questionId, q])
+      );
+      auditedEngine = {
+        ...engine,
+        setAnswer: (questionId, state) => {
+          const stepId = engine.state().currentStepId;
+          engine.setAnswer(questionId, state);
+          const merged = engine.state().answers[stepId]?.[questionId] ?? state;
+          auditAnswer({ questions, questionId, merged });
+        }
+      };
+      for (const event of [
+        "viewed",
+        "started",
+        "stepChanged",
+        "stepCompleted",
+        "completed",
+        "disqualified",
+        "saved",
+        "error"
+      ]) {
+        teardowns.push(
+          engine.on(event, (payload) => console.debug(`Surface SDK [debug]: ${event}`, payload))
+        );
+      }
+    }
+    let started = false;
+    teardowns.push(
+      engine.on("started", () => {
+        started = true;
+      })
+    );
+    teardowns.push(
+      observeDropoff(pushEvents, () => ({
+        started,
+        formId,
+        stepId: engine.state().currentStepId,
+        sessionId: identity?.leadSessionId ?? void 0
+      }))
+    );
+    if (container) {
+      teardowns.push(bindForm({ engine: auditedEngine, root: container, expectedQuestionIds }));
+    }
+    const hasTrackingConfig = !!settings.gtmId || !!settings.gaMeasurementId || !!settings.metaPixelId || !!settings.hubspotTracking?.trackingId || (settings.adsConversions?.length ?? 0) > 0;
+    if (hasTrackingConfig && !preview && typeof window !== "undefined") {
+      teardowns.push(attachTracking({ engine, formId, settings }));
+    }
+    const enrichmentSources = runtimeConfig ? enrichmentSourcesOf(runtimeConfig.config) : [];
+    const enrichmentActive = runtimeConfig != null && enrichmentSources.length > 0 && hasEnabledEnrichmentProvider(runtimeConfig.settings);
+    if (enrichmentActive && !preview) {
+      teardowns.push(attachEnrichment({ engine, transport, formId, sources: enrichmentSources }));
+    } else if (debug && runtimeConfig && !enrichmentActive && hasDeclaredEnrichmentSource(runtimeConfig.config)) {
+      console.warn(
+        "Surface SDK: the record declares an enrichmentSourceField, but this environment has no enabled enrichment provider \u2014 no enrichment will run (capabilities.enrichment is false)."
+      );
+    }
+    const emailValidator = createEmailValidator({ transport, environmentId, preview });
+    if (emailValidation && !preview) {
+      teardowns.push(attachEmailValidation({ engine, validator: emailValidator }));
+    }
+    let journeyTracker;
+    if (journey && !preview) {
+      journeyTracker = createJourneyTracker({ transport, environmentId });
+      void journeyTracker.trackPageView();
+      teardowns.push(journeyTracker.observeRouteChanges());
+    }
+    return {
+      setAnswer: auditedEngine.setAnswer,
+      setExternalState: engine.setExternalState,
+      next: engine.next,
+      back: engine.back,
+      goToStep: engine.goToStep,
+      submit: engine.submit,
+      disqualify: engine.disqualify,
+      savePartial: engine.savePartial,
+      flush: engine.flush,
+      markViewed: engine.markViewed,
+      mergeMeta: (partial) => {
+        const entries = Object.entries(partial);
+        const reserved = entries.filter(([key]) => RESERVED_META_KEYS.has(key));
+        if (reserved.length > 0) {
+          console.warn(
+            `Surface SDK: mergeMeta dropped reserved key(s) ${reserved.map(([key]) => key).join(", ")} \u2014 these are SDK-owned response markers.`
+          );
+        }
+        engine.mergeMeta(Object.fromEntries(entries.filter(([key]) => !RESERVED_META_KEYS.has(key))));
+      },
+      capabilities: {
+        enrichment: enrichmentActive,
+        emailValidation,
+        tracking: hasTrackingConfig
+      },
+      on: engine.on,
+      state: engine.state,
+      subscribe: engine.subscribe,
+      identify: async () => {
+        const fresh = await ensureIdentified({ transport, environmentId, formId, source, preview });
+        if (fresh) identity = fresh;
+        return fresh;
+      },
+      validateEmail: emailValidator.validate,
+      runtimeConfig,
+      destroy: () => teardowns.forEach((teardown) => teardown())
+    };
+  }
+};
+export {
+  DEFAULT_API_BASE_URL,
+  DEFAULT_REDIRECT_TIMEOUT_MS,
+  ENRICHMENT_STATE_ID,
+  IDENTITY_INFO_ANSWER_KEYS,
+  JOURNEY_COOKIE_NAME,
+  LEAD_DATA_STORAGE_KEY,
+  LEAD_DATA_TTL_MS,
+  RECENT_VISIT_COOKIE_NAME,
+  SurfaceForms,
+  attachEmailValidation,
+  attachEnrichment,
+  bindForm,
+  buildIdentifyPayload,
+  buildRedirectUrl,
+  buildResponsesArray,
+  buildStepTransitionEventBatch,
+  buildUrlData,
+  constructUrlParamsObject,
+  createEmailValidator,
+  createEmitter,
+  createFormEngine,
+  createFormJourneyTracker,
+  createJourneyTracker,
+  createPushEventClient,
+  createSchedulerClient,
+  createStartedDetector,
+  createSubmitResponsePayload,
+  createTransport,
+  createUpdateResponsePayload,
+  enrichmentSourcesOf,
+  ensureIdentified,
+  fetchRuntimeConfig,
+  getBrowserFingerprint,
+  getHash,
+  hasEnabledEnrichmentProvider,
+  identifyLead,
+  mountBookingWidget,
+  observeDropoff,
+  observeFormView,
+  parseCookiesObject,
+  parsePrefillParams,
+  parseQuestionId,
+  performRedirect,
+  readLeadData,
+  statefulQuestionIdsOf,
+  statefulQuestionsOf,
+  stepsOf,
+  submitResponse,
+  toSchedulerAnswerState,
+  updateResponse,
+  writeLeadData
+};
+//# sourceMappingURL=index.mjs.map