@usefillo/core 0.7.0 → 0.9.0

package/dist/index.js

@@ -21,6 +21,12 @@ function valueEquals(value, target) {
     return Number(value) === target;
   return false;
 }
+function conditionNumber(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value !== "string" || value.trim() === "") return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
 function evalCondition(cond, resolve) {
   const value = resolve(cond.fieldId);
   switch (cond.op) {
@@ -41,14 +47,20 @@ function evalCondition(cond, resolve) {
       if (Array.isArray(value)) return value.some((v) => v === cond.value);
       return false;
     case "gt":
-      return typeof value === "number" && value > Number(cond.value);
-    case "lt":
-      return typeof value === "number" && value < Number(cond.value);
+    case "lt": {
+      const left = conditionNumber(value);
+      const right = conditionNumber(cond.value);
+      return left !== null && right !== null && (cond.op === "gt" ? left > right : left < right);
+    }
   }
 }
+function conditionsMet(conds, resolve) {
+  if (conds.length === 0) return true;
+  return conds.every((cond) => evalCondition(cond, resolve));
+}
 function blockVisibleWith(block, resolve) {
   if (!block.visibleIf || block.visibleIf.length === 0) return true;
-  return block.visibleIf.every((cond) => evalCondition(cond, resolve));
+  return conditionsMet(block.visibleIf, resolve);
 }
 function makeResolver(data, scoped, visible) {
   return (fieldId) => scoped.has(fieldId) && !visible.has(fieldId) ? void 0 : data[fieldId];
@@ -74,6 +86,15 @@ function visibleBlocks(page, data) {
   const resolve = makeResolver(data, scoped, visibleFieldIds(fields, data));
   return page.blocks.filter((b) => blockVisibleWith(b, resolve));
 }
+function visiblePageBlocks(form, page, data) {
+  const fields = allFields(form);
+  const scoped = new Set(fields.map((f) => f.id));
+  const formVisible = visibleFieldIds(fields, data);
+  const resolve = makeResolver(data, scoped, formVisible);
+  return page.blocks.filter(
+    (b) => isField(b) ? formVisible.has(b.id) : blockVisibleWith(b, resolve)
+  );
+}
 function allFields(form) {
   return form.pages.flatMap((p) => p.blocks.filter(isField));
 }
@@ -81,13 +102,80 @@ function responseScopeValue(settings, data) {
   const field2 = settings.responseLimit?.scopeField;
   if (!field2) return null;
   const value = data[field2];
-  return typeof value === "string" || typeof value === "number" ? String(value) : null;
+  if (typeof value === "number") return Number.isFinite(value) ? String(value) : null;
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  return normalized || null;
 }
 function visibleFields(form, data) {
   const fields = allFields(form);
   const visible = visibleFieldIds(fields, data);
   return fields.filter((f) => visible.has(f.id));
 }
+function formResolver(form, data) {
+  const fields = allFields(form);
+  const scoped = new Set(fields.map((f) => f.id));
+  return makeResolver(data, scoped, visibleFieldIds(fields, data));
+}
+function resolveNextPage(form, currentPageId, data) {
+  const page = form.pages.find((p) => p.id === currentPageId);
+  const rules = page?.next;
+  if (!rules || rules.length === 0) return { linear: true };
+  const resolve = formResolver(form, data);
+  for (const rule of rules) {
+    if (conditionsMet(rule.when, resolve)) {
+      return rule.to === "end" ? { end: true } : { to: rule.to };
+    }
+  }
+  return { linear: true };
+}
+function reachablePageSequence(form, data) {
+  const seq = [];
+  if (form.pages.length === 0) return seq;
+  const seen = /* @__PURE__ */ new Set();
+  let index = 0;
+  for (let steps = 0; steps <= form.pages.length; steps++) {
+    const page = form.pages[index];
+    if (!page || seen.has(page.id)) break;
+    seen.add(page.id);
+    seq.push(page.id);
+    const nav = resolveNextPage(form, page.id, data);
+    if ("end" in nav) break;
+    if ("to" in nav) {
+      const target = form.pages.findIndex((p) => p.id === nav.to);
+      if (target < 0) break;
+      index = target;
+    } else {
+      index += 1;
+      if (index >= form.pages.length) break;
+    }
+  }
+  return seq;
+}
+function reachablePageIds(form, data) {
+  return new Set(reachablePageSequence(form, data));
+}
+function isTerminalPage(form, pageId, data) {
+  if ("end" in resolveNextPage(form, pageId, data)) return true;
+  const seq = reachablePageSequence(form, data);
+  return seq.length > 0 && seq[seq.length - 1] === pageId;
+}
+function reachableFieldIds(form, data) {
+  const reachablePages = reachablePageIds(form, data);
+  const visible = visibleFieldIds(allFields(form), data);
+  const ids = /* @__PURE__ */ new Set();
+  for (const page of form.pages) {
+    if (!reachablePages.has(page.id)) continue;
+    for (const block of page.blocks) {
+      if (isField(block) && visible.has(block.id)) ids.add(block.id);
+    }
+  }
+  return ids;
+}
+function reachableFields(form, data) {
+  const ids = reachableFieldIds(form, data);
+  return allFields(form).filter((f) => ids.has(f.id));
+}
 
 // src/validation.ts
 import * as z from "zod/mini";
@@ -370,6 +458,76 @@ function isPossiblePhone(value) {
   if (country?.lengths.length) return country.lengths.includes(national.length);
   return national.length >= 4;
 }
+var PHONE_POPOVER_VIEWPORT_GAP = 8;
+function positionPhonePopover(anchor, popover) {
+  if (!anchor || !popover || typeof window === "undefined") return "below";
+  const gap = PHONE_POPOVER_VIEWPORT_GAP;
+  const viewportWidth = document.documentElement.clientWidth || window.innerWidth;
+  const viewportHeight = document.documentElement.clientHeight || window.innerHeight;
+  const anchorRect = anchor.getBoundingClientRect();
+  const spaceBelow = Math.max(0, viewportHeight - anchorRect.bottom - gap);
+  const spaceAbove = Math.max(0, anchorRect.top - gap);
+  const placement = spaceBelow < popover.scrollHeight && spaceAbove > spaceBelow ? "above" : "below";
+  const availableHeight = placement === "above" ? spaceAbove : spaceBelow;
+  const maxHeight = Math.max(0, Math.min(availableHeight, viewportHeight - gap * 2));
+  const maxWidth = Math.max(0, viewportWidth - gap * 2);
+  popover.style.setProperty("--fillo-phone-popover-max-height", `${Math.floor(maxHeight)}px`);
+  popover.style.setProperty("--fillo-phone-popover-max-width", `${Math.floor(maxWidth)}px`);
+  popover.style.setProperty("--fillo-phone-popover-offset-x", "0px");
+  const width = Math.min(popover.offsetWidth, maxWidth);
+  let offsetX = 0;
+  const rightOverflow = anchorRect.left + width - (viewportWidth - gap);
+  if (rightOverflow > 0) offsetX -= rightOverflow;
+  const leftOverflow = gap - (anchorRect.left + offsetX);
+  if (leftOverflow > 0) offsetX += leftOverflow;
+  popover.style.setProperty("--fillo-phone-popover-offset-x", `${Math.round(offsetX)}px`);
+  return placement;
+}
+
+// src/strings.ts
+var REQUIRED_FIELD_MESSAGE = "This field is required";
+var DEFAULT_STRINGS = {
+  back: "Back",
+  next: "Next",
+  submit: "Submit",
+  submitting: "Submitting\u2026",
+  uploading: "Uploading\u2026",
+  optional: " (optional)",
+  other: "Other",
+  otherPrompt: "Other \u2014 please specify",
+  otherPlaceholder: "Your answer",
+  choosePlaceholder: "Choose\u2026",
+  successTitle: "Thanks!",
+  successMessage: "Your response has been recorded.",
+  closed: "This form is no longer accepting responses.",
+  notLive: "This form isn't live yet.",
+  submitFailed: "This form can't submit right now. Please try again in a moment.",
+  loadFailedNotFound: "Form not found \u2014 check the form id and that it's published.",
+  loadFailedNetwork: "Couldn't reach the server \u2014 check your connection or CORS.",
+  loadFailed: "This form could not be loaded.",
+  renderFailed: "This form could not be rendered.",
+  resumeNotice: "Picked up where you left off.",
+  editNotice: "You're updating your earlier response.",
+  resumeStartOver: "Start over",
+  challengeUnavailable: "The verification check couldn't load. Refresh the page, or check that challenges.cloudflare.com isn't blocked."
+};
+var DEFAULT_FIELD_STRINGS = {
+  required: REQUIRED_FIELD_MESSAGE,
+  resumeLinkExpired: "That saved-progress link expired or was already used \u2014 start again below.",
+  alreadyAnswered: "You've already answered this form.",
+  uploadRetry: "Retry",
+  uploadsDisabled: "Uploads are disabled in preview",
+  uploadFailed: "Upload failed \u2014 try again",
+  dropzoneTitle: (multiple) => `Drop ${multiple ? "files" : "a file"} here or click to browse`,
+  dropzoneHint: (maxMb) => `Up to ${maxMb} MB per file`,
+  fileTooLarge: (maxMb) => `Larger than ${maxMb} MB limit`,
+  filesUploading: (count) => `Uploading ${count} ${count === 1 ? "file" : "files"}, please wait\u2026`,
+  uploadsFailed: (count) => `${count} ${count === 1 ? "upload" : "uploads"} failed.`,
+  filesUploaded: (count) => `${count} ${count === 1 ? "file" : "files"} uploaded.`
+};
+function resolveStrings(overrides) {
+  return overrides ? { ...DEFAULT_STRINGS, ...DEFAULT_FIELD_STRINGS, ...overrides } : { ...DEFAULT_STRINGS, ...DEFAULT_FIELD_STRINGS };
+}
 
 // src/validation.ts
 var fileValueSchema = z.object({
@@ -389,7 +547,7 @@ function isEmpty(value) {
 }
 function validateField(field2, value) {
   if (isEmpty(value)) {
-    return field2.required ? "This field is required" : null;
+    return field2.required ? REQUIRED_FIELD_MESSAGE : null;
   }
   switch (field2.kind) {
     case "short_text":
@@ -402,11 +560,16 @@ function validateField(field2, value) {
       return null;
     }
     case "email": {
+      if (typeof value !== "string") return "Enter a valid email address";
+      if (field2.maxLength && value.length > field2.maxLength)
+        return `Must be at most ${field2.maxLength} characters`;
       const r = z.email().safeParse(value);
       return r.success ? null : "Enter a valid email address";
     }
     case "url": {
       if (typeof value !== "string") return "Enter a valid URL (including https://)";
+      if (field2.maxLength && value.length > field2.maxLength)
+        return `Must be at most ${field2.maxLength} characters`;
       try {
         const url = new URL(value);
         if (url.protocol !== "http:" && url.protocol !== "https:") {
@@ -441,9 +604,13 @@ function validateField(field2, value) {
       const ids = new Set(field2.options.map((o) => o.id));
       const arr = value;
       let others = 0;
+      const seen = /* @__PURE__ */ new Set();
       for (const v of arr) {
+        if (typeof v !== "string") return "Pick valid options";
+        if (seen.has(v)) return "Pick each option only once";
+        seen.add(v);
         if (ids.has(v)) continue;
-        if (field2.allowOther !== true || typeof v !== "string" || v.length === 0 || v.length > 500)
+        if (field2.allowOther !== true || v.length === 0 || v.length > 500)
           return "Pick valid options";
         if (++others > 1) return "Only one 'Other' answer is allowed";
       }
@@ -519,7 +686,7 @@ function validateField(field2, value) {
   }
 }
 function validateResponse(form, data) {
-  const fields = visibleFields(form, data);
+  const fields = reachableFields(form, data);
   const errors = {};
   const cleaned = {};
   for (const field2 of fields) {
@@ -535,6 +702,7 @@ function validateResponse(form, data) {
 }
 function normalizeValue(field2, value) {
   if (value === void 0 || value === null) return value;
+  if (field2.kind === "custom") return value;
   if (field2.kind === "number" && typeof value === "string" && value.trim() !== "") {
     const n = Number(value);
     return Number.isNaN(n) ? value : n;
@@ -589,7 +757,11 @@ var blockSchema = z2.looseObject({
 var pageSchema = z2.object({
   id: idSchema,
   title: z2.optional(z2.string().check(z2.maxLength(500))),
-  blocks: z2.array(blockSchema).check(z2.maxLength(500))
+  blocks: z2.array(blockSchema).check(z2.maxLength(500)),
+  // Optional conditional page flow. Kept as unknown here (this schema is strict,
+  // so it would otherwise be dropped at parse) and normalized by hand below once
+  // the page-id set is known — a jump to a missing page is dropped, never kept.
+  next: z2.optional(z2.unknown())
 });
 var schemaShape = z2.object({
   version: z2.literal(1),
@@ -600,7 +772,9 @@ var schemaShape = z2.object({
 });
 var MAX_SCHEMA_VERSION = 1;
 var FILLO_SCHEMA_VERSION = 1;
-var FILLO_SDK_VERSION = true ? "0.7.0" : "0.0.0-dev";
+var FILLO_SDK_VERSION = true ? "0.9.0" : "0.0.0-dev";
+var FILLO_MIN_SDK_VERSION = "0.4.0";
+var FILLO_CHALLENGE_MIN_SDK_VERSION = "0.9.0";
 function str(value, max, fallback = "") {
   return typeof value === "string" ? value.trim().slice(0, max) : fallback;
 }
@@ -630,6 +804,14 @@ function options(value, max = 200) {
     return id && label ? [cleanObject({ id, label, icon })] : [];
   });
 }
+function duplicateOptionId(items) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const { id } of items) {
+    if (ids.has(id)) return id;
+    ids.add(id);
+  }
+  return void 0;
+}
 function conditions(value) {
   if (!Array.isArray(value)) return void 0;
   const normalized = value.slice(0, 20).flatMap((item) => {
@@ -647,6 +829,23 @@ function conditions(value) {
   });
   return normalized.length ? normalized : void 0;
 }
+function jumpRules(value, pageIds, sourceId, allowedFieldIds) {
+  if (!Array.isArray(value)) return void 0;
+  const rules = value.slice(0, 50).flatMap((item) => {
+    if (!item || typeof item !== "object") return [];
+    const rec = item;
+    const to = typeof rec.to === "string" ? rec.to : void 0;
+    if (!to || to !== "end" && !pageIds.has(to)) return [];
+    if (to === sourceId) return [];
+    const rawWhen = rec.when;
+    if (rawWhen !== void 0 && !Array.isArray(rawWhen)) return [];
+    const when2 = conditions(rawWhen);
+    if (Array.isArray(rawWhen) && rawWhen.length > 0 && when2 === void 0) return [];
+    if (when2 && when2.some((c) => !allowedFieldIds.has(c.fieldId))) return [];
+    return [{ when: when2 ?? [], to }];
+  });
+  return rules.length ? rules : void 0;
+}
 function baseBlock(rec) {
   return {
     id: str(rec.id, 128),
@@ -690,6 +889,17 @@ function normalizeResponseLimit(value) {
     onRepeat
   };
 }
+function normalizeTrust(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const rec = value;
+  const unverified = rec.unverified === "allow" || rec.unverified === "quarantine" ? rec.unverified : void 0;
+  const challenge = rec.challenge === "turnstile" ? "turnstile" : void 0;
+  if (!unverified && !challenge) return void 0;
+  return {
+    ...unverified ? { unverified } : {},
+    ...challenge ? { challenge } : {}
+  };
+}
 function normalizeSettings(value) {
   const rec = value && typeof value === "object" ? value : {};
   const submitMode = rec.submitMode === "button" || rec.submitMode === "auto" ? rec.submitMode : void 0;
@@ -701,6 +911,7 @@ function normalizeSettings(value) {
     redirectUrl: normalizeUrl(rec.redirectUrl),
     showProgress: bool(rec.showProgress),
     responseLimit: normalizeResponseLimit(rec.responseLimit),
+    trust: normalizeTrust(rec.trust),
     notifyEmail: z2.email().check(z2.maxLength(254)).safeParse(rec.notifyEmail).success ? rec.notifyEmail : void 0,
     sendReceipt: bool(rec.sendReceipt),
     saveProgress: bool(rec.saveProgress),
@@ -769,17 +980,25 @@ function normalizeBlock(input) {
     case "signature":
     case "date":
       return cleanObject(baseField(rec, kind));
-    case "rating":
-      return cleanObject({ ...baseField(rec, kind), max: int(rec.max, 1, 10, 5) });
+    case "rating": {
+      const max = int(rec.max, 1, 10, 5);
+      return cleanObject({
+        ...baseField(rec, kind),
+        max,
+        insightsMetric: rec.insightsMetric === "csat" && max === 5 ? "csat" : void 0
+      });
+    }
     case "linear_scale": {
       const min = int(rec.min, 0, 9, 1);
       const max = int(rec.max, min + 1, 10, 10);
+      const insightsMetric = rec.insightsMetric === "nps" && min === 0 && max === 10 ? "nps" : rec.insightsMetric === "csat" && min === 1 && max === 5 ? "csat" : void 0;
       return cleanObject({
         ...baseField(rec, kind),
         min,
         max,
         minLabel: optionalStr(rec.minLabel, 100),
-        maxLabel: optionalStr(rec.maxLabel, 100)
+        maxLabel: optionalStr(rec.maxLabel, 100),
+        insightsMetric
       });
     }
     case "ranking": {
@@ -832,22 +1051,56 @@ function normalizeFormSchema(input) {
   if (parsed.data.version > MAX_SCHEMA_VERSION) {
     return { ok: false, error: `Unsupported schema version: ${parsed.data.version}` };
   }
-  const pages = parsed.data.pages.map((page) => {
+  const rebuilt = parsed.data.pages.map((page) => {
     const blocks = page.blocks.flatMap((raw) => {
       const block = normalizeBlock(raw);
       return block ? [block] : [];
     });
+    return { id: str(page.id, 128), title: optionalStr(page.title, 500), blocks, next: page.next };
+  });
+  const targetIds = new Set(rebuilt.map((p) => p.id));
+  const priorFieldIds = /* @__PURE__ */ new Set();
+  const pages = rebuilt.map((page) => {
+    for (const block of page.blocks) {
+      if (isField(block)) priorFieldIds.add(block.id);
+    }
     return cleanObject({
       id: page.id,
-      title: optionalStr(page.title, 500),
-      blocks
+      title: page.title,
+      blocks: page.blocks,
+      next: jumpRules(page.next, targetIds, page.id, new Set(priorFieldIds))
     });
   });
+  const pageIds = /* @__PURE__ */ new Set();
   const seen = /* @__PURE__ */ new Set();
   for (const page of pages) {
+    if (!page.id) return { ok: false, error: "Page ids cannot be blank" };
+    if (pageIds.has(page.id)) return { ok: false, error: `Duplicate page id: ${page.id}` };
+    pageIds.add(page.id);
     for (const block of page.blocks) {
       if (seen.has(block.id)) return { ok: false, error: `Duplicate block id: ${block.id}` };
       seen.add(block.id);
+      if (block.kind === "number" && block.min !== void 0 && block.max !== void 0 && block.min > block.max) {
+        return { ok: false, error: `Field ${block.id} has min greater than max` };
+      }
+      if (block.kind === "select" || block.kind === "multi_select" || block.kind === "dropdown" || block.kind === "ranking") {
+        const duplicate = duplicateOptionId(block.options);
+        if (duplicate) {
+          return { ok: false, error: `Duplicate option id in field ${block.id}: ${duplicate}` };
+        }
+      } else if (block.kind === "matrix") {
+        const duplicateRow = duplicateOptionId(block.rows);
+        if (duplicateRow) {
+          return { ok: false, error: `Duplicate matrix row id in field ${block.id}: ${duplicateRow}` };
+        }
+        const duplicateColumn = duplicateOptionId(block.columns);
+        if (duplicateColumn) {
+          return {
+            ok: false,
+            error: `Duplicate matrix column id in field ${block.id}: ${duplicateColumn}`
+          };
+        }
+      }
     }
   }
   if (pages.every((page) => page.blocks.length === 0)) {
@@ -949,6 +1202,9 @@ function formatAnswer(field2, value) {
 var ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 var MASK = 256 - 256 % ALPHABET.length;
 function createId(size = 12) {
+  if (!Number.isSafeInteger(size) || size <= 0) {
+    throw new RangeError("createId size must be a positive safe integer");
+  }
   const csprng = globalThis.crypto;
   if (typeof csprng === "undefined" || typeof csprng.getRandomValues !== "function") {
     throw new Error("createId requires Web Crypto (globalThis.crypto.getRandomValues)");
@@ -978,12 +1234,12 @@ var BLOCK_KIND_META = {
   dropdown: { label: "Dropdown", hint: "Select from a list" },
   checkbox: { label: "Yes / No", hint: "Single checkbox" },
   rating: { label: "Rating", hint: "1\u20135 stars" },
-  linear_scale: { label: "Linear scale", hint: "1\u201310 with end labels" },
+  linear_scale: { label: "Linear scale", hint: "0\u201310 with end labels" },
   ranking: { label: "Ranking", hint: "Order options by preference" },
   matrix: { label: "Matrix", hint: "Grid of rows \xD7 choices" },
   signature: { label: "Signature", hint: "Draw to sign" },
   date: { label: "Date", hint: "Date picker" },
-  file_upload: { label: "File upload", hint: "Huge files, resumable" },
+  file_upload: { label: "File upload", hint: "Direct to connected storage" },
   hidden: { label: "Hidden field", hint: "Filled from the URL" },
   custom: { label: "Custom", hint: "Your own component (code only)" },
   heading: { label: "Heading", hint: "Section title" },
@@ -1018,10 +1274,11 @@ function createBlock(kind) {
         id,
         kind,
         label: "How likely are you to recommend us?",
-        min: 1,
+        min: 0,
         max: 10,
-        minLabel: "Not likely",
-        maxLabel: "Very likely"
+        minLabel: "Not at all likely",
+        maxLabel: "Extremely likely",
+        insightsMetric: "nps"
       };
     case "ranking":
       return {
@@ -1137,12 +1394,21 @@ function assembleBlock(spec) {
       break;
     case "rating":
       block.max = clampInt(spec.max, 3, 10, 5);
+      if (spec.insightsMetric === "csat" && block.max === 5) {
+        block.insightsMetric = "csat";
+      }
       break;
     case "linear_scale":
       block.min = spec.min === 0 ? 0 : 1;
       block.max = clampInt(spec.max, 2, 10, 10);
       if (spec.minLabel) block.minLabel = str2(spec.minLabel, 100);
       if (spec.maxLabel) block.maxLabel = str2(spec.maxLabel, 100);
+      delete block.insightsMetric;
+      if (spec.insightsMetric === "nps" && block.min === 0 && block.max === 10) {
+        block.insightsMetric = "nps";
+      } else if (spec.insightsMetric === "csat" && block.min === 1 && block.max === 5) {
+        block.insightsMetric = "csat";
+      }
       break;
     case "number":
       if (typeof spec.min === "number") block.min = spec.min;
@@ -1280,25 +1546,30 @@ var sha1Base64 = (bytes) => bytesToBase64(new Sha1().update(bytes).digest());
 
 // src/client.ts
 var FilloError = class extends Error {
-  constructor(message, status, retryAfterSec2) {
+  constructor(message, status, retryAfterSec2, code) {
     super(message);
     this.status = status;
     this.retryAfterSec = retryAfterSec2;
+    this.code = code;
     this.name = "FilloError";
   }
   status;
   retryAfterSec;
+  code;
 };
 function isFilloError(err) {
   return err instanceof Error && err.name === "FilloError";
 }
-async function errorMessage(res, fallback) {
+async function errorDetails(res, fallback) {
   try {
     const body = await res.json();
-    if (typeof body.error === "string" && body.error) return body.error;
+    return {
+      message: typeof body.error === "string" && body.error ? body.error : fallback,
+      code: typeof body.code === "string" && body.code ? body.code : void 0
+    };
   } catch {
   }
-  return fallback;
+  return { message: fallback };
 }
 function retryAfterSec(res) {
   const raw = Number(res.headers.get("retry-after"));
@@ -1306,11 +1577,31 @@ function retryAfterSec(res) {
 }
 var MAX_CHUNK_RETRIES = 3;
 var DEFAULT_TIMEOUT_MS = 3e4;
+var S3_PART_TIMEOUT_MS = 5 * 6e4;
+var UPLOAD_CONTROL_TIMEOUT_MS = 10 * 6e4;
+function waitForRetry(ms, signal) {
+  signal?.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const aborted = () => {
+      clearTimeout(timer);
+      reject(signal?.reason);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", aborted);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", aborted, { once: true });
+  });
+}
+function isControlRetryable(error, includeBusy = false) {
+  const status = isFilloError(error) ? error.status ?? 0 : 0;
+  return status === 0 || status === 503 || status === 504 || includeBusy && status === 409 && isFilloError(error) && error.retryAfterSec !== void 0;
+}
 function isRetryableStatus(status) {
   return status >= 500 || status === 429 || status === 408;
 }
 function asRequestError(err) {
-  if (err instanceof DOMException && err.name === "TimeoutError")
+  if (typeof DOMException !== "undefined" && err instanceof DOMException && err.name === "TimeoutError")
     return new FilloError("Request timed out", 0);
   return err;
 }
@@ -1381,8 +1672,8 @@ var FilloClient = class {
       throw asRequestError(err);
     }
     if (!res.ok) {
-      const message = await errorMessage(res, `Request failed: ${res.status}`);
-      throw new FilloError(message, res.status, retryAfterSec(res));
+      const { message, code } = await errorDetails(res, `Request failed: ${res.status}`);
+      throw new FilloError(message, res.status, retryAfterSec(res), code);
     }
     return await res.json();
   }
@@ -1393,8 +1684,10 @@ var FilloClient = class {
     return form;
   }
   /**
-   * Upsert a code-defined form into the workspace identified by the client's
-   * publishable key. Returns the canonical form id used for submissions.
+   * Resolve a code-defined form through the workspace identified by the
+   * client's publishable key. Depending on workspace policy, changed content
+   * may be staged for review or resolved to the authoritative live snapshot.
+   * Returns the canonical form id used for submissions.
    */
   syncForm(handle, schema, theme) {
     if (!this.key) {
@@ -1434,8 +1727,8 @@ var FilloClient = class {
       return { ok: false, errors: body2.errors };
     }
     if (!res.ok) {
-      const message = await errorMessage(res, `Submit failed: ${res.status}`);
-      throw new FilloError(message, res.status, retryAfterSec(res));
+      const { message, code } = await errorDetails(res, `Submit failed: ${res.status}`);
+      throw new FilloError(message, res.status, retryAfterSec(res), code);
     }
     const body = await res.json();
     return { ok: true, responseId: body.id, duplicate: body.duplicate, updated: body.updated };
@@ -1445,12 +1738,18 @@ var FilloClient = class {
    * used to prefill their answers for editing. Requires a VERIFIED identity
    * ({id, hash}); anything else 404s (returned as null), because an
    * unverified read would hand anyone's answers to any page script.
+   *
+   * `scopeValue` scopes the lookup for forms whose response limit is keyed to
+   * a field (responseLimit.scopeField) — e.g. one response per article. When
+   * the form is scoped, the server returns 404 unless the matching scope value
+   * is sent, so a page loaded for article B never prefills article A's answers.
+   * Optional and back-compatible: omit it for unscoped forms.
    */
-  async fetchOwnResponse(formId, respondent) {
+  async fetchOwnResponse(formId, respondent, scopeValue) {
     try {
       return await this.json(
         `/forms/${encodeURIComponent(formId)}/respondent-response`,
-        { method: "POST", body: JSON.stringify({ respondent }) }
+        { method: "POST", body: JSON.stringify({ respondent, scopeValue }) }
       );
     } catch (err) {
       if (isFilloError(err) && (err.status === 404 || err.status === 403)) return null;
@@ -1530,18 +1829,20 @@ var FilloClient = class {
     });
   }
   /** Current state of an upload session — used to resume after interruption. */
-  getUploadSession(sessionId, token) {
+  getUploadSession(sessionId, token, signal = AbortSignal.timeout(UPLOAD_CONTROL_TIMEOUT_MS)) {
     return this.json(
       `/uploads/${encodeURIComponent(sessionId)}`,
-      token ? { headers: { "X-Fillo-Upload-Token": token } } : void 0
+      {
+        ...token ? { headers: { "X-Fillo-Upload-Token": token } } : {},
+        signal
+      }
     );
   }
   /**
-   * Resumable chunked upload. Creates (or resumes) a session, streams the file
-   * chunk by chunk with progress callbacks, and finalizes into a FileValue that
-   * goes into the response data. Survives flaky connections: each chunk is
-   * retried, and on repeated failure the true offset is re-queried so no byte
-   * is sent twice or skipped.
+   * Provider-aware browser-direct upload. Creates a session, uses the storage
+   * transport selected by the server, reports progress, and finalizes into a
+   * FileValue. Resumable providers can continue an existing session; one-shot
+   * transports are retried according to their own safe semantics.
    *
    * Depending on the form's storage settings the server picks a transport:
    * direct-to-Google-Drive resumable
@@ -1549,28 +1850,68 @@ var FilloClient = class {
    * form owner's Drive and never touch the Fillo server.
    */
   async uploadFile(formId, file, options2) {
-    const name = file instanceof File ? file.name : "upload.bin";
-    const mime = file.type || "application/octet-stream";
+    const name = typeof File !== "undefined" && file instanceof File ? file.name : "upload.bin";
+    const mime = (file.type || "application/octet-stream").trim().toLowerCase();
     let session;
     if (options2.sessionId) {
-      session = await this.getUploadSession(options2.sessionId, options2.uploadToken);
+      const resumed = await this.getUploadSession(
+        options2.sessionId,
+        options2.uploadToken,
+        this.uploadSignal(options2, UPLOAD_CONTROL_TIMEOUT_MS)
+      );
+      if (resumed.formId !== formId || resumed.fieldId !== options2.fieldId || resumed.fileName !== name || resumed.size !== file.size || resumed.mime.trim().toLowerCase() !== mime) {
+        throw new FilloError("File does not match this upload session", 400);
+      }
+      session = resumed;
+      session.token ||= options2.uploadToken;
     } else {
-      session = await this.json(
+      const requestId = createId(24);
+      const requestToken = createId(32);
+      const createSession = () => this.json(
         `/forms/${encodeURIComponent(formId)}/uploads`,
         {
           method: "POST",
           body: JSON.stringify({
+            requestId,
+            uploadToken: requestToken,
             fieldId: options2.fieldId,
             fileName: name,
             size: file.size,
             mime
-          })
+          }),
+          signal: this.uploadSignal(options2, UPLOAD_CONTROL_TIMEOUT_MS)
         }
       );
+      const deadline = Date.now() + UPLOAD_CONTROL_TIMEOUT_MS;
+      let backoffMs = 250;
+      for (; ; ) {
+        try {
+          session = await createSession();
+          break;
+        } catch (error) {
+          if (options2.signal?.aborted) throw error;
+          if (!isControlRetryable(error, true)) throw error;
+          const remaining = deadline - Date.now();
+          if (remaining <= 0) throw error;
+          await waitForRetry(
+            Math.min(backoffMs, remaining),
+            options2.signal
+          );
+          backoffMs = Math.min(backoffMs * 2, 5e3);
+        }
+      }
     }
+    options2.onSession?.({
+      sessionId: session.id,
+      uploadToken: session.token
+    });
+    if (session.status === "complete" && session.file) return session.file;
+    if (session.status === "aborted") throw new FilloError("This upload session was cancelled", 409);
     let completeBody;
     if (session.transport?.type === "gdrive") {
       await this.driveUploadLoop(session, session.transport.uploadUrl, file, options2);
+    } else if (session.transport?.type === "s3-multipart") {
+      await this.s3MultipartUploadLoop(session, file, options2);
     } else if (session.transport?.type === "s3-put") {
       await this.s3PutUpload(session.transport.uploadUrl, file, options2);
     } else if (session.transport?.type === "box") {
@@ -1578,14 +1919,52 @@ var FilloClient = class {
     } else {
       throw new FilloError("This form's storage doesn't support uploads \u2014 connect Drive, S3, or Box.");
     }
-    const done = await this.json(
+    const finalize = () => this.json(
       `/uploads/${encodeURIComponent(session.id)}/complete`,
       {
         method: "POST",
         headers: session.token ? { "X-Fillo-Upload-Token": session.token } : void 0,
-        ...completeBody ? { body: JSON.stringify(completeBody) } : {}
+        ...completeBody ? { body: JSON.stringify(completeBody) } : {},
+        signal: this.uploadSignal(options2, UPLOAD_CONTROL_TIMEOUT_MS)
       }
     );
+    let done;
+    try {
+      done = await finalize();
+    } catch (error) {
+      if (options2.signal?.aborted) throw error;
+      if (!isControlRetryable(error)) throw error;
+      const deadline = Date.now() + UPLOAD_CONTROL_TIMEOUT_MS;
+      let backoffMs = 250;
+      for (; ; ) {
+        const reconciled = await this.getUploadSession(
+          session.id,
+          session.token,
+          this.uploadSignal(
+            options2,
+            Math.max(1, deadline - Date.now())
+          )
+        );
+        if (reconciled.status === "complete" && reconciled.file) {
+          return reconciled.file;
+        }
+        if (reconciled.status === "aborted") throw error;
+        try {
+          done = await finalize();
+          break;
+        } catch (retryError) {
+          if (options2.signal?.aborted) throw retryError;
+          if (!isControlRetryable(retryError, true)) throw retryError;
+        }
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) throw error;
+        await waitForRetry(
+          Math.min(backoffMs, remaining),
+          options2.signal
+        );
+        backoffMs = Math.min(backoffMs * 2, 5e3);
+      }
+    }
     if (!done.file) throw new FilloError("Upload completed but no file was returned");
     return done.file;
   }
@@ -1694,10 +2073,10 @@ var FilloClient = class {
   /**
    * Caller signal (if any) combined with a fresh per-request timeout. Created per
    * fetch so each retry attempt gets its own deadline; the caller's own abort
-   * still drives the resumable-upload cancel semantics.
+   * still drives upload cancellation across every provider transport.
    */
-  uploadSignal(options2) {
-    const timeout = AbortSignal.timeout(DEFAULT_TIMEOUT_MS);
+  uploadSignal(options2, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    const timeout = AbortSignal.timeout(timeoutMs);
     return options2.signal ? AbortSignal.any([options2.signal, timeout]) : timeout;
   }
   /** Retry a request with exponential backoff; never retries an aborted upload. */
@@ -1746,7 +2125,13 @@ var FilloClient = class {
             const match = range?.match(/bytes=0-(\d+)/);
             if (match) offset = Number(match[1]) + 1;
             else if (range == null) offset = 0;
-            else offset = (await this.getUploadSession(session.id, session.token)).uploadedBytes;
+            else {
+              offset = (await this.getUploadSession(
+                session.id,
+                session.token,
+                this.uploadSignal(options2, UPLOAD_CONTROL_TIMEOUT_MS)
+              )).uploadedBytes;
+            }
             break;
           }
           if (res.ok) {
@@ -1759,7 +2144,11 @@ var FilloClient = class {
           attempt += 1;
           if (attempt >= MAX_CHUNK_RETRIES) throw err;
           await new Promise((r) => setTimeout(r, 500 * 2 ** attempt));
-          const fresh = await this.getUploadSession(session.id, session.token);
+          const fresh = await this.getUploadSession(
+            session.id,
+            session.token,
+            this.uploadSignal(options2, UPLOAD_CONTROL_TIMEOUT_MS)
+          );
           offset = fresh.uploadedBytes;
           if (offset >= file.size) break;
           end = Math.min(offset + session.chunkSize, file.size);
@@ -1776,6 +2165,80 @@ var FilloClient = class {
       }
     }
   }
+  /**
+   * S3-compatible multipart protocol. Fillo owns the provider upload id and is
+   * the only party allowed to complete it; the browser receives only narrowly
+   * scoped UploadPart URLs. That keeps uploads resumable and means an old or
+   * slow browser request cannot materialize an object after server-side abort.
+   */
+  async s3MultipartUploadLoop(session, file, options2) {
+    if (!Number.isSafeInteger(session.chunkSize) || session.chunkSize <= 0 || !Number.isSafeInteger(session.uploadedBytes) || session.uploadedBytes < 0 || session.uploadedBytes > file.size || session.uploadedBytes < file.size && session.uploadedBytes % session.chunkSize !== 0) {
+      throw new FilloError("S3 upload session returned invalid progress", 502);
+    }
+    const report = makeReporter(file.size, options2);
+    let offset = session.uploadedBytes;
+    report(offset);
+    while (offset < file.size) {
+      options2.signal?.throwIfAborted();
+      const partNumber = Math.floor(offset / session.chunkSize) + 1;
+      if (partNumber > 1e4) {
+        throw new FilloError("S3 upload needs too many parts", 413);
+      }
+      const end = Math.min(offset + session.chunkSize, file.size);
+      const chunk = file.slice(offset, end);
+      let attempt = 0;
+      for (; ; ) {
+        let uploadUrl;
+        try {
+          const signed = await this.json(
+            `/uploads/${encodeURIComponent(session.id)}/parts`,
+            {
+              method: "POST",
+              headers: session.token ? { "X-Fillo-Upload-Token": session.token } : void 0,
+              body: JSON.stringify({ partNumber }),
+              signal: this.uploadSignal(options2, UPLOAD_CONTROL_TIMEOUT_MS)
+            }
+          );
+          if (typeof signed.uploadUrl !== "string" || !signed.uploadUrl) {
+            throw new FilloError("S3 part URL was unavailable", 502);
+          }
+          uploadUrl = signed.uploadUrl;
+          const res = await this.fetch(uploadUrl, {
+            method: "PUT",
+            body: chunk,
+            signal: this.uploadSignal(options2, S3_PART_TIMEOUT_MS)
+          });
+          if (!res.ok) {
+            throw new FilloError(`S3 part upload failed: ${res.status}`, res.status);
+          }
+          offset = end;
+          report(offset);
+          break;
+        } catch (err) {
+          if (options2.signal?.aborted) throw err;
+          const fresh = await this.getUploadSession(
+            session.id,
+            session.token,
+            this.uploadSignal(options2, UPLOAD_CONTROL_TIMEOUT_MS)
+          );
+          if (fresh.status === "aborted") {
+            throw new FilloError("This upload session was cancelled", 409);
+          }
+          if (!Number.isSafeInteger(fresh.uploadedBytes) || fresh.uploadedBytes < offset || fresh.uploadedBytes > file.size || fresh.uploadedBytes < file.size && fresh.uploadedBytes % session.chunkSize !== 0) {
+            throw new FilloError("S3 upload session returned invalid progress", 502);
+          }
+          if (fresh.uploadedBytes > offset) {
+            offset = fresh.uploadedBytes;
+            report(offset);
+            break;
+          }
+          attempt += 1;
+          if (attempt >= MAX_CHUNK_RETRIES) throw err;
+          await new Promise((resolve) => setTimeout(resolve, 500 * 2 ** attempt));
+        }
+      }
+    }
+  }
   /**
    * S3-compatible single PUT to a presigned URL — bytes go straight to the
    * bucket. Not resumable (S3 single PUT is atomic), but retried on failure.
@@ -1866,7 +2329,7 @@ function prefillFromParams(form, params) {
       }
       case "multi_select": {
         const ids = new Set(field2.options.map((o) => o.id));
-        const picked = raw.split(",").filter((v) => ids.has(v));
+        const picked = [...new Set(raw.split(",").filter((v) => ids.has(v)))];
         if (picked.length > 0) data[field2.id] = picked;
         break;
       }
@@ -2002,10 +2465,20 @@ function isDraftGone(err) {
   return isFilloError(err) && (err.status === 401 || err.status === 403 || err.status === 404);
 }
 var DRAFT_DEBOUNCE_MS = 1500;
+var CHALLENGE_INCOMPLETE_MESSAGE = "Please complete the verification check, then submit.";
+var CHALLENGE_RETRY_MESSAGE = "That verification didn't go through. Please complete the check again and resubmit.";
 function submitFailureMessage(err) {
   if (isFilloError(err) && err.status && err.status > 0 && err.message) return err.message;
   return "Couldn't reach the server \u2014 check your connection and try again. If this keeps happening, a browser extension, firewall, or the site's Content-Security-Policy may be blocking the request.";
 }
+function syncResolutionFailureMessage(err) {
+  if (isFilloError(err)) {
+    const status = err.status ?? 0;
+    const definitive = status > 0 && status < 500 && status !== 408 && status !== 429;
+    if (definitive) return "This form is unavailable.";
+  }
+  return submitFailureMessage(err);
+}
 function createFormController(options2) {
   const { onChange, onSubmitted } = options2;
   const initial = normalizeFormSchema(options2.form);
@@ -2019,6 +2492,7 @@ function createFormController(options2) {
   let pageIndex = 0;
   let status = "idle";
   let restoredSubmission = false;
+  let resumeLinkFailed = false;
   queueMicrotask(() => {
     if (typeof location !== "undefined" && location.search) {
       const params = Object.fromEntries(new URLSearchParams(location.search));
@@ -2054,7 +2528,11 @@ function createFormController(options2) {
             history.replaceState(null, "", location.pathname + location.search);
           } catch {
           }
-        }).catch(() => {
+        }).catch((err) => {
+          if (isDraftGone(err)) {
+            resumeLinkFailed = true;
+            notify();
+          }
         }).finally(() => maybeRestoreDraft());
       }
     }
@@ -2069,6 +2547,7 @@ function createFormController(options2) {
   let sessionStarted = false;
   let resumedDraft = false;
   let editingPrevious = false;
+  let submissionKind = "created";
   let editAttempted = false;
   let draftRef = null;
   let draftTimer = null;
@@ -2088,14 +2567,23 @@ function createFormController(options2) {
       pageIndex: clamped,
       pageCount,
       page,
-      blocks: visibleBlocks(page, data),
+      // Whole-form visibility fixpoint (not just this page's fields) so a field
+      // gated by a cross-page answer renders/validates exactly when the server
+      // keeps it — never a field whose answer submit would silently drop.
+      blocks: visiblePageBlocks(form, page, data),
       isFirstPage: clamped === 0,
-      isLastPage: clamped === pageCount - 1,
+      // Terminal-aware: true when the current page is the last reachable page OR
+      // a matched jump rule ends the form here — so the footer reads Submit and
+      // its handler submits. Same shared engine the validator reaches with.
+      isLastPage: isTerminalPage(form, page.id, data),
       uploading: uploadingFields.size > 0,
       submitError,
       restoredSubmission,
       resumedDraft,
-      editingPrevious
+      editingPrevious,
+      duplicateSubmission: submissionKind === "duplicate",
+      updatedSubmission: submissionKind === "updated",
+      resumeLinkFailed
     };
   }
   let snapshot = computeSnapshot();
@@ -2114,7 +2602,7 @@ function createFormController(options2) {
     const target = form.pages[index];
     if (!target) return {};
     const pageErrors = {};
-    for (const block of visibleBlocks(target, data)) {
+    for (const block of visiblePageBlocks(form, target, data)) {
       if (!isField(block)) continue;
       const error = validateField(block, data[block.id]);
       if (error) pageErrors[block.id] = error;
@@ -2191,7 +2679,8 @@ function createFormController(options2) {
     if (!client || !formId || !respondent?.hash || status !== "idle") return;
     editAttempted = true;
     const c = client;
-    void c.fetchOwnResponse(formId, respondent).then((own) => {
+    const scopeValue = responseScopeValue(form.settings, data) ?? void 0;
+    void c.fetchOwnResponse(formId, respondent, scopeValue).then((own) => {
       if (!own || status !== "idle" || sessionStarted || resumedDraft) return;
       applyDraftSnapshot({ data: own.data, page: 0 });
       if (resumedDraft) {
@@ -2287,6 +2776,20 @@ function createFormController(options2) {
     else uploadingFields.delete(fieldId);
     notify();
   }
+  function currentSeqPosition(seq) {
+    if (seq.length === 0) return -1;
+    const pageCount = form.pages.length;
+    const clamped = Math.min(pageIndex, Math.max(pageCount - 1, 0));
+    const currentId = form.pages[clamped]?.id;
+    const exact = currentId === void 0 ? -1 : seq.indexOf(currentId);
+    if (exact >= 0) return exact;
+    let fallback = 0;
+    for (let i = 0; i < seq.length; i++) {
+      const idx = form.pages.findIndex((p) => p.id === seq[i]);
+      if (idx >= 0 && idx <= clamped) fallback = i;
+    }
+    return fallback;
+  }
   function next() {
     const pageCount = form.pages.length;
     const clamped = Math.min(pageIndex, Math.max(pageCount - 1, 0));
@@ -2298,14 +2801,31 @@ function createFormController(options2) {
         return;
       }
     }
-    pageIndex = Math.min(clamped + 1, pageCount - 1);
+    const current = form.pages[clamped];
+    const seq = reachablePageSequence(form, data);
+    const pos = currentSeqPosition(seq);
+    const terminal = (current ? isTerminalPage(form, current.id, data) : true) || pos < 0 || pos + 1 >= seq.length;
+    if (terminal) {
+      void submit();
+      return;
+    }
+    const nextIndex = form.pages.findIndex((p) => p.id === seq[pos + 1]);
+    pageIndex = nextIndex >= 0 ? nextIndex : Math.min(clamped + 1, pageCount - 1);
     if (sessionId && client) client.reportProgress(sessionId, { furthestPage: pageIndex });
     notify();
     checkpointDraft();
   }
   function back() {
     errors = {};
-    pageIndex = Math.max(Math.min(pageIndex, form.pages.length - 1) - 1, 0);
+    const seq = reachablePageSequence(form, data);
+    const pos = currentSeqPosition(seq);
+    if (pos > 0) {
+      const prevIndex = form.pages.findIndex((p) => p.id === seq[pos - 1]);
+      pageIndex = prevIndex >= 0 ? prevIndex : Math.max(Math.min(pageIndex, form.pages.length - 1) - 1, 0);
+    } else if (seq.length > 0) {
+      const firstIndex = form.pages.findIndex((p) => p.id === seq[0]);
+      pageIndex = firstIndex >= 0 ? firstIndex : 0;
+    }
     notify();
     checkpointDraft();
   }
@@ -2315,13 +2835,13 @@ function createFormController(options2) {
     if (!result.ok) {
       errors = result.errors;
       const firstBad = form.pages.findIndex(
-        (p) => visibleBlocks(p, data).some((b) => b.id in result.errors)
+        (p) => visiblePageBlocks(form, p, data).some((b) => b.id in result.errors)
       );
       if (firstBad >= 0) pageIndex = firstBad;
       notify();
       return;
     }
-    if (client && !formId && options2.resolveFormId) {
+    if (client && options2.resolveFormId) {
       status = "submitting";
       submitError = void 0;
       notify();
@@ -2329,7 +2849,7 @@ function createFormController(options2) {
         formId = await options2.resolveFormId();
       } catch (err) {
         status = "idle";
-        submitError = submitFailureMessage(err);
+        submitError = syncResolutionFailureMessage(err);
         notify();
         throw err;
       }
@@ -2338,6 +2858,13 @@ function createFormController(options2) {
       const visitorKey = form.settings.responseLimit?.by === "browser" ? ensureSubmissionKey(visitorSubmissionKeyId(form, formId, result.data)) : void 0;
       const submissionKey = visitorKey ?? idempotencyKey;
       const submitDraft = form.settings.saveProgress ? draftRef ?? readDraftRef(formId) : null;
+      const challengeToken = options2.challengeRequired ? options2.getChallengeToken?.() : void 0;
+      if (options2.challengeRequired && !challengeToken) {
+        status = "idle";
+        submitError = CHALLENGE_INCOMPLETE_MESSAGE;
+        notify();
+        return;
+      }
       status = "submitting";
       submitError = void 0;
       notify();
@@ -2349,20 +2876,33 @@ function createFormController(options2) {
           surface: options2.surface ?? "headless",
           submissionKey,
           draft: submitDraft ? { id: submitDraft.id, token: submitDraft.token } : void 0,
-          respondent
+          respondent,
+          challengeToken
         });
       } catch (err) {
         status = "idle";
+        if (isFilloError(err) && err.code === "challenge_failed") {
+          submitError = CHALLENGE_RETRY_MESSAGE;
+          options2.onChallengeFailed?.();
+          notify();
+          return;
+        }
         submitError = submitFailureMessage(err);
         notify();
         throw err;
       }
       if (!res.ok) {
         errors = res.errors ?? {};
+        const firstBad = form.pages.findIndex(
+          (p) => visiblePageBlocks(form, p, data).some((b) => b.id in errors)
+        );
+        if (firstBad >= 0) pageIndex = firstBad;
+        else submitError = "We couldn't submit \u2014 please review your answers.";
         status = "idle";
         notify();
         return;
       }
+      submissionKind = res.duplicate ? "duplicate" : res.updated ? "updated" : "created";
       if (sessionId) client.reportProgress(sessionId, { completed: true });
       if (visitorKey) markSubmitted(visitorSubmissionKeyId(form, formId, result.data), res.responseId);
       discardDraftState();
@@ -2449,14 +2989,13 @@ function isAutoSubmitBlock(block) {
   return isField(block) && (block.kind === "select" || block.kind === "dropdown" || block.kind === "checkbox" || block.kind === "rating" || block.kind === "linear_scale");
 }
 function needsExplicitSubmit(visible) {
-  const interactive = visible.filter((b) => !(isField(b) && b.kind === "hidden"));
-  if (interactive.length === 0) return false;
-  if (interactive.length > 1) return true;
+  const interactive = visible.filter((b) => isField(b) && b.kind !== "hidden");
+  if (interactive.length !== 1) return true;
   return !isAutoSubmitBlock(interactive[0]);
 }
 function shouldAutoSubmit(field2, value, ctx) {
   if (ctx.form.settings.submitMode !== "auto") return false;
-  if (!ctx.isLastPage || ctx.status !== "idle" || ctx.uploading) return false;
+  if (ctx.status !== "idle" || ctx.uploading) return false;
   const hasDiscreteAnswer = (() => {
     switch (field2.kind) {
       case "select":
@@ -2474,7 +3013,9 @@ function shouldAutoSubmit(field2, value, ctx) {
   if (!hasDiscreteAnswer) return false;
   if (value === ctx.data[field2.id]) return false;
   const nextData = { ...ctx.data, [field2.id]: value };
-  const interactive = visibleFields(ctx.form, nextData).filter((f) => f.kind !== "hidden");
+  const page = ctx.form.pages.find((p) => p.blocks.some((b) => b.id === field2.id));
+  if (!page || !isTerminalPage(ctx.form, page.id, nextData)) return false;
+  const interactive = reachableFields(ctx.form, nextData).filter((f) => f.kind !== "hidden");
   if (interactive.length !== 1 || interactive[0]?.id !== field2.id) return false;
   return validateResponse(ctx.form, nextData).ok;
 }
@@ -2500,7 +3041,8 @@ var FILLO_SLOTS = [
   "footer",
   "button",
   "success",
-  "resume"
+  "resume",
+  "turnstile"
 ];
 var FILLO_DATA_ATTRS = {
   /** Slot name, on every slot element: `data-fillo="control"`. */
@@ -2549,35 +3091,6 @@ var FILLO_THEME_VARS = [
   { var: "--fillo-primary-contrast" }
 ];
 
-// src/strings.ts
-var DEFAULT_STRINGS = {
-  back: "Back",
-  next: "Next",
-  submit: "Submit",
-  submitting: "Submitting\u2026",
-  uploading: "Uploading\u2026",
-  optional: " (optional)",
-  other: "Other",
-  otherPrompt: "Other \u2014 please specify",
-  otherPlaceholder: "Your answer",
-  choosePlaceholder: "Choose\u2026",
-  successTitle: "Thanks!",
-  successMessage: "Your response has been recorded.",
-  closed: "This form is no longer accepting responses.",
-  notLive: "This form isn't live yet.",
-  submitFailed: "This form can't submit right now. Please try again in a moment.",
-  loadFailedNotFound: "Form not found \u2014 check the form id and that it's published.",
-  loadFailedNetwork: "Couldn't reach the server \u2014 check your connection or CORS.",
-  loadFailed: "This form could not be loaded.",
-  renderFailed: "This form could not be rendered.",
-  resumeNotice: "Picked up where you left off.",
-  editNotice: "You're updating your earlier response.",
-  resumeStartOver: "Start over"
-};
-function resolveStrings(overrides) {
-  return overrides ? { ...DEFAULT_STRINGS, ...overrides } : DEFAULT_STRINGS;
-}
-
 // src/define.ts
 function defineForm(def) {
   return {
@@ -2598,15 +3111,18 @@ function isCodeForm(form) {
 }
 var syncCache = /* @__PURE__ */ new Map();
 var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function isRetryableSyncError(error) {
+  if (!isFilloError(error)) return true;
+  const status = error.status ?? 0;
+  return status === 0 || status === 408 || status === 429 || status >= 500;
+}
 async function syncWithRetry(client, form) {
   let delay = 800;
   for (let attempt = 0; ; attempt++) {
     try {
       return await client.syncForm(form.id, form.schema, form.theme ?? null);
     } catch (err) {
-      const status = isFilloError(err) ? err.status ?? 0 : 0;
-      const retryable = !isFilloError(err) || status === 0 || status === 408 || status === 429 || status >= 500;
-      if (!retryable || attempt >= 2) throw err;
+      if (!isRetryableSyncError(err) || attempt >= 2) throw err;
       const hinted = isFilloError(err) ? err.retryAfterSec : void 0;
       await sleep(Math.min(hinted ? hinted * 1e3 : delay * (1 + Math.random() * 0.5), 15e3));
       delay *= 2;
@@ -2618,17 +3134,32 @@ function contentHash(input) {
   for (let i = 0; i < input.length; i++) h = (h << 5) + h + input.charCodeAt(i) | 0;
   return (h >>> 0).toString(36);
 }
+function formSchemasEqual(left, right) {
+  const canonicalize = (value) => {
+    if (Array.isArray(value)) return value.map(canonicalize);
+    if (value && typeof value === "object") {
+      const record2 = value;
+      return Object.fromEntries(
+        Object.keys(record2).sort().map((key) => [key, canonicalize(record2[key])])
+      );
+    }
+    return value;
+  };
+  return JSON.stringify(canonicalize(left)) === JSON.stringify(canonicalize(right));
+}
+var syncTtlMs = (status) => status === "published" ? 36e5 : 6e4;
+var isVolatileSync = (result) => Boolean(result.staged || result.resolvedSchema || result.syncError);
 function storageKey(client, handle) {
-  return `fillo:sync:${client.baseUrl}|${client.key}|${handle}`;
+  return `fillo:sync:v3:${client.baseUrl}|${client.key}|${handle}`;
 }
 function readStoredSync(client, handle, hash) {
   try {
     const raw = globalThis.localStorage?.getItem(storageKey(client, handle));
     if (!raw) return null;
     const parsed = JSON.parse(raw);
-    if (typeof parsed.formId !== "string" || parsed.hash !== hash || typeof parsed.ts !== "number")
+    if (typeof parsed.formId !== "string" || typeof parsed.slug !== "string" || parsed.hash !== hash || typeof parsed.ts !== "number" || parsed.status !== void 0 && parsed.status !== "draft" && parsed.status !== "published")
       return null;
-    const ttl = parsed.status === "published" ? 36e5 : 6e4;
+    const ttl = syncTtlMs(parsed.status);
     if (Date.now() - parsed.ts > ttl) return null;
     return parsed;
   } catch {
@@ -2636,6 +3167,8 @@ function readStoredSync(client, handle, hash) {
   }
 }
 function writeStoredSync(client, handle, hash, r) {
+  if (r.staged || r.resolvedSchema || r.syncError) return;
+  if (r.challenge) return;
   try {
     globalThis.localStorage?.setItem(
       storageKey(client, handle),
@@ -2654,23 +3187,44 @@ function syncCodeForm(client, form, opts) {
   const content2 = JSON.stringify(form.schema) + JSON.stringify(form.theme ?? null);
   const hash = contentHash(content2);
   const key = `${client.baseUrl}:${client.key}:${form.id}:${hash}`;
-  let pending = syncCache.get(key);
-  if (pending && !opts?.bypassCache) return pending;
+  const cached = syncCache.get(key);
+  if (cached && !opts?.bypassCache) {
+    if (cached.expiresAt === null || cached.expiresAt > Date.now()) return cached.promise;
+    syncCache.delete(key);
+  }
   if (!opts?.bypassCache) {
     const stored = readStoredSync(client, form.id, hash);
     if (stored) {
-      pending = Promise.resolve({ formId: stored.formId, slug: stored.slug, status: stored.status });
-      syncCache.set(key, pending);
-      return pending;
+      const promise2 = Promise.resolve({
+        formId: stored.formId,
+        slug: stored.slug,
+        status: stored.status
+      });
+      syncCache.set(key, {
+        promise: promise2,
+        expiresAt: stored.ts + syncTtlMs(stored.status)
+      });
+      return promise2;
     }
   }
-  pending = syncWithRetry(client, form).then((r) => {
-    writeStoredSync(client, form.id, hash, r);
-    return r;
-  });
-  syncCache.set(key, pending);
-  pending.catch(() => syncCache.delete(key));
-  return pending;
+  const promise = syncWithRetry(client, form);
+  const entry = { promise, expiresAt: null };
+  syncCache.set(key, entry);
+  promise.then(
+    (result) => {
+      if (syncCache.get(key) !== entry) return;
+      if (isVolatileSync(result)) {
+        syncCache.delete(key);
+        return;
+      }
+      entry.expiresAt = Date.now() + syncTtlMs(result.status);
+      writeStoredSync(client, form.id, hash, result);
+    },
+    () => {
+      if (syncCache.get(key) === entry) syncCache.delete(key);
+    }
+  );
+  return promise;
 }
 
 // src/jsx.ts
@@ -2710,8 +3264,8 @@ var JSX_BLOCK_SPECS = [
   field("MultiSelect", "multi_select", CHOICE_EXTRA, { optionChildren: true }),
   field("Dropdown", "dropdown", CHOICE_EXTRA, { optionChildren: true }),
   field("Checkbox", "checkbox", ["appearance"]),
-  field("Rating", "rating", ["max"]),
-  field("Scale", "linear_scale", ["min", "max", "minLabel", "maxLabel"]),
+  field("Rating", "rating", ["max", "insightsMetric"]),
+  field("Scale", "linear_scale", ["min", "max", "minLabel", "maxLabel", "insightsMetric"]),
   field("Ranking", "ranking", ["options"], { optionChildren: true }),
   field("Matrix", "matrix", ["rows", "columns"]),
   field("Signature", "signature", []),
@@ -2876,6 +3430,18 @@ function buildOption(el, parent, parentId) {
   if (props.icon !== void 0) option.icon = props.icon;
   return option;
 }
+function assertUniqueOptionIds(blockId, options2, label) {
+  const optionIds = /* @__PURE__ */ new Set();
+  for (const option of options2) {
+    if (optionIds.has(option.id)) {
+      throw new FilloJsxError(
+        "DUPLICATE_ID",
+        `Two ${label} in "${blockId}" share the id "${option.id}" \u2014 option ids are stored answer values and must be unique within the field`
+      );
+    }
+    optionIds.add(option.id);
+  }
+}
 function schemaFromJsx(children, meta) {
   const elements = flatten(children);
   const pageSpecs = elements.map((el) => ({ el, spec: classify(el) }));
@@ -2916,7 +3482,15 @@ function schemaFromJsx(children, meta) {
     pages.push({ id: "main", blocks });
   }
   const seen = /* @__PURE__ */ new Set();
+  const pageIds = /* @__PURE__ */ new Set();
   for (const page of pages) {
+    if (pageIds.has(page.id)) {
+      throw new FilloJsxError(
+        "DUPLICATE_ID",
+        `Two pages share the id "${page.id}" \u2014 page ids must be unique within a form`
+      );
+    }
+    pageIds.add(page.id);
     for (const block of page.blocks) {
       if (seen.has(block.id)) {
         throw new FilloJsxError(
@@ -2925,6 +3499,11 @@ function schemaFromJsx(children, meta) {
         );
       }
       seen.add(block.id);
+      if ("options" in block) assertUniqueOptionIds(block.id, block.options, "options");
+      if (block.kind === "matrix") {
+        assertUniqueOptionIds(block.id, block.rows, "matrix rows");
+        assertUniqueOptionIds(block.id, block.columns, "matrix columns");
+      }
     }
   }
   return {
@@ -2999,9 +3578,12 @@ function pipeBlock(block, data, form) {
 export {
   BLOCK_KIND_META,
   CONTENT_KINDS,
+  DEFAULT_FIELD_STRINGS,
   DEFAULT_STRINGS,
   DRAFT_KINDS,
+  FILLO_CHALLENGE_MIN_SDK_VERSION,
   FILLO_DATA_ATTRS,
+  FILLO_MIN_SDK_VERSION,
   FILLO_SCHEMA_VERSION,
   FILLO_SDK_VERSION,
   FILLO_SLOTS,
@@ -3012,10 +3594,13 @@ export {
   JSX_BLOCK_COMPONENTS,
   JSX_BLOCK_SPECS,
   PHONE_COUNTRIES,
+  PHONE_POPOVER_VIEWPORT_GAP,
+  REQUIRED_FIELD_MESSAGE,
   Sha1,
   allFields,
   assembleForm,
   codeFormFromJsx,
+  conditionsMet,
   contentHash,
   countryByDialCode,
   countryByIso,
@@ -3028,6 +3613,7 @@ export {
   defineForm,
   digitsOnly,
   flagEmoji,
+  formSchemasEqual,
   formatAnswer,
   formatNational,
   isAutoSubmitBlock,
@@ -3036,14 +3622,21 @@ export {
   isField,
   isFilloError,
   isPossiblePhone,
+  isTerminalPage,
   needsExplicitSubmit,
   normalizeFormSchema,
   normalizeFormTheme,
   normalizeSettings,
   parsePhone,
   pipeBlock,
+  positionPhonePopover,
   prefillFromParams,
   provisionWorkspace,
+  reachableFieldIds,
+  reachableFields,
+  reachablePageIds,
+  reachablePageSequence,
+  resolveNextPage,
   resolveSlotClass,
   resolveStrings,
   resolveText,
@@ -3059,5 +3652,6 @@ export {
   validateResponse,
   visibleBlocks,
   visibleFields,
+  visiblePageBlocks,
   when
 };