@marktiderman/genesis-forms 0.1.1 → 0.3.0

package/dist/index.cjs

@@ -62,6 +62,211 @@ function isFormEvent(value) {
   return typeof value.field === "string" && (value.value === void 0 || isJson(value.value)) && (value.source === void 0 || value.source === "prefill");
 }
 
+// src/structured.ts
+var isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+function intProp(field2, name, fallback, floor = 1) {
+  const v = field2.props?.[name];
+  return typeof v === "number" && Number.isInteger(v) && v >= floor ? v : fallback;
+}
+function optionalIntProp(field2, name, floor = 0) {
+  const v = field2.props?.[name];
+  return typeof v === "number" && Number.isInteger(v) && v >= floor ? v : void 0;
+}
+var blank = (v) => typeof v !== "string" || v.trim() === "";
+var blankText = (v) => typeof v === "string" && v.trim() === "";
+var emptyList = (value, isBlank) => value === void 0 || value === null || Array.isArray(value) && value.every(isBlank);
+var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+function listLimits(field2) {
+  return { min: optionalIntProp(field2, "min") ?? 0, max: intProp(field2, "max", 10), itemMaxLength: intProp(field2, "itemMaxLength", 500) };
+}
+var listItems = (value) => Array.isArray(value) ? value.filter((v) => typeof v === "string" && v.trim() !== "") : [];
+var MAX_TABLE_COLUMNS = 6;
+var MAX_TABLE_CELL_LENGTH = 2e3;
+function tableColumns(field2) {
+  const raw = field2.props?.columns;
+  if (!Array.isArray(raw)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const c of raw) {
+    if (!isObject(c) || typeof c.key !== "string" || !c.key || seen.has(c.key)) continue;
+    seen.add(c.key);
+    const column = { key: c.key, label: typeof c.label === "string" ? c.label : c.key };
+    if (c.long === true) column.long = true;
+    out.push(column);
+  }
+  return out;
+}
+function tableLimits(field2) {
+  return { minRows: optionalIntProp(field2, "minRows") ?? 0, maxRows: intProp(field2, "maxRows", 3) };
+}
+var filledRows = (value) => Array.isArray(value) ? value.filter((r) => isObject(r) && Object.values(r).some((c) => !blank(c))) : [];
+var MAX_TIMESTAMP_SECONDS = 86400;
+function formatTimestamp(seconds) {
+  const total = Number.isFinite(seconds) && seconds > 0 ? Math.floor(seconds) : 0;
+  const h = Math.floor(total / 3600);
+  const m = Math.floor(total % 3600 / 60);
+  const s = String(total % 60).padStart(2, "0");
+  return h ? `${h}:${String(m).padStart(2, "0")}:${s}` : `${m}:${s}`;
+}
+function parseTimestamp(text) {
+  const t = text.trim();
+  if (!t) return null;
+  const parts = t.split(":");
+  if (parts.length > 3) return null;
+  if (parts.length === 1) {
+    if (!/^\d+(\.\d+)?$/.test(t)) return null;
+    const n = Number(t);
+    return n <= MAX_TIMESTAMP_SECONDS ? n : null;
+  }
+  const last = parts.length - 1;
+  let total = 0;
+  for (let i = 0; i < parts.length; i++) {
+    const p = parts[i];
+    const ok = i === 0 ? /^\d+$/.test(p) : i === last ? /^\d{2}(\.\d+)?$/.test(p) : /^\d{2}$/.test(p);
+    if (!ok) return null;
+    const n = Number(p);
+    if (i > 0 && n >= 60) return null;
+    total = total * 60 + n;
+  }
+  return total <= MAX_TIMESTAMP_SECONDS ? total : null;
+}
+var isTimestamp = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= MAX_TIMESTAMP_SECONDS;
+var notesWithText = (value) => Array.isArray(value) ? value.filter((n) => isObject(n) && !blank(n.text)) : [];
+var MAX_HIGHLIGHT_NOTE_LENGTH = 1e3;
+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 structuredFieldTypes = [
+  {
+    type: "list",
+    label: "List",
+    category: "text",
+    value: { json: true },
+    // 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" },
+    isEmpty: (value) => emptyList(value, blankText),
+    validate: (value, field2) => {
+      if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) return "Enter a list of answers.";
+      const { min, max, itemMaxLength } = listLimits(field2);
+      if (value.some((v) => v.trim().length > itemMaxLength)) return `Keep each item under ${itemMaxLength} characters.`;
+      const count = listItems(value).length;
+      if (count < min) return `Add at least ${plural(min, "item")}.`;
+      if (count > max) return `Add at most ${plural(max, "item")}.`;
+      return null;
+    },
+    normalize: (value) => Array.isArray(value) ? listItems(value).map((v) => v.trim()) : value,
+    summarize: (value) => listItems(value).map((v) => v.trim()).join("; "),
+    samples: (field2) => {
+      const { min, max } = listLimits(field2);
+      return [Array.from({ length: Math.min(Math.max(1, min), max) }, (_, i) => `Item ${i + 1}`)];
+    }
+  },
+  {
+    type: "table",
+    label: "Table",
+    category: "advanced",
+    value: { json: true },
+    operators: ["answered", "empty"],
+    a11y: { semantics: "group" },
+    isEmpty: (value) => emptyList(value, (r) => isObject(r) && Object.values(r).every(blankText)),
+    validate: (value, field2) => {
+      const columns = tableColumns(field2);
+      if (!columns.length) return "This question has no columns.";
+      if (!Array.isArray(value) || !value.every(isObject)) return "Fill in the rows.";
+      const keys = new Set(columns.map((c) => c.key));
+      for (const row of value) {
+        for (const [key, cell] of Object.entries(row)) {
+          if (!keys.has(key)) return "An answer names a column this question doesn't have.";
+          if (typeof cell !== "string") return "Fill in the rows with text.";
+          if (cell.trim().length > MAX_TABLE_CELL_LENGTH) return `Keep each answer under ${MAX_TABLE_CELL_LENGTH} characters.`;
+        }
+      }
+      const { minRows, maxRows } = tableLimits(field2);
+      const count = filledRows(value).length;
+      if (count < minRows) return `Fill in at least ${plural(minRows, "row")}.`;
+      if (count > maxRows) return `Fill in at most ${plural(maxRows, "row")}.`;
+      return null;
+    },
+    normalize: (value) => Array.isArray(value) ? filledRows(value).map((row) => {
+      const out = {};
+      for (const [key, cell] of Object.entries(row)) if (typeof cell === "string") out[key] = cell.trim();
+      return out;
+    }) : value,
+    summarize: (value, field2) => {
+      const columns = tableColumns(field2);
+      return filledRows(value).map((row) => columns.filter((c) => !blank(row[c.key])).map((c) => `${c.label}: ${row[c.key].trim()}`).join(" \xB7 ")).join(" / ");
+    },
+    samples: (field2) => {
+      const columns = tableColumns(field2);
+      if (!columns.length) return [];
+      const { minRows, maxRows } = tableLimits(field2);
+      const row = Object.fromEntries(columns.map((c) => [c.key, "sample"]));
+      return [Array.from({ length: Math.min(Math.max(1, minRows), maxRows) }, () => ({ ...row }))];
+    }
+  },
+  {
+    type: "media-notes",
+    label: "Notes at moments",
+    category: "media",
+    value: { json: true },
+    operators: ["answered", "empty"],
+    a11y: { semantics: "group" },
+    isEmpty: (value) => emptyList(value, (n) => isObject(n) && blankText(n.text)),
+    validate: (value, field2) => {
+      if (!Array.isArray(value)) return "Add notes.";
+      const textMaxLength = intProp(field2, "textMaxLength", 1e3);
+      for (const note of value) {
+        if (!isObject(note) || typeof note.text !== "string") return "Add notes.";
+        if (!isTimestamp(note.at)) return "Each note needs a time.";
+        if (note.text.trim().length > textMaxLength) return `Keep each note under ${textMaxLength} characters.`;
+      }
+      const maxNotes = intProp(field2, "maxNotes", 20);
+      return notesWithText(value).length > maxNotes ? `Add at most ${plural(maxNotes, "note")}.` : null;
+    },
+    normalize: (value) => Array.isArray(value) ? notesWithText(value).map((n) => ({ at: n.at, text: n.text.trim() })).sort((a, b) => a.at - b.at) : value,
+    summarize: (value) => notesWithText(value).map((n) => ({ at: typeof n.at === "number" ? n.at : 0, text: n.text.trim() })).sort((a, b) => a.at - b.at).map((n) => `${formatTimestamp(n.at)} ${n.text}`).join("; "),
+    samples: () => [[{ at: 0, text: "sample" }]]
+  },
+  {
+    type: "text-highlights",
+    label: "Highlights",
+    category: "media",
+    value: { json: true },
+    operators: ["answered", "empty"],
+    a11y: { semantics: "group" },
+    isEmpty: (value) => emptyList(value, () => false),
+    validate: (value, field2) => {
+      if (!Array.isArray(value)) return "Highlight a passage.";
+      const maxHighlights = intProp(field2, "maxHighlights", 20);
+      if (value.length > maxHighlights) return `Add at most ${plural(maxHighlights, "highlight")}.`;
+      const text = sourceText(field2);
+      for (const h of value) {
+        if (!isObject(h) || !Number.isInteger(h.start) || !Number.isInteger(h.end) || typeof h.quote !== "string" || typeof h.note !== "string") {
+          return "Highlight a passage of the text.";
+        }
+        const start = h.start;
+        const end = h.end;
+        if (start < 0 || end <= start || h.quote.length !== end - start) return "Highlight a passage of the text.";
+        if (end - start > MAX_HIGHLIGHT_QUOTE_LENGTH) return `Highlight under ${MAX_HIGHLIGHT_QUOTE_LENGTH} characters at a time.`;
+        if (text !== void 0 && (end > text.length || text.slice(start, end) !== h.quote)) return "A highlight doesn't match the text.";
+        if (h.note.trim() === "") return HIGHLIGHT_NOTE_MESSAGE;
+        if (h.note.trim().length > MAX_HIGHLIGHT_NOTE_LENGTH) return `Keep each note under ${MAX_HIGHLIGHT_NOTE_LENGTH} characters.`;
+      }
+      return null;
+    },
+    normalize: (value) => Array.isArray(value) ? value.filter(isObject).map((h) => ({ start: h.start, end: h.end, quote: h.quote, note: String(h.note).trim() })).sort((a, b) => a.start - b.start || a.end - b.end) : value,
+    summarize: (value) => Array.isArray(value) ? value.filter(isObject).map((h) => `"${String(h.quote)}" \u2014 ${String(h.note).trim()}`).join("; ") : "",
+    samples: (field2) => {
+      const text = sourceText(field2);
+      if (text === void 0) return [[{ start: 0, end: 6, quote: "sample", note: "sample" }]];
+      const end = Math.min(text.length, 20);
+      return [[{ start: 0, end, quote: text.slice(0, end), note: "sample" }]];
+    }
+  }
+];
+
 // src/fields.ts
 var REGISTRY = /* @__PURE__ */ Symbol.for("@marktiderman/genesis-forms/field-types");
 var globalScope = globalThis;
@@ -249,7 +454,7 @@ var builtins = [
     summarize: (value) => value ? "Yes" : "No"
   }
 ];
-for (const manifest of builtins) registerFieldType(manifest);
+for (const manifest of [...builtins, ...structuredFieldTypes]) registerFieldType(manifest);
 
 // src/logic.ts
 function own(record, key) {
@@ -399,7 +604,31 @@ function recallRefs(text) {
 }
 
 // src/parse.ts
-var isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+function shown(v) {
+  let text;
+  try {
+    text = JSON.stringify(v);
+  } catch {
+    text = void 0;
+  }
+  text ??= typeof v === "bigint" ? `${v}n` : typeof v;
+  return text.length > 60 ? `${text.slice(0, 57)}...` : text;
+}
+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"
+};
+var ORDERING = /* @__PURE__ */ new Set(["lt", "lte", "gt", "gte"]);
 var OPERATORS = /* @__PURE__ */ new Set([
   "eq",
   "neq",
@@ -439,7 +668,48 @@ function parseForm(input) {
     }
     return true;
   };
-  if (!isObject(input)) {
+  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);
+    }
+  };
+  if (!isObject2(input)) {
     issue("", "A form definition must be an object.");
     return fail();
   }
@@ -448,19 +718,19 @@ function parseForm(input) {
   text(input.title, "title");
   optionalText(input.description, "description");
   if (input.layout !== void 0) {
-    if (!isObject(input.layout)) issue("layout", "Must be an object.");
+    if (!isObject2(input.layout)) issue("layout", "Must be an object.");
     else if (input.layout.mode !== "focus" && input.layout.mode !== "classic") {
       issue("layout.mode", "Must be focus or classic.");
     }
   }
   if (input.settings !== void 0) {
-    if (!isObject(input.settings)) issue("settings", "Must be an object.");
+    if (!isObject2(input.settings)) issue("settings", "Must be an object.");
     else {
       optionalBoolean(input.settings.anonymous, "settings.anonymous");
       optionalBoolean(input.settings.clearHiddenValues, "settings.clearHiddenValues");
     }
   }
-  if (input.meta !== void 0 && (!isObject(input.meta) || !isJson(input.meta))) {
+  if (input.meta !== void 0 && (!isObject2(input.meta) || !isJson(input.meta))) {
     issue("meta", "Must be a JSON object.");
   }
   if (!Array.isArray(input.blocks)) {
@@ -472,9 +742,10 @@ function parseForm(input) {
   const keys = /* @__PURE__ */ new Map();
   const fieldTypes = /* @__PURE__ */ new Map();
   const order = /* @__PURE__ */ new Map();
+  const choices = /* @__PURE__ */ new Map();
   input.blocks.forEach((block, i) => {
     const path = `blocks[${i}]`;
-    if (!isObject(block) || typeof block.id !== "string" || !block.id) {
+    if (!isObject2(block) || typeof block.id !== "string" || !block.id) {
       issue(path, "Every block needs a string id.");
       return;
     }
@@ -495,18 +766,30 @@ function parseForm(input) {
         issue(`${path}.type`, `Unknown field type "${String(block.type)}".`);
       }
       if (block.props !== void 0) {
-        if (!isObject(block.props) || !isJson(block.props)) issue(`${path}.props`, "Must be a JSON object.");
+        if (!isObject2(block.props) || !isJson(block.props)) issue(`${path}.props`, "Must be a JSON object.");
         else if (block.props.options !== void 0) {
           const options = block.props.options;
           if (!Array.isArray(options)) issue(`${path}.props.options`, "Must be an array.");
           else {
             options.forEach((o, j) => {
               const at = `${path}.props.options[${j}]`;
-              if (!isObject(o) || typeof o.value !== "string") issue(at, "Each option needs a string value.");
+              if (!isObject2(o) || typeof o.value !== "string") issue(at, "Each option needs a string value.");
               else optionalText(o.label, `${at}.label`);
             });
+            choices.set(
+              block.id,
+              new Set(options.flatMap((o) => isObject2(o) && typeof o.value === "string" ? [o.value] : []))
+            );
           }
         }
+        const { max, maxLength: maxLength2 } = isObject2(block.props) ? block.props : {};
+        if (block.type === "rating" && max !== void 0 && !(isInt(max) && max >= 2 && max <= 10)) {
+          issue(`${path}.props.max`, "Must be a whole number from 2 to 10.");
+        }
+        if (maxLength2 !== void 0 && !(isInt(maxLength2) && maxLength2 > 0)) {
+          issue(`${path}.props.maxLength`, "Must be a whole number above 0.");
+        }
+        if (isObject2(block.props) && typeof block.type === "string") structuredProps(block.type, block.props, `${path}.props`);
       }
       if (validKey) {
         if (keys.has(block.key)) issue(`${path}.key`, `Duplicate key "${String(block.key)}".`);
@@ -523,9 +806,10 @@ function parseForm(input) {
     }
   });
   const hiddenNames = /* @__PURE__ */ new Set();
+  const hiddenTypes = /* @__PURE__ */ new Map();
   if (input.hidden !== void 0 && !Array.isArray(input.hidden)) issue("hidden", "Must be an array.");
   (Array.isArray(input.hidden) ? input.hidden : []).forEach((h, i) => {
-    if (!isObject(h) || typeof h.name !== "string" || !h.name) {
+    if (!isObject2(h) || typeof h.name !== "string" || !h.name) {
       issue(`hidden[${i}]`, "Each hidden input needs a name.");
       return;
     }
@@ -538,13 +822,15 @@ function parseForm(input) {
       issue(`hidden[${i}].type`, "Must be string, number or boolean.");
     }
     optionalBoolean(h.sensitive, `hidden[${i}].sensitive`);
+    optionalBoolean(h.identifying, `hidden[${i}].identifying`);
     hiddenNames.add(h.name);
+    if (typeof h.type === "string") hiddenTypes.set(h.name, h.type);
   });
   const endingIds = /* @__PURE__ */ new Set();
   if (input.endings !== void 0 && !Array.isArray(input.endings)) issue("endings", "Must be an array.");
   (Array.isArray(input.endings) ? input.endings : []).forEach((e, i) => {
     const path = `endings[${i}]`;
-    if (!isObject(e)) {
+    if (!isObject2(e)) {
       issue(path, "Each ending must be an object with an id and a title.");
       return;
     }
@@ -556,7 +842,7 @@ function parseForm(input) {
   });
   const checkOperand = (o, path, reads) => {
     if (o === void 0) return;
-    if (!isObject(o)) return issue(path, "An operand must be an object.");
+    if (!isObject2(o)) return issue(path, "An operand must be an object.");
     if ("field" in o) {
       if (typeof o.field !== "string" || !fieldTypes.has(o.field)) return issue(path, `No field "${String(o.field)}".`);
       reads.push(o.field);
@@ -569,7 +855,7 @@ function parseForm(input) {
     }
   };
   const checkCondition = (c, path, reads, depth = 0) => {
-    if (!isObject(c)) return issue(path, "A condition must be an object.");
+    if (!isObject2(c)) return issue(path, "A condition must be an object.");
     if (depth > MAX_CONDITION_DEPTH) return issue(path, "The condition is nested too deeply.");
     if ("all" in c || "any" in c) {
       const group = "all" in c ? "all" : "any";
@@ -578,7 +864,7 @@ function parseForm(input) {
       return list.forEach((x, i) => checkCondition(x, `${path}.${group}[${i}]`, reads, depth + 1));
     }
     if ("not" in c) return checkCondition(c.not, `${path}.not`, reads, depth + 1);
-    if (typeof c.op !== "string" || !isObject(c.left)) {
+    if (typeof c.op !== "string" || !isObject2(c.left)) {
       return issue(path, "A comparison needs an `op` and a `left` operand.");
     }
     if (!OPERATORS.has(c.op)) issue(`${path}.op`, `Unknown operator "${c.op}".`);
@@ -587,16 +873,53 @@ function parseForm(input) {
     if (typeof c.left.field === "string") {
       const manifest = getFieldType(fieldTypes.get(c.left.field) ?? "");
       if (manifest && OPERATORS.has(c.op) && !manifest.operators.includes(c.op)) {
-        issue(`${path}.op`, `"${c.op}" does not apply to a ${manifest.type} field.`);
+        return issue(`${path}.op`, `"${c.op}" does not apply to a ${manifest.type} field.`);
       }
     }
+    checkLiterals(c.op, c.left, c.right, path);
+  };
+  const checkLiterals = (op, left, right, path) => {
+    if (op === "answered" || op === "empty" || !OPERATORS.has(op)) return;
+    const literal = isObject2(right) && "value" in right;
+    if (right !== void 0 && !literal) return;
+    let what = "the left side";
+    let type;
+    let options;
+    if (typeof left.field === "string" && fieldTypes.has(left.field)) {
+      const fieldType = fieldTypes.get(left.field);
+      what = `"${keyOf(left.field)}"`;
+      type = LITERAL_TYPE[fieldType];
+      if (fieldType === "single-choice" || fieldType === "multi-choice") options = choices.get(left.field);
+    } else if (typeof left.hidden === "string" && hiddenTypes.has(left.hidden)) {
+      what = `hidden input "${left.hidden}"`;
+      type = hiddenTypes.get(left.hidden);
+    }
+    const outcome = op === "neq" ? "always true" : "never true";
+    let values;
+    if (op === "in") {
+      if (!literal || !Array.isArray(right.value)) {
+        return void warnings.push({ path: `${path}.right`, message: "`in` needs a list of values; it never matches." });
+      }
+      values = right.value;
+    } else if (!literal) return;
+    else values = [right.value];
+    if (ORDERING.has(op)) {
+      if (type !== void 0 && type !== "number") {
+        return void warnings.push({ path: `${path}.op`, message: `"${op}" compares numbers, but ${what} holds a ${type}; it is never true.` });
+      }
+      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 keyOf = (id) => [...keys].find(([, v]) => v === id)?.[0] ?? id;
   const ruleIds = /* @__PURE__ */ new Set();
   if (input.logic !== void 0 && !Array.isArray(input.logic)) issue("logic", "Must be an array.");
   (Array.isArray(input.logic) ? input.logic : []).forEach((rule, i) => {
     const path = `logic[${i}]`;
-    if (!isObject(rule) || typeof rule.id !== "string" || !isObject(rule.when)) {
+    if (!isObject2(rule) || typeof rule.id !== "string" || !isObject2(rule.when)) {
       issue(path, "Each rule needs an id and a `when` condition.");
       return;
     }
@@ -615,7 +938,7 @@ function parseForm(input) {
         at = rule.from;
         inclusive = true;
       }
-      if (isObject(rule.to)) {
+      if (isObject2(rule.to)) {
         if (typeof rule.to.ending !== "string" || !endingIds.has(rule.to.ending)) {
           issue(`${path}.to`, `No ending "${String(rule.to.ending)}".`);
         }
@@ -647,7 +970,7 @@ function parseForm(input) {
     }
   });
   input.blocks.forEach((block, i) => {
-    if (!isObject(block)) return;
+    if (!isObject2(block)) return;
     const raw = block.kind === "field" ? [block.label, block.description] : block.kind === "content" ? [block.text] : [];
     const texts = raw.filter((t) => typeof t === "string");
     for (const t of texts) {
@@ -665,11 +988,23 @@ function parseForm(input) {
       }
     }
   });
+  const extra = [["description", input.description]];
+  (Array.isArray(input.endings) ? input.endings : []).forEach((e, i) => {
+    if (isObject2(e)) extra.push([`endings[${i}]`, e.title], [`endings[${i}]`, e.description]);
+  });
+  for (const [path, t] of extra) {
+    if (typeof t !== "string") continue;
+    for (const ref of recallRefs(t)) {
+      if (ref.kind === "hidden" ? !hiddenNames.has(ref.name) : !keys.has(ref.name)) {
+        warnings.push({ path, message: `Recalls unknown ${ref.kind === "hidden" ? "hidden input" : "field"} "${ref.name}"; it shows its fallback text.` });
+      }
+    }
+  }
   return issues.length ? fail() : { ok: true, form: input, warnings };
 }
 
 // src/define.ts
-function field(type, key, options, props) {
+function field(type, key, options, props2) {
   const block = {
     kind: "field",
     id: options.id ?? key,
@@ -682,16 +1017,18 @@ function field(type, key, options, props) {
   if (options.required) block.required = true;
   if (options.sensitive) block.sensitive = true;
   if (options.identifying) block.identifying = true;
-  if (props && Object.keys(props).length) block.props = props;
+  if (props2 && Object.keys(props2).length) block.props = props2;
   return block;
 }
+var props = (all) => Object.fromEntries(Object.entries(all).filter((e) => e[1] !== void 0));
 var choiceProps = (options) => ({
   options: options.map((o) => o.label ? { value: o.value, label: o.label } : { value: o.value })
 });
 var hiddenSpec = (type, o) => ({
   type,
   source: o.source ?? "url",
-  ...o.sensitive ? { sensitive: true } : {}
+  ...o.sensitive ? { sensitive: true } : {},
+  ...o.identifying ? { identifying: true } : {}
 });
 var f = {
   shortText: (key, o) => field("short-text", key, o, o.maxLength ? { maxLength: o.maxLength } : void 0),
@@ -703,6 +1040,41 @@ var f = {
   singleChoice: (key, o) => field("single-choice", key, o, choiceProps(o.options)),
   multiChoice: (key, o) => field("multi-choice", key, o, choiceProps(o.options)),
   yesNo: (key, o) => field("yes-no", key, o),
+  /** Several short answers, one per line: goals, action items, three things that went well. */
+  list: (key, o) => field(
+    "list",
+    key,
+    o,
+    props({ min: o.min, max: o.max, itemMaxLength: o.itemMaxLength, placeholder: o.itemPlaceholder })
+  ),
+  /**
+   * A small table each answer fills row by row, one answer per column: an
+   * action plan (What / Who / By when), pros and cons.
+   */
+  table: (key, o) => field("table", key, o, {
+    columns: o.columns.map((c) => c.long ? { key: c.key, label: c.label, long: true } : { key: c.key, label: c.label }),
+    ...props({ minRows: o.minRows, maxRows: o.maxRows })
+  }),
+  /**
+   * Notes pinned to times in a video or audio (lecture notes, a recorded call
+   * review): `at` is seconds from its start.
+   */
+  mediaNotes: (key, o) => field(
+    "media-notes",
+    key,
+    o,
+    props({ maxNotes: o.maxNotes, textMaxLength: o.textMaxLength })
+  ),
+  /**
+   * Highlight passages of a text and note on each (annotating an article, a
+   * policy or a contract): `text` here, or supplied by the host app.
+   */
+  textHighlights: (key, o) => field(
+    "text-highlights",
+    key,
+    o,
+    props({ text: o.text, maxHighlights: o.maxHighlights })
+  ),
   /** Any registered field type, including plugins. */
   custom: (type, key, o) => field(type, key, o, o.props),
   heading: (id, text) => ({ kind: "content", id, type: "heading", text }),
@@ -786,7 +1158,8 @@ function defineForm(input) {
       name,
       type: spec.type,
       source: spec.source,
-      ...spec.sensitive ? { sensitive: true } : {}
+      ...spec.sensitive ? { sensitive: true } : {},
+      ...spec.identifying ? { identifying: true } : {}
     }));
   }
   if (input.logic?.length) definition.logic = input.logic.map((rule, i) => rule.build(resolve2, `r${i + 1}`));
@@ -811,6 +1184,7 @@ ${list}`);
 
 // src/hidden.ts
 var MAX_HIDDEN_STRING_LENGTH = 1e3;
+var DECIMAL = /^-?\d+(\.\d+)?$/;
 function coerceHiddenValue(value, type) {
   if (typeof value === "string" && value.length > MAX_HIDDEN_STRING_LENGTH) return void 0;
   if (type === "string") {
@@ -820,7 +1194,7 @@ function coerceHiddenValue(value, type) {
   }
   if (type === "number") {
     if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
-    if (typeof value !== "string" || value.trim() === "") return void 0;
+    if (typeof value !== "string" || !DECIMAL.test(value)) return void 0;
     const n = Number(value);
     return Number.isFinite(n) ? n : void 0;
   }
@@ -1001,7 +1375,7 @@ function build(definition, options, replaying = false) {
       for (const id of state.path) {
         const field2 = fields.get(id);
         const value = own(state.values, id);
-        if (field2 && value !== void 0) out[id] = normalizeValue(value, field2);
+        if (field2 && !isEmptyValue(value, field2)) out[id] = normalizeValue(value, field2);
       }
       return out;
     }
@@ -1171,8 +1545,15 @@ function describeCondition(condition, def, fields = fieldMap(def)) {
   return `${left} ${op} ${right}`;
 }
 
+exports.HIGHLIGHT_NOTE_MESSAGE = HIGHLIGHT_NOTE_MESSAGE;
 exports.MAX_HIDDEN_STRING_LENGTH = MAX_HIDDEN_STRING_LENGTH;
+exports.MAX_HIGHLIGHT_NOTE_LENGTH = MAX_HIGHLIGHT_NOTE_LENGTH;
+exports.MAX_HIGHLIGHT_QUOTE_LENGTH = MAX_HIGHLIGHT_QUOTE_LENGTH;
+exports.MAX_TABLE_CELL_LENGTH = MAX_TABLE_CELL_LENGTH;
+exports.MAX_TABLE_COLUMNS = MAX_TABLE_COLUMNS;
+exports.MAX_TIMESTAMP_SECONDS = MAX_TIMESTAMP_SECONDS;
 exports.REQUIRED_MESSAGE = REQUIRED_MESSAGE;
+exports.STRUCTURED_FIELD_TYPES = STRUCTURED_FIELD_TYPES;
 exports.canonicalJson = canonicalJson;
 exports.choiceOptions = choiceOptions;
 exports.coerceHidden = coerceHidden;
@@ -1185,20 +1566,25 @@ exports.evaluate = evaluate;
 exports.explain = explain;
 exports.f = f;
 exports.fingerprint = fingerprint;
+exports.formatTimestamp = formatTimestamp;
 exports.getFieldType = getFieldType;
 exports.isEmptyValue = isEmptyValue;
 exports.isFormEvent = isFormEvent;
 exports.isJson = isJson;
 exports.isSensitive = isSensitive;
 exports.listFieldTypes = listFieldTypes;
+exports.listLimits = listLimits;
 exports.normalizeValue = normalizeValue;
 exports.parseForm = parseForm;
+exports.parseTimestamp = parseTimestamp;
 exports.recall = recall;
 exports.registerFieldType = registerFieldType;
 exports.replay = replay;
 exports.ruleVisible = ruleVisible;
 exports.steps = steps;
 exports.summarizeValue = summarizeValue;
+exports.tableColumns = tableColumns;
+exports.tableLimits = tableLimits;
 exports.validateField = validateField;
 exports.when = when;
 //# sourceMappingURL=index.cjs.map