@marktiderman/genesis-forms 0.8.0 → 0.9.0

package/dist/server.cjs

@@ -1,5 +1,44 @@
 'use strict';
 
+// src/props-check.ts
+var RESERVED_NAMES = new Set(Object.getOwnPropertyNames(Object.prototype));
+var isPlainRecord = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var isWholeNumber = (v) => typeof v === "number" && Number.isInteger(v);
+var isFiniteNumber = (v) => typeof v === "number" && Number.isFinite(v);
+function propsChecker(prefix, report) {
+  const at = (path) => path ? `${prefix}.${path}` : prefix;
+  const issue = (path, message) => report(at(path), message);
+  return {
+    issue,
+    text(v, path, nonEmpty = false) {
+      if (typeof v !== "string" || nonEmpty && !v) issue(path, nonEmpty ? "Required." : "Required text.");
+    },
+    optionalText(v, path) {
+      if (v !== void 0 && typeof v !== "string") issue(path, "Must be text.");
+    },
+    optionalBoolean(v, path) {
+      if (v !== void 0 && typeof v !== "boolean") issue(path, "Must be true or false.");
+    },
+    optionalInt(v, path, floor) {
+      if (v !== void 0 && !(isWholeNumber(v) && v >= floor)) issue(path, `Must be a whole number of ${floor} or more.`);
+    },
+    ordered(low, high, path, what) {
+      if (isWholeNumber(low) && isWholeNumber(high) && low > high) issue(path, `Can't be more than the ${what}.`);
+    },
+    name(v, path, what) {
+      if (typeof v !== "string" || !v) {
+        issue(path, `${what} must be a non-empty string.`);
+        return false;
+      }
+      if (RESERVED_NAMES.has(v)) {
+        issue(path, `"${v}" is reserved and cannot be used as ${what.toLowerCase()}.`);
+        return false;
+      }
+      return true;
+    }
+  };
+}
+
 // src/formula.ts
 var FORMULA_FUNCTIONS = ["sum", "avg", "min", "max"];
 var MAX_FORMULA_LENGTH = 2e3;
@@ -426,11 +465,11 @@ function calculator(definition, work) {
   for (const block of definition.blocks) {
     if (block.kind !== "field" || !isCalculated(block)) continue;
     const props = calculatedProps(block);
-    const parsed = parseFormula(props.formula);
+    const parsed2 = parseFormula(props.formula);
     const reads = [];
     const slots = /* @__PURE__ */ new Map();
     const byKey = /* @__PURE__ */ new Map();
-    for (const ref of parsed.ok ? refNodes(parsed.ast) : []) {
+    for (const ref of parsed2.ok ? refNodes(parsed2.ast) : []) {
       const id = idByKey.get(ref.key);
       const key = `${id ?? ""}\0${ref.column ?? ""}`;
       let slot = byKey.get(key);
@@ -440,7 +479,7 @@ function calculator(definition, work) {
       }
       slots.set(ref, slot);
     }
-    compiled.push({ field: block, props, ast: parsed.ok ? parsed.ast : null, size: parsed.ok ? formulaSize(parsed.ast) : 0, reads, slots, last: null });
+    compiled.push({ field: block, props, ast: parsed2.ok ? parsed2.ast : null, size: parsed2.ok ? formulaSize(parsed2.ast) : 0, reads, slots, last: null });
   }
   const extracted = /* @__PURE__ */ new WeakMap();
   const cachedList = (value, column) => {
@@ -534,6 +573,17 @@ var calculatedFieldType = {
   value: { json: true },
   operators: numberOps,
   a11y: { semantics: "control" },
+  // A number, unless the format says text; without a format it can hold either, so it isn't known.
+  literal: (props) => props.format === "text" ? "string" : props.format === "number" || props.format === "percent" ? "number" : void 0,
+  // The formula itself is checked once every key is known (`parseForm`).
+  checkProps: (props, check) => {
+    if (props.format !== void 0 && props.format !== "number" && props.format !== "percent" && props.format !== "text") {
+      check.issue("format", "Must be number, percent or text.");
+    }
+    if (props.decimals !== void 0 && !(isWholeNumber(props.decimals) && props.decimals >= 0 && props.decimals <= MAX_CALCULATED_DECIMALS)) {
+      check.issue("decimals", `Must be a whole number from 0 to ${MAX_CALCULATED_DECIMALS}.`);
+    }
+  },
   // 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)
@@ -591,12 +641,42 @@ var MAX_HIGHLIGHT_NOTE_LENGTH = 1e3;
 var MAX_HIGHLIGHT_QUOTE_LENGTH = 2e3;
 var HIGHLIGHT_NOTE_MESSAGE = "Add a note to each highlight.";
 var sourceText = (field) => typeof field.props?.text === "string" && field.props.text ? field.props.text : void 0;
+var listProps = (props, check) => {
+  check.optionalInt(props.min, "min", 0);
+  check.optionalInt(props.max, "max", 1);
+  check.optionalInt(props.itemMaxLength, "itemMaxLength", 1);
+  check.optionalText(props.placeholder, "placeholder");
+  check.ordered(props.min, props.max ?? 10, "min", "most items");
+};
+var tableProps = (props, check) => {
+  const columns = props.columns;
+  if (!Array.isArray(columns) || columns.length < 1 || columns.length > MAX_TABLE_COLUMNS) {
+    check.issue("columns", `Must be a list of 1 to ${MAX_TABLE_COLUMNS} columns.`);
+  } else {
+    const seen = /* @__PURE__ */ new Set();
+    columns.forEach((c, j) => {
+      const at = `columns[${j}]`;
+      if (!isPlainRecord(c)) return check.issue(at, "Each column needs a key and a label.");
+      if (check.name(c.key, `${at}.key`, "A column key")) {
+        if (seen.has(c.key)) check.issue(`${at}.key`, `Duplicate column key "${c.key}".`);
+        seen.add(c.key);
+      }
+      check.text(c.label, `${at}.label`);
+      check.optionalBoolean(c.long, `${at}.long`);
+    });
+  }
+  check.optionalInt(props.minRows, "minRows", 0);
+  check.optionalInt(props.maxRows, "maxRows", 1);
+  check.ordered(props.minRows, props.maxRows ?? 3, "minRows", "most rows");
+};
 var structuredFieldTypes = [
   {
     type: "list",
     label: "List",
     category: "text",
     value: { json: true },
+    literal: "string",
+    checkProps: listProps,
     // logic.ts `contains` on an array is exact item equality, same as multi-choice, so it is offered.
     operators: ["contains", "answered", "empty"],
     a11y: { semantics: "group" },
@@ -622,6 +702,7 @@ var structuredFieldTypes = [
     label: "Table",
     category: "advanced",
     value: { json: true },
+    checkProps: tableProps,
     operators: ["answered", "empty"],
     a11y: { semantics: "group" },
     isEmpty: (value) => emptyList(value, (r) => isObject(r) && Object.values(r).every(blankText)),
@@ -665,6 +746,10 @@ var structuredFieldTypes = [
     label: "Notes at moments",
     category: "media",
     value: { json: true },
+    checkProps: (props, check) => {
+      check.optionalInt(props.maxNotes, "maxNotes", 1);
+      check.optionalInt(props.textMaxLength, "textMaxLength", 1);
+    },
     operators: ["answered", "empty"],
     a11y: { semantics: "group" },
     isEmpty: (value) => emptyList(value, (n) => isObject(n) && blankText(n.text)),
@@ -688,6 +773,10 @@ var structuredFieldTypes = [
     label: "Highlights",
     category: "media",
     value: { json: true },
+    checkProps: (props, check) => {
+      check.optionalText(props.text, "text");
+      check.optionalInt(props.maxHighlights, "maxHighlights", 1);
+    },
     operators: ["answered", "empty"],
     a11y: { semantics: "group" },
     isEmpty: (value) => emptyList(value, () => false),
@@ -780,6 +869,22 @@ var photoFieldType = {
   value: { json: true },
   operators: ["answered", "empty"],
   a11y: { semantics: "group" },
+  checkProps: (props, check) => {
+    if (props.maxFiles !== void 0 && !(isWholeNumber(props.maxFiles) && props.maxFiles >= 1 && props.maxFiles <= MAX_PHOTO_FILES)) {
+      check.issue("maxFiles", `Must be a whole number from 1 to ${MAX_PHOTO_FILES}.`);
+    }
+    if (props.maxSizeMb !== void 0 && !(isWholeNumber(props.maxSizeMb) && props.maxSizeMb >= 1 && props.maxSizeMb <= MAX_PHOTO_SIZE_MB)) {
+      check.issue("maxSizeMb", `Must be a whole number from 1 to ${MAX_PHOTO_SIZE_MB}.`);
+    }
+    if (props.formats !== void 0) {
+      const formats = props.formats;
+      if (!Array.isArray(formats) || formats.length === 0 || !formats.every(isPhotoFormat)) {
+        check.issue("formats", "Must be a list of one or more of jpeg, png, heic and webp.");
+      } else if (new Set(formats).size !== formats.length) {
+        check.issue("formats", "Name each format once.");
+      }
+    }
+  },
   isEmpty: (value) => value === void 0 || value === null || Array.isArray(value) && value.length === 0,
   validate: (value, field) => {
     if (!Array.isArray(value) || !value.every(isPhotoRef)) return "Add a photo.";
@@ -797,22 +902,59 @@ var photoFieldType = {
 };
 
 // src/fields.ts
-var REGISTRY = /* @__PURE__ */ Symbol.for("@marktiderman/genesis-forms/field-types");
+var VALIDATOR_FAILED_MESSAGE = "This answer couldn't be checked.";
+var REGISTRY = /* @__PURE__ */ Symbol.for("@marktiderman/genesis-forms/field-types@2");
+var BUILT_IN = /* @__PURE__ */ Symbol.for("@marktiderman/genesis-forms/built-in-field-types@2");
 var globalScope = globalThis;
 var registry = globalScope[REGISTRY] ??= /* @__PURE__ */ new Map();
-function registerFieldType(manifest) {
-  if (!manifest.type) throw new Error("registerFieldType: a field type needs a `type`.");
-  const value = manifest.value;
-  if (!value.json && (typeof value.serialize !== "function" || typeof value.deserialize !== "function")) {
-    throw new Error(
-      `registerFieldType: "${manifest.type}" stores a non-JSON value, so it must provide both serialize and deserialize.`
-    );
+var builtIn = globalScope[BUILT_IN] ??= /* @__PURE__ */ new Set();
+var freezeRecord = (v) => v && typeof v === "object" && !Array.isArray(v) ? Object.freeze({ ...v }) : v;
+function frozen(manifest) {
+  const copy = { ...manifest };
+  for (const key of ["choice", "a11y", "value"]) if (key in copy) copy[key] = freezeRecord(copy[key]);
+  if (Array.isArray(copy.operators)) {
+    const operators = Object.freeze([...copy.operators]);
+    Object.defineProperty(copy, "operators", { get: () => [...operators], enumerable: true });
   }
-  registry.set(manifest.type, manifest);
+  return Object.freeze(copy);
+}
+function registerBuiltIn(manifest) {
+  builtIn.add(manifest.type);
+  if (!registry.has(manifest.type)) registry.set(manifest.type, frozen(manifest));
 }
 function getFieldType(type) {
   return registry.get(type);
 }
+function choiceKind(type) {
+  return registry.get(type)?.choice;
+}
+function isChoiceField(block) {
+  return !!block && block.kind === "field" && typeof block.type === "string" && choiceKind(block.type) !== void 0;
+}
+function literalType(type, props) {
+  const literal = registry.get(type)?.literal;
+  if (typeof literal !== "function") return literal;
+  try {
+    return literal(props);
+  } catch {
+    return void 0;
+  }
+}
+var CONTENT_REGISTRY = /* @__PURE__ */ Symbol.for("@marktiderman/genesis-forms/content-types@1");
+var contentScope = globalThis;
+var contentRegistry = contentScope[CONTENT_REGISTRY] ??= /* @__PURE__ */ new Map();
+function getContentType(type) {
+  return contentRegistry.get(type);
+}
+function listContentTypes() {
+  return [...contentRegistry.values()];
+}
+for (const manifest of [
+  { type: "heading", label: "Heading" },
+  { type: "text", label: "Text" }
+]) {
+  if (!contentRegistry.has(manifest.type)) contentRegistry.set(manifest.type, frozen(manifest));
+}
 function isEmptyValue(value, field) {
   const manifest = field ? registry.get(field.type) : void 0;
   if (manifest?.isEmpty) return manifest.isEmpty(value);
@@ -995,6 +1137,18 @@ function isPhoneNumber(value) {
   }
   return digits >= 7 && digits <= 15;
 }
+var oneOptionValidate = (value, field) => typeof value === "string" && (choiceOptions(field).some((o) => o.value === value) || typedOther(field, value)) ? null : "Choose one of the options.";
+var oneOptionSummary = (value, field) => optionLabel(field, String(value));
+var optionsValidate = (value, field) => {
+  const allowed = new Set(choiceOptions(field).map((o) => o.value));
+  const others = Array.isArray(value) ? value.filter((v) => typeof v === "string" && !allowed.has(v)) : [];
+  return Array.isArray(value) && new Set(value).size === value.length && value.every((v) => typeof v === "string") && (others.length === 0 || others.length === 1 && typedOther(field, others[0])) ? null : "Choose from the options.";
+};
+var optionsSummary = (value, field) => Array.isArray(value) ? value.map((v) => optionLabel(field, String(v))).join(", ") : String(value);
+var scaleProps = (props, check) => {
+  check.optionalText(props.lowLabel, "lowLabel");
+  check.optionalText(props.highLabel, "highLabel");
+};
 var builtins = [
   {
     type: "short-text",
@@ -1003,6 +1157,7 @@ var builtins = [
     value: { json: true },
     operators: textOps,
     a11y: { semantics: "control" },
+    literal: "string",
     validate: textValidate(500)
   },
   {
@@ -1012,6 +1167,7 @@ var builtins = [
     value: { json: true },
     operators: textOps,
     a11y: { semantics: "control" },
+    literal: "string",
     validate: textValidate(5e3)
   },
   {
@@ -1021,6 +1177,7 @@ var builtins = [
     value: { json: true },
     operators: textOps,
     a11y: { semantics: "control", autocomplete: "email", inputMode: "email" },
+    literal: "string",
     validate: (value) => typeof value === "string" && isEmailAddress(value.trim()) ? null : "Enter an email address like name@example.com.",
     normalize: (value) => typeof value === "string" ? value.trim() : value
   },
@@ -1031,6 +1188,7 @@ var builtins = [
     value: { json: true },
     operators: ["eq", "neq", "answered", "empty"],
     a11y: { semantics: "control", autocomplete: "tel", inputMode: "tel" },
+    literal: "string",
     validate: (value) => typeof value === "string" && isPhoneNumber(value.trim()) ? null : "Enter a phone number with 7 to 15 digits.",
     normalize: (value) => typeof value === "string" ? value.trim() : value,
     summarize: (value) => String(value)
@@ -1042,6 +1200,13 @@ var builtins = [
     value: { json: true },
     operators: numberOps2,
     a11y: { semantics: "group" },
+    literal: "number",
+    checkProps: (props, check) => {
+      scaleProps(props, check);
+      if (props.display !== void 0 && props.display !== "numbers" && props.display !== "stars") {
+        check.issue("display", "Must be numbers or stars.");
+      }
+    },
     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}.`;
@@ -1059,6 +1224,8 @@ var builtins = [
     value: { json: true },
     operators: numberOps2,
     a11y: { semantics: "group" },
+    literal: "number",
+    checkProps: scaleProps,
     validate: (value) => Number.isInteger(value) && value >= 0 && value <= 10 ? null : "Choose a score from 0 to 10.",
     summarize: (value, field) => {
       const end = scaleEndLabel(field, value, 0, 10);
@@ -1072,8 +1239,10 @@ var builtins = [
     value: { json: true },
     operators: ["eq", "neq", "in", "answered", "empty"],
     a11y: { semantics: "group" },
-    validate: (value, field) => typeof value === "string" && (choiceOptions(field).some((o) => o.value === value) || typedOther(field, value)) ? null : "Choose one of the options.",
-    summarize: (value, field) => optionLabel(field, String(value))
+    literal: "string",
+    choice: { multiple: false },
+    validate: oneOptionValidate,
+    summarize: oneOptionSummary
   },
   {
     type: "multi-choice",
@@ -1082,12 +1251,10 @@ var builtins = [
     value: { json: true },
     operators: ["contains", "answered", "empty"],
     a11y: { semantics: "group" },
-    validate: (value, field) => {
-      const allowed = new Set(choiceOptions(field).map((o) => o.value));
-      const others = Array.isArray(value) ? value.filter((v) => typeof v === "string" && !allowed.has(v)) : [];
-      return Array.isArray(value) && new Set(value).size === value.length && value.every((v) => typeof v === "string") && (others.length === 0 || others.length === 1 && typedOther(field, others[0])) ? null : "Choose from the options.";
-    },
-    summarize: (value, field) => Array.isArray(value) ? value.map((v) => optionLabel(field, String(v))).join(", ") : String(value)
+    literal: "string",
+    choice: { multiple: true },
+    validate: optionsValidate,
+    summarize: optionsSummary
   },
   {
     type: "yes-no",
@@ -1096,6 +1263,7 @@ var builtins = [
     value: { json: true },
     operators: ["eq", "neq", "answered", "empty"],
     a11y: { semantics: "group" },
+    literal: "boolean",
     validate: (value) => typeof value === "boolean" ? null : "Choose yes or no.",
     summarize: (value) => value ? "Yes" : "No"
   },
@@ -1106,8 +1274,10 @@ var builtins = [
     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) || typedOther(field, value)) ? null : "Choose one of the options.",
-    summarize: (value, field) => optionLabel(field, String(value))
+    literal: "string",
+    choice: { multiple: false },
+    validate: oneOptionValidate,
+    summarize: oneOptionSummary
   },
   {
     type: "number",
@@ -1116,6 +1286,16 @@ var builtins = [
     value: { json: true },
     operators: numberOps2,
     a11y: { semantics: "control", inputMode: "decimal" },
+    literal: "number",
+    checkProps: (props, check) => {
+      for (const k of ["min", "max", "step"]) {
+        if (props[k] !== void 0 && !isFiniteNumber(props[k])) check.issue(k, "Must be a number.");
+      }
+      if (isFiniteNumber(props.step) && props.step <= 0) check.issue("step", "Must be above 0.");
+      if (isFiniteNumber(props.min) && isFiniteNumber(props.max) && props.min > props.max) {
+        check.issue("min", "Can't be more than the largest number.");
+      }
+    },
     validate: (value, field) => {
       if (typeof value !== "number" || !Number.isFinite(value)) return "Enter a number.";
       const { min, max, step } = numberLimits(field);
@@ -1142,6 +1322,17 @@ var builtins = [
     value: { json: true },
     operators: ["eq", "neq", "answered", "empty"],
     a11y: { semantics: "control" },
+    literal: "string",
+    checkProps: (props, check) => {
+      for (const k of ["min", "max"]) {
+        if (props[k] !== void 0 && !(typeof props[k] === "string" && isIsoDate(props[k]))) {
+          check.issue(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) {
+        check.issue("min", "Can't be after the latest date.");
+      }
+    },
     validate: (value, field) => {
       if (typeof value !== "string" || !isIsoDate(value.trim())) return "Enter a date like 2026-10-22.";
       const date = value.trim();
@@ -1164,6 +1355,8 @@ var builtins = [
     value: { json: true },
     operators: ["answered", "empty"],
     a11y: { semantics: "group" },
+    literal: "boolean",
+    checkProps: (props, check) => check.optionalText(props.text, "text"),
     // 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.",
@@ -1213,7 +1406,7 @@ function dateLimits(field) {
   if (typeof max === "string" && isIsoDate(max)) out.max = max;
   return out;
 }
-for (const manifest of [...builtins, ...structuredFieldTypes, calculatedFieldType, photoFieldType]) registerFieldType(manifest);
+for (const manifest of [...builtins, ...structuredFieldTypes, calculatedFieldType, photoFieldType]) registerBuiltIn(manifest);
 
 // src/events.ts
 function isPlainObject(value) {
@@ -1430,8 +1623,8 @@ function fieldMap(def) {
 }
 
 // src/options.ts
-var CHOICE_FIELD_TYPES = /* @__PURE__ */ new Set(["single-choice", "multi-choice", "dropdown"]);
-var isChoice = (block) => !!block && block.kind === "field" && CHOICE_FIELD_TYPES.has(block.type);
+var isChoice = isChoiceField;
+var isMultiple = (field) => choiceKind(field.type)?.multiple === true;
 function put(record, key, value) {
   Object.defineProperty(record, key, { value, enumerable: true, writable: true, configurable: true });
 }
@@ -1512,7 +1705,7 @@ function isPrefillParam(param) {
   return typeof param === "string" && param.length <= MAX_PREFILL_PARAM_LENGTH && /^[A-Za-z0-9_.-]+$/.test(param);
 }
 function prefillSetting(field) {
-  if (!CHOICE_FIELD_TYPES.has(field.type)) return void 0;
+  if (!choiceKind(field.type)) return void 0;
   const raw = field.props?.prefill;
   if (!raw || typeof raw !== "object" || Array.isArray(raw) || !isPrefillParam(raw.param)) return void 0;
   return { param: raw.param, hideWhenPrefilled: raw.hideWhenPrefilled === true };
@@ -1540,7 +1733,7 @@ function prefillFromLink(definition, params, values = {}) {
     if (!raw.length) continue;
     const shown2 = new Set(visibleOptions(definition, block, seen).map((o) => o.value));
     let value;
-    if (block.type === "multi-choice") {
+    if (isMultiple(block)) {
       const picked = [];
       for (const r of raw) {
         for (const v of shown2.has(r) ? [r] : r.split(",").map((s) => s.trim())) {
@@ -1583,6 +1776,21 @@ function snapshotOf(byValue, value) {
 function answerSnapshots(definition, answers) {
   const out = {};
   for (const block of definition.blocks) {
+    if (block.kind !== "field") continue;
+    const manifest = getFieldType(block.type);
+    const custom = manifest?.choice ? void 0 : manifest?.snapshot;
+    if (custom) {
+      const value2 = own(answers, block.id);
+      if (isEmptyValue(value2, block)) continue;
+      let snapshot2;
+      try {
+        snapshot2 = custom(value2, block);
+      } catch {
+        snapshot2 = void 0;
+      }
+      if (snapshot2 !== void 0) put(out, block.id, snapshot2);
+      continue;
+    }
     if (!isChoice(block) || !optionsSource(block)) continue;
     const value = own(answers, block.id);
     if (isEmptyValue(value, block)) continue;
@@ -1600,6 +1808,22 @@ function answersFromSnapshots(definition, snapshots) {
   const answers = {};
   const missing = {};
   for (const block of definition.blocks) {
+    if (block.kind !== "field") continue;
+    const manifest = getFieldType(block.type);
+    const custom = manifest?.choice ? void 0 : manifest?.fromSnapshot;
+    if (custom) {
+      const raw2 = own(snapshots, block.id);
+      if (raw2 === void 0) continue;
+      let restored;
+      try {
+        restored = custom(raw2, block);
+      } catch {
+        restored = void 0;
+      }
+      if (restored?.value !== void 0) put(answers, block.id, restored.value);
+      if (Array.isArray(restored?.missing) && restored.missing.length) put(missing, block.id, restored.missing);
+      continue;
+    }
     if (!isChoice(block)) continue;
     const raw = own(snapshots, block.id);
     const list = (Array.isArray(raw) ? raw : raw === void 0 ? [] : [raw]).flatMap((s) => {
@@ -1622,7 +1846,7 @@ function answersFromSnapshots(definition, snapshots) {
       if (value === void 0) lost.push(s);
       else if (!found.includes(value)) found.push(value);
     }
-    if (found.length) put(answers, block.id, block.type === "multi-choice" ? found : found[0]);
+    if (found.length) put(answers, block.id, isMultiple(block) ? found : found[0]);
     if (lost.length) put(missing, block.id, lost);
   }
   return { answers, missing };
@@ -1663,8 +1887,13 @@ function validateField(field, value, options = {}) {
   }
   const manifest = getFieldType(field.type);
   if (!manifest) return `Unknown field type "${field.type}".`;
-  const builtIn = manifest.validate?.(value, field) ?? null;
-  if (builtIn) return builtIn;
+  let builtIn2;
+  try {
+    builtIn2 = manifest.validate?.(value, field) ?? null;
+  } catch {
+    builtIn2 = VALIDATOR_FAILED_MESSAGE;
+  }
+  if (builtIn2) return builtIn2;
   return options.custom ? runCustom(options.custom, value) : null;
 }
 
@@ -1966,25 +2195,6 @@ function shown(v) {
 }
 var isObject2 = (v) => !!v && typeof v === "object" && !Array.isArray(v);
 var isInt = (v) => typeof v === "number" && Number.isInteger(v);
-var LITERAL_TYPE = {
-  "short-text": "string",
-  "long-text": "string",
-  email: "string",
-  phone: "string",
-  rating: "number",
-  nps: "number",
-  "single-choice": "string",
-  "multi-choice": "string",
-  "yes-no": "boolean",
-  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",
@@ -1998,8 +2208,11 @@ var OPERATORS = /* @__PURE__ */ new Set([
   "answered",
   "empty"
 ]);
-var RESERVED = new Set(Object.getOwnPropertyNames(Object.prototype));
 var MAX_CONDITION_DEPTH = 32;
+function contentKinds() {
+  const names = listContentTypes().map((c) => c.type);
+  return names.length > 1 ? `${names.slice(0, -1).join(", ")} or ${names[names.length - 1]}` : names[0] ?? "a registered content type";
+}
 function parseForm(input) {
   const issues = [];
   const warnings = [];
@@ -2029,7 +2242,7 @@ function parseForm(input) {
     }
     const fits = (x) => typeof x === "string" && x.length <= OPTION_LIMITS.attributeValue;
     for (const [name2, v] of Object.entries(attributes)) {
-      if (!name2.trim() || name2.length > OPTION_LIMITS.attributeName || RESERVED.has(name2)) {
+      if (!name2.trim() || name2.length > OPTION_LIMITS.attributeName || RESERVED_NAMES.has(name2)) {
         issue(`${at}.attributes`, `${shown(name2)} isn't a usable attribute name (at most ${OPTION_LIMITS.attributeName} characters).`);
       } else if (!fits(v) && !(Array.isArray(v) && v.length <= OPTION_LIMITS.attributeItems && v.every(fits))) {
         issue(
@@ -2044,104 +2257,18 @@ function parseForm(input) {
       issue(path, `${what} must be a non-empty string.`);
       return false;
     }
-    if (RESERVED.has(v)) {
+    if (RESERVED_NAMES.has(v)) {
       issue(path, `"${v}" is reserved and cannot be used as ${what.toLowerCase()}.`);
       return false;
     }
     return true;
   };
-  const optionalInt = (v, path, floor) => {
-    if (v !== void 0 && !(isInt(v) && v >= floor)) issue(path, `Must be a whole number of ${floor} or more.`);
-  };
-  const ordered = (low, high, path, what) => {
-    if (isInt(low) && isInt(high) && low > high) issue(path, `Can't be more than the ${what}.`);
-  };
-  const structuredProps = (type, props, path) => {
-    if (type === "list") {
-      optionalInt(props.min, `${path}.min`, 0);
-      optionalInt(props.max, `${path}.max`, 1);
-      optionalInt(props.itemMaxLength, `${path}.itemMaxLength`, 1);
-      optionalText(props.placeholder, `${path}.placeholder`);
-      ordered(props.min, props.max ?? 10, `${path}.min`, "most items");
-    } else if (type === "table") {
-      const columns = props.columns;
-      if (!Array.isArray(columns) || columns.length < 1 || columns.length > MAX_TABLE_COLUMNS) {
-        issue(`${path}.columns`, `Must be a list of 1 to ${MAX_TABLE_COLUMNS} columns.`);
-      } else {
-        const seen = /* @__PURE__ */ new Set();
-        columns.forEach((c, j) => {
-          const at = `${path}.columns[${j}]`;
-          if (!isObject2(c)) return issue(at, "Each column needs a key and a label.");
-          if (name(c.key, `${at}.key`, "A column key")) {
-            if (seen.has(c.key)) issue(`${at}.key`, `Duplicate column key "${c.key}".`);
-            seen.add(c.key);
-          }
-          text(c.label, `${at}.label`);
-          optionalBoolean(c.long, `${at}.long`);
-        });
-      }
-      optionalInt(props.minRows, `${path}.minRows`, 0);
-      optionalInt(props.maxRows, `${path}.maxRows`, 1);
-      ordered(props.minRows, props.maxRows ?? 3, `${path}.minRows`, "most rows");
-    } else if (type === "media-notes") {
-      optionalInt(props.maxNotes, `${path}.maxNotes`, 1);
-      optionalInt(props.textMaxLength, `${path}.textMaxLength`, 1);
-    } 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 (type === PHOTO_TYPE) {
-      if (props.maxFiles !== void 0 && !(isInt(props.maxFiles) && props.maxFiles >= 1 && props.maxFiles <= MAX_PHOTO_FILES)) {
-        issue(`${path}.maxFiles`, `Must be a whole number from 1 to ${MAX_PHOTO_FILES}.`);
-      }
-      if (props.maxSizeMb !== void 0 && !(isInt(props.maxSizeMb) && props.maxSizeMb >= 1 && props.maxSizeMb <= MAX_PHOTO_SIZE_MB)) {
-        issue(`${path}.maxSizeMb`, `Must be a whole number from 1 to ${MAX_PHOTO_SIZE_MB}.`);
-      }
-      if (props.formats !== void 0) {
-        const formats = props.formats;
-        if (!Array.isArray(formats) || formats.length === 0 || !formats.every(isPhotoFormat)) {
-          issue(`${path}.formats`, "Must be a list of one or more of jpeg, png, heic and webp.");
-        } else if (new Set(formats).size !== formats.length) {
-          issue(`${path}.formats`, "Name each format once.");
-        }
-      }
+  const kindProps = (check, props, path) => {
+    if (!check) return;
+    try {
+      check(props, propsChecker(path, issue));
+    } catch {
+      issue(path, "These settings couldn't be checked.");
     }
   };
   if (!isObject2(input)) {
@@ -2180,7 +2307,7 @@ function parseForm(input) {
   const order = /* @__PURE__ */ new Map();
   const tableColumnKeys = /* @__PURE__ */ new Map();
   const choices = /* @__PURE__ */ new Map();
-  const calculatedLiteral = /* @__PURE__ */ new Map();
+  const literals = /* @__PURE__ */ new Map();
   input.blocks.forEach((block, i) => {
     const path = `blocks[${i}]`;
     if (!isObject2(block) || typeof block.id !== "string" || !block.id) {
@@ -2208,7 +2335,7 @@ function parseForm(input) {
         if (from !== void 0) {
           if (!isObject2(from) || from.source !== "host" || typeof from.key !== "string" || !from.key) {
             issue(`${path}.props.optionsFrom`, 'Must be { source: "host", key } with a non-empty key.');
-          } else if (typeof block.type === "string" && !CHOICE_TYPES.has(block.type)) {
+          } else if (typeof block.type === "string" && !choiceKind(block.type)) {
             warnings.push({ path: `${path}.props.optionsFrom`, message: "Only single choice, multiple choice and dropdown questions take options from the app." });
           }
           const filter = isObject2(from) ? from.filter : void 0;
@@ -2230,7 +2357,7 @@ function parseForm(input) {
             );
           } else {
             optionalBoolean(prefill.hideWhenPrefilled, `${path}.props.prefill.hideWhenPrefilled`);
-            if (typeof block.type === "string" && !CHOICE_TYPES.has(block.type)) {
+            if (typeof block.type === "string" && !choiceKind(block.type)) {
               warnings.push({ path: `${path}.props.prefill`, message: "Only single choice, multiple choice and dropdown questions are filled in from a link." });
             }
           }
@@ -2261,7 +2388,7 @@ function parseForm(input) {
         if (other !== void 0) {
           if (other !== true && other !== false && !(isObject2(other) && (other.label === void 0 || typeof other.label === "string"))) {
             issue(`${path}.props.other`, "Must be true, false or { label }.");
-          } else if (other !== false && typeof block.type === "string" && !CHOICE_TYPES.has(block.type)) {
+          } else if (other !== false && typeof block.type === "string" && !choiceKind(block.type)) {
             warnings.push({ path: `${path}.props.other`, message: 'Only single choice, multiple choice and dropdown questions take an "Other" answer.' });
           }
         }
@@ -2274,19 +2401,14 @@ 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`);
+        kindProps(getFieldType(block.type)?.checkProps, 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);
-      }
+      literals.set(block.id, typeof block.type === "string" ? literalType(block.type, isObject2(block.props) ? block.props : {}) : void 0);
       if (block.type === "table" && isObject2(block.props) && Array.isArray(block.props.columns)) {
         tableColumnKeys.set(
           block.id,
@@ -2294,8 +2416,13 @@ function parseForm(input) {
         );
       }
     } else if (block.kind === "content") {
-      if (block.type !== "heading" && block.type !== "text") issue(`${path}.type`, "Must be heading or text.");
+      const content = typeof block.type === "string" ? getContentType(block.type) : void 0;
+      if (!content) issue(`${path}.type`, `Must be ${contentKinds()}.`);
       text(block.text, `${path}.text`);
+      if (content?.checkProps) {
+        if (block.props === void 0 || isObject2(block.props) && isJson(block.props)) kindProps(content.checkProps, block.props ?? {}, `${path}.props`);
+        else issue(`${path}.props`, "Must be a JSON object.");
+      }
     } else if (block.kind === "page-break") {
       optionalText(block.title, `${path}.title`);
     } else {
@@ -2316,10 +2443,10 @@ function parseForm(input) {
     }
     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 parsed2 = parseFormula(formula);
+    if (!parsed2.ok) return issue(path, `${parsed2.message} (at character ${parsed2.at + 1})`);
     const reported = /* @__PURE__ */ new Set();
-    for (const ref of parsed.refs) {
+    for (const ref of parsed2.refs) {
       const name2 = ref.column === void 0 ? ref.key : `${ref.key}.${ref.column}`;
       if (reported.has(name2)) continue;
       reported.add(name2);
@@ -2425,8 +2552,8 @@ function parseForm(input) {
     if (typeof left.field === "string" && fieldTypes.has(left.field)) {
       const fieldType = fieldTypes.get(left.field);
       what = `"${keyOf(left.field)}"`;
-      type = calculatedLiteral.has(left.field) ? calculatedLiteral.get(left.field) : LITERAL_TYPE[fieldType];
-      if (CHOICE_TYPES.has(fieldType)) options = choices.get(left.field);
+      type = literals.get(left.field);
+      if (choiceKind(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);
@@ -2540,6 +2667,40 @@ function parseForm(input) {
   return issues.length ? fail() : { ok: true, form: input, warnings };
 }
 
+// src/merge.ts
+function put2(record, key, value) {
+  Object.defineProperty(record, key, { value, enumerable: true, writable: true, configurable: true });
+}
+function mergeResponses(definition, base, patch, options = {}) {
+  const def = withHostOptions(definition, options.hostOptions);
+  const fields = fieldMap(def);
+  const keepable = (field) => !!field && !isCalculated(field) && !withheld(def, field);
+  let values = /* @__PURE__ */ Object.create(null);
+  const record = (r) => r && typeof r === "object" && !Array.isArray(r) ? r : {};
+  const from = record(base);
+  const changes = record(patch);
+  for (const [id, field] of fields) {
+    if (!keepable(field)) continue;
+    const changed = Object.prototype.hasOwnProperty.call(changes, id);
+    const value = changed ? own(changes, id) : own(from, id);
+    if (value === void 0 || value === null || isEmptyValue(value, field)) continue;
+    values[id] = value;
+  }
+  for (const id of Object.keys(values)) values = clearFilteredAnswers(def, values, id);
+  const initial = {};
+  for (const id of Object.keys(values)) if (values[id] !== void 0) put2(initial, id, values[id]);
+  const state = createForm(def, { initialValues: initial, hidden: options.hidden, clock: () => void 0 }).getState();
+  const keepOffPath = (options.offPath ?? (def.settings?.clearHiddenValues === false ? "keep" : "drop")) === "keep";
+  const onPath = new Set(state.path);
+  const out = {};
+  for (const id of fields.keys()) {
+    if (!keepOffPath && !onPath.has(id)) continue;
+    const value = own(initial, id);
+    if (value !== void 0) put2(out, id, value);
+  }
+  return out;
+}
+
 // src/edit-link.ts
 var EDIT_LINK_TTL_SECONDS = 30 * 24 * 60 * 60;
 var MIN_EDIT_SECRET_BYTES = 32;
@@ -2644,19 +2805,29 @@ function withEditLinkHeaders(request, response, options = {}) {
 }
 
 // src/rate-limit.ts
-var DEFAULT_TRUSTED_IP_HEADERS = ["x-vercel-forwarded-for", "x-forwarded-for", "x-real-ip"];
+var DEFAULT_TRUSTED_IP_HEADERS = ["x-vercel-forwarded-for", "cf-connecting-ip"];
 var RATE_LIMIT_DEFAULTS = {
   submit: { limit: 60, windowSeconds: 600 },
   progress: { limit: 900, windowSeconds: 600 },
   upload: { limit: 120, windowSeconds: 600 }
 };
-function clientIp(headers, trusted = DEFAULT_TRUSTED_IP_HEADERS) {
+function clientIp(headers, options = DEFAULT_TRUSTED_IP_HEADERS) {
+  const { headers: trusted = DEFAULT_TRUSTED_IP_HEADERS, forwardedForHops: hops } = isHeaderList(options) ? { headers: options } : options;
   for (const name of trusted) {
     const first = headers.get(name)?.split(",")[0]?.trim();
     if (first) return first;
   }
+  if (hops !== void 0) {
+    if (!Number.isInteger(hops) || hops < 1) throw new RangeError("forwardedForHops must be a whole number of at least 1");
+    const entries = (headers.get("x-forwarded-for") ?? "").split(",").map((entry2) => entry2.trim());
+    const entry = entries.length >= hops ? entries[entries.length - hops] : void 0;
+    if (entry) return entry;
+  }
   return "unknown";
 }
+function isHeaderList(options) {
+  return Array.isArray(options);
+}
 function addressPrefix(ip) {
   const bare = ip.replace(/^\[|\](:\d+)?$/g, "").split("%")[0].toLowerCase();
   if (!bare.includes(":")) return bare;
@@ -2816,9 +2987,9 @@ function createUploadHandler(options) {
     if (text === null) return json({ error: say.tooLong }, 413);
     let body;
     try {
-      const parsed = JSON.parse(text);
-      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("not an object");
-      body = parsed;
+      const parsed2 = JSON.parse(text);
+      if (!parsed2 || typeof parsed2 !== "object" || Array.isArray(parsed2)) throw new Error("not an object");
+      body = parsed2;
     } catch {
       return json({ error: say.notJson }, 400);
     }
@@ -2874,7 +3045,10 @@ function createUploadHandler(options) {
       const key = await rateLimitKey({
         kind: "upload",
         scope: form.scope,
-        ip: clientIp(request.headers, limit.trustedIpHeaders ?? DEFAULT_TRUSTED_IP_HEADERS),
+        ip: clientIp(request.headers, {
+          headers: limit.trustedIpHeaders ?? DEFAULT_TRUSTED_IP_HEADERS,
+          forwardedForHops: limit.forwardedForHops
+        }),
         secret: limit.secret
       });
       const allowed = await allow(
@@ -2911,6 +3085,216 @@ function createUploadHandler(options) {
   };
 }
 
+// src/hash.ts
+function canonicalJson(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+  if (Array.isArray(value)) return value.map(sortKeys);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const key of Object.keys(value).sort()) {
+      const v = value[key];
+      if (v !== void 0) out[key] = sortKeys(v);
+    }
+    return out;
+  }
+  return value;
+}
+function fingerprint(value) {
+  const str = canonicalJson(value);
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let i = 0; i < str.length; i++) {
+    const ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16).padStart(14, "0");
+}
+
+// src/submit-protocol.ts
+var IDEMPOTENCY_KEY_PATTERN = /^[A-Za-z0-9_-]{16,128}$/;
+function isIdempotencyKey(value) {
+  return typeof value === "string" && IDEMPOTENCY_KEY_PATTERN.test(value);
+}
+function submitOutcome(result) {
+  if (!isSubmitResult(result)) return "retry";
+  if (result.ok || result.reason === "duplicate") return "delivered";
+  if (result.reason === "invalid" || result.reason === "conflict" || result.reason === "closed") return "rejected";
+  return "retry";
+}
+function isSubmitResult(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const v = value;
+  const stored = typeof v.id === "string" && v.id !== "" && typeof v.receivedAt === "string";
+  if (v.ok === true) return stored;
+  if (v.ok !== false) return false;
+  switch (v.reason) {
+    case "duplicate":
+      return stored;
+    case "invalid":
+      return !!v.errors && typeof v.errors === "object" && !Array.isArray(v.errors);
+    case "rate_limited":
+      return v.retryAfterSeconds === void 0 || typeof v.retryAfterSeconds === "number" && Number.isFinite(v.retryAfterSeconds);
+    case "conflict":
+    case "closed":
+    case "store_failed":
+      return true;
+    default:
+      return false;
+  }
+}
+
+// src/submit.ts
+var INVALID_KEY = {
+  ok: false,
+  reason: "invalid",
+  errors: { "": "Missing or malformed idempotency key: 16 to 128 letters, digits, - or _." }
+};
+var MALFORMED = { ok: false, reason: "invalid", errors: { "": "Malformed submission." } };
+var CONFLICT = { ok: false, reason: "conflict" };
+var parsed = /* @__PURE__ */ new WeakMap();
+function assertPublishable(definition) {
+  if (typeof definition === "object" && definition !== null && parsed.has(definition)) return;
+  const result = parseForm(definition);
+  if (!result.ok) {
+    throw new Error(`submitResponse: the published definition is invalid: ${result.issues.map((i) => i.message).join("; ")}`);
+  }
+  parsed.set(definition, true);
+}
+async function sha256Hex(text) {
+  const digest = new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text)));
+  let hex = "";
+  for (const b of digest) hex += b.toString(16).padStart(2, "0");
+  return hex;
+}
+function hashInput(input) {
+  return sha256Hex(canonicalJson({ answers: input.answers, events: input.events, hidden: input.hidden }));
+}
+function isoOrNull(ms) {
+  if (typeof ms !== "number" || !Number.isFinite(ms)) return null;
+  const date = new Date(ms);
+  return Number.isNaN(date.getTime()) ? null : date.toISOString();
+}
+function isRef(ref) {
+  if (!ref || typeof ref !== "object") return false;
+  const r = ref;
+  return typeof r.id === "string" && r.id !== "" && typeof r.receivedAt === "string" && typeof r.inputHash === "string" && r.inputHash !== "";
+}
+function duplicateOf(ref, inputHash, log, formId) {
+  if (!isRef(ref)) {
+    log(`the store answered a duplicate for form ${formId} without its id, receivedAt and inputHash`);
+    return { ok: false, reason: "store_failed" };
+  }
+  if (ref.inputHash !== inputHash) return CONFLICT;
+  return { ok: false, reason: "duplicate", id: ref.id, receivedAt: ref.receivedAt };
+}
+var NO_OWNER = { attemptHash: "" };
+function submissionOptions(options) {
+  const {
+    definition: _definition,
+    store: _store,
+    formId: _formId,
+    version: _version,
+    open: _open,
+    rateLimit: _rateLimit,
+    uploads: _uploads,
+    now: _now,
+    log: _log,
+    ...rest
+  } = options;
+  return rest;
+}
+async function submitResponse(input, options) {
+  const { definition, store } = options;
+  assertPublishable(definition);
+  if (uploadFields(definition).length > 0 && !options.uploads) {
+    throw new Error("submitResponse: this form has upload fields; pass `uploads` (the attempt and the upload store).");
+  }
+  const log = options.log ?? ((m) => console.error(`[submit] ${m}`));
+  if (!input || typeof input !== "object" || Array.isArray(input)) return MALFORMED;
+  if (!isIdempotencyKey(input.idempotencyKey)) return INVALID_KEY;
+  const formId = options.formId ?? definition.id;
+  const key = input.idempotencyKey;
+  let hash;
+  const inputHash = () => hash ??= hashInput(input);
+  let existing;
+  try {
+    existing = await store.find(formId, key);
+  } catch (e) {
+    log(`find failed for form ${formId}: ${e instanceof Error ? e.message : String(e)}`);
+    return { ok: false, reason: "store_failed" };
+  }
+  if (existing) return duplicateOf(existing, await inputHash(), log, formId);
+  if (options.open === false) return { ok: false, reason: "closed" };
+  if (options.rateLimit) {
+    let answer = true;
+    try {
+      answer = await options.rateLimit();
+    } catch (e) {
+      log(`the rate limit could not be checked; letting the submission through: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    if (answer === false) return { ok: false, reason: "rate_limited" };
+    if (answer !== true && answer && typeof answer === "object") {
+      const after = answer.retryAfterSeconds;
+      return Number.isFinite(after) && after >= 0 ? { ok: false, reason: "rate_limited", retryAfterSeconds: Math.ceil(after) } : { ok: false, reason: "rate_limited" };
+    }
+  }
+  const checked = validateSubmission(
+    definition,
+    { answers: input.answers, events: input.events, hidden: input.hidden },
+    { ...submissionOptions(options), complete: true }
+  );
+  if (!checked.ok) return { ok: false, reason: "invalid", errors: checked.errors };
+  const submission = checked.submission;
+  let answers = submission.answers;
+  if (options.uploads) {
+    try {
+      const owner = options.uploads.owner ?? (typeof input.attemptId === "string" && input.attemptId !== "" ? { attemptHash: await attemptHash(input.attemptId) } : (
+        // No attempt: no upload can be this visit's, so any file named is refused.
+        NO_OWNER
+      ));
+      const files = await checkUploads(definition, answers, { formId, owner, store: options.uploads.store });
+      if (!files.ok) return { ok: false, reason: "invalid", errors: files.errors };
+      answers = files.answers;
+    } catch (e) {
+      log(`upload check failed for form ${formId}: ${e instanceof Error ? e.message : String(e)}`);
+      return { ok: false, reason: "store_failed" };
+    }
+  }
+  const record = {
+    formId,
+    idempotencyKey: key,
+    inputHash: await inputHash(),
+    definitionVersion: options.version ?? fingerprint(definition),
+    receivedAt: (options.now?.() ?? /* @__PURE__ */ new Date()).toISOString(),
+    clientSubmittedAt: isoOrNull(input.clientSubmittedAt),
+    answers,
+    hidden: submission.hidden,
+    context: submission.context,
+    ending: submission.ending,
+    ignored: submission.ignored,
+    snapshots: answerSnapshots(withHostOptions(definition, options.hostOptions), answers),
+    uploadIds: uploadFields(definition).flatMap((field) => photoRefs(answers[field.id]).map((ref) => ref.id))
+  };
+  let saved;
+  try {
+    saved = await store.save(record);
+  } catch (e) {
+    log(`save failed for form ${formId}: ${e instanceof Error ? e.message : String(e)}`);
+    return { ok: false, reason: "store_failed" };
+  }
+  if (saved && typeof saved === "object" && "duplicate" in saved) return duplicateOf(saved.duplicate, record.inputHash, log, formId);
+  if (!saved || typeof saved.id !== "string" || saved.id === "") {
+    log(`save for form ${formId} answered without an id`);
+    return { ok: false, reason: "store_failed" };
+  }
+  return { ok: true, id: saved.id, receivedAt: record.receivedAt };
+}
+
 // src/server.ts
 var MAX_EVENTS = 1e4;
 var MAX_SUBMISSION_VALUES = 2e5;
@@ -2948,13 +3332,13 @@ function submissionValues(input, limit) {
   } else count += countValues(input.answers, limit - count);
   return count;
 }
-var MALFORMED = { ok: false, errors: { "": "Malformed submission." } };
+var MALFORMED2 = { ok: false, errors: { "": "Malformed submission." } };
 var parsedDefinitions = /* @__PURE__ */ new WeakMap();
 function checkDefinition(definition) {
   if (typeof definition === "object" && definition !== null && parsedDefinitions.has(definition)) return null;
-  const parsed = parseForm(definition);
-  if (!parsed.ok) {
-    const list = parsed.issues.map((i) => i.path ? `${i.path}: ${i.message}` : i.message).join("; ");
+  const parsed2 = parseForm(definition);
+  if (!parsed2.ok) {
+    const list = parsed2.issues.map((i) => i.path ? `${i.path}: ${i.message}` : i.message).join("; ");
     return `Invalid form definition: ${list}`;
   }
   parsedDefinitions.set(definition, true);
@@ -2978,7 +3362,7 @@ function validateSubmission(published, submission, options = {}) {
   const invalid = checkDefinition(published);
   if (invalid) return { ok: false, errors: { "": invalid } };
   const definition = withHostOptions(published, options.hostOptions);
-  if (!isPlainObject(submission)) return MALFORMED;
+  if (!isPlainObject(submission)) return MALFORMED2;
   const maxEvents = options.maxEvents ?? MAX_EVENTS;
   let sent = submission;
   if (Array.isArray(submission.events)) {
@@ -2996,7 +3380,7 @@ function validateSubmission(published, submission, options = {}) {
     };
   }
   const input = wellFormed(sent);
-  if (!input) return MALFORMED;
+  if (!input) return MALFORMED2;
   const ignored = /* @__PURE__ */ new Set();
   const client = coerceHidden(definition, input.hidden, { sources: ["url", "host"] });
   for (const name of client.ignored) ignored.add(`hidden.${name}`);
@@ -3098,6 +3482,7 @@ function publicDefinition(definition) {
 exports.DEFAULT_TRUSTED_IP_HEADERS = DEFAULT_TRUSTED_IP_HEADERS;
 exports.EDIT_LINK_PARAM = EDIT_LINK_PARAM;
 exports.EDIT_LINK_TTL_SECONDS = EDIT_LINK_TTL_SECONDS;
+exports.IDEMPOTENCY_KEY_PATTERN = IDEMPOTENCY_KEY_PATTERN;
 exports.MAX_EVENTS = MAX_EVENTS;
 exports.MAX_REPLAY_WORK = MAX_REPLAY_WORK;
 exports.MAX_SUBMISSION_VALUES = MAX_SUBMISSION_VALUES;
@@ -3118,10 +3503,15 @@ exports.createEditSecretReader = createEditSecretReader;
 exports.createUploadHandler = createUploadHandler;
 exports.editLinkUrl = editLinkUrl;
 exports.isEditLinkRequest = isEditLinkRequest;
+exports.isIdempotencyKey = isIdempotencyKey;
+exports.isSubmitResult = isSubmitResult;
 exports.isUsableEditSecret = isUsableEditSecret;
+exports.mergeResponses = mergeResponses;
 exports.publicDefinition = publicDefinition;
 exports.rateLimitKey = rateLimitKey;
 exports.signEditToken = signEditToken;
+exports.submitOutcome = submitOutcome;
+exports.submitResponse = submitResponse;
 exports.uploadFields = uploadFields;
 exports.uploadRules = uploadRules;
 exports.validateSubmission = validateSubmission;