@sonordev/site-kit 7.1.2 → 7.2.0

package/dist/{chunk-AQSNPZY4.js → chunk-C2FZBUSS.js}

@@ -89,4 +89,83 @@ function isFieldComplete(field, values, isVisible = (f) => isFieldVisible(f, val
   return validateField(field, values, isVisible) === null;
 }
 
-export { isDisplayOnly, isEmptyValue, isFieldComplete, isFieldVisible, validateField };
+// src/forms/form-dom-values.ts
+function isUnreadable(field) {
+  return isDisplayOnly(field) || field.field_type === "file";
+}
+function controlsNamed(form, name) {
+  const out = [];
+  for (const el of Array.from(form.elements)) {
+    const control = el;
+    if (control.name === name && !control.disabled) out.push(control);
+  }
+  return out;
+}
+function isInput(el, type) {
+  return el.tagName === "INPUT" && el.type === type;
+}
+function isBlank(value) {
+  return isEmptyValue(value) || value === false || typeof value === "string" && value.trim() === "";
+}
+function readField(field, controls) {
+  switch (field.field_type) {
+    case "checkbox": {
+      const boxes = controls.filter((c) => isInput(c, "checkbox"));
+      if (boxes.length === 0) return void 0;
+      const isGroup = boxes.length > 1 || boxes[0].getAttribute("value") !== null;
+      return isGroup ? boxes.filter((b) => b.checked).map((b) => b.value) : boxes[0].checked;
+    }
+    case "radio": {
+      const chosen = controls.find((c) => isInput(c, "radio") && c.checked);
+      return chosen ? chosen.value : void 0;
+    }
+    case "rating": {
+      const chosen = controls.find((c) => isInput(c, "radio") && c.checked);
+      return chosen ? Number(chosen.value) : void 0;
+    }
+    case "multi-select": {
+      const select = controls.find((c) => c.tagName === "SELECT");
+      return select ? Array.from(select.selectedOptions, (o) => o.value) : void 0;
+    }
+    case "slider": {
+      const range = controls[0];
+      return range && range.value !== "" ? Number(range.value) : void 0;
+    }
+    default: {
+      const control = controls[0];
+      return control ? control.value : void 0;
+    }
+  }
+}
+function readFormControlValues(form, fields, honeypotName) {
+  const out = {};
+  if (!form || !fields) return out;
+  for (const field of fields) {
+    if (!field.slug || field.slug === honeypotName || isUnreadable(field)) continue;
+    const controls = controlsNamed(form, field.slug);
+    if (controls.length === 0) continue;
+    const value = readField(field, controls);
+    if (!isBlank(value)) out[field.slug] = value;
+  }
+  return out;
+}
+function shellValuesToCarry(form, fields, honeypotName) {
+  const values = readFormControlValues(form, fields, honeypotName);
+  for (const field of fields || []) {
+    const value = values[field.slug];
+    if (value === void 0) continue;
+    const fallback = field.default_value ?? "";
+    if (!Array.isArray(value) && String(value) === String(fallback)) delete values[field.slug];
+  }
+  return values;
+}
+function unseenControlValues(form, fields, honeypotName, state) {
+  const dom = readFormControlValues(form, fields, honeypotName);
+  const unseen = {};
+  for (const [slug, value] of Object.entries(dom)) {
+    if (isBlank(state[slug])) unseen[slug] = value;
+  }
+  return unseen;
+}
+
+export { isDisplayOnly, isEmptyValue, isFieldComplete, isFieldVisible, shellValuesToCarry, unseenControlValues, validateField };

package/dist/{chunk-NK4CSJNP.js → chunk-CF5QNFYU.js}

@@ -2,8 +2,8 @@
 import { sanitizeFleetVersion, buildFleetHeartbeatPayload } from './chunk-ZTZQPYP6.js';
 import { useDeferredActivation } from './chunk-YC7ELZS3.js';
 import { resolveAnalyticsTarget } from './chunk-43OCZ3JA.js';
-import { sonorFetch } from './chunk-3SDOQUUF.js';
-import { SITE_KIT_VERSION } from './chunk-AH5Q262S.js';
+import { sonorFetch } from './chunk-D6ZC7XKZ.js';
+import { SITE_KIT_VERSION } from './chunk-F24FNCTK.js';
 import { useRef, useEffect } from 'react';
 
 // src/fleet/heartbeat.ts

package/dist/{chunk-D5EC5KVO.js → chunk-D5DCBD4Y.js}

@@ -1,5 +1,5 @@
 'use client';
-import { isEmptyValue, isDisplayOnly } from './chunk-AQSNPZY4.js';
+import { isEmptyValue, isDisplayOnly } from './chunk-C2FZBUSS.js';
 import { useMemo, useState, useRef, useEffect } from 'react';
 
 var NO_CONTROLS = {};
@@ -26,7 +26,7 @@ function useFieldControls(fields) {
     }
     if (needsFile && !requested.current.file) {
       requested.current.file = true;
-      import('./FileField-QKA3JB2Q.js').then((m) => {
+      import('./FileField-CI4UL5SH.js').then((m) => {
         if (!cancelled) setControls((prev) => ({ ...prev, File: m.FileField }));
       }).catch(() => {
         requested.current.file = false;

package/dist/{chunk-3SDOQUUF.js → chunk-D6ZC7XKZ.js}

@@ -1,5 +1,5 @@
-import { isTokenMode, getFreshCredential, isSiteToken, refreshSiteToken, currentCredential, credentialBreakerId } from './chunk-VDF5DFWT.js';
-import { SITE_KIT_VERSION } from './chunk-AH5Q262S.js';
+import { isTokenMode, getFreshCredential, isSiteToken, refreshSiteToken, currentCredential, credentialBreakerId } from './chunk-K4ZHAURD.js';
+import { SITE_KIT_VERSION } from './chunk-F24FNCTK.js';
 
 // src/shared/fetchWithRetry.ts
 function backoffDelay(attempt, response) {

package/dist/chunk-EJVQJCG5.js

@@ -0,0 +1,370 @@
+'use client';
+import { DEFAULT_WIDGET_Z_INDEX } from './chunk-27FISYK4.js';
+import { getOrCreateVisitorId } from './chunk-24QZEO3Q.js';
+import { resolveAnalyticsTarget } from './chunk-43OCZ3JA.js';
+import { sonorFetch } from './chunk-D6ZC7XKZ.js';
+import { useState, useEffect, useCallback, useRef } from 'react';
+import ReactDOM from 'react-dom';
+import dynamic from 'next/dynamic';
+import { usePathname } from 'next/navigation';
+import { jsx, Fragment } from 'react/jsx-runtime';
+
+// src/shared/mid-form.ts
+var BUTTON_TYPES = /* @__PURE__ */ new Set(["button", "submit", "reset", "image"]);
+var UNREACHABLE = '[inert],[aria-hidden="true"],[data-sk-honeypot]';
+var typedInto = /* @__PURE__ */ new WeakSet();
+var watched = /* @__PURE__ */ new WeakSet();
+function watchFormInput(doc = document) {
+  if (watched.has(doc)) return;
+  watched.add(doc);
+  const note = (e) => {
+    const target = e.composedPath?.()[0] ?? e.target;
+    if (target) typedInto.add(target);
+  };
+  doc.addEventListener("input", note, true);
+  doc.addEventListener("change", note, true);
+}
+function isFillable(el) {
+  if (!el) return false;
+  const tag = el.tagName;
+  if (tag !== "INPUT" && tag !== "TEXTAREA" && tag !== "SELECT") return false;
+  if (tag === "INPUT") {
+    const type = el.type;
+    if (type === "hidden" || BUTTON_TYPES.has(type)) return false;
+  }
+  return !el.closest(UNREACHABLE);
+}
+function belongsToForm(el) {
+  return Boolean(el.form ?? el.closest("form"));
+}
+function focused(doc) {
+  let el = doc.activeElement;
+  while (el?.shadowRoot?.activeElement) el = el.shadowRoot.activeElement;
+  return el;
+}
+function renderedSelected(option) {
+  return option.defaultSelected || option.hasAttribute("selected");
+}
+function selectChanged(select) {
+  const options = Array.from(select.options);
+  if (select.multiple) return options.some((o) => o.selected !== renderedSelected(o));
+  if (!select.value) return false;
+  const initial = [...options].reverse().find(renderedSelected) ?? options.find((o) => !o.disabled);
+  return select.options[select.selectedIndex] !== initial;
+}
+function isFilled(el) {
+  if (!isFillable(el)) return false;
+  const typed = typedInto.has(el);
+  if (!typed && (el.disabled || el.tagName !== "SELECT" && el.readOnly)) return false;
+  if (el.tagName === "SELECT") return selectChanged(el);
+  const field = el;
+  if (field.type === "checkbox" || field.type === "radio") {
+    const box = field;
+    return box.checked !== box.defaultChecked;
+  }
+  return field.value.trim() !== "" && (typed || field.value !== field.defaultValue);
+}
+function isVisitorMidForm(doc = document) {
+  if (doc.querySelector('[data-sk-state="submitting"]')) return true;
+  if (doc.querySelector('[data-sk-form-mount][data-sk-carried="true"] form')) return true;
+  const active = focused(doc);
+  if (active && belongsToForm(active) && (isFillable(active) || active.tagName === "IFRAME")) return true;
+  for (const form of Array.from(doc.forms)) {
+    for (const el of Array.from(form.elements)) if (isFilled(el)) return true;
+  }
+  return false;
+}
+function whenNotMidForm(open, options = {}) {
+  const { doc = document, settleMs = 1500, pollMs = 5e3 } = options;
+  if (!isVisitorMidForm(doc)) {
+    open();
+    return () => {
+    };
+  }
+  let done = false;
+  let settle;
+  const stop = () => {
+    done = true;
+    clearTimeout(settle);
+    clearInterval(poll);
+    doc.removeEventListener("focusout", onFocusOut, true);
+  };
+  const check = () => {
+    if (done || isVisitorMidForm(doc)) return;
+    stop();
+    open();
+  };
+  const onFocusOut = () => {
+    clearTimeout(settle);
+    settle = setTimeout(check, settleMs);
+  };
+  const poll = setInterval(check, pollMs);
+  doc.addEventListener("focusout", onFocusOut, true);
+  return stop;
+}
+
+// src/website/popup-rules.ts
+function matchPath(pathname, pattern) {
+  if (pattern.endsWith("*")) return pathname.startsWith(pattern.slice(0, -1));
+  return pathname === pattern;
+}
+function deviceFromUserAgent(ua) {
+  if (/tablet|ipad|playbook|silk/i.test(ua)) return "tablet";
+  if (/mobile|iphone|ipod|android|blackberry|opera mini|iemobile/i.test(ua)) return "mobile";
+  return "desktop";
+}
+function seenKey(popupId) {
+  return `_engage_${popupId}`;
+}
+function isEligible(popup, pathname, device, store, now = Date.now()) {
+  const pages = popup.targeting?.pages;
+  if (pages) {
+    if (pages.exclude?.some((p) => matchPath(pathname, p))) return false;
+    if (pages.include && !pages.include.some((p) => matchPath(pathname, p))) return false;
+  }
+  if (popup.targeting?.devices && !popup.targeting.devices.includes(device)) return false;
+  const frequency = popup.trigger?.frequency;
+  if (frequency) {
+    const key = seenKey(popup.id);
+    if (frequency.type === "once") {
+      if (store.local?.getItem(key)) return false;
+    } else if (frequency.type === "once-per-session") {
+      if (store.session?.getItem(key)) return false;
+    } else if (frequency.type === "every-n-days" && frequency.days) {
+      const last = store.local?.getItem(key);
+      if (last && now - parseInt(last, 10) < frequency.days * 864e5) return false;
+    }
+  }
+  return true;
+}
+var PLACEMENT = {
+  popup: "popup",
+  bar: "bar",
+  nudge: "slide-in",
+  "slide-in": "slide-in"
+};
+function popupPlacement(popup) {
+  if (!popup.blocks?.length) return void 0;
+  return popup.layout?.placement ?? PLACEMENT[popup.type] ?? "popup";
+}
+function waitsForForms(popup) {
+  return popupPlacement(popup) !== "bar";
+}
+function activatePopup(active, id, popups) {
+  if (active.includes(id)) return active;
+  const isPopup = (popupId) => {
+    const popup = popups.find((p) => p.id === popupId);
+    return popup ? popupPlacement(popup) === "popup" : false;
+  };
+  if (isPopup(id) && active.some(isPopup)) return active;
+  return [...active, id];
+}
+var LazyBlocksPopup = dynamic(
+  () => import('./BlocksPopup-YJNJIVPO.js').then((m) => ({ default: m.BlocksPopup })),
+  { ssr: false }
+);
+function SitePopups(props) {
+  const target = resolveAnalyticsTarget(props);
+  if (!target) return null;
+  return /* @__PURE__ */ jsx(AllowedSitePopups, { ...props, ...target });
+}
+function AllowedSitePopups({
+  apiUrl,
+  apiKey,
+  zIndex = DEFAULT_WIDGET_Z_INDEX,
+  debug = false
+}) {
+  const pathname = usePathname();
+  const [popups, setPopups] = useState([]);
+  const [active, setActive] = useState([]);
+  const [dismissed, setDismissed] = useState(/* @__PURE__ */ new Set());
+  useEffect(() => {
+    let cancelled = false;
+    async function load() {
+      const visitorId = getOrCreateVisitorId();
+      const url = typeof window !== "undefined" ? window.location.href : "";
+      try {
+        const response = await sonorFetch(
+          `${apiUrl.replace(/\/$/, "")}/engage/widget/elements?url=${encodeURIComponent(url)}&visitorId=${encodeURIComponent(visitorId)}&deviceType=${getDeviceType()}`,
+          {},
+          { apiKey }
+        );
+        if (!response.ok) {
+          if (debug) console.error("[SitePopups] Error loading popups:", response.statusText);
+          return;
+        }
+        const json = await response.json();
+        const list = json.data?.elements ?? json.elements ?? [];
+        const drawable = list.filter((popup) => popupPlacement(popup) !== void 0);
+        if (debug) console.log("[SitePopups] Loaded popups:", drawable);
+        if (!cancelled) setPopups(drawable);
+      } catch (error) {
+        if (debug) console.error("[SitePopups] Error loading popups:", error);
+      }
+    }
+    load();
+    return () => {
+      cancelled = true;
+    };
+  }, [apiUrl, apiKey, debug]);
+  useEffect(() => {
+    watchFormInput();
+  }, []);
+  useEffect(() => {
+    if (!popups.length) return;
+    const store = { local: storageOrNull("local"), session: storageOrNull("session") };
+    const device = getDeviceType();
+    const eligible = popups.filter((popup) => !dismissed.has(popup.id) && isEligible(popup, pathname, device, store));
+    if (debug) console.log("[SitePopups] Eligible popups:", eligible);
+    const eligibleIds = new Set(eligible.map((p) => p.id));
+    setActive((prev) => {
+      const kept = prev.filter((id) => eligibleIds.has(id));
+      return kept.length === prev.length ? prev : kept;
+    });
+    const cleanups = [];
+    const activate = (popup) => {
+      const show = () => setActive((prev) => activatePopup(prev, popup.id, popups));
+      if (waitsForForms(popup)) cleanups.push(whenNotMidForm(show));
+      else show();
+    };
+    eligible.forEach((popup) => {
+      const trigger = popup.trigger;
+      if (trigger?.type === "immediate" || !trigger?.type) {
+        activate(popup);
+      } else if (trigger.type === "delay" && trigger.delay) {
+        const timer = setTimeout(() => activate(popup), trigger.delay * 1e3);
+        cleanups.push(() => clearTimeout(timer));
+      } else if (trigger.type === "exit-intent") {
+        const handleMouseLeave = (e) => {
+          if (e.clientY < 10) {
+            activate(popup);
+            document.removeEventListener("mouseleave", handleMouseLeave);
+          }
+        };
+        document.addEventListener("mouseleave", handleMouseLeave);
+        cleanups.push(() => document.removeEventListener("mouseleave", handleMouseLeave));
+      } else if (trigger.type === "scroll" && trigger.scrollPercentage) {
+        const handleScroll = () => {
+          const scrollPercent = window.scrollY / (document.body.scrollHeight - window.innerHeight) * 100;
+          if (scrollPercent >= (trigger.scrollPercentage || 50)) {
+            activate(popup);
+            window.removeEventListener("scroll", handleScroll);
+          }
+        };
+        window.addEventListener("scroll", handleScroll, { passive: true });
+        cleanups.push(() => window.removeEventListener("scroll", handleScroll));
+      }
+    });
+    return () => {
+      cleanups.forEach((fn) => fn());
+    };
+  }, [popups, pathname, dismissed, debug]);
+  const recordSeen = useCallback((popupId) => {
+    const popup = popups.find((p) => p.id === popupId);
+    if (!popup?.trigger?.frequency) return;
+    try {
+      if (popup.trigger.frequency.type === "once-per-session") {
+        sessionStorage.setItem(seenKey(popupId), "true");
+      } else {
+        localStorage.setItem(seenKey(popupId), Date.now().toString());
+      }
+    } catch {
+    }
+  }, [popups]);
+  const handleDismiss = useCallback((popupId) => {
+    setDismissed((prev) => /* @__PURE__ */ new Set([...prev, popupId]));
+    setActive((prev) => prev.filter((id) => id !== popupId));
+    recordSeen(popupId);
+  }, [recordSeen]);
+  if (typeof document === "undefined" || !active.length) return null;
+  return ReactDOM.createPortal(
+    /* @__PURE__ */ jsx(Fragment, { children: active.map((popupId) => {
+      const popup = popups.find((p) => p.id === popupId);
+      if (!popup) return null;
+      return /* @__PURE__ */ jsx(
+        PopupView,
+        {
+          popup,
+          onDismiss: () => handleDismiss(popup.id),
+          onEngaged: () => recordSeen(popup.id),
+          zIndex,
+          apiUrl,
+          apiKey
+        },
+        popup.id
+      );
+    }) }),
+    document.body
+  );
+}
+function PopupView({
+  popup,
+  onDismiss,
+  onEngaged,
+  zIndex,
+  apiUrl,
+  apiKey
+}) {
+  const rootRef = useRef(null);
+  const counted = useRef(false);
+  useEffect(() => {
+    const el = rootRef.current;
+    if (!el || counted.current) return;
+    const observer = new IntersectionObserver(
+      ([entry]) => {
+        if (entry.isIntersecting && !counted.current) {
+          counted.current = true;
+          trackPopupEvent(apiUrl, apiKey, "impression", { elementId: popup.id });
+          observer.disconnect();
+        }
+      },
+      { threshold: 0.5 }
+    );
+    observer.observe(el);
+    return () => observer.disconnect();
+  }, [apiUrl, apiKey, popup.id]);
+  const layout = popup.layout;
+  const position = layout?.corner ?? popup.config?.position;
+  const corner = position === "bottom-left" || position === "top-left" || position === "top-right" ? position : "bottom-right";
+  return /* @__PURE__ */ jsx(
+    LazyBlocksPopup,
+    {
+      blocks: popup.blocks,
+      placement: popupPlacement(popup) ?? "popup",
+      edge: layout?.edge,
+      accent: layout?.accent,
+      corner,
+      zIndex,
+      rootRef,
+      elementId: popup.id,
+      onClose: onDismiss,
+      onButton: (url) => {
+        onEngaged();
+        trackPopupEvent(apiUrl, apiKey, "click", { elementId: popup.id, action: "navigate", url });
+      }
+    }
+  );
+}
+function trackPopupEvent(apiUrl, apiKey, endpoint, data) {
+  const visitorId = typeof localStorage !== "undefined" ? localStorage.getItem("_sk_vid") : null;
+  sonorFetch(`${apiUrl.replace(/\/$/, "")}/engage/widget/${endpoint}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ ...data, visitorId, pageUrl: window.location.href }),
+    keepalive: true
+  }, { apiKey, retries: 0 }).catch(() => {
+  });
+}
+function getDeviceType() {
+  if (typeof navigator === "undefined") return "desktop";
+  return deviceFromUserAgent(navigator.userAgent);
+}
+function storageOrNull(kind) {
+  try {
+    return kind === "local" ? window.localStorage : window.sessionStorage;
+  } catch {
+    return null;
+  }
+}
+
+export { SitePopups };

package/dist/{chunk-AH5Q262S.js → chunk-F24FNCTK.js}

@@ -1,4 +1,4 @@
 // src/shared/version.ts
-var SITE_KIT_VERSION = "7.1.2";
+var SITE_KIT_VERSION = "7.2.0";
 
 export { SITE_KIT_VERSION };

package/dist/{chunk-V6FDQLR7.js → chunk-FR6BYFPC.js}

@@ -1,10 +1,11 @@
 'use client';
-import { isFieldVisible, validateField, isFieldComplete } from './chunk-AQSNPZY4.js';
-import { normalizeFormConfig } from './chunk-5SQK3D53.js';
+import { readAgentSubmit, formToolAttributes } from './chunk-Q6E4OPGG.js';
+import { isFieldVisible, validateField, isFieldComplete, unseenControlValues } from './chunk-C2FZBUSS.js';
+import { normalizeFormConfig, DEFAULT_FORM_SUCCESS_MESSAGE } from './chunk-5SQK3D53.js';
 import { DEFAULT_HONEYPOT_FIELD } from './chunk-NJCTQH2P.js';
 import { onPageLeave } from './chunk-L2V5PUFN.js';
 import { uuid } from './chunk-GJWI74ZZ.js';
-import { sonorFetch, sonorBeacon } from './chunk-3SDOQUUF.js';
+import { sonorFetch, sonorBeacon } from './chunk-D6ZC7XKZ.js';
 import { useRef, useCallback, useEffect, useState, useMemo } from 'react';
 
 // src/forms/field-interactions.ts
@@ -567,7 +568,8 @@ async function submitForm({
   config,
   values,
   honeypotValue,
-  formLoadedAt
+  formLoadedAt,
+  agentInvoked
 }) {
   const { apiUrl, apiKey } = getApiConfig();
   if (!apiKey) {
@@ -606,7 +608,8 @@ async function submitForm({
       // Sub-site host — preserved on form_submissions for lead attribution
       // across multi-site projects. Resolved by SiteKitClientProviders.
       site: typeof window !== "undefined" ? window.__SITE_KIT_SITE__ || window.location.host : void 0,
-      _formLoadedAt: formLoadedAt
+      _formLoadedAt: formLoadedAt,
+      ...agentInvoked ? { agentInvoked: true } : {}
     }
   };
   const response = await sonorFetch(
@@ -800,23 +803,24 @@ function useForm(formIdOrSlug, options = {}) {
     setErrors(newErrors);
     return Object.keys(newErrors).length === 0;
   }, [fields, validateField2]);
-  const validateAll = useCallback(() => {
+  const validateAllFor = useCallback((vals) => {
+    const visible = (field) => isFieldVisible(field, vals);
     const newErrors = {};
     for (const field of allFields) {
-      const error = validateField2(field);
+      const error = validateField(field, vals, visible);
       if (error) newErrors[field.slug] = error;
     }
     setErrors(newErrors);
-    return Object.keys(newErrors).length === 0;
-  }, [allFields, validateField2]);
-  const buildVisibleValues = useCallback(() => {
+    return newErrors;
+  }, [allFields]);
+  const buildVisibleValues = useCallback((vals) => {
     const out = {};
     for (const field of allFields) {
-      if (!isFieldVisible2(field)) continue;
-      if (field.slug in values) out[field.slug] = values[field.slug];
+      if (!isFieldVisible(field, vals)) continue;
+      if (field.slug in vals) out[field.slug] = vals[field.slug];
     }
     return out;
-  }, [allFields, values, isFieldVisible2]);
+  }, [allFields]);
   const setFieldValue = useCallback((key, value) => {
     setValuesState((prev) => ({ ...prev, [key]: value }));
     trackFieldChange(key);
@@ -862,19 +866,25 @@ function useForm(formIdOrSlug, options = {}) {
       trackStepChange(targetStep);
     }
   }, [totalSteps, trackStepChange]);
-  const submit = useCallback(async () => {
-    if (!form) return;
-    if (isSubmittingRef.current) return;
-    if (!validateAll()) return;
+  const submit = useCallback(async (options2) => {
+    if (!form) return { status: "failed", message: "The form is still loading." };
+    if (isSubmittingRef.current) return { status: "busy" };
+    const domFills = options2 && typeof options2 === "object" && options2.domFills && typeof options2.domFills === "object" ? options2.domFills : null;
+    const agentInvoked = !!options2 && typeof options2 === "object" && options2.agentInvoked === true;
+    const vals = domFills && Object.keys(domFills).length > 0 ? { ...values, ...domFills } : values;
+    if (vals !== values) setValuesState(vals);
+    const invalid = validateAllFor(vals);
+    if (Object.keys(invalid).length > 0) return { status: "invalid", errors: invalid };
     isSubmittingRef.current = true;
     setIsSubmitting(true);
     setSubmitError(null);
     try {
       const data = await submitForm({
         config: form,
-        values: buildVisibleValues(),
+        values: buildVisibleValues(vals),
         honeypotValue: "",
-        formLoadedAt: formLoadedAt()
+        formLoadedAt: formLoadedAt(),
+        agentInvoked
       });
       trackComplete();
       setIsComplete(true);
@@ -883,15 +893,35 @@ function useForm(formIdOrSlug, options = {}) {
       if (finalRedirect) {
         window.location.href = finalRedirect;
       }
+      const confirmation = typeof form.success_message === "string" && form.success_message.trim() ? form.success_message.trim() : DEFAULT_FORM_SUCCESS_MESSAGE;
+      return { status: "sent", message: confirmation, submissionId: data.submissionId || void 0 };
     } catch (error) {
       console.error("[useForm] Submission error:", error);
-      setSubmitError("Something went wrong sending your submission. Please try again.");
+      const message = "Something went wrong sending your submission. Please try again.";
+      setSubmitError(message);
       onError?.(error);
+      return { status: "failed", message };
     } finally {
       isSubmittingRef.current = false;
       setIsSubmitting(false);
     }
-  }, [form, validateAll, buildVisibleValues, trackComplete, onSuccess, onError, redirectUrl]);
+  }, [form, values, validateAllFor, buildVisibleValues, trackComplete, onSuccess, onError, redirectUrl]);
+  const handleSubmit = useCallback((event) => {
+    event.preventDefault();
+    const agent = readAgentSubmit(event.nativeEvent);
+    if (form?.is_multi_step && step < totalSteps) {
+      const moved = nextStep();
+      agent.respond(
+        Promise.resolve(
+          moved ? { status: "next_step", step: step + 1, totalSteps } : { status: "invalid", errors: {} }
+        )
+      );
+      return;
+    }
+    const domFills = unseenControlValues(event.currentTarget, allFields, "", values);
+    agent.respond(submit({ agentInvoked: agent.invoked, domFills }));
+  }, [form, step, totalSteps, nextStep, allFields, values, submit]);
+  const toolAttributes = useMemo(() => form ? formToolAttributes(form) : null, [form]);
   const reset = useCallback(() => {
     setValuesState(initialValues);
     setErrors({});
@@ -926,6 +956,8 @@ function useForm(formIdOrSlug, options = {}) {
     validateField: validateField2,
     isFieldVisible: isFieldVisible2,
     submit,
+    handleSubmit,
+    toolAttributes,
     isSubmitting,
     isComplete,
     reset,

package/dist/{chunk-UXOGCKL6.js → chunk-GEXT7BTE.js}

@@ -1,7 +1,7 @@
 'use client';
 import { locToPath, isMalformedSitemapPath, inferPageType } from './chunk-YVKRYQRG.js';
 import { resolveAnalyticsTarget } from './chunk-43OCZ3JA.js';
-import { sonorFetch } from './chunk-3SDOQUUF.js';
+import { sonorFetch } from './chunk-D6ZC7XKZ.js';
 import { useRef, useEffect } from 'react';
 
 var SYNC_STAMP_KEY = "_sk_sitemap_synced_at";