@usefillo/core 0.6.2 → 0.8.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,9 +47,11 @@ 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 blockVisibleWith(block, resolve) {
@@ -74,9 +82,27 @@ 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));
 }
+function responseScopeValue(settings, data) {
+  const field2 = settings.responseLimit?.scopeField;
+  if (!field2) return null;
+  const value = data[field2];
+  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);
@@ -364,6 +390,75 @@ 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"
+};
+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({
@@ -383,7 +478,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":
@@ -396,11 +491,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:") {
@@ -435,9 +535,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";
       }
@@ -529,6 +633,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;
@@ -594,7 +699,8 @@ var schemaShape = z2.object({
 });
 var MAX_SCHEMA_VERSION = 1;
 var FILLO_SCHEMA_VERSION = 1;
-var FILLO_SDK_VERSION = true ? "0.6.2" : "0.0.0-dev";
+var FILLO_SDK_VERSION = true ? "0.8.0" : "0.0.0-dev";
+var FILLO_MIN_SDK_VERSION = "0.4.0";
 function str(value, max, fallback = "") {
   return typeof value === "string" ? value.trim().slice(0, max) : fallback;
 }
@@ -624,6 +730,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) => {
@@ -668,10 +782,25 @@ function normalizeUrl(value) {
     return void 0;
   }
 }
+function normalizeResponseLimit(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const rec = value;
+  const by = rec.by === "browser" || rec.by === "field" || rec.by === "identify" ? rec.by : void 0;
+  if (!by) return void 0;
+  const field2 = by === "field" ? optionalStr(rec.field, 128) : void 0;
+  if (by === "field" && !field2) return void 0;
+  const scopeField = optionalStr(rec.scopeField, 128);
+  const onRepeat = rec.onRepeat === "update" && by === "identify" ? "update" : "keep";
+  return {
+    by,
+    ...field2 ? { field: field2 } : {},
+    ...scopeField ? { scopeField } : {},
+    onRepeat
+  };
+}
 function normalizeSettings(value) {
   const rec = value && typeof value === "object" ? value : {};
   const submitMode = rec.submitMode === "button" || rec.submitMode === "auto" ? rec.submitMode : void 0;
-  const submissionLimit = rec.submissionLimit === "once_per_visitor" || rec.submissionLimit === "multiple" ? rec.submissionLimit : void 0;
   return {
     submitMode,
     submitLabel: optionalStr(rec.submitLabel, 100),
@@ -679,9 +808,14 @@ function normalizeSettings(value) {
     successMessage: optionalStr(rec.successMessage, 5e3),
     redirectUrl: normalizeUrl(rec.redirectUrl),
     showProgress: bool(rec.showProgress),
-    submissionLimit,
+    responseLimit: normalizeResponseLimit(rec.responseLimit),
     notifyEmail: z2.email().check(z2.maxLength(254)).safeParse(rec.notifyEmail).success ? rec.notifyEmail : void 0,
-    sendReceipt: bool(rec.sendReceipt)
+    sendReceipt: bool(rec.sendReceipt),
+    saveProgress: bool(rec.saveProgress),
+    draftAnswersVisible: bool(rec.draftAnswersVisible),
+    resumeEmails: bool(rec.resumeEmails),
+    resumeUrl: normalizeUrl(rec.resumeUrl),
+    draftDigest: bool(rec.draftDigest)
   };
 }
 function cleanObject(obj) {
@@ -743,17 +877,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": {
@@ -812,16 +954,41 @@ function normalizeFormSchema(input) {
       return block ? [block] : [];
     });
     return cleanObject({
-      id: page.id,
+      id: str(page.id, 128),
       title: optionalStr(page.title, 500),
       blocks
     });
   });
+  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)) {
@@ -923,6 +1090,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)");
@@ -952,12 +1122,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" },
@@ -992,10 +1162,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 {
@@ -1049,8 +1220,7 @@ function createEmptyForm(title = "Untitled form") {
       submitLabel: "Submit",
       successTitle: "Thanks!",
       successMessage: "Your response has been recorded.",
-      showProgress: true,
-      submissionLimit: "multiple"
+      showProgress: true
     }
   };
 }
@@ -1112,12 +1282,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;
@@ -1255,25 +1434,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"));
@@ -1281,11 +1465,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;
 }
@@ -1356,8 +1560,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();
   }
@@ -1368,8 +1572,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) {
@@ -1409,11 +1615,34 @@ 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 };
+    return { ok: true, responseId: body.id, duplicate: body.duplicate, updated: body.updated };
+  }
+  /**
+   * The identified person's own living response on an upsert-mode form —
+   * 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, scopeValue) {
+    try {
+      return await this.json(
+        `/forms/${encodeURIComponent(formId)}/respondent-response`,
+        { method: "POST", body: JSON.stringify({ respondent, scopeValue }) }
+      );
+    } catch (err) {
+      if (isFilloError(err) && (err.status === 404 || err.status === 403)) return null;
+      throw err;
+    }
   }
   /**
    * Open a respondent session for funnel analysis. Fire-and-forget: returns the
@@ -1448,19 +1677,60 @@ var FilloClient = class {
     } catch {
     }
   }
+  /**
+   * Create a saved-progress draft (forms with settings.saveProgress). Returns
+   * the draft id and its ownership token — the token is shown only once.
+   */
+  createDraft(formId, body) {
+    return this.json(`/forms/${encodeURIComponent(formId)}/drafts`, {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  /** Fetch a draft to restore. 404s once expired, consumed, or deleted. When
+   *  `adopt` is set (resume-link adoption), the server rotates the bearer and
+   *  returns the new `token` — the URL token becomes single-use. */
+  getDraft(draftId, token, adopt) {
+    return this.json(`/drafts/${encodeURIComponent(draftId)}`, {
+      headers: adopt ? { "X-Fillo-Draft-Token": token, "X-Fillo-Draft-Adopt": "1" } : { "X-Fillo-Draft-Token": token }
+    });
+  }
+  /**
+   * Overwrite a draft's answers/page and slide its expiry. `keepalive` lets a
+   * tab-close flush outlive the page; browsers reject keepalive bodies over
+   * ~64KB, in which case this save is simply lost — the debounced autosaves
+   * every few keystrokes are the real persistence, the flush is a bonus.
+   */
+  async saveDraft(draftId, token, body, opts) {
+    await this.json(`/drafts/${encodeURIComponent(draftId)}`, {
+      method: "PATCH",
+      headers: { "X-Fillo-Draft-Token": token },
+      body: JSON.stringify(body),
+      ...opts?.keepalive ? { keepalive: true } : {}
+    });
+  }
+  /** Discard a draft (the "Start over" path). */
+  async deleteDraft(draftId, token) {
+    await this.json(`/drafts/${encodeURIComponent(draftId)}`, {
+      method: "DELETE",
+      headers: { "X-Fillo-Draft-Token": token }
+    });
+  }
   /** 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
@@ -1468,28 +1738,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") {
@@ -1497,14 +1807,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;
   }
@@ -1613,10 +1961,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. */
@@ -1665,7 +2013,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) {
@@ -1678,7 +2032,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);
@@ -1695,6 +2053,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.
@@ -1785,7 +2217,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;
       }
@@ -1842,25 +2274,36 @@ function randomSubmissionKey() {
   }
   return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
 }
-function readStoredSubmission(formId) {
+function readStoredJson(memory, storageKey2, memoryKey, isValid) {
   const store = browserStorage();
-  if (!store) return memorySubmissionKeys.get(formId) ?? null;
+  if (!store) return memory.get(memoryKey) ?? null;
   try {
-    const parsed = JSON.parse(store.getItem(submissionStorageKey(formId)) ?? "null");
-    if (parsed && typeof parsed.key === "string") return parsed;
+    const parsed = JSON.parse(store.getItem(storageKey2) ?? "null");
+    if (parsed && isValid(parsed)) return parsed;
   } catch {
   }
   return null;
 }
-function writeStoredSubmission(formId, value) {
-  memorySubmissionKeys.set(formId, value);
+function writeStoredJson(memory, storageKey2, memoryKey, value) {
+  memory.set(memoryKey, value);
   const store = browserStorage();
   if (!store) return;
   try {
-    store.setItem(submissionStorageKey(formId), JSON.stringify(value));
+    store.setItem(storageKey2, JSON.stringify(value));
   } catch {
   }
 }
+function readStoredSubmission(formId) {
+  return readStoredJson(
+    memorySubmissionKeys,
+    submissionStorageKey(formId),
+    formId,
+    (p) => typeof p.key === "string"
+  );
+}
+function writeStoredSubmission(formId, value) {
+  writeStoredJson(memorySubmissionKeys, submissionStorageKey(formId), formId, value);
+}
 function ensureSubmissionKey(formId) {
   const existing = readStoredSubmission(formId);
   if (existing?.key) return existing.key;
@@ -1876,14 +2319,52 @@ function markSubmitted(formId, responseId) {
     responseId
   });
 }
-function hasSubmittedOnce(form, formId) {
-  if (form.settings.submissionLimit !== "once_per_visitor" || !formId) return false;
-  return Boolean(readStoredSubmission(formId)?.submittedAt);
+function visitorSubmissionKeyId(form, formId, data) {
+  const scope = responseScopeValue(form.settings, data);
+  return scope === null ? formId : `${formId}::${scope}`;
+}
+function hasSubmittedOnce(form, formId, data) {
+  if (form.settings.responseLimit?.by !== "browser" || !formId) return false;
+  return Boolean(readStoredSubmission(visitorSubmissionKeyId(form, formId, data))?.submittedAt);
+}
+var memoryDraftRefs = /* @__PURE__ */ new Map();
+function draftStorageKey(formId) {
+  return `fillo:draft:${formId}`;
+}
+function readDraftRef(formId) {
+  return readStoredJson(memoryDraftRefs, draftStorageKey(formId), formId, (p) => {
+    const ref = p;
+    return typeof ref.id === "string" && typeof ref.token === "string";
+  });
+}
+function writeDraftRef(formId, ref) {
+  writeStoredJson(memoryDraftRefs, draftStorageKey(formId), formId, ref);
+}
+function clearDraftRef(formId) {
+  memoryDraftRefs.delete(formId);
+  const store = browserStorage();
+  if (!store) return;
+  try {
+    store.removeItem(draftStorageKey(formId));
+  } catch {
+  }
+}
+function isDraftGone(err) {
+  return isFilloError(err) && (err.status === 401 || err.status === 403 || err.status === 404);
 }
+var DRAFT_DEBOUNCE_MS = 1500;
 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);
@@ -1891,15 +2372,14 @@ function createFormController(options2) {
   let form = initial.schema;
   let formId = options2.formId;
   let client = options2.client;
+  let respondent = options2.respondent;
   let data = { ...options2.initialData ?? {} };
   let errors = {};
   let pageIndex = 0;
   let status = "idle";
+  let restoredSubmission = false;
+  let resumeLinkFailed = false;
   queueMicrotask(() => {
-    if (status === "idle" && hasSubmittedOnce(form, formId)) {
-      status = "submitted";
-      notify();
-    }
     if (typeof location !== "undefined" && location.search) {
       const params = Object.fromEntries(new URLSearchParams(location.search));
       let merged = null;
@@ -1914,6 +2394,35 @@ function createFormController(options2) {
         notify();
       }
     }
+    if (status === "idle" && hasSubmittedOnce(form, formId, data)) {
+      status = "submitted";
+      restoredSubmission = true;
+      notify();
+    }
+    let adopting = false;
+    if (form.settings.saveProgress && formId && client && typeof location !== "undefined" && location.hash.includes("fillo-draft=")) {
+      const match = /fillo-draft=([^&]+)/.exec(location.hash);
+      const raw = match?.[1] ? decodeURIComponent(match[1]) : "";
+      const dot = raw.indexOf(".");
+      if (dot > 0) {
+        adopting = true;
+        const did = raw.slice(0, dot);
+        const dtok = raw.slice(dot + 1);
+        client.getDraft(did, dtok, true).then((d) => {
+          writeDraftRef(formId, { id: did, token: d.token ?? dtok });
+          try {
+            history.replaceState(null, "", location.pathname + location.search);
+          } catch {
+          }
+        }).catch((err) => {
+          if (isDraftGone(err)) {
+            resumeLinkFailed = true;
+            notify();
+          }
+        }).finally(() => maybeRestoreDraft());
+      }
+    }
+    if (!adopting) maybeRestoreDraft();
   });
   let submitError;
   const uploadingFields = /* @__PURE__ */ new Set();
@@ -1922,6 +2431,17 @@ function createFormController(options2) {
   const idempotencyKey = randomSubmissionKey();
   let sessionId = null;
   let sessionStarted = false;
+  let resumedDraft = false;
+  let editingPrevious = false;
+  let submissionKind = "created";
+  let editAttempted = false;
+  let draftRef = null;
+  let draftTimer = null;
+  let draftChain = Promise.resolve();
+  let draftDirty = false;
+  let draftDisabled = false;
+  let draftRestoreAttempted = false;
+  let draftAffinityAttempted = false;
   function computeSnapshot() {
     const pageCount = form.pages.length;
     const clamped = Math.min(pageIndex, Math.max(pageCount - 1, 0));
@@ -1933,11 +2453,20 @@ 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,
       uploading: uploadingFields.size > 0,
-      submitError
+      submitError,
+      restoredSubmission,
+      resumedDraft,
+      editingPrevious,
+      duplicateSubmission: submissionKind === "duplicate",
+      updatedSubmission: submissionKind === "updated",
+      resumeLinkFailed
     };
   }
   let snapshot = computeSnapshot();
@@ -1956,13 +2485,161 @@ 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;
     }
     return pageErrors;
   }
+  function draftsEnabled() {
+    return Boolean(form.settings.saveProgress && client && formId && !draftDisabled);
+  }
+  function knownFieldIds() {
+    const ids = /* @__PURE__ */ new Set();
+    for (const page of form.pages) {
+      for (const block of page.blocks) if (isField(block)) ids.add(block.id);
+    }
+    return ids;
+  }
+  function applyDraftSnapshot(draft) {
+    if (status !== "idle" || sessionStarted) return;
+    const ids = knownFieldIds();
+    let merged = null;
+    for (const [key, value] of Object.entries(draft.data ?? {})) {
+      if (data[key] === void 0 && ids.has(key)) {
+        merged = merged ?? { ...data };
+        merged[key] = value;
+      }
+    }
+    const target = typeof draft.page === "number" && Number.isFinite(draft.page) ? Math.max(0, Math.min(Math.floor(draft.page), form.pages.length - 1)) : 0;
+    const movePage = target > 0 && pageIndex === 0;
+    if (!merged && !movePage) return;
+    if (merged) data = merged;
+    if (movePage) pageIndex = target;
+    resumedDraft = true;
+    notify();
+  }
+  function maybeRestoreDraft() {
+    if (status !== "idle") return;
+    if (!draftsEnabled()) {
+      maybePrefillOwnResponse();
+      return;
+    }
+    const fid = formId;
+    const c = client;
+    const ref = draftRef ?? readDraftRef(fid);
+    if (ref && !draftRestoreAttempted) {
+      draftRestoreAttempted = true;
+      draftRef = ref;
+      void c.getDraft(ref.id, ref.token).then(applyDraftSnapshot).catch((err) => {
+        if (isDraftGone(err)) {
+          clearDraftRef(fid);
+          draftRef = null;
+        }
+      });
+      return;
+    }
+    if (!ref && !draftAffinityAttempted && respondent?.hash) {
+      draftAffinityAttempted = true;
+      void c.createDraft(fid, { data: {}, page: 0, respondent }).then((created) => {
+        if (draftRef) return;
+        draftRef = { id: created.id, token: created.token };
+        writeDraftRef(fid, draftRef);
+        if (created.existing) {
+          return c.getDraft(created.id, created.token).then(applyDraftSnapshot);
+        }
+        maybePrefillOwnResponse();
+      }).catch((err) => {
+        if (!(isFilloError(err) && err.status !== void 0 && err.status >= 400 && err.status < 500)) {
+          draftAffinityAttempted = false;
+        }
+      });
+    }
+  }
+  function maybePrefillOwnResponse() {
+    if (editAttempted || form.settings.responseLimit?.onRepeat !== "update") return;
+    if (!client || !formId || !respondent?.hash || status !== "idle") return;
+    editAttempted = true;
+    const c = client;
+    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) {
+        resumedDraft = false;
+        editingPrevious = true;
+        notify();
+      }
+    }).catch(() => {
+    });
+  }
+  function persistDraft(keepalive = false) {
+    if (draftTimer) {
+      clearTimeout(draftTimer);
+      draftTimer = null;
+    }
+    if (!draftsEnabled() || status !== "idle" || !draftDirty) return;
+    const fid = formId;
+    const c = client;
+    draftDirty = false;
+    draftChain = draftChain.then(async () => {
+      const payload = {
+        data,
+        page: Math.max(0, Math.min(pageIndex, form.pages.length - 1))
+      };
+      const ref = draftRef ?? readDraftRef(fid);
+      try {
+        if (ref) {
+          try {
+            await c.saveDraft(ref.id, ref.token, payload, keepalive ? { keepalive: true } : void 0);
+            draftRef = ref;
+            return;
+          } catch (err) {
+            if (!isDraftGone(err)) throw err;
+            clearDraftRef(fid);
+            draftRef = null;
+          }
+        }
+        const created = await c.createDraft(
+          fid,
+          respondent?.hash ? { ...payload, respondent } : payload
+        );
+        draftRef = { id: created.id, token: created.token };
+        writeDraftRef(fid, draftRef);
+        if (created.existing) draftDirty = true;
+      } catch (err) {
+        if (isFilloError(err) && err.status !== void 0 && err.status >= 400 && err.status < 500 && err.status !== 429) {
+          draftDisabled = true;
+        } else {
+          draftDirty = true;
+        }
+      }
+    });
+  }
+  function scheduleDraftSave() {
+    if (!draftsEnabled() || status !== "idle") return;
+    draftDirty = true;
+    if (draftTimer) clearTimeout(draftTimer);
+    draftTimer = setTimeout(() => {
+      draftTimer = null;
+      persistDraft();
+    }, DRAFT_DEBOUNCE_MS);
+  }
+  function checkpointDraft() {
+    if (!draftsEnabled() || !sessionStarted && !draftRef) return;
+    draftDirty = true;
+    persistDraft();
+  }
+  function discardDraftState() {
+    if (draftTimer) {
+      clearTimeout(draftTimer);
+      draftTimer = null;
+    }
+    draftDirty = false;
+    if (formId) clearDraftRef(formId);
+    draftRef = null;
+  }
   function setValue(fieldId, value) {
     if (!sessionStarted && client && formId) {
       sessionStarted = true;
@@ -1975,6 +2652,7 @@ function createFormController(options2) {
       errors = Object.fromEntries(Object.entries(errors).filter(([k]) => k !== fieldId));
     }
     notify();
+    scheduleDraftSave();
   }
   function setUploading(fieldId, busy) {
     if (busy) uploadingFields.add(fieldId);
@@ -1995,11 +2673,13 @@ function createFormController(options2) {
     pageIndex = 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);
     notify();
+    checkpointDraft();
   }
   async function submit() {
     if (status === "submitting" || status === "submitted") return;
@@ -2007,13 +2687,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();
@@ -2021,14 +2701,15 @@ function createFormController(options2) {
         formId = await options2.resolveFormId();
       } catch (err) {
         status = "idle";
-        submitError = submitFailureMessage(err);
+        submitError = syncResolutionFailureMessage(err);
         notify();
         throw err;
       }
     }
     if (client && formId) {
-      const visitorKey = form.settings.submissionLimit === "once_per_visitor" ? ensureSubmissionKey(formId) : void 0;
+      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;
       status = "submitting";
       submitError = void 0;
       notify();
@@ -2038,7 +2719,9 @@ function createFormController(options2) {
           hp: options2.getHoneypot?.() ?? "",
           elapsedMs: Date.now() - mountedAt,
           surface: options2.surface ?? "headless",
-          submissionKey
+          submissionKey,
+          draft: submitDraft ? { id: submitDraft.id, token: submitDraft.token } : void 0,
+          respondent
         });
       } catch (err) {
         status = "idle";
@@ -2048,12 +2731,19 @@ function createFormController(options2) {
       }
       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(formId, res.responseId);
+      if (visitorKey) markSubmitted(visitorSubmissionKeyId(form, formId, result.data), res.responseId);
+      discardDraftState();
       status = "submitted";
       notify();
       emitSubmitted(res.responseId, result.data);
@@ -2086,15 +2776,47 @@ function createFormController(options2) {
     setContext(ctx) {
       if ("formId" in ctx) formId = ctx.formId;
       if ("client" in ctx) client = ctx.client;
+      if ("respondent" in ctx) respondent = ctx.respondent;
       if (ctx.form && ctx.form !== form) {
         const next2 = normalizeFormSchema(ctx.form);
         if (!next2.ok) throw new Error(`Invalid form schema: ${next2.error}`);
         form = next2.schema;
       }
-      if (status === "idle" && hasSubmittedOnce(form, formId)) status = "submitted";
+      if (status === "idle" && hasSubmittedOnce(form, formId, data)) {
+        status = "submitted";
+        restoredSubmission = true;
+      }
+      maybeRestoreDraft();
+      notify();
+    },
+    flushDraft() {
+      persistDraft(true);
+    },
+    resetDraft() {
+      if (status === "submitting") return;
+      const ref = draftRef ?? (formId ? readDraftRef(formId) : null);
+      discardDraftState();
+      if (ref && client) void client.deleteDraft(ref.id, ref.token).catch(() => {
+      });
+      data = { ...options2.initialData ?? {} };
+      if (typeof location !== "undefined" && location.search) {
+        const params = Object.fromEntries(new URLSearchParams(location.search));
+        for (const [key, value] of Object.entries(prefillFromParams(form, params))) {
+          if (data[key] === void 0) data[key] = value;
+        }
+      }
+      errors = {};
+      pageIndex = 0;
+      submitError = void 0;
+      resumedDraft = false;
+      editingPrevious = false;
       notify();
     },
     destroy() {
+      if (draftTimer) {
+        clearTimeout(draftTimer);
+        draftTimer = null;
+      }
       listeners.clear();
     }
   };
@@ -2105,9 +2827,8 @@ 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) {
@@ -2155,7 +2876,8 @@ var FILLO_SLOTS = [
   "error",
   "footer",
   "button",
-  "success"
+  "success",
+  "resume"
 ];
 var FILLO_DATA_ATTRS = {
   /** Slot name, on every slot element: `data-fillo="control"`. */
@@ -2204,32 +2926,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."
-};
-function resolveStrings(overrides) {
-  return overrides ? { ...DEFAULT_STRINGS, ...overrides } : DEFAULT_STRINGS;
-}
-
 // src/define.ts
 function defineForm(def) {
   return {
@@ -2250,15 +2946,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;
@@ -2270,17 +2969,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:v2:${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 {
@@ -2288,6 +3002,7 @@ function readStoredSync(client, handle, hash) {
   }
 }
 function writeStoredSync(client, handle, hash, r) {
+  if (r.staged || r.resolvedSchema || r.syncError) return;
   try {
     globalThis.localStorage?.setItem(
       storageKey(client, handle),
@@ -2306,23 +3021,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
@@ -2362,8 +3098,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", []),
@@ -2528,6 +3264,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) }));
@@ -2568,7 +3316,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(
@@ -2577,6 +3333,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 {
@@ -2651,9 +3412,11 @@ function pipeBlock(block, data, form) {
 export {
   BLOCK_KIND_META,
   CONTENT_KINDS,
+  DEFAULT_FIELD_STRINGS,
   DEFAULT_STRINGS,
   DRAFT_KINDS,
   FILLO_DATA_ATTRS,
+  FILLO_MIN_SDK_VERSION,
   FILLO_SCHEMA_VERSION,
   FILLO_SDK_VERSION,
   FILLO_SLOTS,
@@ -2664,6 +3427,8 @@ export {
   JSX_BLOCK_COMPONENTS,
   JSX_BLOCK_SPECS,
   PHONE_COUNTRIES,
+  PHONE_POPOVER_VIEWPORT_GAP,
+  REQUIRED_FIELD_MESSAGE,
   Sha1,
   allFields,
   assembleForm,
@@ -2680,6 +3445,7 @@ export {
   defineForm,
   digitsOnly,
   flagEmoji,
+  formSchemasEqual,
   formatAnswer,
   formatNational,
   isAutoSubmitBlock,
@@ -2691,13 +3457,16 @@ export {
   needsExplicitSubmit,
   normalizeFormSchema,
   normalizeFormTheme,
+  normalizeSettings,
   parsePhone,
   pipeBlock,
+  positionPhonePopover,
   prefillFromParams,
   provisionWorkspace,
   resolveSlotClass,
   resolveStrings,
   resolveText,
+  responseScopeValue,
   schemaFromJsx,
   sha1Base64,
   shouldAutoSubmit,
@@ -2709,5 +3478,6 @@ export {
   validateResponse,
   visibleBlocks,
   visibleFields,
+  visiblePageBlocks,
   when
 };