@marktiderman/genesis-forms 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1174 @@
+// src/hash.ts
+function canonicalJson(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+  if (Array.isArray(value)) return value.map(sortKeys);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const key of Object.keys(value).sort()) {
+      const v = value[key];
+      if (v !== void 0) out[key] = sortKeys(v);
+    }
+    return out;
+  }
+  return value;
+}
+function fingerprint(value) {
+  const str = canonicalJson(value);
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let i = 0; i < str.length; i++) {
+    const ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16).padStart(14, "0");
+}
+
+// src/events.ts
+function isPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function isJson(value) {
+  const stack = [value];
+  while (stack.length) {
+    const v = stack.pop();
+    if (v === null || typeof v === "string" || typeof v === "boolean") continue;
+    if (typeof v === "number") {
+      if (!Number.isFinite(v)) return false;
+      continue;
+    }
+    if (Array.isArray(v)) {
+      for (let i = 0; i < v.length; i++) stack.push(v[i]);
+      continue;
+    }
+    if (!isPlainObject(v)) return false;
+    for (const key of Object.keys(v)) stack.push(v[key]);
+  }
+  return true;
+}
+var EVENT_TYPES = /* @__PURE__ */ new Set(["answer", "next", "back", "submit"]);
+function isFormEvent(value) {
+  if (!isPlainObject(value) || typeof value.type !== "string" || !EVENT_TYPES.has(value.type)) return false;
+  if (value.at !== void 0 && !(typeof value.at === "number" && Number.isFinite(value.at))) return false;
+  if (value.type !== "answer") return true;
+  return typeof value.field === "string" && (value.value === void 0 || isJson(value.value)) && (value.source === void 0 || value.source === "prefill");
+}
+
+// src/fields.ts
+var REGISTRY = /* @__PURE__ */ Symbol.for("@marktiderman/genesis-forms/field-types");
+var globalScope = globalThis;
+var registry = globalScope[REGISTRY] ??= /* @__PURE__ */ new Map();
+function registerFieldType(manifest) {
+  if (!manifest.type) throw new Error("registerFieldType: a field type needs a `type`.");
+  const value = manifest.value;
+  if (!value.json && (typeof value.serialize !== "function" || typeof value.deserialize !== "function")) {
+    throw new Error(
+      `registerFieldType: "${manifest.type}" stores a non-JSON value, so it must provide both serialize and deserialize.`
+    );
+  }
+  registry.set(manifest.type, manifest);
+}
+function getFieldType(type) {
+  return registry.get(type);
+}
+function listFieldTypes() {
+  return [...registry.values()];
+}
+function isEmptyValue(value, field2) {
+  const manifest = field2 ? registry.get(field2.type) : void 0;
+  if (manifest?.isEmpty) return manifest.isEmpty(value);
+  if (value === void 0 || value === null) return true;
+  if (typeof value === "string") return value.trim() === "";
+  if (Array.isArray(value)) return value.length === 0;
+  return false;
+}
+function normalizeValue(value, field2) {
+  const manifest = registry.get(field2.type);
+  return manifest?.normalize ? manifest.normalize(value, field2) : value;
+}
+function isSensitive(block) {
+  return block.kind === "field" && (block.sensitive === true || block.props?.sensitive === true);
+}
+function summarizeValue(value, field2) {
+  if (isEmptyValue(value, field2)) return "";
+  const manifest = registry.get(field2.type);
+  if (manifest?.summarize) return manifest.summarize(value, field2);
+  if (Array.isArray(value)) return value.join(", ");
+  return String(value);
+}
+function choiceOptions(field2) {
+  const raw = field2.props?.options;
+  if (!Array.isArray(raw)) return [];
+  return raw.flatMap(
+    (o) => o && typeof o === "object" && !Array.isArray(o) && typeof o.value === "string" ? [{ value: o.value, label: typeof o.label === "string" ? o.label : void 0 }] : []
+  );
+}
+function optionLabel(field2, value) {
+  const option = choiceOptions(field2).find((o) => o.value === value);
+  return option?.label ?? value;
+}
+function intRange(field2, min, maxDefault) {
+  const max = typeof field2.props?.max === "number" ? field2.props.max : maxDefault;
+  return { min, max };
+}
+var numberOps = ["eq", "neq", "lt", "lte", "gt", "gte", "in", "answered", "empty"];
+var textOps = ["eq", "neq", "contains", "answered", "empty"];
+function maxLength(field2, fallback) {
+  return typeof field2.props?.maxLength === "number" ? field2.props.maxLength : fallback;
+}
+function textValidate(fallback) {
+  return (value, field2) => {
+    if (typeof value !== "string") return "Enter text.";
+    const limit = maxLength(field2, fallback);
+    return value.length > limit ? `Keep it under ${limit} characters.` : null;
+  };
+}
+var MAX_EMAIL_LENGTH = 254;
+function isEmailAddress(value) {
+  if (value.length > MAX_EMAIL_LENGTH || /\s/.test(value)) return false;
+  const at = value.indexOf("@");
+  if (at < 1 || value.indexOf("@", at + 1) !== -1) return false;
+  const domain = value.slice(at + 1);
+  return domain.slice(1, -1).includes(".");
+}
+var MAX_PHONE_LENGTH = 32;
+function isPhoneNumber(value) {
+  if (value.length > MAX_PHONE_LENGTH) return false;
+  let digits = 0;
+  for (let i = 0; i < value.length; i++) {
+    const c = value[i];
+    if (c >= "0" && c <= "9") digits++;
+    else if (c === "+") {
+      if (i !== 0) return false;
+    } else if (c !== " " && c !== "-" && c !== "(" && c !== ")" && c !== ".") return false;
+  }
+  return digits >= 7 && digits <= 15;
+}
+var builtins = [
+  {
+    type: "short-text",
+    label: "Short text",
+    category: "text",
+    value: { json: true },
+    operators: textOps,
+    a11y: { semantics: "control" },
+    validate: textValidate(500)
+  },
+  {
+    type: "long-text",
+    label: "Long text",
+    category: "text",
+    value: { json: true },
+    operators: textOps,
+    a11y: { semantics: "control" },
+    validate: textValidate(5e3)
+  },
+  {
+    type: "email",
+    label: "Email",
+    category: "text",
+    value: { json: true },
+    operators: textOps,
+    a11y: { semantics: "control", autocomplete: "email", inputMode: "email" },
+    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
+  },
+  {
+    type: "phone",
+    label: "Phone",
+    category: "text",
+    value: { json: true },
+    operators: ["eq", "neq", "answered", "empty"],
+    a11y: { semantics: "control", autocomplete: "tel", inputMode: "tel" },
+    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)
+  },
+  {
+    type: "rating",
+    label: "Rating",
+    category: "scale",
+    value: { json: true },
+    operators: numberOps,
+    a11y: { semantics: "group" },
+    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}.`;
+    },
+    summarize: (value, field2) => `${value}/${intRange(field2, 1, 5).max}`
+  },
+  {
+    type: "nps",
+    label: "Net Promoter Score",
+    category: "scale",
+    value: { json: true },
+    operators: numberOps,
+    a11y: { semantics: "group" },
+    validate: (value) => Number.isInteger(value) && value >= 0 && value <= 10 ? null : "Choose a score from 0 to 10.",
+    summarize: (value) => `${value}/10`
+  },
+  {
+    type: "single-choice",
+    label: "Single choice",
+    category: "choice",
+    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) ? null : "Choose one of the options.",
+    summarize: (value, field2) => optionLabel(field2, String(value))
+  },
+  {
+    type: "multi-choice",
+    label: "Multiple choice",
+    category: "choice",
+    value: { json: true },
+    operators: ["contains", "answered", "empty"],
+    a11y: { semantics: "group" },
+    validate: (value, field2) => {
+      const allowed = new Set(choiceOptions(field2).map((o) => o.value));
+      return Array.isArray(value) && value.length <= allowed.size && new Set(value).size === value.length && value.every((v) => typeof v === "string" && allowed.has(v)) ? null : "Choose from the options.";
+    },
+    summarize: (value, field2) => Array.isArray(value) ? value.map((v) => optionLabel(field2, String(v))).join(", ") : String(value)
+  },
+  {
+    type: "yes-no",
+    label: "Yes / no",
+    category: "choice",
+    value: { json: true },
+    operators: ["eq", "neq", "answered", "empty"],
+    a11y: { semantics: "group" },
+    validate: (value) => typeof value === "boolean" ? null : "Choose yes or no.",
+    summarize: (value) => value ? "Yes" : "No"
+  }
+];
+for (const manifest of builtins) registerFieldType(manifest);
+
+// src/logic.ts
+function own(record, key) {
+  return Object.prototype.hasOwnProperty.call(record, key) ? record[key] : void 0;
+}
+function resolve(operand, scope) {
+  if ("field" in operand) return own(scope.values, operand.field);
+  if ("hidden" in operand) return own(scope.hidden, operand.hidden);
+  return operand.value;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((v, i) => deepEqual(v, b[i]));
+  }
+  return false;
+}
+function evaluate(condition, scope) {
+  if ("all" in condition) return condition.all.every((c) => evaluate(c, scope));
+  if ("any" in condition) return condition.any.some((c) => evaluate(c, scope));
+  if ("not" in condition) return !evaluate(condition.not, scope);
+  const left = resolve(condition.left, scope);
+  const right = condition.right ? resolve(condition.right, scope) : void 0;
+  const field2 = "field" in condition.left ? scope.fields.get(condition.left.field) : void 0;
+  const unanswered = isEmptyValue(left, field2);
+  switch (condition.op) {
+    case "answered":
+      return !unanswered;
+    case "empty":
+      return unanswered;
+    case "eq":
+      return !unanswered && deepEqual(left, right);
+    case "neq":
+      return unanswered || !deepEqual(left, right);
+    case "lt":
+    case "lte":
+    case "gt":
+    case "gte": {
+      if (typeof left !== "number" || typeof right !== "number") return false;
+      if (condition.op === "lt") return left < right;
+      if (condition.op === "lte") return left <= right;
+      if (condition.op === "gt") return left > right;
+      return left >= right;
+    }
+    case "in":
+      return !unanswered && Array.isArray(right) && right.some((r) => deepEqual(r, left));
+    case "contains":
+      if (unanswered) return false;
+      if (Array.isArray(left)) return left.some((l) => deepEqual(l, right));
+      return typeof left === "string" && typeof right === "string" && left.toLowerCase().includes(right.toLowerCase());
+  }
+}
+function steps(def) {
+  return def.blocks.filter((b) => b.kind !== "page-break");
+}
+function visibilityRules(def, blockId) {
+  return (def.logic ?? []).filter(
+    (r) => (r.effect === "show" || r.effect === "hide") && r.target === blockId
+  );
+}
+function withheld(def, field2) {
+  return def.settings?.anonymous === true && field2?.identifying === true;
+}
+function rulesAllow(def, blockId, scope) {
+  if (withheld(def, scope.fields.get(blockId))) return false;
+  const rules = visibilityRules(def, blockId);
+  if (rules.some((r) => r.effect === "hide" && evaluate(r.when, scope))) return false;
+  const shows = rules.filter((r) => r.effect === "show");
+  return shows.length === 0 || shows.some((r) => evaluate(r.when, scope));
+}
+function walkPath(def, scope) {
+  const list = steps(def);
+  const index = new Map(list.map((b, i2) => [b.id, i2]));
+  const position = new Map(def.blocks.map((b, i2) => [b.id, i2]));
+  const jumps = (def.logic ?? []).filter(
+    (r) => r.effect === "jump"
+  );
+  const defaultEnding = def.endings?.find((e) => e.id === "default")?.id ?? def.endings?.[0]?.id ?? null;
+  const placed = /* @__PURE__ */ Object.create(null);
+  const local = { values: placed, hidden: scope.hidden, fields: scope.fields };
+  const path = [];
+  const nextVisible = (from) => {
+    for (let i2 = from; i2 < list.length; i2++) if (rulesAllow(def, list[i2].id, local)) return i2;
+    return list.length;
+  };
+  let ending = defaultEnding;
+  let i = nextVisible(0);
+  while (i < list.length) {
+    const block = list[i];
+    path.push(block.id);
+    if (block.kind === "field") placed[block.id] = own(scope.values, block.id);
+    const jump = jumps.find((r) => r.from === block.id && evaluate(r.when, local));
+    if (jump) {
+      if (typeof jump.to === "object") {
+        ending = jump.to.ending;
+        break;
+      }
+      const target = index.get(jump.to);
+      if (target !== void 0 && target > i) {
+        i = nextVisible(target);
+        continue;
+      }
+    }
+    i = nextVisible(i + 1);
+  }
+  const scopeAt = (blockId, inclusive = false) => {
+    const at = position.get(blockId) ?? -1;
+    const values = /* @__PURE__ */ Object.create(null);
+    for (const id of path) {
+      const p = position.get(id);
+      if (p > at || p === at && !inclusive) break;
+      if (id in placed) values[id] = placed[id];
+    }
+    return { values, hidden: scope.hidden, fields: scope.fields };
+  };
+  return { path, ending, scopeAt };
+}
+function computePath(def, scope) {
+  const { path, ending } = walkPath(def, scope);
+  return { path, ending };
+}
+function ruleVisible(def, blockId, scope) {
+  return rulesAllow(def, blockId, walkPath(def, scope).scopeAt(blockId));
+}
+function fieldMap(def) {
+  const map = /* @__PURE__ */ new Map();
+  for (const block of def.blocks) if (block.kind === "field") map.set(block.id, block);
+  return map;
+}
+
+// src/recall.ts
+var TOKEN = /\{\{\s*(field|hidden):([A-Za-z0-9_-]+)\s*(?:\|([^}]*))?\}\}/g;
+function recall(text, scope) {
+  return text.replace(TOKEN, (_match, kind, name, fallback) => {
+    if (kind === "field") {
+      const field2 = scope.fieldsByKey.get(name);
+      const out2 = field2 ? summarizeValue(own(scope.values, field2.id), field2) : "";
+      return out2 || (fallback ?? "").trim();
+    }
+    const value = own(scope.hidden, name);
+    const out = value === void 0 || value === null ? "" : String(value);
+    return out || (fallback ?? "").trim();
+  });
+}
+function recallRefs(text) {
+  return [...text.matchAll(TOKEN)].map((m) => ({ kind: m[1], name: m[2] }));
+}
+
+// src/parse.ts
+var isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var OPERATORS = /* @__PURE__ */ new Set([
+  "eq",
+  "neq",
+  "lt",
+  "lte",
+  "gt",
+  "gte",
+  "in",
+  "contains",
+  "answered",
+  "empty"
+]);
+var RESERVED = new Set(Object.getOwnPropertyNames(Object.prototype));
+var MAX_CONDITION_DEPTH = 32;
+function parseForm(input) {
+  const issues = [];
+  const warnings = [];
+  const fail = () => ({ ok: false, issues, warnings });
+  const issue = (path, message) => void issues.push({ path, message });
+  const text = (v, path, nonEmpty = false) => {
+    if (typeof v !== "string" || nonEmpty && !v) issue(path, nonEmpty ? "Required." : "Required text.");
+  };
+  const optionalText = (v, path) => {
+    if (v !== void 0 && typeof v !== "string") issue(path, "Must be text.");
+  };
+  const optionalBoolean = (v, path) => {
+    if (v !== void 0 && typeof v !== "boolean") issue(path, "Must be true or false.");
+  };
+  const name = (v, path, what) => {
+    if (typeof v !== "string" || !v) {
+      issue(path, `${what} must be a non-empty string.`);
+      return false;
+    }
+    if (RESERVED.has(v)) {
+      issue(path, `"${v}" is reserved and cannot be used as ${what.toLowerCase()}.`);
+      return false;
+    }
+    return true;
+  };
+  if (!isObject(input)) {
+    issue("", "A form definition must be an object.");
+    return fail();
+  }
+  if (input.schemaVersion !== 1) issue("schemaVersion", "Unsupported schemaVersion; expected 1.");
+  text(input.id, "id", true);
+  text(input.title, "title");
+  optionalText(input.description, "description");
+  if (input.layout !== void 0) {
+    if (!isObject(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.");
+    else {
+      optionalBoolean(input.settings.anonymous, "settings.anonymous");
+      optionalBoolean(input.settings.clearHiddenValues, "settings.clearHiddenValues");
+    }
+  }
+  if (input.meta !== void 0 && (!isObject(input.meta) || !isJson(input.meta))) {
+    issue("meta", "Must be a JSON object.");
+  }
+  if (!Array.isArray(input.blocks)) {
+    issue("blocks", "Must be an array.");
+    return fail();
+  }
+  const ids = /* @__PURE__ */ new Set();
+  const pageBreaks = /* @__PURE__ */ new Set();
+  const keys = /* @__PURE__ */ new Map();
+  const fieldTypes = /* @__PURE__ */ new Map();
+  const order = /* @__PURE__ */ new Map();
+  input.blocks.forEach((block, i) => {
+    const path = `blocks[${i}]`;
+    if (!isObject(block) || typeof block.id !== "string" || !block.id) {
+      issue(path, "Every block needs a string id.");
+      return;
+    }
+    if (!name(block.id, `${path}.id`, "A block id")) return;
+    if (ids.has(block.id)) issue(`${path}.id`, `Duplicate id "${block.id}".`);
+    ids.add(block.id);
+    if (block.kind === "page-break") pageBreaks.add(block.id);
+    order.set(block.id, i);
+    if (block.kind === "field") {
+      text(block.label, `${path}.label`);
+      optionalText(block.description, `${path}.description`);
+      optionalText(block.placeholder, `${path}.placeholder`);
+      optionalBoolean(block.required, `${path}.required`);
+      optionalBoolean(block.sensitive, `${path}.sensitive`);
+      optionalBoolean(block.identifying, `${path}.identifying`);
+      const validKey = name(block.key, `${path}.key`, "A field key");
+      if (typeof block.type !== "string" || !getFieldType(block.type)) {
+        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.");
+        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.");
+              else optionalText(o.label, `${at}.label`);
+            });
+          }
+        }
+      }
+      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 : "");
+    } else if (block.kind === "content") {
+      if (block.type !== "heading" && block.type !== "text") issue(`${path}.type`, "Must be heading or text.");
+      text(block.text, `${path}.text`);
+    } else if (block.kind === "page-break") {
+      optionalText(block.title, `${path}.title`);
+    } else {
+      issue(`${path}.kind`, "Unknown block kind.");
+    }
+  });
+  const hiddenNames = /* @__PURE__ */ new Set();
+  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) {
+      issue(`hidden[${i}]`, "Each hidden input needs a name.");
+      return;
+    }
+    if (!name(h.name, `hidden[${i}].name`, "A hidden input name")) return;
+    if (hiddenNames.has(h.name)) issue(`hidden[${i}].name`, `Duplicate hidden input "${h.name}".`);
+    if (typeof h.source !== "string" || !["url", "host", "server"].includes(h.source)) {
+      issue(`hidden[${i}].source`, "Must be url, host or server.");
+    }
+    if (typeof h.type !== "string" || !["string", "number", "boolean"].includes(h.type)) {
+      issue(`hidden[${i}].type`, "Must be string, number or boolean.");
+    }
+    optionalBoolean(h.sensitive, `hidden[${i}].sensitive`);
+    hiddenNames.add(h.name);
+  });
+  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)) {
+      issue(path, "Each ending must be an object with an id and a title.");
+      return;
+    }
+    text(e.title, `${path}.title`);
+    optionalText(e.description, `${path}.description`);
+    if (!name(e.id, `${path}.id`, "An ending id")) return;
+    if (endingIds.has(e.id)) issue(`${path}.id`, `Duplicate ending id "${e.id}".`);
+    endingIds.add(e.id);
+  });
+  const checkOperand = (o, path, reads) => {
+    if (o === void 0) return;
+    if (!isObject(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);
+    } else if ("hidden" in o) {
+      if (typeof o.hidden !== "string" || !hiddenNames.has(o.hidden)) {
+        issue(path, `No hidden input "${String(o.hidden)}".`);
+      }
+    } else if (!("value" in o) || !isJson(o.value)) {
+      issue(path, "An operand needs a `field`, a `hidden` input or a JSON `value`.");
+    }
+  };
+  const checkCondition = (c, path, reads, depth = 0) => {
+    if (!isObject(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";
+      const list = c[group];
+      if (!Array.isArray(list)) return issue(path, `\`${group}\` must be an array.`);
+      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)) {
+      return issue(path, "A comparison needs an `op` and a `left` operand.");
+    }
+    if (!OPERATORS.has(c.op)) issue(`${path}.op`, `Unknown operator "${c.op}".`);
+    checkOperand(c.left, `${path}.left`, reads);
+    checkOperand(c.right, `${path}.right`, reads);
+    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.`);
+      }
+    }
+  };
+  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)) {
+      issue(path, "Each rule needs an id and a `when` condition.");
+      return;
+    }
+    if (ruleIds.has(rule.id)) issue(`${path}.id`, `Duplicate rule id "${rule.id}".`);
+    ruleIds.add(rule.id);
+    const reads = [];
+    checkCondition(rule.when, `${path}.when`, reads);
+    let at;
+    let inclusive = false;
+    if (rule.effect === "jump") {
+      if (typeof rule.from !== "string" || !ids.has(rule.from)) {
+        issue(`${path}.from`, `No block "${String(rule.from)}".`);
+      } else if (pageBreaks.has(rule.from)) {
+        issue(`${path}.from`, "A jump can't start at a page break; use the block before it.");
+      } else {
+        at = rule.from;
+        inclusive = true;
+      }
+      if (isObject(rule.to)) {
+        if (typeof rule.to.ending !== "string" || !endingIds.has(rule.to.ending)) {
+          issue(`${path}.to`, `No ending "${String(rule.to.ending)}".`);
+        }
+      } else if (typeof rule.to !== "string" || !ids.has(rule.to)) {
+        issue(`${path}.to`, `No block "${String(rule.to)}".`);
+      } else if (pageBreaks.has(rule.to)) {
+        issue(`${path}.to`, "A jump can't land on a page break; jump to the first block after it.");
+      } else if (at !== void 0 && (order.get(rule.to) ?? 0) <= (order.get(at) ?? 0)) {
+        warnings.push({ path: `${path}.to`, message: "Jumps only go forward; this one is ignored." });
+      }
+    } else if (rule.effect === "show" || rule.effect === "hide") {
+      if (typeof rule.target !== "string" || !ids.has(rule.target)) {
+        issue(`${path}.target`, `No block "${String(rule.target)}".`);
+      } else at = rule.target;
+    } else {
+      issue(`${path}.effect`, "Must be show, hide or jump.");
+    }
+    if (at !== void 0) {
+      const limit = order.get(at) ?? 0;
+      for (const field2 of new Set(reads)) {
+        const p = order.get(field2) ?? 0;
+        if (p > limit || p === limit && !inclusive) {
+          warnings.push({
+            path: `${path}.when`,
+            message: `Reads "${keyOf(field2)}", which does not come before "${keyOf(at)}"; it always reads as unanswered.`
+          });
+        }
+      }
+    }
+  });
+  input.blocks.forEach((block, i) => {
+    if (!isObject(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) {
+      for (const ref of recallRefs(t)) {
+        if (ref.kind === "hidden" && !hiddenNames.has(ref.name)) {
+          issue(`blocks[${i}]`, `Recalls unknown hidden input "${ref.name}".`);
+        }
+        if (ref.kind === "field") {
+          const target = keys.get(ref.name);
+          if (!target) issue(`blocks[${i}]`, `Recalls unknown field "${ref.name}".`);
+          else if ((order.get(target) ?? 0) >= i) {
+            warnings.push({ path: `blocks[${i}]`, message: `Recalls "${ref.name}", which comes later.` });
+          }
+        }
+      }
+    }
+  });
+  return issues.length ? fail() : { ok: true, form: input, warnings };
+}
+
+// src/define.ts
+function field(type, key, options, props) {
+  const block = {
+    kind: "field",
+    id: options.id ?? key,
+    key,
+    type,
+    label: options.label
+  };
+  if (options.description) block.description = options.description;
+  if (options.placeholder) block.placeholder = options.placeholder;
+  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;
+  return block;
+}
+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 } : {}
+});
+var f = {
+  shortText: (key, o) => field("short-text", key, o, o.maxLength ? { maxLength: o.maxLength } : void 0),
+  longText: (key, o) => field("long-text", key, o, o.maxLength ? { maxLength: o.maxLength } : void 0),
+  email: (key, o) => field("email", key, o),
+  phone: (key, o) => field("phone", key, o),
+  rating: (key, o) => field("rating", key, o, { max: o.max ?? 5 }),
+  nps: (key, o) => field("nps", key, o),
+  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),
+  /** 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 }),
+  text: (id, text) => ({ kind: "content", id, type: "text", text }),
+  pageBreak: (id, title) => title ? { kind: "page-break", id, title } : { kind: "page-break", id },
+  hidden: {
+    string: (o = {}) => hiddenSpec("string", o),
+    number: (o = {}) => hiddenSpec("number", o),
+    boolean: (o = {}) => hiddenSpec("boolean", o)
+  }
+};
+function effects(fromKey, condition) {
+  const spec = (make) => ({
+    __rule: true,
+    build: make
+  });
+  return {
+    show: (target) => spec((r, id) => ({ id, when: condition(r), effect: "show", target: r(target, "target") })),
+    hide: (target) => spec((r, id) => ({ id, when: condition(r), effect: "hide", target: r(target, "target") })),
+    jumpTo: (target) => spec((r, id) => {
+      if (!fromKey) throw new Error("jumpTo needs a starting field: use when(key)\u2026");
+      return {
+        id,
+        when: condition(r),
+        effect: "jump",
+        from: r(fromKey),
+        to: typeof target === "string" ? r(target, "target") : target
+      };
+    })
+  };
+}
+var compare = (key, op, value) => (r) => value === void 0 ? { op, left: { field: r(key) } } : { op, left: { field: r(key) }, right: { value } };
+function when(key) {
+  const on = (op, value) => effects(key, compare(key, op, value));
+  return {
+    is: (value) => on("eq", value),
+    isNot: (value) => on("neq", value),
+    lessThan: (n) => on("lt", n),
+    atMost: (n) => on("lte", n),
+    greaterThan: (n) => on("gt", n),
+    atLeast: (n) => on("gte", n),
+    isOneOf: (values) => on("in", values),
+    includes: (value) => on("contains", value),
+    isAnswered: () => on("answered"),
+    isEmpty: () => on("empty")
+  };
+}
+when.condition = (condition, from) => effects(from ?? null, (r) => resolveCondition(condition, r));
+function resolveCondition(c, r) {
+  if ("all" in c) return { all: c.all.map((x) => resolveCondition(x, r)) };
+  if ("any" in c) return { any: c.any.map((x) => resolveCondition(x, r)) };
+  if ("not" in c) return { not: resolveCondition(c.not, r) };
+  const fix = (o) => "field" in o ? { field: r(o.field) } : o;
+  return c.right ? { op: c.op, left: fix(c.left), right: fix(c.right) } : { op: c.op, left: fix(c.left) };
+}
+function defineForm(input) {
+  const keyToId = /* @__PURE__ */ new Map();
+  const contentIds = /* @__PURE__ */ new Set();
+  for (const block of input.blocks) {
+    if (block.kind === "field") keyToId.set(block.key, block.id);
+    else contentIds.add(block.id);
+  }
+  const resolve2 = (key, as = "field") => {
+    const id = keyToId.get(key) ?? (as === "target" && contentIds.has(key) ? key : void 0);
+    if (!id) {
+      const what = as === "target" ? "field key or content block id" : "field with key";
+      throw new Error(`defineForm "${input.id}": no ${what} "${key}".`);
+    }
+    return id;
+  };
+  const definition = {
+    schemaVersion: 1,
+    id: input.id,
+    title: input.title,
+    blocks: input.blocks.map((b) => ({ ...b }))
+  };
+  if (input.description) definition.description = input.description;
+  if (input.layout) definition.layout = input.layout;
+  if (input.hidden && Object.keys(input.hidden).length) {
+    definition.hidden = Object.entries(input.hidden).map(([name, spec]) => ({
+      name,
+      type: spec.type,
+      source: spec.source,
+      ...spec.sensitive ? { sensitive: true } : {}
+    }));
+  }
+  if (input.logic?.length) definition.logic = input.logic.map((rule, i) => rule.build(resolve2, `r${i + 1}`));
+  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);
+  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),
+    $answers: void 0,
+    $hidden: void 0
+  };
+}
+
+// src/hidden.ts
+var MAX_HIDDEN_STRING_LENGTH = 1e3;
+function coerceHiddenValue(value, type) {
+  if (typeof value === "string" && value.length > MAX_HIDDEN_STRING_LENGTH) return void 0;
+  if (type === "string") {
+    if (typeof value === "string") return value;
+    if (typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) return String(value);
+    return void 0;
+  }
+  if (type === "number") {
+    if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+    if (typeof value !== "string" || value.trim() === "") return void 0;
+    const n = Number(value);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  if (typeof value === "boolean") return value;
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return void 0;
+}
+function coerceHidden(definition, raw, options = {}) {
+  const declared = new Map((definition.hidden ?? []).map((h) => [h.name, h]));
+  const values = {};
+  const ignored = [];
+  if (!isPlainObject(raw)) return { values, ignored };
+  for (const name of Object.keys(raw)) {
+    const value = raw[name];
+    if (value === void 0) continue;
+    const spec = declared.get(name);
+    if (!spec || options.sources && !options.sources.includes(spec.source)) {
+      ignored.push(name);
+      continue;
+    }
+    const coerced = coerceHiddenValue(value, spec.type);
+    if (coerced === void 0) ignored.push(name);
+    else Object.defineProperty(values, name, { value: coerced, enumerable: true, writable: true, configurable: true });
+  }
+  return { values, ignored };
+}
+
+// src/validate.ts
+var REQUIRED_MESSAGE = "This question needs an answer.";
+function runCustom(validator, value) {
+  if (typeof validator === "function") return validator(value);
+  const result = validator["~standard"].validate(value);
+  if (result instanceof Promise) {
+    throw new Error("Async validators are not supported in the engine yet; run them on the server.");
+  }
+  const issues = result.issues;
+  return issues?.length ? issues[0].message : null;
+}
+function validateField(field2, value, options = {}) {
+  if (isEmptyValue(value, field2)) {
+    return field2.required && options.requireAnswers !== false ? REQUIRED_MESSAGE : null;
+  }
+  const manifest = getFieldType(field2.type);
+  if (!manifest) return `Unknown field type "${field2.type}".`;
+  const builtIn = manifest.validate?.(value, field2) ?? null;
+  if (builtIn) return builtIn;
+  return options.custom ? runCustom(options.custom, value) : null;
+}
+
+// src/engine.ts
+function createForm(definition, options = {}) {
+  return build(definition, options).engine;
+}
+function build(definition, options, replaying = false) {
+  const fields = fieldMap(definition);
+  const byKey = new Map([...fields.values()].map((f2) => [f2.key, f2]));
+  const blocks = new Map(definition.blocks.map((b) => [b.id, b]));
+  const clock = definition.settings?.anonymous === true ? () => void 0 : options.clock ?? (() => Date.now());
+  const listeners = /* @__PURE__ */ new Set();
+  let batch = replaying;
+  const scopeOf = (values, hidden) => ({
+    values,
+    hidden,
+    fields
+  });
+  const declared = new Set((definition.hidden ?? []).map((h) => h.name));
+  const initialHidden = {};
+  for (const [name, value] of Object.entries(options.hidden ?? {})) {
+    if (!declared.has(name)) initialHidden[name] = value;
+  }
+  Object.assign(initialHidden, coerceHidden(definition, options.hidden).values);
+  const first = computePath(definition, scopeOf({}, initialHidden));
+  let state = {
+    values: {},
+    hidden: initialHidden,
+    path: first.path,
+    current: first.path[0] ?? null,
+    history: [],
+    errors: {},
+    status: "in_progress",
+    ending: null,
+    events: []
+  };
+  const emit = (next) => {
+    state = next;
+    if (batch) return;
+    for (const l of listeners) l();
+  };
+  const log = (event) => {
+    if (!batch) return [...state.events, event];
+    state.events.push(event);
+    return state.events;
+  };
+  const stamp = (event) => {
+    const at = clock();
+    return at === void 0 ? event : { ...event, at };
+  };
+  const isVisibleIn = (s, id) => s.path.includes(id);
+  const errorsFor = (s, ids) => {
+    const errors = {};
+    for (const id of ids) {
+      const field2 = fields.get(id);
+      if (!field2 || !isVisibleIn(s, id)) continue;
+      const message = validateField(field2, own(s.values, id), { custom: options.validators?.[id] });
+      if (message) errors[id] = message;
+    }
+    return errors;
+  };
+  const answer = (id, value, event) => {
+    if (state.status === "completed" || own(state.values, id) === value) return;
+    const values = { ...state.values, [id]: value };
+    const { path } = computePath(definition, scopeOf(values, state.hidden));
+    const errors = { ...state.errors };
+    delete errors[id];
+    emit({ ...state, values, path, errors, events: log(event) });
+  };
+  const engine = {
+    definition,
+    getState: () => state,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    idOf(key) {
+      const field2 = byKey.get(key);
+      if (!field2) throw new Error(`No field with key "${key}".`);
+      return field2.id;
+    },
+    field: (id) => fields.get(id),
+    block: (id) => blocks.get(id),
+    isVisible: (id) => isVisibleIn(state, id),
+    setValue(id, value) {
+      if (!fields.has(id)) throw new Error(`No field "${id}".`);
+      answer(id, value, stamp({ type: "answer", field: id, value }));
+    },
+    next() {
+      if (!state.current || state.status === "completed") return false;
+      const errors = errorsFor(state, [state.current]);
+      const events = log(stamp({ type: "next" }));
+      if (Object.keys(errors).length) {
+        emit({ ...state, errors: { ...state.errors, ...errors }, events });
+        return false;
+      }
+      const at = state.path.indexOf(state.current);
+      const target = state.path[at + 1];
+      if (!target) {
+        emit({ ...state, events });
+        return true;
+      }
+      emit({ ...state, current: target, history: [...state.history, state.current], events });
+      return true;
+    },
+    back() {
+      if (state.status === "completed") return;
+      const history = [...state.history];
+      let previous = history.pop();
+      while (previous && !state.path.includes(previous)) previous = history.pop();
+      if (!previous) return;
+      emit({ ...state, current: previous, history, events: log(stamp({ type: "back" })) });
+    },
+    submit() {
+      if (state.status === "completed") return false;
+      const errors = errorsFor(state, state.path);
+      const events = log(stamp({ type: "submit" }));
+      if (Object.keys(errors).length) {
+        const firstError = state.path.find((id) => own(errors, id)) ?? state.current;
+        emit({ ...state, errors, current: firstError, events });
+        return false;
+      }
+      const { ending } = computePath(definition, scopeOf(state.values, state.hidden));
+      emit({ ...state, errors: {}, status: "completed", ending, events });
+      return true;
+    },
+    text: (template) => recall(template, { fieldsByKey: byKey, values: state.values, hidden: state.hidden }),
+    answers() {
+      const out = {};
+      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);
+      }
+      return out;
+    }
+  };
+  if (options.initialValues) {
+    for (const [id, value] of Object.entries(options.initialValues)) {
+      if (!fields.has(id) || value === void 0) continue;
+      answer(id, value, stamp({ type: "answer", field: id, value, source: "prefill" }));
+    }
+  }
+  const apply = (event) => {
+    if (event.type === "answer") {
+      if (fields.has(event.field)) {
+        const { at: _at, ...logged } = event;
+        answer(event.field, event.value, logged);
+      }
+    } else if (event.type === "next") engine.next();
+    else if (event.type === "back") engine.back();
+    else if (event.type === "submit") engine.submit();
+  };
+  const finish = () => {
+    batch = false;
+    state = { ...state, events: [...state.events] };
+  };
+  return { engine, apply, finish };
+}
+function replay(definition, events, options = {}) {
+  const { engine, apply, finish } = build(definition, { ...options, initialValues: void 0, clock: () => void 0 }, true);
+  for (const event of events) apply(event);
+  finish();
+  return engine;
+}
+
+// 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;
+  const def = input.definition;
+  const fields = fieldMap(def);
+  const scope = { values: input.values, hidden: input.hidden ?? {}, fields };
+  const block = def.blocks.find((b) => b.id === blockId) ?? def.blocks.find((b) => b.kind === "field" && b.key === blockId);
+  if (!block) throw new Error(`explain: no block "${blockId}".`);
+  const id = block.id;
+  const nameOf = (bid) => {
+    const b = def.blocks.find((x) => x.id === bid);
+    return b?.kind === "field" ? b.key : bid;
+  };
+  const key = nameOf(id);
+  const walk = walkPath(def, scope);
+  const at = walk.scopeAt(id);
+  const rules = (def.logic ?? []).filter((r) => (r.effect === "show" || r.effect === "hide") && r.target === id).map((r) => {
+    const matched = evaluate(r.when, at);
+    const cond = describeCondition(r.when, def, fields);
+    const sentence = r.effect === "hide" ? matched ? `Hidden because ${cond}.` : `Would be hidden if ${cond}.` : matched ? `Shown because ${cond}.` : `Hidden until ${cond}.`;
+    return { ruleId: r.id, effect: r.effect, matched, sentence };
+  });
+  const { path } = walk;
+  const onPath = path.includes(id);
+  const visibleByRules = ruleVisible(def, id, scope);
+  const skippedBy = onPath ? void 0 : findSkippingJump(def, walk, id, nameOf);
+  const visible = onPath && visibleByRules;
+  let validation;
+  if (block.kind === "field") {
+    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 };
+      else validation = { status: isEmptyValue(value, block) ? "unanswered" : "valid" };
+    }
+  }
+  let summary;
+  if (block.kind === "page-break") summary = "Page breaks are never on the path; they only group blocks into pages.";
+  else if (visible) summary = rules.find((r) => r.effect === "show" && r.matched)?.sentence ?? "Visible: no rule hides it.";
+  else if (block.kind === "field" && withheld(def, block)) {
+    summary = "Not asked: the form is anonymous and this field identifies the respondent.";
+  } else if (!visibleByRules) {
+    summary = rules.find((r) => r.effect === "hide" && r.matched)?.sentence ?? rules.find((r) => r.effect === "show")?.sentence ?? "Hidden by logic.";
+  } else if (skippedBy) summary = skippedBy.sentence;
+  else summary = "Not on the path.";
+  return {
+    blockId: id,
+    key,
+    kind: block.kind,
+    onPath,
+    ruleVisible: visibleByRules,
+    visible,
+    ...skippedBy ? { skippedBy } : {},
+    rules,
+    ...validation ? { validation } : {},
+    summary
+  };
+}
+function findSkippingJump(def, walk, id, nameOf) {
+  const list = steps(def);
+  const index = new Map(list.map((b, i) => [b.id, i]));
+  const at = index.get(id);
+  if (at === void 0) return void 0;
+  const jumps = (def.logic ?? []).filter((r) => r.effect === "jump");
+  for (const from of walk.path) {
+    const i = index.get(from);
+    if (i >= at) break;
+    const scope = walk.scopeAt(from, true);
+    const jump = jumps.find((r) => r.from === from && evaluate(r.when, scope));
+    if (!jump) continue;
+    const cond = describeCondition(jump.when, def, fieldMap(def));
+    if (typeof jump.to === "object") {
+      return {
+        ruleId: jump.id,
+        from,
+        to: jump.to,
+        sentence: `Skipped: ${nameOf(from)} jumps to the "${jump.to.ending}" ending because ${cond}.`
+      };
+    }
+    const target = index.get(jump.to);
+    if (target !== void 0 && target > i && at < target) {
+      return {
+        ruleId: jump.id,
+        from,
+        to: jump.to,
+        sentence: `Skipped: ${nameOf(from)} jumps to ${nameOf(jump.to)} because ${cond}.`
+      };
+    }
+  }
+  return void 0;
+}
+var OPS = {
+  eq: "is",
+  neq: "is not",
+  lt: "is less than",
+  lte: "is at most",
+  gt: "is more than",
+  gte: "is at least",
+  in: "is one of",
+  contains: "includes",
+  answered: "is answered",
+  empty: "is unanswered"
+};
+function describeValue(value, field2) {
+  if (value === void 0 || value === null) return "nothing";
+  if (typeof value === "boolean") return value ? "Yes" : "No";
+  if (typeof value === "number") return String(value);
+  if (typeof value === "string") {
+    const label = field2 ? choiceOptions(field2).find((o) => o.value === value)?.label : void 0;
+    return `"${label ?? value}"`;
+  }
+  if (Array.isArray(value)) return value.map((v) => describeValue(v, field2)).join(", ");
+  return JSON.stringify(value);
+}
+function describeOperand(operand, def, fields) {
+  if ("field" in operand) return fields.get(operand.field)?.key ?? operand.field;
+  if ("hidden" in operand) return `the ${operand.hidden} input`;
+  return describeValue(operand.value);
+}
+function describeCondition(condition, def, fields = fieldMap(def)) {
+  const group = (c) => {
+    const text = describeCondition(c, def, fields);
+    return "all" in c || "any" in c ? `(${text})` : text;
+  };
+  if ("all" in condition) return condition.all.map(group).join(" and ");
+  if ("any" in condition) return condition.any.map(group).join(" or ");
+  if ("not" in condition) return `it is not the case that ${group(condition.not)}`;
+  const left = describeOperand(condition.left, def, fields);
+  const op = OPS[condition.op] ?? condition.op;
+  if (!condition.right) return `${left} ${op}`;
+  const field2 = "field" in condition.left ? fields.get(condition.left.field) : void 0;
+  const right = "value" in condition.right ? describeValue(condition.right.value, field2) : describeOperand(condition.right, def, fields);
+  return `${left} ${op} ${right}`;
+}
+
+export { MAX_HIDDEN_STRING_LENGTH, REQUIRED_MESSAGE, canonicalJson, choiceOptions, coerceHidden, coerceHiddenValue, computePath, createForm, defineForm, describeCondition, evaluate, explain, f, fingerprint, getFieldType, isEmptyValue, isFormEvent, isJson, isSensitive, listFieldTypes, normalizeValue, parseForm, recall, registerFieldType, replay, ruleVisible, steps, summarizeValue, validateField, when };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map