@usefillo/core 0.10.0 → 0.12.0

package/dist/index.js

@@ -4,6 +4,117 @@ function isField(block) {
   return !CONTENT_KINDS.includes(block.kind);
 }
 
+// src/canonical.ts
+function isEmpty(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string") return value.trim() === "";
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "boolean") return value === false;
+  if (typeof value === "object") return Object.keys(value).length === 0;
+  return false;
+}
+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;
+  }
+  if ((field2.kind === "rating" || field2.kind === "linear_scale") && typeof value === "string") {
+    const n = Number(value);
+    return Number.isNaN(n) ? value : n;
+  }
+  if (typeof value === "string") return value.trim();
+  return value;
+}
+function canonicalValue(field2, value) {
+  const normalized = normalizeValue(field2, value);
+  return isEmpty(normalized) ? void 0 : normalized;
+}
+
+// src/calc.ts
+function clampDecimals(decimals) {
+  if (decimals === void 0 || !Number.isFinite(decimals)) return 0;
+  return Math.max(0, Math.min(6, Math.round(decimals)));
+}
+function roundHalfAwayFromZero(value, decimals) {
+  const factor = 10 ** decimals;
+  const rounded = Math.round(Math.abs(value) * factor) / factor;
+  return value < 0 ? -rounded : rounded;
+}
+function finiteOrNull(value) {
+  return Number.isFinite(value) ? value : null;
+}
+function evaluateCalc(expr, resolve) {
+  switch (expr.op) {
+    case "value":
+      return conditionNumber(resolve(expr.fieldId));
+    case "const":
+      return finiteOrNull(expr.value);
+    case "add":
+    case "mul":
+    case "min":
+    case "max": {
+      if (expr.args.length === 0) return null;
+      const values = [];
+      for (const arg of expr.args) {
+        const value = evaluateCalc(arg, resolve);
+        if (value === null) return null;
+        values.push(value);
+      }
+      if (expr.op === "add") return finiteOrNull(values.reduce((a, b) => a + b, 0));
+      if (expr.op === "mul") return finiteOrNull(values.reduce((a, b) => a * b, 1));
+      return expr.op === "min" ? Math.min(...values) : Math.max(...values);
+    }
+    case "sub":
+    case "div": {
+      const left = evaluateCalc(expr.left, resolve);
+      if (left === null) return null;
+      const right = evaluateCalc(expr.right, resolve);
+      if (right === null) return null;
+      if (expr.op === "sub") return finiteOrNull(left - right);
+      return right === 0 ? null : finiteOrNull(left / right);
+    }
+    case "round": {
+      const value = evaluateCalc(expr.arg, resolve);
+      return value === null ? null : finiteOrNull(roundHalfAwayFromZero(value, clampDecimals(expr.decimals)));
+    }
+    case "if":
+      return evaluateCalc(conditionsMet(expr.when, resolve) ? expr.then : expr.else, resolve);
+  }
+}
+function evaluateCalculatedField(field2, resolve) {
+  const value = evaluateCalc(field2.calc, resolve);
+  if (value === null || field2.decimals === void 0) return value;
+  return finiteOrNull(roundHalfAwayFromZero(value, clampDecimals(field2.decimals)));
+}
+function computeCalculated(form, data) {
+  const fields = allFields(form);
+  if (!fields.some((field2) => field2.kind === "calculated")) return data;
+  let view = data;
+  let reachable = reachableFieldIds(form, view);
+  for (let i = 0; i <= fields.length; i++) {
+    const next = {};
+    let pruned = false;
+    for (const [key, value] of Object.entries(view)) {
+      if (reachable.has(key)) next[key] = value;
+      else pruned = true;
+    }
+    if (!pruned) break;
+    view = next;
+    reachable = reachableFieldIds(form, view);
+  }
+  const state = resolveLogicState(fields, view);
+  const out = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (!state.calcIds.has(key)) out[key] = value;
+  }
+  for (const [key, value] of Object.entries(state.calc)) {
+    if (reachable.has(key)) out[key] = value;
+  }
+  return out;
+}
+
 // src/logic.ts
 function isAnswered(value) {
   if (value === null || value === void 0) return false;
@@ -62,37 +173,71 @@ function blockVisibleWith(block, resolve) {
   if (!block.visibleIf || block.visibleIf.length === 0) return true;
   return conditionsMet(block.visibleIf, resolve);
 }
-function makeResolver(data, scoped, visible) {
-  return (fieldId) => scoped.has(fieldId) && !visible.has(fieldId) ? void 0 : data[fieldId];
+function makeResolver(canonical, raw, scoped, visible, calcIds, calc) {
+  return (fieldId) => {
+    if (scoped.has(fieldId)) {
+      if (!visible.has(fieldId)) return void 0;
+      return calcIds.has(fieldId) ? calc[fieldId] : canonical[fieldId];
+    }
+    return raw[fieldId];
+  };
 }
-function visibleFieldIds(fields, data) {
+function resolveLogicState(fields, data) {
   const scoped = new Set(fields.map((f) => f.id));
+  const calcFields = fields.filter((f) => f.kind === "calculated");
+  const calcIds = new Set(calcFields.map((f) => f.id));
+  const canonical = {};
+  for (const f of fields) {
+    if (f.kind === "calculated") continue;
+    const value = canonicalValue(f, data[f.id]);
+    if (value !== void 0) canonical[f.id] = value;
+  }
   let visible = scoped;
+  let calc = {};
   for (let i = 0; i <= fields.length; i++) {
-    const resolve = makeResolver(data, scoped, visible);
-    const next = /* @__PURE__ */ new Set();
-    for (const f of fields) if (blockVisibleWith(f, resolve)) next.add(f.id);
-    if (next.size === visible.size && [...next].every((id) => visible.has(id))) return next;
-    visible = next;
+    let nextCalc = calc;
+    if (calcFields.length > 0) {
+      nextCalc = { ...calc };
+      const resolveCalc = makeResolver(canonical, data, scoped, visible, calcIds, nextCalc);
+      for (const field2 of calcFields) {
+        const value = visible.has(field2.id) ? evaluateCalculatedField(field2, resolveCalc) : null;
+        if (value === null) delete nextCalc[field2.id];
+        else nextCalc[field2.id] = value;
+      }
+    }
+    const resolve = makeResolver(canonical, data, scoped, visible, calcIds, nextCalc);
+    const nextVisible = /* @__PURE__ */ new Set();
+    for (const f of fields) if (blockVisibleWith(f, resolve)) nextVisible.add(f.id);
+    const stable = nextVisible.size === visible.size && [...nextVisible].every((id) => visible.has(id)) && calcEquals(calc, nextCalc);
+    visible = nextVisible;
+    calc = nextCalc;
+    if (stable) break;
   }
-  return visible;
+  return {
+    visible,
+    calc,
+    calcIds,
+    resolve: makeResolver(canonical, data, scoped, visible, calcIds, calc)
+  };
+}
+function calcEquals(a, b) {
+  const aKeys = Object.keys(a);
+  return aKeys.length === Object.keys(b).length && aKeys.every((key) => a[key] === b[key]);
+}
+function visibleFieldIds(fields, data) {
+  return resolveLogicState(fields, data).visible;
 }
 function isBlockVisible(block, data) {
   return blockVisibleWith(block, (fieldId) => data[fieldId]);
 }
 function visibleBlocks(page, data) {
-  const fields = page.blocks.filter(isField);
-  const scoped = new Set(fields.map((f) => f.id));
-  const resolve = makeResolver(data, scoped, visibleFieldIds(fields, data));
-  return page.blocks.filter((b) => blockVisibleWith(b, resolve));
+  const state = resolveLogicState(page.blocks.filter(isField), data);
+  return page.blocks.filter((b) => blockVisibleWith(b, state.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);
+  const state = resolveLogicState(allFields(form), data);
   return page.blocks.filter(
-    (b) => isField(b) ? formVisible.has(b.id) : blockVisibleWith(b, resolve)
+    (b) => isField(b) ? state.visible.has(b.id) : blockVisibleWith(b, state.resolve)
   );
 }
 function allFields(form) {
@@ -113,9 +258,7 @@ function visibleFields(form, 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));
+  return resolveLogicState(allFields(form), data).resolve;
 }
 function resolveNextPage(form, currentPageId, data) {
   const page = form.pages.find((p) => p.id === currentPageId);
@@ -181,79 +324,122 @@ function reachableFields(form, data) {
 import * as z from "zod/mini";
 
 // src/phone.ts
-var C = (iso2, name, dialCode, lengths = [], groups = [], example = "") => ({ iso2, name, dialCode, lengths, groups, example });
+var regionNames;
+function regionDisplayNames() {
+  if (regionNames !== void 0) return regionNames ?? void 0;
+  if (typeof Intl === "undefined" || typeof Intl.DisplayNames === "undefined") {
+    regionNames = null;
+    return void 0;
+  }
+  try {
+    regionNames = new Intl.DisplayNames(void 0, { type: "region" });
+  } catch {
+    regionNames = null;
+  }
+  return regionNames ?? void 0;
+}
+function regionName(iso2) {
+  try {
+    return regionDisplayNames()?.of(iso2) ?? iso2;
+  } catch {
+    return iso2;
+  }
+}
+var C = (iso2, dialCode, lengths = [], groups = [], example = "") => ({ iso2, name: regionName(iso2), dialCode, lengths, groups, example });
+var CURATED_COUNTRIES = [
+  C("US", "1", [10], [3, 3, 4], "2015550123"),
+  C("CA", "1", [10], [3, 3, 4], "5145550123"),
+  C("GB", "44", [10], [4, 6], "7400123456"),
+  C("AU", "61", [9], [3, 3, 3], "412345678"),
+  C("DE", "49", [10, 11], [4, 7], "15123456789"),
+  C("FR", "33", [9], [1, 2, 2, 2, 2], "612345678"),
+  C("IN", "91", [10], [5, 5], "8123456789"),
+  C("DK", "45", [8], [2, 2, 2, 2], "32123456"),
+  C("SE", "46", [9], [2, 3, 4], "701234567"),
+  C("NO", "47", [8], [3, 2, 3], "40612345"),
+  C("FI", "358", [9, 10], [2, 3, 4], "412345678"),
+  C("NL", "31", [9], [1, 4, 4], "612345678"),
+  C("BE", "32", [9], [3, 2, 2, 2], "470123456"),
+  C("ES", "34", [9], [3, 3, 3], "612345678"),
+  C("IT", "39", [9, 10], [3, 3, 4], "3123456789"),
+  C("PT", "351", [9], [3, 3, 3], "912345678"),
+  C("IE", "353", [9], [2, 3, 4], "851234567"),
+  C("CH", "41", [9], [2, 3, 2, 2], "781234567"),
+  C("AT", "43", [10, 11], [3, 7], "6641234567"),
+  C("PL", "48", [9], [3, 3, 3], "512345678"),
+  C("CZ", "420", [9], [3, 3, 3], "601123456"),
+  C("GR", "30", [10], [3, 3, 4], "6912345678"),
+  C("RO", "40", [9], [3, 3, 3], "712345678"),
+  C("HU", "36", [9], [2, 3, 4], "201234567"),
+  C("UA", "380", [9], [2, 3, 2, 2], "501234567"),
+  C("RU", "7", [10], [3, 3, 2, 2], "9123456789"),
+  C("TR", "90", [10], [3, 3, 2, 2], "5012345678"),
+  C("IL", "972", [9], [2, 3, 4], "501234567"),
+  C("AE", "971", [9], [2, 3, 4], "501234567"),
+  C("SA", "966", [9], [2, 3, 4], "512345678"),
+  C("ZA", "27", [9], [2, 3, 4], "711234567"),
+  C("NG", "234", [10], [3, 3, 4], "8021234567"),
+  C("KE", "254", [9], [3, 3, 3], "712123456"),
+  C("EG", "20", [10], [3, 3, 4], "1001234567"),
+  C("BR", "55", [10, 11], [2, 5, 4], "11961234567"),
+  C("MX", "52", [10], [3, 3, 4], "2221234567"),
+  C("AR", "54", [10], [4, 6], "1123456789"),
+  C("CL", "56", [9], [1, 4, 4], "221234567"),
+  C("CO", "57", [10], [3, 3, 4], "3211234567"),
+  C("PE", "51", [9], [3, 3, 3], "912345678"),
+  C("CN", "86", [11], [3, 4, 4], "13123456789"),
+  C("JP", "81", [10], [2, 4, 4], "9012345678"),
+  C("KR", "82", [9, 10], [2, 4, 4], "1023456789"),
+  C("SG", "65", [8], [4, 4], "81234567"),
+  C("HK", "852", [8], [4, 4], "51234567"),
+  C("TW", "886", [9], [3, 3, 3], "912345678"),
+  C("MY", "60", [9, 10], [2, 3, 4], "123456789"),
+  C("ID", "62", [10, 11], [3, 4, 4], "81234567890"),
+  C("TH", "66", [9], [2, 3, 4], "812345678"),
+  C("PH", "63", [10], [3, 3, 4], "9171234567"),
+  C("VN", "84", [9], [3, 3, 3], "912345678"),
+  C("PK", "92", [10], [3, 3, 4], "3012345678"),
+  C("BD", "880", [10], [2, 4, 4], "1812345678"),
+  C("NZ", "64", [9, 10], [2, 3, 4], "211234567"),
+  C("SK", "421", [9], [3, 3, 3], "912123456"),
+  C("BG", "359", [9], [2, 3, 4], "481234567"),
+  C("HR", "385", [8, 9], [2, 3, 4], "921234567"),
+  C("RS", "381", [8, 9], [2, 3, 4], "601234567"),
+  C("SI", "386", [8], [2, 3, 3], "31234567"),
+  C("LT", "370", [8], [3, 2, 3], "61234567"),
+  C("LV", "371", [8], [2, 3, 3], "21234567"),
+  C("EE", "372", [7, 8], [3, 4], "51234567"),
+  C("IS", "354", [7], [3, 4], "6111234"),
+  C("LU", "352", [9], [3, 3, 3], "628123456"),
+  C("MA", "212", [9], [3, 3, 3], "650123456"),
+  C("CR", "506", [8], [4, 4], "83123456"),
+  C("EC", "593", [9], [2, 3, 4], "991234567"),
+  C("UY", "598", [8], [1, 3, 4], "94231234"),
+  C("QA", "974", [8], [4, 4], "33123456"),
+  C("KW", "965", [8], [4, 4], "50012345")
+];
+var PACKED_DIAL_CODES = "AD376 AF93 AG1 AI1 AL355 AM374 AO244 AS1 AW297 AX358 AZ994 BA387 BB1 BF226 BH973 BI257 BJ229 BL590 BM1 BN673 BO591 BQ599 BS1 BT975 BV47 BW267 BY375 BZ501 CC61 CD243 CF236 CG242 CI225 CK682 CM237 CU53 CV238 CW599 CX61 CY357 DJ253 DM1 DO1 DZ213 EH212 ER291 ET251 FJ679 FK500 FM691 FO298 GA241 GD1 GE995 GF594 GG44 GH233 GI350 GL299 GM220 GN224 GP590 GQ240 GS500 GT502 GU1 GW245 GY592 HN504 HT509 IM44 IO246 IQ964 IR98 JE44 JM1 JO962 KG996 KH855 KI686 KM269 KN1 KP850 KY1 KZ7 LA856 LB961 LC1 LI423 LK94 LR231 LS266 LY218 MC377 MD373 ME382 MF590 MG261 MH692 MK389 ML223 MM95 MN976 MO853 MP1 MQ596 MR222 MS1 MT356 MU230 MV960 MW265 MZ258 NA264 NC687 NE227 NF672 NI505 NP977 NR674 NU683 OM968 PA507 PF689 PG675 PM508 PN64 PR1 PS970 PW680 PY595 RE262 RW250 SB677 SC248 SD249 SH290 SJ47 SL232 SM378 SN221 SO252 SR597 SS211 ST239 SV503 SX1 SY963 SZ268 TC1 TD235 TF262 TG228 TJ992 TK690 TL670 TM993 TN216 TO676 TT1 TV688 TZ255 UG256 UZ998 VA379 VC1 VE58 VG1 VI1 VU678 WF681 WS685 XK383 YE967 YT262 ZM260 ZW263";
+function parsePackedCountries(packed) {
+  const out = [];
+  for (const token of packed.trim().split(/\s+/)) {
+    const iso2 = token.slice(0, 2);
+    const dialCode = token.slice(2);
+    out.push({ iso2, name: regionName(iso2), dialCode, lengths: [], groups: [], example: "" });
+  }
+  return out;
+}
 var PHONE_COUNTRIES = [
-  C("US", "United States", "1", [10], [3, 3, 4], "2015550123"),
-  C("CA", "Canada", "1", [10], [3, 3, 4], "5145550123"),
-  C("GB", "United Kingdom", "44", [10], [4, 6], "7400123456"),
-  C("AU", "Australia", "61", [9], [3, 3, 3], "412345678"),
-  C("DE", "Germany", "49", [10, 11], [4, 7], "15123456789"),
-  C("FR", "France", "33", [9], [1, 2, 2, 2, 2], "612345678"),
-  C("IN", "India", "91", [10], [5, 5], "8123456789"),
-  C("DK", "Denmark", "45", [8], [2, 2, 2, 2], "32123456"),
-  C("SE", "Sweden", "46", [9], [2, 3, 4], "701234567"),
-  C("NO", "Norway", "47", [8], [3, 2, 3], "40612345"),
-  C("FI", "Finland", "358", [9, 10], [2, 3, 4], "412345678"),
-  C("NL", "Netherlands", "31", [9], [1, 4, 4], "612345678"),
-  C("BE", "Belgium", "32", [9], [3, 2, 2, 2], "470123456"),
-  C("ES", "Spain", "34", [9], [3, 3, 3], "612345678"),
-  C("IT", "Italy", "39", [9, 10], [3, 3, 4], "3123456789"),
-  C("PT", "Portugal", "351", [9], [3, 3, 3], "912345678"),
-  C("IE", "Ireland", "353", [9], [2, 3, 4], "851234567"),
-  C("CH", "Switzerland", "41", [9], [2, 3, 2, 2], "781234567"),
-  C("AT", "Austria", "43", [10, 11], [3, 7], "6641234567"),
-  C("PL", "Poland", "48", [9], [3, 3, 3], "512345678"),
-  C("CZ", "Czechia", "420", [9], [3, 3, 3], "601123456"),
-  C("GR", "Greece", "30", [10], [3, 3, 4], "6912345678"),
-  C("RO", "Romania", "40", [9], [3, 3, 3], "712345678"),
-  C("HU", "Hungary", "36", [9], [2, 3, 4], "201234567"),
-  C("UA", "Ukraine", "380", [9], [2, 3, 2, 2], "501234567"),
-  C("RU", "Russia", "7", [10], [3, 3, 2, 2], "9123456789"),
-  C("TR", "Turkey", "90", [10], [3, 3, 2, 2], "5012345678"),
-  C("IL", "Israel", "972", [9], [2, 3, 4], "501234567"),
-  C("AE", "United Arab Emirates", "971", [9], [2, 3, 4], "501234567"),
-  C("SA", "Saudi Arabia", "966", [9], [2, 3, 4], "512345678"),
-  C("ZA", "South Africa", "27", [9], [2, 3, 4], "711234567"),
-  C("NG", "Nigeria", "234", [10], [3, 3, 4], "8021234567"),
-  C("KE", "Kenya", "254", [9], [3, 3, 3], "712123456"),
-  C("EG", "Egypt", "20", [10], [3, 3, 4], "1001234567"),
-  C("BR", "Brazil", "55", [10, 11], [2, 5, 4], "11961234567"),
-  C("MX", "Mexico", "52", [10], [3, 3, 4], "2221234567"),
-  C("AR", "Argentina", "54", [10], [4, 6], "1123456789"),
-  C("CL", "Chile", "56", [9], [1, 4, 4], "221234567"),
-  C("CO", "Colombia", "57", [10], [3, 3, 4], "3211234567"),
-  C("PE", "Peru", "51", [9], [3, 3, 3], "912345678"),
-  C("CN", "China", "86", [11], [3, 4, 4], "13123456789"),
-  C("JP", "Japan", "81", [10], [2, 4, 4], "9012345678"),
-  C("KR", "South Korea", "82", [9, 10], [2, 4, 4], "1023456789"),
-  C("SG", "Singapore", "65", [8], [4, 4], "81234567"),
-  C("HK", "Hong Kong", "852", [8], [4, 4], "51234567"),
-  C("TW", "Taiwan", "886", [9], [3, 3, 3], "912345678"),
-  C("MY", "Malaysia", "60", [9, 10], [2, 3, 4], "123456789"),
-  C("ID", "Indonesia", "62", [10, 11], [3, 4, 4], "81234567890"),
-  C("TH", "Thailand", "66", [9], [2, 3, 4], "812345678"),
-  C("PH", "Philippines", "63", [10], [3, 3, 4], "9171234567"),
-  C("VN", "Vietnam", "84", [9], [3, 3, 3], "912345678"),
-  C("PK", "Pakistan", "92", [10], [3, 3, 4], "3012345678"),
-  C("BD", "Bangladesh", "880", [10], [2, 4, 4], "1812345678"),
-  C("NZ", "New Zealand", "64", [9, 10], [2, 3, 4], "211234567"),
-  C("SK", "Slovakia", "421", [9], [3, 3, 3], "912123456"),
-  C("BG", "Bulgaria", "359", [9], [2, 3, 4], "481234567"),
-  C("HR", "Croatia", "385", [8, 9], [2, 3, 4], "921234567"),
-  C("RS", "Serbia", "381", [8, 9], [2, 3, 4], "601234567"),
-  C("SI", "Slovenia", "386", [8], [2, 3, 3], "31234567"),
-  C("LT", "Lithuania", "370", [8], [3, 2, 3], "61234567"),
-  C("LV", "Latvia", "371", [8], [2, 3, 3], "21234567"),
-  C("EE", "Estonia", "372", [7, 8], [3, 4], "51234567"),
-  C("IS", "Iceland", "354", [7], [3, 4], "6111234"),
-  C("LU", "Luxembourg", "352", [9], [3, 3, 3], "628123456"),
-  C("MA", "Morocco", "212", [9], [3, 3, 3], "650123456"),
-  C("CR", "Costa Rica", "506", [8], [4, 4], "83123456"),
-  C("EC", "Ecuador", "593", [9], [2, 3, 4], "991234567"),
-  C("UY", "Uruguay", "598", [8], [1, 3, 4], "94231234"),
-  C("QA", "Qatar", "974", [8], [4, 4], "33123456"),
-  C("KW", "Kuwait", "965", [8], [4, 4], "50012345")
+  ...CURATED_COUNTRIES,
+  ...parsePackedCountries(PACKED_DIAL_CODES)
 ];
+var PHONE_PICKER_COUNTRIES = sortForPicker(PHONE_COUNTRIES);
+function sortForPicker(countries) {
+  if (typeof Intl === "undefined" || typeof Intl.Collator === "undefined") {
+    return [...countries].sort((a, b) => a.iso2 < b.iso2 ? -1 : a.iso2 > b.iso2 ? 1 : 0);
+  }
+  const collator = new Intl.Collator(void 0, { sensitivity: "base" });
+  return [...countries].sort((a, b) => collator.compare(a.name, b.name));
+}
 var byIso = new Map(PHONE_COUNTRIES.map((c) => [c.iso2, c]));
 var timeZoneIso = {
   "Africa/Cairo": "EG",
@@ -431,19 +617,24 @@ function toE164(country, national) {
   const digits = digitsOnly(national);
   return digits ? `+${country.dialCode}${digits}` : "";
 }
-function parsePhone(value, fallback) {
+function parsePhone(value, fallback, opts) {
   const trimmed = (value ?? "").trim();
   const hasPlus = trimmed.startsWith("+");
   const digits = digitsOnly(trimmed);
-  if (!digits) return { country: fallback, national: "", e164: "" };
   if (hasPlus) {
+    if (!digits) return { national: "", e164: "", pending: true, raw: trimmed };
+    const previous = opts?.previousDigits ? digitsOnly(opts.previousDigits) : "";
+    if (previous && digits === previous) {
+      return { national: digits, e164: `+${digits}`, pending: true, raw: trimmed };
+    }
     const country = countryByDialCode(digits);
     if (country) {
       const national = digits.slice(country.dialCode.length);
       return { country, national, e164: `+${digits}` };
     }
-    return { national: digits, e164: `+${digits}` };
+    return { national: digits, e164: `+${digits}`, pending: true, raw: trimmed };
   }
+  if (!digits) return { country: fallback, national: "", e164: "" };
   if (fallback) {
     const national = digits.startsWith(fallback.dialCode) ? digits.slice(fallback.dialCode.length) : digits;
     return { country: fallback, national, e164: `+${fallback.dialCode}${national}` };
@@ -475,10 +666,12 @@ function positionPhonePopover(anchor, popover) {
   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);
+  const rtl = getComputedStyle(anchor).direction === "rtl";
+  const unshiftedLeft = rtl ? anchorRect.right - width : anchorRect.left;
   let offsetX = 0;
-  const rightOverflow = anchorRect.left + width - (viewportWidth - gap);
+  const rightOverflow = unshiftedLeft + width - (viewportWidth - gap);
   if (rightOverflow > 0) offsetX -= rightOverflow;
-  const leftOverflow = gap - (anchorRect.left + offsetX);
+  const leftOverflow = gap - (unshiftedLeft + offsetX);
   if (leftOverflow > 0) offsetX += leftOverflow;
   popover.style.setProperty("--fillo-phone-popover-offset-x", `${Math.round(offsetX)}px`);
   return placement;
@@ -501,8 +694,8 @@ var DEFAULT_STRINGS = {
   successMessage: "Your response has been recorded.",
   closed: "This form is no longer accepting responses.",
   notLive: "This form isn't live yet.",
-  notOpenTitle: "Not open just yet",
-  notOpenBody: "This form is still being set up. Check back soon.",
+  notOpenTitle: "This form isn't open yet",
+  notOpenBody: "The form owner is still setting things up. Please check back soon.",
   closedTitle: "Responses are closed",
   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.",
@@ -519,15 +712,24 @@ var DEFAULT_FIELD_STRINGS = {
   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",
+  uploadsDisabled: "Connect this form to Fillo to enable uploads",
+  uploadsRenderOnly: "Uploads are unavailable in this render-only preview",
   uploadsUnavailable: "Uploads are temporarily unavailable",
+  uploadUnavailable: "We couldn't upload this file right now. Try again in a moment.",
   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.`
+  filesUploaded: (count) => `${count} ${count === 1 ? "file" : "files"} uploaded.`,
+  submittingAnnouncement: "Submitting your response\u2026",
+  errorSummaryTitle: "Please fix the following:",
+  rankingPosition: (label, position, count) => `${label}, position ${position} of ${count}`,
+  phoneCountrySelected: (name) => `${name} selected`,
+  phoneResultsCount: (count) => `${count} ${count === 1 ? "result" : "results"}`,
+  signatureEmpty: "No signature yet",
+  signatureSigned: "Signature saved"
 };
 function resolveStrings(overrides) {
   return overrides ? { ...DEFAULT_STRINGS, ...DEFAULT_FIELD_STRINGS, ...overrides } : { ...DEFAULT_STRINGS, ...DEFAULT_FIELD_STRINGS };
@@ -541,16 +743,9 @@ var fileValueSchema = z.object({
   mime: z.string(),
   url: z.optional(z.string())
 });
-function isEmpty(value) {
-  if (value === null || value === void 0) return true;
-  if (typeof value === "string") return value.trim() === "";
-  if (Array.isArray(value)) return value.length === 0;
-  if (typeof value === "boolean") return value === false;
-  if (typeof value === "object") return Object.keys(value).length === 0;
-  return false;
-}
 function validateField(field2, value) {
   if (isEmpty(value)) {
+    if (field2.kind === "calculated") return null;
     return field2.required ? REQUIRED_FIELD_MESSAGE : null;
   }
   switch (field2.kind) {
@@ -667,6 +862,9 @@ function validateField(field2, value) {
     case "hidden": {
       return typeof value === "string" ? null : "Invalid value";
     }
+    case "calculated": {
+      return null;
+    }
     case "custom": {
       return null;
     }
@@ -694,6 +892,7 @@ function validateResponse(form, data) {
   const errors = {};
   const cleaned = {};
   for (const field2 of fields) {
+    if (field2.kind === "calculated") continue;
     const value = normalizeValue(field2, data[field2.id]);
     const error = validateField(field2, value);
     if (error) {
@@ -704,20 +903,6 @@ function validateResponse(form, data) {
   }
   return { ok: Object.keys(errors).length === 0, errors, data: cleaned };
 }
-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;
-  }
-  if ((field2.kind === "rating" || field2.kind === "linear_scale") && typeof value === "string") {
-    const n = Number(value);
-    return Number.isNaN(n) ? value : n;
-  }
-  if (typeof value === "string") return value.trim();
-  return value;
-}
 
 // src/schema-validation.ts
 import * as z2 from "zod/mini";
@@ -740,6 +925,7 @@ var FIELD_KINDS = [
   "date",
   "file_upload",
   "hidden",
+  "calculated",
   "custom"
 ];
 var CONTENT_KINDS2 = ["heading", "paragraph", "divider"];
@@ -776,9 +962,10 @@ var schemaShape = z2.object({
 });
 var MAX_SCHEMA_VERSION = 1;
 var FILLO_SCHEMA_VERSION = 1;
-var FILLO_SDK_VERSION = true ? "0.10.0" : "0.0.0-dev";
+var FILLO_SDK_VERSION = true ? "0.12.0" : "0.0.0-dev";
 var FILLO_MIN_SDK_VERSION = "0.4.0";
 var FILLO_CHALLENGE_MIN_SDK_VERSION = "0.9.0";
+var FILLO_CALC_MIN_SDK_VERSION = "0.11.0";
 function str(value, max, fallback = "") {
   return typeof value === "string" ? value.trim().slice(0, max) : fallback;
 }
@@ -786,6 +973,11 @@ function optionalStr(value, max) {
   const s = str(value, max);
   return s === "" ? void 0 : s;
 }
+function optionalAffix(value, max) {
+  if (typeof value !== "string") return void 0;
+  const s = value.slice(0, max);
+  return s.trim() === "" ? void 0 : s;
+}
 function bool(value) {
   return typeof value === "boolean" ? value : void 0;
 }
@@ -833,7 +1025,17 @@ function conditions(value) {
   });
   return normalized.length ? normalized : void 0;
 }
-function jumpRules(value, pageIds, sourceId, allowedFieldIds) {
+function jumpDepsAllowed(fieldId, calcRefs, allowed, seen) {
+  const refs = calcRefs.get(fieldId);
+  if (refs === void 0) return allowed.has(fieldId);
+  if (seen.has(fieldId)) return true;
+  seen.add(fieldId);
+  for (const ref of refs) {
+    if (!jumpDepsAllowed(ref, calcRefs, allowed, seen)) return false;
+  }
+  return true;
+}
+function jumpRules(value, pageIds, sourceId, allowedFieldIds, calcRefs) {
   if (!Array.isArray(value)) return void 0;
   const rules = value.slice(0, 50).flatMap((item) => {
     if (!item || typeof item !== "object") return [];
@@ -845,11 +1047,187 @@ function jumpRules(value, pageIds, sourceId, allowedFieldIds) {
     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 [];
+    if (when2 && when2.some((c) => !jumpDepsAllowed(c.fieldId, calcRefs, allowedFieldIds, /* @__PURE__ */ new Set())))
+      return [];
     return [{ when: when2 ?? [], to }];
   });
   return rules.length ? rules : void 0;
 }
+var CALC_OPERAND_KINDS = ["number", "rating", "linear_scale", "calculated"];
+function normalizeCalc(value, depth = 0) {
+  if (depth > 32) return null;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const rec = value;
+  switch (rec.op) {
+    case "value": {
+      const fieldId = str(rec.fieldId, 128);
+      return fieldId ? { op: "value", fieldId } : null;
+    }
+    case "const": {
+      const n = finite(rec.value);
+      return n === void 0 ? null : { op: "const", value: n };
+    }
+    case "add":
+    case "mul":
+    case "min":
+    case "max": {
+      if (!Array.isArray(rec.args) || rec.args.length < 1 || rec.args.length > 50) return null;
+      const args = [];
+      for (const raw of rec.args) {
+        const arg = normalizeCalc(raw, depth + 1);
+        if (!arg) return null;
+        args.push(arg);
+      }
+      return { op: rec.op, args };
+    }
+    case "sub":
+    case "div": {
+      const left = normalizeCalc(rec.left, depth + 1);
+      const right = normalizeCalc(rec.right, depth + 1);
+      return left && right ? { op: rec.op, left, right } : null;
+    }
+    case "round": {
+      const arg = normalizeCalc(rec.arg, depth + 1);
+      if (!arg) return null;
+      return cleanObject({
+        op: "round",
+        arg,
+        decimals: finite(rec.decimals) === void 0 ? void 0 : int(rec.decimals, 0, 6, 0)
+      });
+    }
+    case "if": {
+      if (!Array.isArray(rec.when)) return null;
+      const when2 = conditions(rec.when) ?? [];
+      if (when2.length !== rec.when.length) return null;
+      const then = normalizeCalc(rec.then, depth + 1);
+      const els = normalizeCalc(rec.else, depth + 1);
+      return then && els ? { op: "if", when: when2, then, else: els } : null;
+    }
+    default:
+      return null;
+  }
+}
+function collectCalcRefs(expr, valueRefs, whenRefs) {
+  switch (expr.op) {
+    case "value":
+      valueRefs.add(expr.fieldId);
+      return;
+    case "const":
+      return;
+    case "add":
+    case "mul":
+    case "min":
+    case "max":
+      for (const arg of expr.args) collectCalcRefs(arg, valueRefs, whenRefs);
+      return;
+    case "sub":
+    case "div":
+      collectCalcRefs(expr.left, valueRefs, whenRefs);
+      collectCalcRefs(expr.right, valueRefs, whenRefs);
+      return;
+    case "round":
+      collectCalcRefs(expr.arg, valueRefs, whenRefs);
+      return;
+    case "if":
+      for (const cond of expr.when) whenRefs.add(cond.fieldId);
+      collectCalcRefs(expr.then, valueRefs, whenRefs);
+      collectCalcRefs(expr.else, valueRefs, whenRefs);
+      return;
+  }
+}
+function validateCalculatedFields(pages) {
+  const kinds = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    for (const block of page.blocks) if (isField(block)) kinds.set(block.id, block.kind);
+  }
+  const deps = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    for (const block of page.blocks) {
+      if (block.kind !== "calculated") continue;
+      const calc = normalizeCalc(block.calc);
+      if (!calc) {
+        return `Field ${block.id} has a malformed calc expression \u2014 build it from value/const/add/sub/mul/div/min/max/round/if nodes`;
+      }
+      block.calc = calc;
+      const valueRefs = /* @__PURE__ */ new Set();
+      const whenRefs = /* @__PURE__ */ new Set();
+      collectCalcRefs(calc, valueRefs, whenRefs);
+      for (const ref of valueRefs) {
+        const kind = kinds.get(ref);
+        if (kind === void 0) {
+          return `Calculated field ${block.id} references a missing field: ${ref} \u2014 remove the reference or restore that field`;
+        }
+        if (!CALC_OPERAND_KINDS.includes(kind)) {
+          return `Calculated field ${block.id} references non-numeric field ${ref} (${kind}) \u2014 calculations can read number, rating, linear_scale, and calculated fields only`;
+        }
+      }
+      deps.set(
+        block.id,
+        [...valueRefs, ...whenRefs].filter((ref) => kinds.get(ref) === "calculated")
+      );
+    }
+  }
+  const state = /* @__PURE__ */ new Map();
+  const visit = (id, path) => {
+    const mark = state.get(id);
+    if (mark === "done") return null;
+    if (mark === "visiting") {
+      const chain = [...path.slice(path.indexOf(id)), id].join(" \u2192 ");
+      return `Calculated field ${id} depends on its own result (${chain}) \u2014 break the cycle so the value can be computed`;
+    }
+    state.set(id, "visiting");
+    for (const dep of deps.get(id) ?? []) {
+      const error = visit(dep, [...path, id]);
+      if (error) return error;
+    }
+    state.set(id, "done");
+    return null;
+  };
+  for (const id of deps.keys()) {
+    const error = visit(id, []);
+    if (error) return error;
+  }
+  return null;
+}
+var MAX_CALC_FIELDS = 100;
+var MAX_CALC_TOTAL_NODES = 5e3;
+function countCalcNodes(expr) {
+  switch (expr.op) {
+    case "value":
+    case "const":
+      return 1;
+    case "add":
+    case "mul":
+    case "min":
+    case "max":
+      return 1 + expr.args.reduce((n, arg) => n + countCalcNodes(arg), 0);
+    case "sub":
+    case "div":
+      return 1 + countCalcNodes(expr.left) + countCalcNodes(expr.right);
+    case "round":
+      return 1 + countCalcNodes(expr.arg);
+    case "if":
+      return 1 + countCalcNodes(expr.then) + countCalcNodes(expr.else);
+  }
+}
+function calcComplexityError(pages) {
+  let calcFields = 0;
+  let totalNodes = 0;
+  for (const page of pages) {
+    for (const block of page.blocks) {
+      if (block.kind !== "calculated") continue;
+      calcFields += 1;
+      totalNodes += countCalcNodes(block.calc);
+    }
+  }
+  if (calcFields > MAX_CALC_FIELDS) {
+    return `Form has ${calcFields} calculated fields \u2014 the maximum is ${MAX_CALC_FIELDS}; remove some or consolidate them into fewer expressions`;
+  }
+  if (totalNodes > MAX_CALC_TOTAL_NODES) {
+    return `Calculated expressions total ${totalNodes} operations \u2014 the maximum is ${MAX_CALC_TOTAL_NODES} across the form; simplify or split up the calculations`;
+  }
+  return null;
+}
 function baseBlock(rec) {
   return {
     id: str(rec.id, 128),
@@ -961,7 +1339,20 @@ function normalizeBlock(input) {
         maxLength: finite(rec.maxLength) === void 0 ? void 0 : int(rec.maxLength, 1, 2e4, 2e4)
       });
     case "number":
-      return cleanObject({ ...baseField(rec, kind), min: finite(rec.min), max: finite(rec.max) });
+      return cleanObject({
+        ...baseField(rec, kind),
+        min: finite(rec.min),
+        max: finite(rec.max),
+        // Display-only (decision 1 in the number-formatting contract) —
+        // mirrors the calculated field's decimals/prefix/suffix carry-through
+        // exactly, plus notation which calculated doesn't have.
+        decimals: finite(rec.decimals) === void 0 ? void 0 : int(rec.decimals, 0, 6, 0),
+        prefix: optionalAffix(rec.prefix, 100),
+        suffix: optionalAffix(rec.suffix, 100),
+        // The only supported values; anything else drops silently rather than
+        // erroring (an old/garbage value is just "no grouping").
+        notation: rec.notation === "grouped" ? "grouped" : rec.notation === "grouped-comma" ? "grouped-comma" : rec.notation === "grouped-dot" ? "grouped-dot" : void 0
+      });
     case "select":
     case "multi_select":
     case "dropdown": {
@@ -1025,6 +1416,21 @@ function normalizeBlock(input) {
         paramName: optionalStr(rec.paramName, 128),
         defaultValue: optionalStr(rec.defaultValue, 1e3)
       });
+    case "calculated":
+      return cleanObject({
+        ...baseField(rec, kind),
+        // A derived value isn't answerable, so it can't be required (the
+        // hidden-field precedent) — a required one could never be satisfied.
+        required: false,
+        // Kept raw here on purpose: the calc AST is normalized and structurally
+        // validated in normalizeFormSchema once the full field universe is
+        // known (missing refs, operand kinds, cycles are HARD errors there — a
+        // calculated field must never be silently dropped or degraded).
+        calc: rec.calc,
+        decimals: finite(rec.decimals) === void 0 ? void 0 : int(rec.decimals, 0, 6, 0),
+        prefix: optionalAffix(rec.prefix, 100),
+        suffix: optionalAffix(rec.suffix, 100)
+      });
     case "file_upload":
       return cleanObject({
         ...baseField(rec, kind),
@@ -1063,6 +1469,22 @@ function normalizeFormSchema(input) {
     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 calcRefs = /* @__PURE__ */ new Map();
+  for (const page of rebuilt) {
+    for (const block of page.blocks) {
+      if (block.kind !== "calculated") continue;
+      const refs = /* @__PURE__ */ new Set();
+      const calc = normalizeCalc(block.calc);
+      if (calc) {
+        const valueRefs = /* @__PURE__ */ new Set();
+        const whenRefs = /* @__PURE__ */ new Set();
+        collectCalcRefs(calc, valueRefs, whenRefs);
+        for (const ref of valueRefs) refs.add(ref);
+        for (const ref of whenRefs) refs.add(ref);
+      }
+      calcRefs.set(block.id, refs);
+    }
+  }
   const priorFieldIds = /* @__PURE__ */ new Set();
   const pages = rebuilt.map((page) => {
     for (const block of page.blocks) {
@@ -1072,7 +1494,7 @@ function normalizeFormSchema(input) {
       id: page.id,
       title: page.title,
       blocks: page.blocks,
-      next: jumpRules(page.next, targetIds, page.id, new Set(priorFieldIds))
+      next: jumpRules(page.next, targetIds, page.id, new Set(priorFieldIds), calcRefs)
     });
   });
   const pageIds = /* @__PURE__ */ new Set();
@@ -1107,6 +1529,10 @@ function normalizeFormSchema(input) {
       }
     }
   }
+  const calcError = validateCalculatedFields(pages);
+  if (calcError) return { ok: false, error: calcError };
+  const calcComplexity = calcComplexityError(pages);
+  if (calcComplexity) return { ok: false, error: calcComplexity };
   if (pages.every((page) => page.blocks.length === 0)) {
     return { ok: false, error: "Schema must contain at least one valid block" };
   }
@@ -1179,8 +1605,19 @@ function formatAnswer(field2, value) {
       return value === true ? "Yes" : "No";
     case "rating":
     case "linear_scale":
-    case "number":
       return typeof value === "number" ? String(value) : String(value);
+    case "number": {
+      const n = typeof value === "number" ? value : Number(value);
+      if (!Number.isFinite(n)) return String(value);
+      const text = field2.decimals === void 0 ? String(n) : n.toFixed(Math.max(0, Math.min(6, field2.decimals)));
+      return `${field2.prefix ?? ""}${text}${field2.suffix ?? ""}`;
+    }
+    case "calculated": {
+      const n = typeof value === "number" ? value : Number(value);
+      if (!Number.isFinite(n)) return String(value);
+      const text = field2.decimals === void 0 ? String(n) : n.toFixed(Math.max(0, Math.min(6, field2.decimals)));
+      return `${field2.prefix ?? ""}${text}${field2.suffix ?? ""}`;
+    }
     case "phone": {
       const { country, national, e164 } = parsePhone(String(value));
       if (!e164) return String(value);
@@ -1202,6 +1639,103 @@ function formatAnswer(field2, value) {
   }
 }
 
+// src/number-format.ts
+function clampDecimals2(decimals) {
+  return Math.max(0, Math.min(6, Math.round(decimals)));
+}
+function localeForNotation(notation) {
+  switch (notation) {
+    case "grouped-comma":
+      return "en-US";
+    case "grouped-dot":
+      return "de-DE";
+    case "grouped":
+    case void 0:
+      return void 0;
+  }
+}
+function formatGroupedNumber(value, opts) {
+  if (!Number.isFinite(value)) return String(value);
+  const decimals = opts?.decimals === void 0 ? void 0 : clampDecimals2(opts.decimals);
+  if (typeof Intl === "undefined") {
+    return decimals === void 0 ? String(value) : value.toFixed(decimals);
+  }
+  const format = { useGrouping: true };
+  if (decimals === void 0) {
+    format.maximumFractionDigits = 20;
+  } else {
+    format.minimumFractionDigits = decimals;
+    format.maximumFractionDigits = decimals;
+  }
+  return new Intl.NumberFormat(opts?.locale, format).format(value);
+}
+function stripAll(text, separator) {
+  return separator ? text.split(separator).join("") : text;
+}
+function toCanonicalDecimal(text, decimal) {
+  return decimal === "." ? text : text.split(decimal).join(".");
+}
+function resolveAmbiguousGrouping(body, group, decimal) {
+  if (decimal !== group && body.includes(decimal)) {
+    const i = body.lastIndexOf(decimal);
+    const intPart = stripAll(body.slice(0, i), group);
+    const fracPart = body.slice(i + decimal.length);
+    return `${intPart}.${fracPart}`;
+  }
+  const segments = body.split(group);
+  if (segments.length === 1) return body;
+  const isPureGrouping = segments.every(
+    (seg, i) => i === 0 ? /^[1-9]\d{0,2}$/.test(seg) : /^\d{3}$/.test(seg)
+  );
+  if (isPureGrouping) return segments.join("");
+  return `${segments.slice(0, -1).join("")}.${segments.at(-1) ?? ""}`;
+}
+function parseGroupedNumber(text, locale) {
+  if (typeof Intl === "undefined") return text;
+  if (text.trim() === "") return text;
+  const parts = new Intl.NumberFormat(locale).formatToParts(12345678e-1);
+  const group = parts.find((p) => p.type === "group")?.value ?? ",";
+  const decimal = parts.find((p) => p.type === "decimal")?.value ?? ".";
+  let body = text.trim();
+  const negative = body.startsWith("-");
+  if (negative) body = body.slice(1);
+  if (/^\s$/.test(group)) {
+    body = toCanonicalDecimal(body.replace(/\s/g, ""), decimal);
+  } else if (group === "." || group === ",") {
+    body = resolveAmbiguousGrouping(body, group, decimal);
+  } else {
+    body = toCanonicalDecimal(stripAll(body, group), decimal);
+  }
+  if (body === "" || body === "." || !/^\d*\.?\d*$/.test(body)) return text;
+  return negative ? `-${body}` : body;
+}
+function isValidPartialNumberText(text, locale) {
+  const negative = text.startsWith("-");
+  const body = negative ? text.slice(1) : text;
+  if (body.includes("-")) return false;
+  if (body === "") return true;
+  if (typeof Intl === "undefined") {
+    return /^[\d.,]*$/.test(body);
+  }
+  const parts = new Intl.NumberFormat(locale).formatToParts(12345678e-1);
+  const group = parts.find((p) => p.type === "group")?.value ?? ",";
+  const decimal = parts.find((p) => p.type === "decimal")?.value ?? ".";
+  const dotIsGroup = group === ".";
+  const groupIsWhitespace = /^\s$/.test(group);
+  const decimalMarks = dotIsGroup ? [decimal] : Array.from(/* @__PURE__ */ new Set([".", decimal]));
+  let decimalSeen = 0;
+  for (const ch of body) {
+    if (/\d/.test(ch)) continue;
+    if (decimalMarks.includes(ch)) {
+      if (++decimalSeen > 1) return false;
+      continue;
+    }
+    if (groupIsWhitespace ? /\s/.test(ch) : ch === group) continue;
+    return false;
+  }
+  return true;
+}
+
 // src/ids.ts
 var ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 var MASK = 256 - 256 % ALPHABET.length;
@@ -1245,6 +1779,7 @@ var BLOCK_KIND_META = {
   date: { label: "Date", hint: "Date picker" },
   file_upload: { label: "File upload", hint: "Direct to connected storage" },
   hidden: { label: "Hidden field", hint: "Filled from the URL" },
+  calculated: { label: "Calculated value", hint: "Computed from other answers" },
   custom: { label: "Custom", hint: "Your own component (code only)" },
   heading: { label: "Heading", hint: "Section title" },
   paragraph: { label: "Paragraph", hint: "Explanatory text" },
@@ -1314,6 +1849,8 @@ function createBlock(kind) {
       return { id, kind, label: "Sign here" };
     case "hidden":
       return { id, kind, label: "Hidden field" };
+    case "calculated":
+      return { id, kind, label: "Calculated value", calc: { op: "const", value: 0 } };
     case "custom":
       return { id, kind, label: "Custom field", component: "" };
     case "file_upload":
@@ -2344,6 +2881,9 @@ function prefillFromParams(form, params) {
       case "custom":
         break;
       // not prefillable from a URL
+      case "calculated":
+        break;
+      // engine-computed, never prefillable — a crafted URL can't seed it
       default:
         data[field2.id] = raw;
     }
@@ -2494,7 +3034,7 @@ function createFormController(options2) {
   let formId = options2.formId;
   let client = options2.client;
   let respondent = options2.respondent;
-  let data = { ...options2.initialData ?? {} };
+  let data = computeCalculated(form, { ...options2.initialData ?? {} });
   let errors = {};
   let pageIndex = 0;
   let status = "idle";
@@ -2511,7 +3051,7 @@ function createFormController(options2) {
         }
       }
       if (merged && status === "idle") {
-        data = merged;
+        data = computeCalculated(form, merged);
         notify();
       }
     }
@@ -2639,7 +3179,7 @@ function createFormController(options2) {
     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 (merged) data = computeCalculated(form, merged);
     if (movePage) pageIndex = target;
     resumedDraft = true;
     notify();
@@ -2769,7 +3309,7 @@ function createFormController(options2) {
       sessionStarted = true;
       void client.startSession(formId, form.pages.length).then((id) => sessionId = id);
     }
-    data = { ...data, [fieldId]: value };
+    data = computeCalculated(form, { ...data, [fieldId]: value });
     onChange?.(data);
     submitError = void 0;
     if (fieldId in errors) {
@@ -2840,9 +3380,26 @@ function createFormController(options2) {
     if (status === "submitting" || status === "submitted") return;
     const result = validateResponse(form, data);
     if (!result.ok) {
-      errors = result.errors;
+      const transportlessPreview = options2.skipValidation && !(client && formId);
+      const previewErrors = transportlessPreview ? Object.fromEntries(
+        Object.entries(result.errors).filter(
+          ([fieldId]) => form.pages.every(
+            (page) => page.blocks.every(
+              (block) => !(isField(block) && block.id === fieldId && block.kind === "file_upload")
+            )
+          )
+        )
+      ) : result.errors;
+      if (transportlessPreview && Object.keys(previewErrors).length === 0) {
+        errors = {};
+        status = "submitted";
+        notify();
+        emitSubmitted(void 0, data);
+        return;
+      }
+      errors = previewErrors;
       const firstBad = form.pages.findIndex(
-        (p) => visiblePageBlocks(form, p, data).some((b) => b.id in result.errors)
+        (p) => visiblePageBlocks(form, p, data).some((b) => b.id in previewErrors)
       );
       if (firstBad >= 0) pageIndex = firstBad;
       notify();
@@ -2953,6 +3510,7 @@ function createFormController(options2) {
         const next2 = normalizeFormSchema(ctx.form);
         if (!next2.ok) throw new Error(`Invalid form schema: ${next2.error}`);
         form = next2.schema;
+        data = computeCalculated(form, data);
       }
       if (status === "idle" && hasSubmittedOnce(form, formId, data)) {
         status = "submitted";
@@ -2977,6 +3535,7 @@ function createFormController(options2) {
           if (data[key] === void 0) data[key] = value;
         }
       }
+      data = computeCalculated(form, data);
       errors = {};
       pageIndex = 0;
       submitError = void 0;
@@ -2999,7 +3558,9 @@ 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");
+  const interactive = visible.filter(
+    (b) => isField(b) && b.kind !== "hidden" && b.kind !== "calculated"
+  );
   if (interactive.length !== 1) return true;
   return !isAutoSubmitBlock(interactive[0]);
 }
@@ -3025,11 +3586,40 @@ function shouldAutoSubmit(field2, value, ctx) {
   const nextData = { ...ctx.data, [field2.id]: value };
   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");
+  const interactive = reachableFields(ctx.form, nextData).filter(
+    (f) => f.kind !== "hidden" && f.kind !== "calculated"
+  );
   if (interactive.length !== 1 || interactive[0]?.id !== field2.id) return false;
   return validateResponse(ctx.form, nextData).ok;
 }
 
+// src/radio-nav.ts
+function radioGroupStep(key, index, length, opts) {
+  if (length <= 0) return null;
+  const rtl = opts?.rtl ?? false;
+  if (key === "Home") return 0;
+  if (key === "End") return length - 1;
+  let delta;
+  switch (key) {
+    case "ArrowRight":
+      delta = rtl ? -1 : 1;
+      break;
+    case "ArrowLeft":
+      delta = rtl ? 1 : -1;
+      break;
+    case "ArrowDown":
+      delta = 1;
+      break;
+    case "ArrowUp":
+      delta = -1;
+      break;
+    default:
+      return null;
+  }
+  const next = index + delta;
+  return Math.min(length - 1, Math.max(0, next));
+}
+
 // src/appearance.ts
 var FILLO_SLOTS = [
   "root",
@@ -3052,7 +3642,8 @@ var FILLO_SLOTS = [
   "button",
   "success",
   "resume",
-  "turnstile"
+  "turnstile",
+  "calculated"
 ];
 var FILLO_DATA_ATTRS = {
   /** Slot name, on every slot element: `data-fillo="control"`. */
@@ -3100,6 +3691,35 @@ var FILLO_THEME_VARS = [
   { var: "--fillo-error" },
   { var: "--fillo-primary-contrast" }
 ];
+var DARK_LUMINANCE_THRESHOLD = Math.sqrt(1.05 * 0.05) - 0.05;
+var HEX6 = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i;
+var HEX3 = /^#([0-9a-f])([0-9a-f])([0-9a-f])$/i;
+function srgbToLinear(channel255) {
+  const c = channel255 / 255;
+  return c <= 0.03928 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4;
+}
+function relativeLuminance(token) {
+  const trimmed = token.trim();
+  let hex = null;
+  const six = HEX6.exec(trimmed);
+  if (six) {
+    hex = `${six[1]}${six[2]}${six[3]}`;
+  } else {
+    const three = HEX3.exec(trimmed);
+    if (three) hex = `${three[1]}${three[1]}${three[2]}${three[2]}${three[3]}${three[3]}`;
+  }
+  if (!hex) return null;
+  const r = parseInt(hex.slice(0, 2), 16);
+  const g = parseInt(hex.slice(2, 4), 16);
+  const b = parseInt(hex.slice(4, 6), 16);
+  return 0.2126 * srgbToLinear(r) + 0.7152 * srgbToLinear(g) + 0.0722 * srgbToLinear(b);
+}
+function resolveThemeAppearance(theme) {
+  if (!theme || theme.colorScheme || !theme.background || !theme.text) return theme;
+  const luminance = relativeLuminance(theme.background);
+  if (luminance == null) return theme;
+  return { ...theme, colorScheme: luminance > DARK_LUMINANCE_THRESHOLD ? "light" : "dark" };
+}
 
 // src/define.ts
 function defineForm(def) {
@@ -3158,16 +3778,18 @@ function formSchemasEqual(left, right) {
   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 || result.accepting === false);
+var isVolatileSync = (result) => Boolean(
+  result.staged || result.resolvedSchema || result.syncError || result.accepting === false || result.uploadsAvailable === false
+);
 function storageKey(client, handle) {
-  return `fillo:sync:v3:${client.baseUrl}|${client.key}|${handle}`;
+  return `fillo:sync:v4:${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" || typeof parsed.slug !== "string" || parsed.hash !== hash || typeof parsed.ts !== "number" || parsed.status !== void 0 && parsed.status !== "draft" && parsed.status !== "published")
+    if (typeof parsed.formId !== "string" || typeof parsed.slug !== "string" || parsed.hash !== hash || typeof parsed.ts !== "number" || parsed.uploadFileSizeLimitMb !== void 0 && (typeof parsed.uploadFileSizeLimitMb !== "number" || !Number.isFinite(parsed.uploadFileSizeLimitMb) || parsed.uploadFileSizeLimitMb <= 0) || parsed.status !== void 0 && parsed.status !== "draft" && parsed.status !== "published")
       return null;
     const ttl = syncTtlMs(parsed.status);
     if (Date.now() - parsed.ts > ttl) return null;
@@ -3186,6 +3808,7 @@ function writeStoredSync(client, handle, hash, r) {
         formId: r.formId,
         slug: r.slug,
         status: r.status,
+        uploadFileSizeLimitMb: r.uploadFileSizeLimitMb,
         hash,
         ts: Date.now()
       })
@@ -3208,7 +3831,8 @@ function syncCodeForm(client, form, opts) {
       const promise2 = Promise.resolve({
         formId: stored.formId,
         slug: stored.slug,
-        status: stored.status
+        status: stored.status,
+        uploadFileSizeLimitMb: stored.uploadFileSizeLimitMb
       });
       syncCache.set(key, {
         promise: promise2,
@@ -3269,7 +3893,7 @@ var JSX_BLOCK_SPECS = [
   field("Email", "email", ["maxLength"]),
   field("Url", "url", ["maxLength"]),
   field("Phone", "phone", ["defaultCountry"]),
-  field("Number", "number", ["min", "max"]),
+  field("Number", "number", ["min", "max", "decimals", "prefix", "suffix", "notation"]),
   field("Select", "select", CHOICE_EXTRA, { optionChildren: true }),
   field("MultiSelect", "multi_select", CHOICE_EXTRA, { optionChildren: true }),
   field("Dropdown", "dropdown", CHOICE_EXTRA, { optionChildren: true }),
@@ -3282,6 +3906,7 @@ var JSX_BLOCK_SPECS = [
   field("Date", "date", []),
   field("FileUpload", "file_upload", ["maxFiles", "maxFileSizeMb", "accept"]),
   field("Hidden", "hidden", ["paramName", "defaultValue"]),
+  field("Calculated", "calculated", ["calc", "decimals", "prefix", "suffix"]),
   field("Custom", "custom", ["component", "config"]),
   content("Heading", "heading", true),
   content("Paragraph", "paragraph", true),
@@ -3608,6 +4233,7 @@ export {
   DEFAULT_FIELD_STRINGS,
   DEFAULT_STRINGS,
   DRAFT_KINDS,
+  FILLO_CALC_MIN_SDK_VERSION,
   FILLO_CHALLENGE_MIN_SDK_VERSION,
   FILLO_DATA_ATTRS,
   FILLO_MIN_SDK_VERSION,
@@ -3621,12 +4247,14 @@ export {
   JSX_BLOCK_COMPONENTS,
   JSX_BLOCK_SPECS,
   PHONE_COUNTRIES,
+  PHONE_PICKER_COUNTRIES,
   PHONE_POPOVER_VIEWPORT_GAP,
   REQUIRED_FIELD_MESSAGE,
   Sha1,
   allFields,
   assembleForm,
   codeFormFromJsx,
+  computeCalculated,
   conditionsMet,
   contentHash,
   countryByDialCode,
@@ -3639,9 +4267,11 @@ export {
   createId,
   defineForm,
   digitsOnly,
+  evaluateCalc,
   flagEmoji,
   formSchemasEqual,
   formatAnswer,
+  formatGroupedNumber,
   formatNational,
   isAutoSubmitBlock,
   isBlockVisible,
@@ -3652,15 +4282,19 @@ export {
   isLikelyDevEnv,
   isPossiblePhone,
   isTerminalPage,
+  isValidPartialNumberText,
+  localeForNotation,
   needsExplicitSubmit,
   normalizeFormSchema,
   normalizeFormTheme,
   normalizeSettings,
+  parseGroupedNumber,
   parsePhone,
   pipeBlock,
   positionPhonePopover,
   prefillFromParams,
   provisionWorkspace,
+  radioGroupStep,
   reachableFieldIds,
   reachableFields,
   reachablePageIds,
@@ -3669,6 +4303,7 @@ export {
   resolveSlotClass,
   resolveStrings,
   resolveText,
+  resolveThemeAppearance,
   responseScopeValue,
   schemaFromJsx,
   sha1Base64,