@marktiderman/genesis-forms 0.0.0-stage → 0.1.0

package/dist/server.cjs

@@ -0,0 +1,988 @@
+'use strict';
+
+// 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 isEmptyValue(value, field) {
+  const manifest = field ? registry.get(field.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, field) {
+  const manifest = registry.get(field.type);
+  return manifest?.normalize ? manifest.normalize(value, field) : value;
+}
+function summarizeValue(value, field) {
+  if (isEmptyValue(value, field)) return "";
+  const manifest = registry.get(field.type);
+  if (manifest?.summarize) return manifest.summarize(value, field);
+  if (Array.isArray(value)) return value.join(", ");
+  return String(value);
+}
+function choiceOptions(field) {
+  const raw = field.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(field, value) {
+  const option = choiceOptions(field).find((o) => o.value === value);
+  return option?.label ?? value;
+}
+function intRange(field, min, maxDefault) {
+  const max = typeof field.props?.max === "number" ? field.props.max : maxDefault;
+  return { min, max };
+}
+var numberOps = ["eq", "neq", "lt", "lte", "gt", "gte", "in", "answered", "empty"];
+var textOps = ["eq", "neq", "contains", "answered", "empty"];
+function maxLength(field, fallback) {
+  return typeof field.props?.maxLength === "number" ? field.props.maxLength : fallback;
+}
+function textValidate(fallback) {
+  return (value, field) => {
+    if (typeof value !== "string") return "Enter text.";
+    const limit = maxLength(field, 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, field) => {
+      const { min, max } = intRange(field, 1, 5);
+      return Number.isInteger(value) && value >= min && value <= max ? null : `Choose a rating from ${min} to ${max}.`;
+    },
+    summarize: (value, field) => `${value}/${intRange(field, 1, 5).max}`
+  },
+  {
+    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, field) => typeof value === "string" && choiceOptions(field).some((o) => o.value === value) ? null : "Choose one of the options.",
+    summarize: (value, field) => optionLabel(field, String(value))
+  },
+  {
+    type: "multi-choice",
+    label: "Multiple choice",
+    category: "choice",
+    value: { json: true },
+    operators: ["contains", "answered", "empty"],
+    a11y: { semantics: "group" },
+    validate: (value, field) => {
+      const allowed = new Set(choiceOptions(field).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, field) => Array.isArray(value) ? value.map((v) => optionLabel(field, 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/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");
+}
+function isUnknownEvent(value) {
+  return isPlainObject(value) && typeof value.type === "string" && !EVENT_TYPES.has(value.type);
+}
+function compactEvents(events) {
+  const out = [];
+  for (const event of events) {
+    const last = out[out.length - 1];
+    if (event.type === "answer" && last?.type === "answer" && last.field === event.field) {
+      out[out.length - 1] = event;
+    } else out.push(event);
+  }
+  return out;
+}
+
+// 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/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 field = "field" in condition.left ? scope.fields.get(condition.left.field) : void 0;
+  const unanswered = isEmptyValue(left, field);
+  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, field) {
+  return def.settings?.anonymous === true && field?.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 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 field = scope.fieldsByKey.get(name);
+      const out2 = field ? summarizeValue(own(scope.values, field.id), field) : "";
+      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/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(field, value, options = {}) {
+  if (isEmptyValue(value, field)) {
+    return field.required && options.requireAnswers !== false ? REQUIRED_MESSAGE : null;
+  }
+  const manifest = getFieldType(field.type);
+  if (!manifest) return `Unknown field type "${field.type}".`;
+  const builtIn = manifest.validate?.(value, field) ?? 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((f) => [f.key, f]));
+  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 field = fields.get(id);
+      if (!field || !isVisibleIn(s, id)) continue;
+      const message = validateField(field, 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 field = byKey.get(key);
+      if (!field) throw new Error(`No field with key "${key}".`);
+      return field.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 field = fields.get(id);
+        const value = own(state.values, id);
+        if (field && value !== void 0) out[id] = normalizeValue(value, field);
+      }
+      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/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 field of new Set(reads)) {
+        const p = order.get(field) ?? 0;
+        if (p > limit || p === limit && !inclusive) {
+          warnings.push({
+            path: `${path}.when`,
+            message: `Reads "${keyOf(field)}", 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/server.ts
+var MAX_EVENTS = 1e4;
+var MALFORMED = { ok: false, errors: { "": "Malformed submission." } };
+var parsedDefinitions = /* @__PURE__ */ new WeakMap();
+function checkDefinition(definition) {
+  if (typeof definition === "object" && definition !== null && parsedDefinitions.has(definition)) return null;
+  const parsed = parseForm(definition);
+  if (!parsed.ok) {
+    const list = parsed.issues.map((i) => i.path ? `${i.path}: ${i.message}` : i.message).join("; ");
+    return `Invalid form definition: ${list}`;
+  }
+  parsedDefinitions.set(definition, true);
+  return null;
+}
+function wellFormed(input) {
+  if (!isPlainObject(input)) return null;
+  const { answers, events, hidden } = input;
+  const record = (v) => v === void 0 || isPlainObject(v) && Object.keys(v).every((k) => v[k] === void 0 || isJson(v[k]));
+  if (!record(answers) || !record(hidden)) return null;
+  if (events === void 0) return { answers, hidden };
+  if (!Array.isArray(events)) return null;
+  const known = [];
+  for (const e of events) {
+    if (isFormEvent(e)) known.push(e);
+    else if (!isUnknownEvent(e)) return null;
+  }
+  return { answers, events: known, hidden };
+}
+function validateSubmission(definition, submission, options = {}) {
+  const invalid = checkDefinition(definition);
+  if (invalid) return { ok: false, errors: { "": invalid } };
+  const input = wellFormed(submission);
+  if (!input) return MALFORMED;
+  const ignored = [];
+  const client = coerceHidden(definition, input.hidden, { sources: ["url", "host"] });
+  for (const name of client.ignored) ignored.push(`hidden.${name}`);
+  const hidden = client.values;
+  const context = coerceHidden(definition, options.context, { sources: ["server"] }).values;
+  const fields = fieldMap(definition);
+  const dropped = /* @__PURE__ */ new Set();
+  const accept = (id) => {
+    if (!fields.has(id)) return void ignored.push(id);
+    if (!withheld(definition, fields.get(id))) return true;
+    if (!dropped.has(id)) ignored.push(id);
+    dropped.add(id);
+    return false;
+  };
+  const engineHidden = { ...hidden, ...context };
+  let engine;
+  if (input.events) {
+    const events = compactEvents(input.events);
+    const max = options.maxEvents ?? MAX_EVENTS;
+    if (events.length > max) {
+      return { ok: false, errors: { "": `Too many events: ${events.length} after compaction; the limit is ${max}.` } };
+    }
+    const kept = events.filter((e) => e.type !== "answer" || accept(e.field) !== false);
+    engine = replay(definition, kept, { hidden: engineHidden, validators: options.validators });
+  } else {
+    const answers2 = {};
+    for (const id of Object.keys(input.answers ?? {})) {
+      const value = own(input.answers, id);
+      if (accept(id) && value !== void 0) answers2[id] = value;
+    }
+    engine = createForm(definition, {
+      initialValues: answers2,
+      hidden: engineHidden,
+      validators: options.validators,
+      clock: () => void 0
+    });
+  }
+  const complete = options.complete !== false;
+  if (complete) {
+    if (engine.getState().status !== "completed" && !engine.submit()) {
+      return { ok: false, errors: engine.getState().errors };
+    }
+  } else {
+    const errors = {};
+    for (const [id, value] of Object.entries(engine.answers())) {
+      const message = validateField(fields.get(id), value, {
+        requireAnswers: false,
+        custom: options.validators?.[id]
+      });
+      if (message) errors[id] = message;
+    }
+    if (Object.keys(errors).length) return { ok: false, errors };
+  }
+  const state = engine.getState();
+  const answers = engine.answers();
+  if (definition.settings?.clearHiddenValues === false) {
+    for (const [id, field] of fields) {
+      if (withheld(definition, field)) continue;
+      const value = own(state.values, id);
+      if (own(answers, id) !== void 0 || value === void 0 || isEmptyValue(value, field)) continue;
+      const message = validateField(field, value, { requireAnswers: false, custom: options.validators?.[id] });
+      if (message === null) answers[id] = normalizeValue(value, field);
+    }
+  }
+  return {
+    ok: true,
+    submission: {
+      status: complete ? "completed" : "draft",
+      answers,
+      hidden,
+      context,
+      ending: complete ? state.ending : null,
+      ignored
+    }
+  };
+}
+function publicDefinition(definition) {
+  return JSON.parse(JSON.stringify(definition));
+}
+
+exports.MAX_EVENTS = MAX_EVENTS;
+exports.publicDefinition = publicDefinition;
+exports.validateSubmission = validateSubmission;
+//# sourceMappingURL=server.cjs.map
+//# sourceMappingURL=server.cjs.map