@marktiderman/genesis-forms 0.3.1 → 0.4.0

package/dist/testing.cjs

@@ -1,5 +1,408 @@
 'use strict';
 
+// src/formula.ts
+var FORMULA_FUNCTIONS = ["sum", "avg", "min", "max"];
+var MAX_FORMULA_LENGTH = 2e3;
+var MAX_DEPTH = 64;
+var OP_ALIASES = { "\u2212": "-", "\xD7": "*", "\xF7": "/", "\u2260": "!=", "\u2264": "<=", "\u2265": ">=", "=": "==" };
+var TWO_CHAR = /* @__PURE__ */ new Set(["==", "!=", "<=", ">="]);
+var ONE_CHAR = /* @__PURE__ */ new Set(["+", "-", "*", "/", "<", ">", "(", ")", "?", ":", ",", ".", "=", "\u2212", "\xD7", "\xF7", "\u2260", "\u2264", "\u2265"]);
+var COMPARISONS = /* @__PURE__ */ new Set(["==", "!=", "<", "<=", ">", ">="]);
+var FormulaError = class extends Error {
+  constructor(message, at) {
+    super(message);
+    this.at = at;
+  }
+  at;
+};
+var isIdStart = (c) => c >= "a" && c <= "z" || c >= "A" && c <= "Z" || c === "_";
+var isIdPart = (c) => isIdStart(c) || c >= "0" && c <= "9";
+var isDigit = (c) => c >= "0" && c <= "9";
+function tokenize(source) {
+  const tokens = [];
+  let i = 0;
+  while (i < source.length) {
+    const c = source[i];
+    if (c === " " || c === "	" || c === "\n" || c === "\r") {
+      i++;
+      continue;
+    }
+    const at = i;
+    if (isDigit(c) || c === "." && isDigit(source[i + 1] ?? "")) {
+      while (isDigit(source[i] ?? "")) i++;
+      if (source[i] === "." && isDigit(source[i + 1] ?? "")) {
+        i++;
+        while (isDigit(source[i] ?? "")) i++;
+      }
+      const v = Number(source.slice(at, i));
+      if (!Number.isFinite(v)) throw new FormulaError("This number is too large.", at);
+      tokens.push({ t: "num", v, at });
+      continue;
+    }
+    if (isIdStart(c)) {
+      while (isIdPart(source[i] ?? "")) i++;
+      tokens.push({ t: "id", v: source.slice(at, i), at });
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "\u201C") {
+      const close = c === "\u201C" ? "\u201D" : c;
+      const end = source.indexOf(close, i + 1);
+      if (end === -1) throw new FormulaError("This text has no closing quote.", at);
+      tokens.push({ t: "str", v: source.slice(i + 1, end), at });
+      i = end + 1;
+      continue;
+    }
+    const two = source.slice(i, i + 2);
+    if (TWO_CHAR.has(two)) {
+      tokens.push({ t: "op", v: two, at });
+      i += 2;
+      continue;
+    }
+    if (ONE_CHAR.has(c)) {
+      tokens.push({ t: "op", v: OP_ALIASES[c] ?? c, at });
+      i++;
+      continue;
+    }
+    throw new FormulaError(`"${c}" can't be used in a formula.`, at);
+  }
+  tokens.push({ t: "end", at: source.length });
+  return tokens;
+}
+function parseFormula(source) {
+  if (typeof source !== "string" || source.trim() === "") return { ok: false, message: "Write a formula.", at: 0 };
+  if (source.length > MAX_FORMULA_LENGTH) {
+    return { ok: false, message: `Keep the formula under ${MAX_FORMULA_LENGTH} characters.`, at: MAX_FORMULA_LENGTH };
+  }
+  let tokens;
+  try {
+    tokens = tokenize(source);
+  } catch (e) {
+    const err = e;
+    return { ok: false, message: err.message, at: err.at };
+  }
+  let pos = 0;
+  const refs = [];
+  const peek = () => tokens[pos];
+  const isOp = (v) => {
+    const tok = peek();
+    return tok.t === "op" && tok.v === v;
+  };
+  const expect = (v, message) => {
+    if (!isOp(v)) throw new FormulaError(message, peek().at);
+    pos++;
+  };
+  const describe = (tok) => tok.t === "end" ? "the formula ends there" : `found "${String(tok.v)}"`;
+  const guard = (depth) => {
+    if (depth > MAX_DEPTH) throw new FormulaError("The formula is nested too deeply.", peek().at);
+  };
+  const ternary = (depth) => {
+    guard(depth);
+    const test = comparison(depth);
+    if (!isOp("?")) return test;
+    pos++;
+    const then = ternary(depth + 1);
+    expect(":", "A `?` needs a `:` and the other value: `test ? a : b`.");
+    const otherwise = ternary(depth + 1);
+    return { kind: "if", test, then, else: otherwise };
+  };
+  const comparison = (depth) => {
+    const left = additive(depth);
+    const tok = peek();
+    if (tok.t !== "op" || !COMPARISONS.has(tok.v)) return left;
+    pos++;
+    const right = additive(depth);
+    const next = peek();
+    if (next.t === "op" && COMPARISONS.has(next.v)) {
+      throw new FormulaError("Compare two values at a time; combine comparisons with `? :`.", next.at);
+    }
+    return { kind: "binary", op: tok.v, left, right };
+  };
+  const additive = (depth) => {
+    let left = multiplicative(depth);
+    for (let tok = peek(); tok.t === "op" && (tok.v === "+" || tok.v === "-"); tok = peek()) {
+      pos++;
+      left = { kind: "binary", op: tok.v, left, right: multiplicative(depth) };
+    }
+    return left;
+  };
+  const multiplicative = (depth) => {
+    let left = unary(depth);
+    for (let tok = peek(); tok.t === "op" && (tok.v === "*" || tok.v === "/"); tok = peek()) {
+      pos++;
+      left = { kind: "binary", op: tok.v, left, right: unary(depth) };
+    }
+    return left;
+  };
+  const unary = (depth) => {
+    guard(depth);
+    if (isOp("-")) {
+      pos++;
+      return { kind: "unary", op: "-", arg: unary(depth + 1) };
+    }
+    if (isOp("+")) {
+      pos++;
+      return unary(depth + 1);
+    }
+    return primary(depth);
+  };
+  const primary = (depth) => {
+    const tok = peek();
+    if (tok.t === "num") {
+      pos++;
+      return { kind: "number", value: tok.v };
+    }
+    if (tok.t === "str") {
+      pos++;
+      return { kind: "text", value: tok.v };
+    }
+    if (tok.t === "op" && tok.v === "(") {
+      pos++;
+      const inner = ternary(depth + 1);
+      expect(")", "A `(` has no matching `)`.");
+      return inner;
+    }
+    if (tok.t === "id") {
+      pos++;
+      if (isOp("(")) {
+        if (!FORMULA_FUNCTIONS.includes(tok.v)) {
+          throw new FormulaError(`There is no function "${tok.v}"; use ${FORMULA_FUNCTIONS.join(", ")}.`, tok.at);
+        }
+        pos++;
+        const args = [];
+        if (!isOp(")")) {
+          args.push(ternary(depth + 1));
+          while (isOp(",")) {
+            pos++;
+            args.push(ternary(depth + 1));
+          }
+        }
+        expect(")", `"${tok.v}(" has no matching ")".`);
+        if (!args.length) throw new FormulaError(`${tok.v}() needs something to work on.`, tok.at);
+        return { kind: "call", fn: tok.v, args };
+      }
+      if (isOp(".")) {
+        pos++;
+        const column = peek();
+        if (column.t !== "id") throw new FormulaError(`Name a column after "${tok.v}.".`, column.at);
+        pos++;
+        refs.push({ key: tok.v, column: column.v });
+        return { kind: "ref", key: tok.v, column: column.v, at: tok.at };
+      }
+      refs.push({ key: tok.v });
+      return { kind: "ref", key: tok.v, at: tok.at };
+    }
+    throw new FormulaError(`Expected a number, an answer or "(", but ${describe(tok)}.`, tok.at);
+  };
+  try {
+    const ast = ternary(0);
+    const rest = peek();
+    if (rest.t !== "end") throw new FormulaError(`Expected an operator such as + or *, but ${describe(rest)}.`, rest.at);
+    return { ok: true, ast, refs };
+  } catch (e) {
+    if (e instanceof FormulaError) return { ok: false, message: e.message, at: e.at };
+    return { ok: false, message: "The formula is nested too deeply.", at: 0 };
+  }
+}
+var NUMERIC = /^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$/;
+function formulaNumber(v) {
+  if (typeof v === "number") return Number.isFinite(v) ? v : null;
+  if (typeof v === "boolean") return v ? 1 : 0;
+  if (typeof v === "string") {
+    const t = v.trim().replace(/,/g, "");
+    return t.length <= 64 && NUMERIC.test(t) ? finite(Number(t)) : null;
+  }
+  return null;
+}
+var finite = (n) => Number.isFinite(n) ? n : null;
+var scalar = (v) => Array.isArray(v) ? null : v;
+function truthy(v) {
+  if (v === null) return false;
+  if (typeof v === "boolean") return v;
+  if (typeof v === "number") return v !== 0;
+  if (typeof v === "string") return v.trim() !== "";
+  return v.length > 0;
+}
+function numbersIn(values, out = []) {
+  for (const v of values) {
+    if (Array.isArray(v)) numbersIn(v, out);
+    else {
+      const n = formulaNumber(v);
+      if (n !== null) out.push(n);
+    }
+  }
+  return out;
+}
+function compare(op, a, b) {
+  const blank2 = (v) => v === null || Array.isArray(v) || typeof v === "string" && v.trim() === "";
+  if (blank2(a) || blank2(b)) return op === "!=";
+  const x = formulaNumber(a);
+  const y = formulaNumber(b);
+  if (x !== null && y !== null) {
+    if (op === "==") return x === y;
+    if (op === "!=") return x !== y;
+    if (op === "<") return x < y;
+    if (op === "<=") return x <= y;
+    if (op === ">") return x > y;
+    return x >= y;
+  }
+  if (op === "==") return String(a) === String(b);
+  if (op === "!=") return String(a) !== String(b);
+  return false;
+}
+function evaluateFormula(ast, read) {
+  const run = (node) => {
+    switch (node.kind) {
+      case "number":
+      case "text":
+        return node.value;
+      case "ref":
+        return read(node.column !== void 0 ? { key: node.key, column: node.column } : { key: node.key });
+      case "unary": {
+        const n = formulaNumber(scalar(run(node.arg)));
+        return n === null ? null : -n;
+      }
+      case "if":
+        return truthy(run(node.test)) ? run(node.then) : run(node.else);
+      case "call": {
+        const nums = numbersIn(node.args.map(run));
+        const total = nums.reduce((a, b) => a + b, 0);
+        if (node.fn === "sum") return finite(total);
+        if (!nums.length) return null;
+        if (node.fn === "avg") return finite(total / nums.length);
+        return nums.reduce((a, b) => node.fn === "min" ? Math.min(a, b) : Math.max(a, b));
+      }
+      case "binary": {
+        const a = run(node.left);
+        const b = run(node.right);
+        if (node.op === "+" || node.op === "-" || node.op === "*" || node.op === "/") {
+          const x = formulaNumber(scalar(a));
+          const y = formulaNumber(scalar(b));
+          if (x === null || y === null) return null;
+          if (node.op === "+") return finite(x + y);
+          if (node.op === "-") return finite(x - y);
+          if (node.op === "*") return finite(x * y);
+          return y === 0 ? null : finite(x / y);
+        }
+        return compare(node.op, a, b);
+      }
+    }
+  };
+  try {
+    return run(ast);
+  } catch {
+    return null;
+  }
+}
+
+// src/calculated.ts
+var CALCULATED_TYPE = "calculated";
+var MAX_CALCULATED_DECIMALS = 10;
+function calculatedProps(field) {
+  const p = field.props ?? {};
+  const out = { formula: typeof p.formula === "string" ? p.formula : "" };
+  if (p.format === "number" || p.format === "percent" || p.format === "text") out.format = p.format;
+  if (typeof p.decimals === "number" && Number.isInteger(p.decimals) && p.decimals >= 0 && p.decimals <= MAX_CALCULATED_DECIMALS) {
+    out.decimals = p.decimals;
+  }
+  return out;
+}
+var isCalculated = (field) => field?.type === CALCULATED_TYPE;
+var round = (n, decimals) => {
+  if (decimals === void 0) return n;
+  const r = Number(n.toFixed(decimals));
+  return Object.is(r, -0) ? 0 : r;
+};
+function calculatedValue(result, field) {
+  const { format, decimals } = calculatedProps(field);
+  if (result === null || Array.isArray(result)) return void 0;
+  if (format === "number" || format === "percent") {
+    const n = formulaNumber(result);
+    return n === null ? void 0 : round(n, decimals);
+  }
+  if (format === "text") {
+    if (typeof result === "number") return decimals === void 0 ? String(result) : result.toFixed(decimals);
+    return typeof result === "boolean" ? result ? "Yes" : "No" : result;
+  }
+  return typeof result === "number" ? round(result, decimals) : result;
+}
+function formatCalculated(value, field) {
+  if (value === void 0 || value === null) return "";
+  const { format, decimals } = calculatedProps(field);
+  const fixed = (n) => decimals === void 0 ? String(Number(n.toFixed(6))) : n.toFixed(decimals);
+  if (typeof value === "number") return format === "percent" ? `${fixed(value * 100)}%` : fixed(value);
+  if (typeof value === "boolean") return value ? "Yes" : "No";
+  return typeof value === "string" ? value : "";
+}
+var MAX_FORMULA_ITEMS = 1e4;
+function formulaInput(value, column) {
+  if (value === void 0 || value === null) return null;
+  if (Array.isArray(value) && value.length > MAX_FORMULA_ITEMS) return null;
+  if (column !== void 0) {
+    if (!Array.isArray(value)) return null;
+    return value.flatMap((row) => {
+      if (!row || typeof row !== "object" || Array.isArray(row)) return [];
+      const cell = row[column];
+      return typeof cell === "string" || typeof cell === "number" ? [cell] : [];
+    });
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((v) => typeof v === "string" || typeof v === "number" || typeof v === "boolean" ? [v] : []);
+  }
+  return typeof value === "object" ? null : value;
+}
+var UNREAD = /* @__PURE__ */ Symbol("unread");
+function calculator(definition) {
+  const compiled = [];
+  const idByKey = /* @__PURE__ */ new Map();
+  for (const block of definition.blocks) {
+    if (block.kind !== "field") continue;
+    idByKey.set(block.key, block.id);
+  }
+  for (const block of definition.blocks) {
+    if (block.kind !== "field" || !isCalculated(block)) continue;
+    const parsed = parseFormula(calculatedProps(block).formula);
+    const reads = parsed.ok ? parsed.refs.map((r) => idByKey.get(r.key)) : [];
+    compiled.push({ field: block, ast: parsed.ok ? parsed.ast : null, reads, last: null });
+  }
+  const withCalculated = (values, path) => {
+    if (!compiled.length) return values;
+    const visible = new Set(path);
+    let next = values;
+    const input = (id) => id === void 0 || !visible.has(id) || !Object.prototype.hasOwnProperty.call(next, id) ? UNREAD : next[id];
+    for (const entry of compiled) {
+      const { field, ast } = entry;
+      const inputs = entry.reads.map(input);
+      let value;
+      if (entry.last && entry.last.inputs.length === inputs.length && entry.last.inputs.every((v, i) => v === inputs[i])) {
+        value = entry.last.value;
+      } else {
+        const read = (ref) => {
+          const raw = input(idByKey.get(ref.key));
+          return raw === UNREAD ? null : formulaInput(raw, ref.column);
+        };
+        value = ast ? calculatedValue(evaluateFormula(ast, read), field) : void 0;
+        entry.last = { inputs, value };
+      }
+      const current = Object.prototype.hasOwnProperty.call(next, field.id) ? next[field.id] : void 0;
+      if (current !== value) next = { ...next, [field.id]: value };
+    }
+    return next;
+  };
+  return { active: compiled.length > 0, withCalculated };
+}
+var numberOps = ["eq", "neq", "lt", "lte", "gt", "gte", "in", "answered", "empty"];
+var calculatedFieldType = {
+  type: CALCULATED_TYPE,
+  label: "Calculated",
+  category: "advanced",
+  value: { json: true },
+  operators: numberOps,
+  a11y: { semantics: "control" },
+  // The engine works the value out; any number, text or true / false it made is valid.
+  validate: (value) => typeof value === "number" || typeof value === "string" || typeof value === "boolean" ? null : "This value is worked out from other answers.",
+  summarize: (value, field) => formatCalculated(value, field)
+};
+
 // src/structured.ts
 var isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
 function intProp(field, name, fallback, floor = 1) {
@@ -233,7 +636,7 @@ function intRange(field, min, maxDefault) {
   const max = typeof field.props?.max === "number" ? field.props.max : maxDefault;
   return { min, max };
 }
-var numberOps = ["eq", "neq", "lt", "lte", "gt", "gte", "in", "answered", "empty"];
+var numberOps2 = ["eq", "neq", "lt", "lte", "gt", "gte", "in", "answered", "empty"];
 var textOps = ["eq", "neq", "contains", "answered", "empty"];
 function maxLength(field, fallback) {
   return typeof field.props?.maxLength === "number" ? field.props.maxLength : fallback;
@@ -311,23 +714,30 @@ var builtins = [
     label: "Rating",
     category: "scale",
     value: { json: true },
-    operators: numberOps,
+    operators: numberOps2,
     a11y: { semantics: "group" },
     validate: (value, field) => {
       const { min, max } = intRange(field, 1, 5);
       return Number.isInteger(value) && value >= min && value <= max ? null : `Choose a rating from ${min} to ${max}.`;
     },
-    summarize: (value, field) => `${value}/${intRange(field, 1, 5).max}`
+    summarize: (value, field) => {
+      const { max } = intRange(field, 1, 5);
+      const end = scaleEndLabel(field, value, 1, max);
+      return end ? `${value}/${max} (${end})` : `${value}/${max}`;
+    }
   },
   {
     type: "nps",
     label: "Net Promoter Score",
     category: "scale",
     value: { json: true },
-    operators: numberOps,
+    operators: numberOps2,
     a11y: { semantics: "group" },
     validate: (value) => Number.isInteger(value) && value >= 0 && value <= 10 ? null : "Choose a score from 0 to 10.",
-    summarize: (value) => `${value}/10`
+    summarize: (value, field) => {
+      const end = scaleEndLabel(field, value, 0, 10);
+      return end ? `${value}/10 (${end})` : `${value}/10`;
+    }
   },
   {
     type: "single-choice",
@@ -361,9 +771,122 @@ var builtins = [
     a11y: { semantics: "group" },
     validate: (value) => typeof value === "boolean" ? null : "Choose yes or no.",
     summarize: (value) => value ? "Yes" : "No"
+  },
+  {
+    type: "dropdown",
+    label: "Dropdown",
+    category: "choice",
+    value: { json: true },
+    operators: ["eq", "neq", "in", "answered", "empty"],
+    a11y: { semantics: "control" },
+    validate: (value, field) => typeof value === "string" && choiceOptions(field).some((o) => o.value === value) ? null : "Choose one of the options.",
+    summarize: (value, field) => optionLabel(field, String(value))
+  },
+  {
+    type: "number",
+    label: "Number",
+    category: "text",
+    value: { json: true },
+    operators: numberOps2,
+    a11y: { semantics: "control", inputMode: "decimal" },
+    validate: (value, field) => {
+      if (typeof value !== "number" || !Number.isFinite(value)) return "Enter a number.";
+      const { min, max, step } = numberLimits(field);
+      if (min !== void 0 && max !== void 0 && (value < min || value > max)) {
+        return `Enter a number from ${min} to ${max}.`;
+      }
+      if (min !== void 0 && value < min) return `Enter ${min} or more.`;
+      if (max !== void 0 && value > max) return `Enter ${max} or less.`;
+      if (step !== void 0 && !onStep(value, min ?? 0, step)) {
+        return step === 1 && Number.isInteger(min ?? 0) ? "Enter a whole number." : `Enter a number in steps of ${step}.`;
+      }
+      return null;
+    },
+    summarize: (value) => String(value),
+    samples: (field) => {
+      const { min, max } = numberLimits(field);
+      return [min, max, 0, 1].filter((v) => v !== void 0);
+    }
+  },
+  {
+    type: "date",
+    label: "Date",
+    category: "date",
+    value: { json: true },
+    operators: ["eq", "neq", "answered", "empty"],
+    a11y: { semantics: "control" },
+    validate: (value, field) => {
+      if (typeof value !== "string" || !isIsoDate(value.trim())) return "Enter a date like 2026-10-22.";
+      const date = value.trim();
+      const { min, max } = dateLimits(field);
+      if (min && max && (date < min || date > max)) return `Choose a date from ${min} to ${max}.`;
+      if (min && date < min) return `Choose ${min} or later.`;
+      if (max && date > max) return `Choose ${max} or earlier.`;
+      return null;
+    },
+    normalize: (value) => typeof value === "string" ? value.trim() : value,
+    samples: (field) => {
+      const { min, max } = dateLimits(field);
+      return [min ?? max ?? "2000-01-01"];
+    }
+  },
+  {
+    type: "consent",
+    label: "Consent checkbox",
+    category: "choice",
+    value: { json: true },
+    operators: ["answered", "empty"],
+    a11y: { semantics: "group" },
+    // Unchecked is unanswered, so a required consent must be checked.
+    isEmpty: (value) => value === void 0 || value === null || value === false,
+    validate: (value) => value === true ? null : "Check the box to agree.",
+    summarize: () => "Agreed",
+    samples: () => [true]
   }
 ];
-for (const manifest of [...builtins, ...structuredFieldTypes]) registerFieldType(manifest);
+function scaleLabels(field) {
+  const out = {};
+  const low = field.props?.lowLabel;
+  const high = field.props?.highLabel;
+  if (typeof low === "string" && low.trim()) out.low = low.trim();
+  if (typeof high === "string" && high.trim()) out.high = high.trim();
+  return out;
+}
+function scaleEndLabel(field, value, min, max) {
+  const { low, high } = scaleLabels(field);
+  return value === min ? low : value === max ? high : void 0;
+}
+var finite2 = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
+function numberLimits(field) {
+  const out = {};
+  const min = finite2(field.props?.min);
+  const max = finite2(field.props?.max);
+  const step = finite2(field.props?.step);
+  if (min !== void 0) out.min = min;
+  if (max !== void 0) out.max = max;
+  if (step !== void 0 && step > 0) out.step = step;
+  return out;
+}
+function onStep(value, base, step) {
+  const n = (value - base) / step;
+  return Math.abs(n - Math.round(n)) < 1e-9 * Math.max(1, Math.abs(n));
+}
+function isIsoDate(value) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) return false;
+  const [y, m, d] = value.split("-").map(Number);
+  if (y < 1 || m < 1 || m > 12 || d < 1) return false;
+  const days = [31, y % 4 === 0 && (y % 100 !== 0 || y % 400 === 0) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  return d <= days[m - 1];
+}
+function dateLimits(field) {
+  const out = {};
+  const min = field.props?.min;
+  const max = field.props?.max;
+  if (typeof min === "string" && isIsoDate(min)) out.min = min;
+  if (typeof max === "string" && isIsoDate(max)) out.max = max;
+  return out;
+}
+for (const manifest of [...builtins, ...structuredFieldTypes, calculatedFieldType]) registerFieldType(manifest);
 
 // src/events.ts
 function isPlainObject(value) {
@@ -608,7 +1131,7 @@ function runCustom(validator, value) {
 }
 function validateField(field, value, options = {}) {
   if (isEmptyValue(value, field)) {
-    return field.required && options.requireAnswers !== false ? REQUIRED_MESSAGE : null;
+    return field.required && field.type !== CALCULATED_TYPE && options.requireAnswers !== false ? REQUIRED_MESSAGE : null;
   }
   const manifest = getFieldType(field.type);
   if (!manifest) return `Unknown field type "${field.type}".`;
@@ -639,9 +1162,21 @@ function build(definition, options, replaying = false) {
     if (!declared.has(name)) initialHidden[name] = value;
   }
   Object.assign(initialHidden, coerceHidden(definition, options.hidden).values);
-  const first = computePath(definition, scopeOf({}, initialHidden));
+  const calc = calculator(definition);
+  const settle = (values, hidden) => {
+    let { path } = computePath(definition, scopeOf(values, hidden));
+    if (!calc.active) return { values, path };
+    for (let round2 = 0; round2 < 4; round2++) {
+      const next = calc.withCalculated(values, path);
+      if (next === values) break;
+      values = next;
+      path = computePath(definition, scopeOf(values, hidden)).path;
+    }
+    return { values, path };
+  };
+  const first = settle({}, initialHidden);
   let state = {
-    values: {},
+    values: first.values,
     hidden: initialHidden,
     path: first.path,
     current: first.path[0] ?? null,
@@ -676,12 +1211,25 @@ function build(definition, options, replaying = false) {
     }
     return errors;
   };
+  let unsettled = false;
+  const settleNow = () => {
+    if (!unsettled) return;
+    unsettled = false;
+    const { values, path } = settle(state.values, state.hidden);
+    state = { ...state, values, path };
+  };
   const answer = (id, value, event) => {
-    if (state.status === "completed" || own(state.values, id) === value) return;
-    const values = { ...state.values, [id]: value };
-    const { path } = computePath(definition, scopeOf(values, state.hidden));
+    if (state.status === "completed" || own(state.values, id) === value || isCalculated(fields.get(id))) return;
     const errors = { ...state.errors };
     delete errors[id];
+    if (batch) {
+      state.values = { ...state.values, [id]: value };
+      state.errors = errors;
+      log(event);
+      unsettled = true;
+      return;
+    }
+    const { values, path } = settle({ ...state.values, [id]: value }, state.hidden);
     emit({ ...state, values, path, errors, events: log(event) });
   };
   const engine = {
@@ -753,10 +1301,14 @@ function build(definition, options, replaying = false) {
     }
   };
   if (options.initialValues) {
+    const wasBatch = batch;
+    batch = true;
     for (const [id, value] of Object.entries(options.initialValues)) {
       if (!fields.has(id) || value === void 0) continue;
       answer(id, value, stamp({ type: "answer", field: id, value, source: "prefill" }));
     }
+    settleNow();
+    batch = wasBatch;
   }
   const apply = (event) => {
     if (event.type === "answer") {
@@ -764,11 +1316,19 @@ function build(definition, options, replaying = false) {
         const { at: _at, ...logged } = event;
         answer(event.field, event.value, logged);
       }
-    } else if (event.type === "next") engine.next();
-    else if (event.type === "back") engine.back();
-    else if (event.type === "submit") engine.submit();
+    } else if (event.type === "next") {
+      settleNow();
+      engine.next();
+    } else if (event.type === "back") {
+      settleNow();
+      engine.back();
+    } else if (event.type === "submit") {
+      settleNow();
+      engine.submit();
+    }
   };
   const finish = () => {
+    settleNow();
     batch = false;
     state = { ...state, events: [...state.events] };
   };
@@ -829,6 +1389,7 @@ function dedupe(values) {
   });
 }
 function domainOf(field, extra, maxOptions) {
+  if (field.type === CALCULATED_TYPE) return dedupe([void 0, ...extra]).map((value) => ({ value }));
   const options = choiceOptions(field).map((o) => o.value);
   let base;
   switch (field.type) {
@@ -844,6 +1405,7 @@ function domainOf(field, extra, maxOptions) {
       base = [true, false];
       break;
     case "single-choice":
+    case "dropdown":
       base = options;
       break;
     case "multi-choice": {
@@ -981,8 +1543,15 @@ var LITERAL_TYPE = {
   "single-choice": "string",
   "multi-choice": "string",
   "yes-no": "boolean",
-  list: "string"
+  list: "string",
+  dropdown: "string",
+  number: "number",
+  date: "string",
+  consent: "boolean",
+  // A calculated field holds a number unless its format says text; see `literalType`.
+  calculated: "number"
 };
+var CHOICE_TYPES = /* @__PURE__ */ new Set(["single-choice", "multi-choice", "dropdown"]);
 var ORDERING = /* @__PURE__ */ new Set(["lt", "lte", "gt", "gte"]);
 var OPERATORS = /* @__PURE__ */ new Set([
   "eq",
@@ -1062,7 +1631,44 @@ function parseForm(input) {
     } else if (type === "text-highlights") {
       optionalText(props.text, `${path}.text`);
       optionalInt(props.maxHighlights, `${path}.maxHighlights`, 1);
+    } else if (type === CALCULATED_TYPE) {
+      if (props.format !== void 0 && props.format !== "number" && props.format !== "percent" && props.format !== "text") {
+        issue(`${path}.format`, "Must be number, percent or text.");
+      }
+      if (props.decimals !== void 0 && !(isInt(props.decimals) && props.decimals >= 0 && props.decimals <= MAX_CALCULATED_DECIMALS)) {
+        issue(`${path}.decimals`, `Must be a whole number from 0 to ${MAX_CALCULATED_DECIMALS}.`);
+      }
+    }
+  };
+  const isFiniteNumber = (v) => typeof v === "number" && Number.isFinite(v);
+  const fieldProps = (type, props, path) => {
+    if (type === "rating" || type === "nps") {
+      optionalText(props.lowLabel, `${path}.lowLabel`);
+      optionalText(props.highLabel, `${path}.highLabel`);
+    }
+    if (type === "rating" && props.display !== void 0 && props.display !== "numbers" && props.display !== "stars") {
+      issue(`${path}.display`, "Must be numbers or stars.");
+    }
+    if (type === "number") {
+      for (const k of ["min", "max", "step"]) {
+        if (props[k] !== void 0 && !isFiniteNumber(props[k])) issue(`${path}.${k}`, "Must be a number.");
+      }
+      if (isFiniteNumber(props.step) && props.step <= 0) issue(`${path}.step`, "Must be above 0.");
+      if (isFiniteNumber(props.min) && isFiniteNumber(props.max) && props.min > props.max) {
+        issue(`${path}.min`, "Can't be more than the largest number.");
+      }
+    }
+    if (type === "date") {
+      for (const k of ["min", "max"]) {
+        if (props[k] !== void 0 && !(typeof props[k] === "string" && isIsoDate(props[k]))) {
+          issue(`${path}.${k}`, "Must be a date like 2026-10-22.");
+        }
+      }
+      if (typeof props.min === "string" && typeof props.max === "string" && isIsoDate(props.min) && isIsoDate(props.max) && props.min > props.max) {
+        issue(`${path}.min`, "Can't be after the latest date.");
+      }
     }
+    if (type === "consent") optionalText(props.text, `${path}.text`);
   };
   if (!isObject2(input)) {
     issue("", "A form definition must be an object.");
@@ -1097,7 +1703,9 @@ function parseForm(input) {
   const keys = /* @__PURE__ */ new Map();
   const fieldTypes = /* @__PURE__ */ new Map();
   const order = /* @__PURE__ */ new Map();
+  const tableColumnKeys = /* @__PURE__ */ new Map();
   const choices = /* @__PURE__ */ new Map();
+  const calculatedLiteral = /* @__PURE__ */ new Map();
   input.blocks.forEach((block, i) => {
     const path = `blocks[${i}]`;
     if (!isObject2(block) || typeof block.id !== "string" || !block.id) {
@@ -1147,12 +1755,24 @@ function parseForm(input) {
       }
       if (typeof block.type === "string" && (block.props === void 0 || isObject2(block.props))) {
         structuredProps(block.type, block.props ?? {}, `${path}.props`);
+        fieldProps(block.type, block.props ?? {}, `${path}.props`);
       }
       if (validKey) {
         if (keys.has(block.key)) issue(`${path}.key`, `Duplicate key "${String(block.key)}".`);
         keys.set(block.key, block.id);
       }
       fieldTypes.set(block.id, typeof block.type === "string" ? block.type : "");
+      if (block.type === CALCULATED_TYPE) {
+        const format = isObject2(block.props) ? block.props.format : void 0;
+        if (format === "text") calculatedLiteral.set(block.id, "string");
+        else if (format !== "number" && format !== "percent") calculatedLiteral.set(block.id, void 0);
+      }
+      if (block.type === "table" && isObject2(block.props) && Array.isArray(block.props.columns)) {
+        tableColumnKeys.set(
+          block.id,
+          new Set(block.props.columns.flatMap((c) => isObject2(c) && typeof c.key === "string" ? [c.key] : []))
+        );
+      }
     } else if (block.kind === "content") {
       if (block.type !== "heading" && block.type !== "text") issue(`${path}.type`, "Must be heading or text.");
       text(block.text, `${path}.text`);
@@ -1162,6 +1782,38 @@ function parseForm(input) {
       issue(`${path}.kind`, "Unknown block kind.");
     }
   });
+  input.blocks.forEach((block, i) => {
+    if (!isObject2(block) || block.kind !== "field" || block.type !== CALCULATED_TYPE) return;
+    const path = `blocks[${i}].props.formula`;
+    if (block.required === true) {
+      warnings.push({ path: `blocks[${i}].required`, message: "A calculated field is worked out, not answered, so it is never required." });
+    }
+    const formula = isObject2(block.props) ? block.props.formula : void 0;
+    if (typeof formula !== "string" || !formula.trim()) return issue(path, "A calculated field needs a formula.");
+    const parsed = parseFormula(formula);
+    if (!parsed.ok) return issue(path, `${parsed.message} (at character ${parsed.at + 1})`);
+    const reported = /* @__PURE__ */ new Set();
+    for (const ref of parsed.refs) {
+      const name2 = ref.column === void 0 ? ref.key : `${ref.key}.${ref.column}`;
+      if (reported.has(name2)) continue;
+      reported.add(name2);
+      const target = keys.get(ref.key);
+      const targetType = target === void 0 ? void 0 : fieldTypes.get(target);
+      const at = target === void 0 ? void 0 : order.get(target);
+      if (target === void 0 || targetType === void 0) issue(path, `The formula uses "${ref.key}", which is not the answer name of a question in this form.`);
+      else if (target === block.id) issue(path, "The formula uses this field's own value.");
+      else if (targetType === CALCULATED_TYPE && (at ?? 0) > i) {
+        issue(path, `The formula uses "${ref.key}", a calculated field that comes after this one; move it earlier.`);
+      } else if (targetType === "table") {
+        const columns = tableColumnKeys.get(target);
+        if (ref.column === void 0) issue(path, `"${ref.key}" is a table: name one of its columns, like ${ref.key}.${[...columns ?? []][0] ?? "column"}.`);
+        else if (columns && !columns.has(ref.column)) issue(path, `The table "${ref.key}" has no column "${ref.column}".`);
+      } else if (ref.column !== void 0) issue(path, `"${ref.key}" is not a table, so it has no column "${ref.column}".`);
+      else if (targetType === "media-notes" || targetType === "text-highlights") {
+        warnings.push({ path, message: `"${ref.key}" holds notes, not numbers; the formula reads it as blank.` });
+      }
+    }
+  });
   const hiddenNames = /* @__PURE__ */ new Set();
   const hiddenTypes = /* @__PURE__ */ new Map();
   if (input.hidden !== void 0 && !Array.isArray(input.hidden)) issue("hidden", "Must be an array.");
@@ -1245,8 +1897,8 @@ function parseForm(input) {
     if (typeof left.field === "string" && fieldTypes.has(left.field)) {
       const fieldType = fieldTypes.get(left.field);
       what = `"${keyOf(left.field)}"`;
-      type = LITERAL_TYPE[fieldType];
-      if (fieldType === "single-choice" || fieldType === "multi-choice") options = choices.get(left.field);
+      type = calculatedLiteral.has(left.field) ? calculatedLiteral.get(left.field) : LITERAL_TYPE[fieldType];
+      if (CHOICE_TYPES.has(fieldType)) options = choices.get(left.field);
     } else if (typeof left.hidden === "string" && hiddenTypes.has(left.hidden)) {
       what = `hidden input "${left.hidden}"`;
       type = hiddenTypes.get(left.hidden);
@@ -1401,6 +2053,7 @@ function validateSubmission(definition, submission, options = {}) {
   const fields = fieldMap(definition);
   const accept = (id) => {
     if (!fields.has(id)) return void ignored.add(id);
+    if (isCalculated(fields.get(id))) return false;
     if (!withheld(definition, fields.get(id))) return true;
     ignored.add(id);
     return false;