@marktiderman/genesis-forms 0.8.0 → 0.9.1

package/dist/index.cjs

@@ -30,6 +30,45 @@ function fingerprint(value) {
   return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16).padStart(14, "0");
 }
 
+// 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, message2) => report(at(path), message2);
+  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;
@@ -39,8 +78,8 @@ 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);
+  constructor(message2, at) {
+    super(message2);
     this.at = at;
   }
   at;
@@ -118,8 +157,8 @@ function parseFormula(source) {
     const tok = peek();
     return tok.t === "op" && tok.v === v;
   };
-  const expect = (v, message) => {
-    if (!isOp(v)) throw new FormulaError(message, peek().at);
+  const expect = (v, message2) => {
+    if (!isOp(v)) throw new FormulaError(message2, peek().at);
     pos++;
   };
   const describe = (tok) => tok.t === "end" ? "the formula ends there" : `found "${String(tok.v)}"`;
@@ -593,6 +632,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: (props2) => props2.format === "text" ? "string" : props2.format === "number" || props2.format === "percent" ? "number" : void 0,
+  // The formula itself is checked once every key is known (`parseForm`).
+  checkProps: (props2, check) => {
+    if (props2.format !== void 0 && props2.format !== "number" && props2.format !== "percent" && props2.format !== "text") {
+      check.issue("format", "Must be number, percent or text.");
+    }
+    if (props2.decimals !== void 0 && !(isWholeNumber(props2.decimals) && props2.decimals >= 0 && props2.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, field2) => formatCalculated(value, field2)
@@ -705,12 +755,42 @@ var MAX_HIGHLIGHT_QUOTE_LENGTH = 2e3;
 var HIGHLIGHT_NOTE_MESSAGE = "Add a note to each highlight.";
 var sourceText = (field2) => typeof field2.props?.text === "string" && field2.props.text ? field2.props.text : void 0;
 var STRUCTURED_FIELD_TYPES = ["list", "table", "media-notes", "text-highlights"];
+var listProps = (props2, check) => {
+  check.optionalInt(props2.min, "min", 0);
+  check.optionalInt(props2.max, "max", 1);
+  check.optionalInt(props2.itemMaxLength, "itemMaxLength", 1);
+  check.optionalText(props2.placeholder, "placeholder");
+  check.ordered(props2.min, props2.max ?? 10, "min", "most items");
+};
+var tableProps = (props2, check) => {
+  const columns = props2.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(props2.minRows, "minRows", 0);
+  check.optionalInt(props2.maxRows, "maxRows", 1);
+  check.ordered(props2.minRows, props2.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" },
@@ -736,6 +816,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)),
@@ -779,6 +860,10 @@ var structuredFieldTypes = [
     label: "Notes at moments",
     category: "media",
     value: { json: true },
+    checkProps: (props2, check) => {
+      check.optionalInt(props2.maxNotes, "maxNotes", 1);
+      check.optionalInt(props2.textMaxLength, "textMaxLength", 1);
+    },
     operators: ["answered", "empty"],
     a11y: { semantics: "group" },
     isEmpty: (value) => emptyList(value, (n) => isObject(n) && blankText(n.text)),
@@ -802,6 +887,10 @@ var structuredFieldTypes = [
     label: "Highlights",
     category: "media",
     value: { json: true },
+    checkProps: (props2, check) => {
+      check.optionalText(props2.text, "text");
+      check.optionalInt(props2.maxHighlights, "maxHighlights", 1);
+    },
     operators: ["answered", "empty"],
     a11y: { semantics: "group" },
     isEmpty: (value) => emptyList(value, () => false),
@@ -894,6 +983,22 @@ var photoFieldType = {
   value: { json: true },
   operators: ["answered", "empty"],
   a11y: { semantics: "group" },
+  checkProps: (props2, check) => {
+    if (props2.maxFiles !== void 0 && !(isWholeNumber(props2.maxFiles) && props2.maxFiles >= 1 && props2.maxFiles <= MAX_PHOTO_FILES)) {
+      check.issue("maxFiles", `Must be a whole number from 1 to ${MAX_PHOTO_FILES}.`);
+    }
+    if (props2.maxSizeMb !== void 0 && !(isWholeNumber(props2.maxSizeMb) && props2.maxSizeMb >= 1 && props2.maxSizeMb <= MAX_PHOTO_SIZE_MB)) {
+      check.issue("maxSizeMb", `Must be a whole number from 1 to ${MAX_PHOTO_SIZE_MB}.`);
+    }
+    if (props2.formats !== void 0) {
+      const formats = props2.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, field2) => {
     if (!Array.isArray(value) || !value.every(isPhotoRef)) return "Add a photo.";
@@ -911,18 +1016,48 @@ 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`.");
+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 });
+  }
+  return Object.freeze(copy);
+}
+function registerFieldType(manifest, options = {}) {
+  if (!manifest || typeof manifest.type !== "string" || !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")) {
+  if (value && !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.`
     );
   }
-  registry.set(manifest.type, manifest);
+  if (!value || !Array.isArray(manifest.operators)) {
+    throw new Error(`registerFieldType: "${manifest.type}" needs a \`value\` and a list of \`operators\`.`);
+  }
+  if (manifest.choice !== void 0 && typeof manifest.choice?.multiple !== "boolean") {
+    throw new Error(`registerFieldType: "${manifest.type}" has a \`choice\` without \`multiple: true | false\`.`);
+  }
+  if (builtIn.has(manifest.type) && options.replace !== true) {
+    throw new Error(
+      `registerFieldType: "${manifest.type}" is a built-in field type; pass { replace: true } to replace it for every form in this process.`
+    );
+  }
+  registry.set(manifest.type, frozen(withChoiceDefaults(manifest)));
+}
+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);
@@ -930,6 +1065,67 @@ function getFieldType(type) {
 function listFieldTypes() {
   return [...registry.values()];
 }
+function isBuiltInFieldType(type) {
+  return builtIn.has(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, props2) {
+  const literal = registry.get(type)?.literal;
+  if (typeof literal !== "function") return literal;
+  try {
+    return literal(props2);
+  } 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();
+var BUILT_IN_CONTENT = /* @__PURE__ */ new Set(["heading", "text"]);
+function registerContentType(manifest, options = {}) {
+  if (!manifest || typeof manifest.type !== "string" || !manifest.type) {
+    throw new Error("registerContentType: a content type needs a `type`.");
+  }
+  if (typeof manifest.label !== "string") throw new Error(`registerContentType: "${manifest.type}" needs a \`label\`.`);
+  for (const hook of ["checkProps", "text"]) {
+    if (manifest[hook] !== void 0 && typeof manifest[hook] !== "function") {
+      throw new Error(`registerContentType: "${manifest.type}" has a \`${hook}\` that isn't a function.`);
+    }
+  }
+  if (BUILT_IN_CONTENT.has(manifest.type) && options.replace !== true) {
+    throw new Error(
+      `registerContentType: "${manifest.type}" is a built-in content type; pass { replace: true } to replace it for every form in this process.`
+    );
+  }
+  contentRegistry.set(manifest.type, frozen(manifest));
+}
+function getContentType(type) {
+  return contentRegistry.get(type);
+}
+function listContentTypes() {
+  return [...contentRegistry.values()];
+}
+function contentText(block) {
+  const text = contentRegistry.get(block.type)?.text;
+  if (!text) return block.text;
+  try {
+    const shown2 = text(block);
+    return typeof shown2 === "string" ? shown2 : block.text;
+  } catch {
+    return block.text;
+  }
+}
+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, field2) {
   const manifest = field2 ? registry.get(field2.type) : void 0;
   if (manifest?.isEmpty) return manifest.isEmpty(value);
@@ -1115,6 +1311,27 @@ function isPhoneNumber(value) {
   }
   return digits >= 7 && digits <= 15;
 }
+var oneOptionValidate = (value, field2) => typeof value === "string" && (choiceOptions(field2).some((o) => o.value === value) || typedOther(field2, value)) ? null : "Choose one of the options.";
+var oneOptionSummary = (value, field2) => optionLabel(field2, String(value));
+var optionsValidate = (value, field2) => {
+  const allowed = new Set(choiceOptions(field2).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(field2, others[0])) ? null : "Choose from the options.";
+};
+var optionsSummary = (value, field2) => Array.isArray(value) ? value.map((v) => optionLabel(field2, String(v))).join(", ") : String(value);
+function withChoiceDefaults(manifest) {
+  if (!manifest.choice || manifest.validate && manifest.summarize) return manifest;
+  const multiple = manifest.choice.multiple;
+  return {
+    ...manifest,
+    validate: manifest.validate ?? (multiple ? optionsValidate : oneOptionValidate),
+    summarize: manifest.summarize ?? (multiple ? optionsSummary : oneOptionSummary)
+  };
+}
+var scaleProps = (props2, check) => {
+  check.optionalText(props2.lowLabel, "lowLabel");
+  check.optionalText(props2.highLabel, "highLabel");
+};
 var builtins = [
   {
     type: "short-text",
@@ -1123,6 +1340,7 @@ var builtins = [
     value: { json: true },
     operators: textOps,
     a11y: { semantics: "control" },
+    literal: "string",
     validate: textValidate(500)
   },
   {
@@ -1132,6 +1350,7 @@ var builtins = [
     value: { json: true },
     operators: textOps,
     a11y: { semantics: "control" },
+    literal: "string",
     validate: textValidate(5e3)
   },
   {
@@ -1141,6 +1360,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
   },
@@ -1151,6 +1371,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)
@@ -1162,6 +1383,13 @@ var builtins = [
     value: { json: true },
     operators: numberOps2,
     a11y: { semantics: "group" },
+    literal: "number",
+    checkProps: (props2, check) => {
+      scaleProps(props2, check);
+      if (props2.display !== void 0 && props2.display !== "numbers" && props2.display !== "stars") {
+        check.issue("display", "Must be numbers or stars.");
+      }
+    },
     validate: (value, field2) => {
       const { min, max } = intRange(field2, 1, 5);
       return Number.isInteger(value) && value >= min && value <= max ? null : `Choose a rating from ${min} to ${max}.`;
@@ -1179,6 +1407,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, field2) => {
       const end = scaleEndLabel(field2, value, 0, 10);
@@ -1192,8 +1422,10 @@ var builtins = [
     value: { json: true },
     operators: ["eq", "neq", "in", "answered", "empty"],
     a11y: { semantics: "group" },
-    validate: (value, field2) => typeof value === "string" && (choiceOptions(field2).some((o) => o.value === value) || typedOther(field2, value)) ? null : "Choose one of the options.",
-    summarize: (value, field2) => optionLabel(field2, String(value))
+    literal: "string",
+    choice: { multiple: false },
+    validate: oneOptionValidate,
+    summarize: oneOptionSummary
   },
   {
     type: "multi-choice",
@@ -1202,12 +1434,10 @@ var builtins = [
     value: { json: true },
     operators: ["contains", "answered", "empty"],
     a11y: { semantics: "group" },
-    validate: (value, field2) => {
-      const allowed = new Set(choiceOptions(field2).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(field2, others[0])) ? null : "Choose from the options.";
-    },
-    summarize: (value, field2) => Array.isArray(value) ? value.map((v) => optionLabel(field2, String(v))).join(", ") : String(value)
+    literal: "string",
+    choice: { multiple: true },
+    validate: optionsValidate,
+    summarize: optionsSummary
   },
   {
     type: "yes-no",
@@ -1216,6 +1446,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"
   },
@@ -1226,8 +1457,10 @@ var builtins = [
     value: { json: true },
     operators: ["eq", "neq", "in", "answered", "empty"],
     a11y: { semantics: "control" },
-    validate: (value, field2) => typeof value === "string" && (choiceOptions(field2).some((o) => o.value === value) || typedOther(field2, value)) ? null : "Choose one of the options.",
-    summarize: (value, field2) => optionLabel(field2, String(value))
+    literal: "string",
+    choice: { multiple: false },
+    validate: oneOptionValidate,
+    summarize: oneOptionSummary
   },
   {
     type: "number",
@@ -1236,6 +1469,16 @@ var builtins = [
     value: { json: true },
     operators: numberOps2,
     a11y: { semantics: "control", inputMode: "decimal" },
+    literal: "number",
+    checkProps: (props2, check) => {
+      for (const k of ["min", "max", "step"]) {
+        if (props2[k] !== void 0 && !isFiniteNumber(props2[k])) check.issue(k, "Must be a number.");
+      }
+      if (isFiniteNumber(props2.step) && props2.step <= 0) check.issue("step", "Must be above 0.");
+      if (isFiniteNumber(props2.min) && isFiniteNumber(props2.max) && props2.min > props2.max) {
+        check.issue("min", "Can't be more than the largest number.");
+      }
+    },
     validate: (value, field2) => {
       if (typeof value !== "number" || !Number.isFinite(value)) return "Enter a number.";
       const { min, max, step } = numberLimits(field2);
@@ -1262,6 +1505,17 @@ var builtins = [
     value: { json: true },
     operators: ["eq", "neq", "answered", "empty"],
     a11y: { semantics: "control" },
+    literal: "string",
+    checkProps: (props2, check) => {
+      for (const k of ["min", "max"]) {
+        if (props2[k] !== void 0 && !(typeof props2[k] === "string" && isIsoDate(props2[k]))) {
+          check.issue(k, "Must be a date like 2026-10-22.");
+        }
+      }
+      if (typeof props2.min === "string" && typeof props2.max === "string" && isIsoDate(props2.min) && isIsoDate(props2.max) && props2.min > props2.max) {
+        check.issue("min", "Can't be after the latest date.");
+      }
+    },
     validate: (value, field2) => {
       if (typeof value !== "string" || !isIsoDate(value.trim())) return "Enter a date like 2026-10-22.";
       const date = value.trim();
@@ -1284,6 +1538,8 @@ var builtins = [
     value: { json: true },
     operators: ["answered", "empty"],
     a11y: { semantics: "group" },
+    literal: "boolean",
+    checkProps: (props2, check) => check.optionalText(props2.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.",
@@ -1336,7 +1592,7 @@ function dateLimits(field2) {
   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/hidden.ts
 var MAX_HIDDEN_STRING_LENGTH = 1e3;
@@ -1512,7 +1768,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 = (field2) => choiceKind(field2.type)?.multiple === true;
 function put(record, key, value) {
   Object.defineProperty(record, key, { value, enumerable: true, writable: true, configurable: true });
 }
@@ -1607,7 +1864,7 @@ function isPrefillParam(param) {
   return typeof param === "string" && param.length <= MAX_PREFILL_PARAM_LENGTH && /^[A-Za-z0-9_.-]+$/.test(param);
 }
 function prefillSetting(field2) {
-  if (!CHOICE_FIELD_TYPES.has(field2.type)) return void 0;
+  if (!choiceKind(field2.type)) return void 0;
   const raw = field2.props?.prefill;
   if (!raw || typeof raw !== "object" || Array.isArray(raw) || !isPrefillParam(raw.param)) return void 0;
   return { param: raw.param, hideWhenPrefilled: raw.hideWhenPrefilled === true };
@@ -1635,7 +1892,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())) {
@@ -1684,6 +1941,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;
@@ -1701,6 +1973,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) => {
@@ -1723,7 +2011,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 };
@@ -1760,25 +2048,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",
@@ -1792,13 +2061,16 @@ 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 = [];
   const fail = () => ({ ok: false, issues, warnings });
-  const issue = (path, message) => void issues.push({ path, message });
+  const issue = (path, message2) => void issues.push({ path, message: message2 });
   const text = (v, path, nonEmpty = false) => {
     if (typeof v !== "string" || nonEmpty && !v) issue(path, nonEmpty ? "Required." : "Required text.");
   };
@@ -1823,7 +2095,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(
@@ -1838,104 +2110,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, props2, path) => {
-    if (type === "list") {
-      optionalInt(props2.min, `${path}.min`, 0);
-      optionalInt(props2.max, `${path}.max`, 1);
-      optionalInt(props2.itemMaxLength, `${path}.itemMaxLength`, 1);
-      optionalText(props2.placeholder, `${path}.placeholder`);
-      ordered(props2.min, props2.max ?? 10, `${path}.min`, "most items");
-    } else if (type === "table") {
-      const columns = props2.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(props2.minRows, `${path}.minRows`, 0);
-      optionalInt(props2.maxRows, `${path}.maxRows`, 1);
-      ordered(props2.minRows, props2.maxRows ?? 3, `${path}.minRows`, "most rows");
-    } else if (type === "media-notes") {
-      optionalInt(props2.maxNotes, `${path}.maxNotes`, 1);
-      optionalInt(props2.textMaxLength, `${path}.textMaxLength`, 1);
-    } else if (type === "text-highlights") {
-      optionalText(props2.text, `${path}.text`);
-      optionalInt(props2.maxHighlights, `${path}.maxHighlights`, 1);
-    } else if (type === CALCULATED_TYPE) {
-      if (props2.format !== void 0 && props2.format !== "number" && props2.format !== "percent" && props2.format !== "text") {
-        issue(`${path}.format`, "Must be number, percent or text.");
-      }
-      if (props2.decimals !== void 0 && !(isInt(props2.decimals) && props2.decimals >= 0 && props2.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, props2, path) => {
-    if (type === "rating" || type === "nps") {
-      optionalText(props2.lowLabel, `${path}.lowLabel`);
-      optionalText(props2.highLabel, `${path}.highLabel`);
-    }
-    if (type === "rating" && props2.display !== void 0 && props2.display !== "numbers" && props2.display !== "stars") {
-      issue(`${path}.display`, "Must be numbers or stars.");
-    }
-    if (type === "number") {
-      for (const k of ["min", "max", "step"]) {
-        if (props2[k] !== void 0 && !isFiniteNumber(props2[k])) issue(`${path}.${k}`, "Must be a number.");
-      }
-      if (isFiniteNumber(props2.step) && props2.step <= 0) issue(`${path}.step`, "Must be above 0.");
-      if (isFiniteNumber(props2.min) && isFiniteNumber(props2.max) && props2.min > props2.max) {
-        issue(`${path}.min`, "Can't be more than the largest number.");
-      }
-    }
-    if (type === "date") {
-      for (const k of ["min", "max"]) {
-        if (props2[k] !== void 0 && !(typeof props2[k] === "string" && isIsoDate(props2[k]))) {
-          issue(`${path}.${k}`, "Must be a date like 2026-10-22.");
-        }
-      }
-      if (typeof props2.min === "string" && typeof props2.max === "string" && isIsoDate(props2.min) && isIsoDate(props2.max) && props2.min > props2.max) {
-        issue(`${path}.min`, "Can't be after the latest date.");
-      }
-    }
-    if (type === "consent") optionalText(props2.text, `${path}.text`);
-    if (type === PHOTO_TYPE) {
-      if (props2.maxFiles !== void 0 && !(isInt(props2.maxFiles) && props2.maxFiles >= 1 && props2.maxFiles <= MAX_PHOTO_FILES)) {
-        issue(`${path}.maxFiles`, `Must be a whole number from 1 to ${MAX_PHOTO_FILES}.`);
-      }
-      if (props2.maxSizeMb !== void 0 && !(isInt(props2.maxSizeMb) && props2.maxSizeMb >= 1 && props2.maxSizeMb <= MAX_PHOTO_SIZE_MB)) {
-        issue(`${path}.maxSizeMb`, `Must be a whole number from 1 to ${MAX_PHOTO_SIZE_MB}.`);
-      }
-      if (props2.formats !== void 0) {
-        const formats = props2.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, props2, path) => {
+    if (!check) return;
+    try {
+      check(props2, propsChecker(path, issue));
+    } catch {
+      issue(path, "These settings couldn't be checked.");
     }
   };
   if (!isObject2(input)) {
@@ -1974,7 +2160,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) {
@@ -2002,7 +2188,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;
@@ -2024,7 +2210,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." });
             }
           }
@@ -2055,7 +2241,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.' });
           }
         }
@@ -2068,19 +2254,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,
@@ -2088,8 +2269,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 {
@@ -2219,8 +2405,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);
@@ -2241,8 +2427,8 @@ function parseForm(input) {
       type = "number";
     }
     for (const v of values) {
-      const message = type !== void 0 && typeof v !== type ? `${what} holds a ${type}, but ${shown(v)} is not one; this comparison is ${outcome}.` : options && typeof v === "string" && !options.has(v) ? `${shown(v)} is not an option of ${what}; this comparison is ${outcome}.` : null;
-      if (message) warnings.push({ path: `${path}.right`, message });
+      const message2 = type !== void 0 && typeof v !== type ? `${what} holds a ${type}, but ${shown(v)} is not one; this comparison is ${outcome}.` : options && typeof v === "string" && !options.has(v) ? `${shown(v)} is not an option of ${what}; this comparison is ${outcome}.` : null;
+      if (message2) warnings.push({ path: `${path}.right`, message: message2 });
     }
   };
   const keyOf = (id) => [...keys].find(([, v]) => v === id)?.[0] ?? id;
@@ -2557,17 +2743,17 @@ function defineForm(input) {
   if (input.endings?.length) definition.endings = input.endings;
   if (input.settings) definition.settings = input.settings;
   if (input.meta) definition.meta = input.meta;
-  const frozen = JSON.parse(JSON.stringify(definition));
-  const parsed = parseForm(frozen);
+  const frozen2 = JSON.parse(JSON.stringify(definition));
+  const parsed = parseForm(frozen2);
   if (!parsed.ok) {
     const list = parsed.issues.map((i) => `  - ${i.path ? `${i.path}: ` : ""}${i.message}`).join("\n");
     throw new Error(`defineForm "${input.id}" is not a valid form:
 ${list}`);
   }
   return {
-    definition: frozen,
-    toJSON: () => JSON.parse(JSON.stringify(frozen)),
-    hash: () => fingerprint(frozen),
+    definition: frozen2,
+    toJSON: () => JSON.parse(JSON.stringify(frozen2)),
+    hash: () => fingerprint(frozen2),
     $answers: void 0,
     $hidden: void 0
   };
@@ -2590,8 +2776,13 @@ function validateField(field2, value, options = {}) {
   }
   const manifest = getFieldType(field2.type);
   if (!manifest) return `Unknown field type "${field2.type}".`;
-  const builtIn = manifest.validate?.(value, field2) ?? null;
-  if (builtIn) return builtIn;
+  let builtIn2;
+  try {
+    builtIn2 = manifest.validate?.(value, field2) ?? null;
+  } catch {
+    builtIn2 = VALIDATOR_FAILED_MESSAGE;
+  }
+  if (builtIn2) return builtIn2;
   return options.custom ? runCustom(options.custom, value) : null;
 }
 
@@ -2685,9 +2876,9 @@ function build(given, options, replaying = false, budget) {
       const field2 = fields.get(id);
       if (!field2 || !isVisibleIn(s, id)) continue;
       const value = own(s.values, id);
-      let message = validateField(field2, value, { custom: options.validators?.[id] });
-      if (!message && filters) message = filteredChoiceError(definition, field2, value, shown2 ??= answersOnPath(s));
-      if (message) errors[id] = message;
+      let message2 = validateField(field2, value, { custom: options.validators?.[id] });
+      if (!message2 && filters) message2 = filteredChoiceError(definition, field2, value, shown2 ??= answersOnPath(s));
+      if (message2) errors[id] = message2;
     }
     return errors;
   };
@@ -2911,6 +3102,40 @@ function formProgress(engine) {
 // src/upload-protocol.ts
 var MAX_UPLOAD_REQUEST_BYTES = 4e3;
 
+// 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 = (field2) => !!field2 && !isCalculated(field2) && !withheld(def, field2);
+  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, field2] of fields) {
+    if (!keepable(field2)) 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, field2)) 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/explain.ts
 function explain(source, blockId, options = {}) {
   const input = "getState" in source ? { definition: source.definition, values: source.getState().values, hidden: source.getState().hidden } : source;
@@ -2943,8 +3168,8 @@ function explain(source, blockId, options = {}) {
     const value = own(input.values, id);
     if (!visible) validation = { status: "not-checked" };
     else {
-      const message = validateField(block, value, { custom: options.validators?.[id] });
-      if (message) validation = { status: "invalid", message };
+      const message2 = validateField(block, value, { custom: options.validators?.[id] });
+      if (message2) validation = { status: "invalid", message: message2 };
       else validation = { status: isEmptyValue(value, block) ? "unanswered" : "valid" };
     }
   }
@@ -3063,13 +3288,598 @@ function carryAnswers(from, to, answers, extra = {}) {
   return out;
 }
 
+// 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/storage.ts
+function memoryStorage() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    getItem: (key) => map.get(key) ?? null,
+    setItem: (key, value) => void map.set(key, value),
+    removeItem: (key) => void map.delete(key),
+    keys: () => [...map.keys()]
+  };
+}
+function webStorage(storage) {
+  const get = () => {
+    const s = storage ? storage() : globalThis.localStorage;
+    if (!s) throw new Error("Web storage isn't available here.");
+    return s;
+  };
+  return {
+    getItem: (key) => get().getItem(key),
+    setItem: (key, value) => get().setItem(key, value),
+    removeItem: (key) => get().removeItem(key)
+  };
+}
+function isThenable(value) {
+  return typeof value?.then === "function";
+}
+function andThen(value, next) {
+  return isThenable(value) ? Promise.resolve(value).then(next) : next(value);
+}
+
+// src/drafts.ts
+var DRAFT_KEY_PREFIX = "genesis-forms:draft:";
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function readDraft(raw, key) {
+  if (typeof raw !== "string") return null;
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!isRecord(value)) return null;
+  const { formId, version, respondent, values, types, resumeAt, savedAt } = value;
+  if (formId !== key.formId || respondent !== key.respondent || typeof version !== "string") return null;
+  if (!isRecord(values) || !isRecord(types) || typeof savedAt !== "number") return null;
+  if (resumeAt !== null && typeof resumeAt !== "string") return null;
+  return value;
+}
+function createDraftStore(storage, options = {}) {
+  const prefix = options.prefix ?? DRAFT_KEY_PREFIX;
+  const storageKey = (key) => `${prefix}${encodeURIComponent(key.formId)}:${encodeURIComponent(key.respondent)}`;
+  return {
+    get: (key) => andThen(storage.getItem(storageKey(key)), (raw) => readDraft(raw, key)),
+    set: (draft) => storage.setItem(storageKey(draft), JSON.stringify(draft)),
+    remove: (key) => storage.removeItem(storageKey(key))
+  };
+}
+function draftOf(engine, key, options = {}) {
+  const definition = engine.definition;
+  const state = engine.getState();
+  const values = {};
+  const types = {};
+  for (const [id, field2] of fieldMap(definition)) {
+    if (isCalculated(field2) || withheld(definition, field2)) continue;
+    if (!options.keepSensitive && isSensitive(field2)) continue;
+    const value = own(state.values, id);
+    if (value === void 0 || isEmptyValue(value, field2)) continue;
+    values[id] = value;
+    types[id] = field2.type;
+  }
+  if (Object.keys(values).length === 0) return null;
+  return {
+    formId: key.formId,
+    version: key.version,
+    respondent: key.respondent,
+    values,
+    types,
+    resumeAt: formProgress(engine).fieldId,
+    savedAt: (options.now ?? Date.now)()
+  };
+}
+var DRAFT_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+function restoreDraft(definition, draft, options) {
+  const now = (options.now ?? Date.now)();
+  if (now - draft.savedAt > (options.maxAgeMs ?? DRAFT_MAX_AGE_MS)) return { ok: false, reason: "expired" };
+  const values = { ...draft.values };
+  if (draft.version !== options.version) {
+    const fields = fieldMap(definition);
+    for (const [id, value] of Object.entries(values)) {
+      const field2 = fields.get(id);
+      if (!field2 || field2.type !== own(draft.types, id) || isCalculated(field2) || withheld(definition, field2)) {
+        return { ok: false, reason: "version" };
+      }
+      if (validateField(field2, value, { requireAnswers: false }) !== null) return { ok: false, reason: "version" };
+    }
+  }
+  const resumeAt = draft.resumeAt && fieldMap(definition).has(draft.resumeAt) ? draft.resumeAt : null;
+  return { ok: true, values, resumeAt };
+}
+function createDraftAutosave(engine, store, key, options = {}) {
+  const delay = options.delayMs ?? 800;
+  const onError = options.onError ?? ((e) => console.warn("[forms] The draft could not be saved.", e));
+  let timer = null;
+  let dirty = false;
+  let cleared = false;
+  let listening = true;
+  let stored = options.stored === true;
+  let chain = Promise.resolve();
+  const run = (step) => {
+    chain = chain.then(async () => {
+      try {
+        const done = step();
+        if (isThenable(done)) await done;
+      } catch (e) {
+        onError(e);
+      }
+    });
+    return chain;
+  };
+  const write = () => {
+    if (timer) clearTimeout(timer);
+    timer = null;
+    if (!dirty || cleared) return chain;
+    dirty = false;
+    const draft = draftOf(engine, key, options);
+    return run(() => {
+      if (cleared) return;
+      if (!draft) {
+        if (!stored) return;
+        return andThen(store.remove(key), () => {
+          stored = false;
+        });
+      }
+      return andThen(store.set(draft), () => {
+        stored = true;
+        options.onSaved?.(draft);
+      });
+    });
+  };
+  const unsubscribe = engine.subscribe(() => {
+    if (!listening) return;
+    dirty = true;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => void write(), delay);
+  });
+  return {
+    flush: () => write(),
+    clear: () => {
+      cleared = true;
+      listening = false;
+      dirty = false;
+      if (timer) clearTimeout(timer);
+      timer = null;
+      unsubscribe();
+      return run(() => store.remove(key));
+    },
+    dispose: () => {
+      const done = write();
+      listening = false;
+      unsubscribe();
+      return done;
+    }
+  };
+}
+
+// src/outbox.ts
+var DEFAULT_PREFIX = "genesis-forms:outbox";
+function defaultKey() {
+  const c = globalThis.crypto;
+  if (c && typeof c.randomUUID === "function") return () => c.randomUUID();
+  throw new Error("createSubmitOutbox: crypto.randomUUID isn't available here; pass createKey (expo-crypto's randomUUID, say).");
+}
+var MAX_TIMER_MS = 2 ** 31 - 1;
+var MAX_WAIT_MS = 24 * 60 * 60 * 1e3;
+var indexChains = /* @__PURE__ */ new WeakMap();
+function withIndexLock(storage, prefix, step) {
+  let chains = indexChains.get(storage);
+  if (!chains) indexChains.set(storage, chains = /* @__PURE__ */ new Map());
+  const locks = globalThis.navigator?.locks;
+  const locked = () => locks && typeof locks.request === "function" ? locks.request(`genesis-forms-outbox:${prefix}`, step) : step();
+  const previous = chains.get(prefix) ?? Promise.resolve();
+  const run = previous.then(locked, locked);
+  chains.set(prefix, run.catch(() => void 0));
+  return run;
+}
+var message = (e) => e instanceof Error ? e.message : String(e);
+function readEntry(raw, id) {
+  if (typeof raw !== "string") return null;
+  let v;
+  try {
+    v = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!v || typeof v !== "object") return null;
+  const e = v;
+  if (e.id !== id || typeof e.formId !== "string" || !e.request || typeof e.request !== "object") return null;
+  if (e.request.idempotencyKey !== id) return null;
+  return {
+    id,
+    formId: e.formId,
+    request: e.request,
+    meta: e.meta ?? null,
+    createdAt: typeof e.createdAt === "number" ? e.createdAt : 0,
+    attempts: typeof e.attempts === "number" ? e.attempts : 0,
+    nextAttemptAt: typeof e.nextAttemptAt === "number" ? e.nextAttemptAt : 0,
+    state: e.state === "failed" ? "failed" : "pending",
+    lastError: typeof e.lastError === "string" ? e.lastError : null,
+    rejection: e.rejection ?? null
+  };
+}
+function readIndex(raw) {
+  if (typeof raw !== "string") return [];
+  try {
+    const v = JSON.parse(raw);
+    return Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function createSubmitOutbox(options) {
+  const { storage, send } = options;
+  const now = options.now ?? Date.now;
+  const prefix = options.prefix ?? DEFAULT_PREFIX;
+  const maxAttempts = Math.max(1, options.maxAttempts ?? 10);
+  const baseMs = options.backoff?.baseMs ?? 2e3;
+  const maxMs = options.backoff?.maxMs ?? 15 * 6e4;
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const createKey = options.createKey ?? defaultKey();
+  const random = options.random ?? Math.random;
+  const log = options.log ?? ((m) => console.warn(`[forms outbox] ${m}`));
+  const indexKey = `${prefix}:index`;
+  const itemKey = (id) => `${prefix}:item:${id}`;
+  const entries = /* @__PURE__ */ new Map();
+  const unreadable = /* @__PURE__ */ new Set();
+  let sendingId = null;
+  let online = options.online ?? true;
+  let loaded = false;
+  let storageError = null;
+  let running = false;
+  let timer = null;
+  let flushing = null;
+  let again = false;
+  const listeners = /* @__PURE__ */ new Set();
+  let snapshot = build2();
+  function build2() {
+    const items = [...entries.values()].sort((a, b) => a.createdAt - b.createdAt || (a.id < b.id ? -1 : 1)).map((e) => ({ ...e, sending: e.id === sendingId }));
+    return {
+      loaded,
+      online,
+      items,
+      pending: items.filter((i) => i.state === "pending").length,
+      failed: items.filter((i) => i.state === "failed").length,
+      storageError,
+      unreadable: [...unreadable]
+    };
+  }
+  function changed() {
+    snapshot = build2();
+    for (const l of [...listeners]) l();
+  }
+  let writes = Promise.resolve();
+  function serial(step) {
+    const run = writes.then(step, step);
+    writes = run.catch(() => void 0);
+    return run;
+  }
+  function updateIndex(change) {
+    return withIndexLock(storage, prefix, async () => {
+      const ids = new Set(readIndex(await storage.getItem(indexKey)));
+      for (const id of entries.keys()) ids.add(id);
+      for (const id of unreadable) ids.add(id);
+      change(ids);
+      await storage.setItem(indexKey, JSON.stringify([...ids]));
+    });
+  }
+  function storageOk() {
+    if (storageError !== null) {
+      storageError = null;
+      changed();
+    }
+  }
+  function storageFailed(what, e) {
+    storageError = `${what}: ${message(e)}`;
+    log(storageError);
+    changed();
+  }
+  async function persist(entry) {
+    try {
+      await serial(() => Promise.resolve(storage.setItem(itemKey(entry.id), JSON.stringify(entry))));
+      storageOk();
+    } catch (e) {
+      storageFailed("Couldn't save the outbox", e);
+    }
+  }
+  async function forget(id) {
+    await serial(async () => {
+      await updateIndex((ids) => void ids.delete(id));
+      await storage.removeItem(itemKey(id));
+    });
+  }
+  async function load() {
+    try {
+      const ids = readIndex(await storage.getItem(indexKey));
+      const gone = [];
+      for (const id of ids) {
+        if (entries.has(id)) continue;
+        const raw = await storage.getItem(itemKey(id));
+        if (raw === null || raw === void 0) {
+          gone.push(id);
+          continue;
+        }
+        const entry = readEntry(raw, id);
+        if (entry) entries.set(id, entry);
+        else if (!unreadable.has(id)) {
+          unreadable.add(id);
+          log(`A stored submission (${id}) couldn't be read; it was left in storage.`);
+        }
+      }
+      if (gone.length) await serial(() => updateIndex((set) => gone.forEach((id) => set.delete(id))));
+      loaded = true;
+      storageError = null;
+    } catch (e) {
+      storageError = `Couldn't read the outbox: ${message(e)}`;
+      log(storageError);
+    }
+    changed();
+  }
+  let ready = load();
+  const isDue = (e, t) => e.state === "pending" && (e.nextAttemptAt <= t || e.nextAttemptAt - t > MAX_WAIT_MS);
+  function revive() {
+    const at = now();
+    const revived = [];
+    for (const [id, e] of entries) {
+      if (e.state === "failed" && e.rejection === null) {
+        const next = { ...e, state: "pending", attempts: 0, nextAttemptAt: at };
+        entries.set(id, next);
+        revived.push(next);
+      }
+    }
+    return revived;
+  }
+  function delayFor(attempts) {
+    const full = Math.min(maxMs, baseMs * 2 ** Math.max(0, attempts - 1));
+    return Math.round(full / 2 + random() * full / 2);
+  }
+  function schedule() {
+    if (timer) clearTimeout(timer);
+    timer = null;
+    if (!running || !online) return;
+    let next = Infinity;
+    const t = now();
+    for (const e of entries.values()) if (e.state === "pending") next = Math.min(next, isDue(e, t) ? t : e.nextAttemptAt);
+    if (next === Infinity) return;
+    timer = setTimeout(() => void outbox.flush(), Math.min(MAX_TIMER_MS, Math.max(0, next - t)));
+  }
+  async function attempt(entry) {
+    sendingId = entry.id;
+    changed();
+    const controller = new AbortController();
+    let timeout = null;
+    let result;
+    let error = null;
+    try {
+      result = await Promise.race([
+        send({ ...entry, sending: true }, { signal: controller.signal }),
+        new Promise((_, reject) => {
+          timeout = setTimeout(() => {
+            controller.abort();
+            reject(new Error(`No answer after ${timeoutMs} ms.`));
+          }, timeoutMs);
+        })
+      ]);
+    } catch (e) {
+      error = message(e);
+    } finally {
+      if (timeout) clearTimeout(timeout);
+      sendingId = null;
+    }
+    if (!entries.has(entry.id)) return changed();
+    const outcome = error === null ? submitOutcome(result) : "retry";
+    if (outcome === "delivered") {
+      entries.delete(entry.id);
+      changed();
+      try {
+        await forget(entry.id);
+        storageOk();
+      } catch (e) {
+        storageFailed("Couldn't remove a delivered submission from the outbox", e);
+      }
+      options.onDelivered?.({ ...entry, sending: false }, result);
+      return;
+    }
+    const next = { ...entry, attempts: entry.attempts + 1 };
+    if (outcome === "rejected") {
+      const r = result;
+      next.state = "failed";
+      next.rejection = r.reason === "invalid" ? { reason: r.reason, errors: r.errors } : { reason: r.reason };
+      next.lastError = r.reason === "closed" ? "The form isn't taking responses." : r.reason === "conflict" ? "The server holds another response under this submission's key." : "The server refused the answers.";
+    } else {
+      next.lastError = error ?? (isSubmitResult(result) && !result.ok ? `The server answered ${result.reason}.` : "The server's answer wasn't understood.");
+      if (next.attempts >= maxAttempts) {
+        next.state = "failed";
+        next.lastError = `Gave up after ${next.attempts} tries. Last: ${next.lastError}`;
+      } else {
+        let wait = delayFor(next.attempts);
+        if (isSubmitResult(result) && !result.ok && result.reason === "rate_limited" && result.retryAfterSeconds !== void 0) {
+          wait = Math.max(wait, Math.min(MAX_WAIT_MS, result.retryAfterSeconds * 1e3));
+        }
+        next.nextAttemptAt = now() + wait;
+      }
+    }
+    entries.set(entry.id, next);
+    changed();
+    await persist(next);
+  }
+  async function drain() {
+    do {
+      again = false;
+      await ready;
+      if (!loaded) {
+        ready = load();
+        await ready;
+      }
+      while (online) {
+        const t = now();
+        const due = [...entries.values()].filter((e) => isDue(e, t)).sort((a, b) => a.createdAt - b.createdAt || (a.id < b.id ? -1 : 1))[0];
+        if (!due) break;
+        await attempt(due);
+      }
+    } while (again);
+  }
+  const outbox = {
+    get ready() {
+      return ready;
+    },
+    async enqueue(input) {
+      await ready;
+      const id = input.idempotencyKey ?? createKey();
+      const existing = entries.get(id);
+      if (existing) return { ...existing, sending: existing.id === sendingId };
+      const submission = JSON.parse(JSON.stringify(input.submission ?? {}));
+      const at = now();
+      const entry = {
+        id,
+        formId: input.formId,
+        request: {
+          ...submission,
+          idempotencyKey: id,
+          clientSubmittedAt: input.clientSubmittedAt ?? at,
+          ...input.attemptId !== void 0 ? { attemptId: input.attemptId } : {}
+        },
+        meta: input.meta ? JSON.parse(JSON.stringify(input.meta)) : null,
+        createdAt: at,
+        attempts: 0,
+        nextAttemptAt: at,
+        state: "pending",
+        lastError: null,
+        rejection: null
+      };
+      try {
+        await serial(async () => {
+          await storage.setItem(itemKey(id), JSON.stringify(entry));
+          await updateIndex((ids) => void ids.add(id));
+        });
+      } catch (e) {
+        storageFailed("Couldn't queue the submission", e);
+        throw e;
+      }
+      storageOk();
+      entries.set(id, entry);
+      changed();
+      if (running) void outbox.flush();
+      return { ...entry, sending: false };
+    },
+    flush() {
+      if (flushing) {
+        again = true;
+        return flushing;
+      }
+      flushing = drain().finally(() => {
+        flushing = null;
+        schedule();
+      });
+      return flushing;
+    },
+    async retry(id) {
+      await ready;
+      const entry = entries.get(id);
+      if (!entry || entry.state !== "failed") return;
+      const next = { ...entry, state: "pending", attempts: 0, nextAttemptAt: now(), lastError: null, rejection: null };
+      entries.set(id, next);
+      changed();
+      await persist(next);
+      await outbox.flush();
+    },
+    async discard(id) {
+      await ready;
+      const entry = entries.get(id);
+      if (!entry || sendingId === id) return false;
+      entries.delete(id);
+      changed();
+      schedule();
+      try {
+        await forget(id);
+        storageOk();
+      } catch (e) {
+        entries.set(id, entry);
+        storageFailed("Couldn't discard the submission", e);
+        throw e;
+      }
+      return true;
+    },
+    setOnline(value) {
+      if (online === value) return;
+      online = value;
+      if (online) {
+        const at = now();
+        for (const [id, e] of entries) if (e.state === "pending" && e.nextAttemptAt > at) entries.set(id, { ...e, nextAttemptAt: at });
+        for (const e of revive()) void persist(e);
+      }
+      changed();
+      if (online && running) void outbox.flush();
+      else schedule();
+    },
+    start() {
+      if (running) return;
+      running = true;
+      void ready.then(() => {
+        const revived = revive();
+        if (revived.length) changed();
+        for (const e of revived) void persist(e);
+        return outbox.flush();
+      });
+    },
+    stop() {
+      running = false;
+      schedule();
+    },
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => void listeners.delete(listener);
+    }
+  };
+  return outbox;
+}
+
 exports.CALCULATED_TYPE = CALCULATED_TYPE;
 exports.CHOICE_FIELD_TYPES = CHOICE_FIELD_TYPES;
 exports.COMPUTED_FIELD_TYPES = COMPUTED_FIELD_TYPES;
 exports.DEFAULT_PHOTO_FILES = DEFAULT_PHOTO_FILES;
 exports.DEFAULT_PHOTO_SIZE_MB = DEFAULT_PHOTO_SIZE_MB;
+exports.DRAFT_KEY_PREFIX = DRAFT_KEY_PREFIX;
+exports.DRAFT_MAX_AGE_MS = DRAFT_MAX_AGE_MS;
 exports.FORMULA_FUNCTIONS = FORMULA_FUNCTIONS;
 exports.HIGHLIGHT_NOTE_MESSAGE = HIGHLIGHT_NOTE_MESSAGE;
+exports.IDEMPOTENCY_KEY_PATTERN = IDEMPOTENCY_KEY_PATTERN;
 exports.MAX_CALCULATED_DECIMALS = MAX_CALCULATED_DECIMALS;
 exports.MAX_FORMULA_ITEMS = MAX_FORMULA_ITEMS;
 exports.MAX_FORMULA_LENGTH = MAX_FORMULA_LENGTH;
@@ -3095,6 +3905,7 @@ exports.REQUIRED_MESSAGE = REQUIRED_MESSAGE;
 exports.SEARCHABLE_OPTION_COUNT = SEARCHABLE_OPTION_COUNT;
 exports.STRUCTURED_FIELD_TYPES = STRUCTURED_FIELD_TYPES;
 exports.UPLOAD_FIELD_TYPES = UPLOAD_FIELD_TYPES;
+exports.VALIDATOR_FAILED_MESSAGE = VALIDATOR_FAILED_MESSAGE;
 exports.answerSnapshots = answerSnapshots;
 exports.answersFromSnapshots = answersFromSnapshots;
 exports.answersOnPath = answersOnPath;
@@ -3102,15 +3913,21 @@ exports.calculatedProps = calculatedProps;
 exports.calculatedValue = calculatedValue;
 exports.canonicalJson = canonicalJson;
 exports.carryAnswers = carryAnswers;
+exports.choiceKind = choiceKind;
 exports.choiceOptions = choiceOptions;
 exports.clearFilteredAnswers = clearFilteredAnswers;
 exports.coerceHidden = coerceHidden;
 exports.coerceHiddenValue = coerceHiddenValue;
 exports.computePath = computePath;
+exports.contentText = contentText;
+exports.createDraftAutosave = createDraftAutosave;
+exports.createDraftStore = createDraftStore;
 exports.createForm = createForm;
+exports.createSubmitOutbox = createSubmitOutbox;
 exports.dateLimits = dateLimits;
 exports.defineForm = defineForm;
 exports.describeCondition = describeCondition;
+exports.draftOf = draftOf;
 exports.evaluate = evaluate;
 exports.evaluateFormula = evaluateFormula;
 exports.explain = explain;
@@ -3124,12 +3941,16 @@ exports.formulaInput = formulaInput;
 exports.formulaNumber = formulaNumber;
 exports.formulaRefs = formulaRefs;
 exports.furthestReached = furthestReached;
+exports.getContentType = getContentType;
 exports.getFieldType = getFieldType;
 exports.hasOptionFilters = hasOptionFilters;
 exports.hiddenByPrefill = hiddenByPrefill;
+exports.isBuiltInFieldType = isBuiltInFieldType;
+exports.isChoiceField = isChoiceField;
 exports.isEmptyValue = isEmptyValue;
 exports.isFormEvent = isFormEvent;
 exports.isHttpsUrl = isHttpsUrl;
+exports.isIdempotencyKey = isIdempotencyKey;
 exports.isIsoDate = isIsoDate;
 exports.isJson = isJson;
 exports.isOtherValue = isOtherValue;
@@ -3138,8 +3959,12 @@ exports.isPhotoRef = isPhotoRef;
 exports.isPrefillParam = isPrefillParam;
 exports.isSearchable = isSearchable;
 exports.isSensitive = isSensitive;
+exports.isSubmitResult = isSubmitResult;
+exports.listContentTypes = listContentTypes;
 exports.listFieldTypes = listFieldTypes;
 exports.listLimits = listLimits;
+exports.memoryStorage = memoryStorage;
+exports.mergeResponses = mergeResponses;
 exports.normalizeValue = normalizeValue;
 exports.numberLimits = numberLimits;
 exports.optionFilter = optionFilter;
@@ -3161,19 +3986,23 @@ exports.prefillSetting = prefillSetting;
 exports.ratingDisplay = ratingDisplay;
 exports.readOption = readOption;
 exports.recall = recall;
+exports.registerContentType = registerContentType;
 exports.registerFieldType = registerFieldType;
 exports.renameFormulaKey = renameFormulaKey;
 exports.replay = replay;
 exports.respondentPath = respondentPath;
+exports.restoreDraft = restoreDraft;
 exports.ruleVisible = ruleVisible;
 exports.scaleLabels = scaleLabels;
 exports.searchOptions = searchOptions;
 exports.steps = steps;
+exports.submitOutcome = submitOutcome;
 exports.summarizeValue = summarizeValue;
 exports.tableColumns = tableColumns;
 exports.tableLimits = tableLimits;
 exports.validateField = validateField;
 exports.visibleOptions = visibleOptions;
+exports.webStorage = webStorage;
 exports.when = when;
 exports.withHostOptions = withHostOptions;
 //# sourceMappingURL=index.cjs.map