@ai-matrx/records 0.87.32 → 0.92.1

package/dist/forms/index.cjs

@@ -0,0 +1,984 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/forms/index.ts
+var forms_exports = {};
+__export(forms_exports, {
+  FORM_EMBEDS: () => FORM_EMBEDS,
+  FORM_FLOWS: () => FORM_FLOWS,
+  FORM_STATE_WORDS: () => FORM_STATE_WORDS,
+  answerRefusal: () => answerRefusal,
+  endingDocument: () => endingDocument,
+  endingsFromDocument: () => endingsFromDocument,
+  formDeclareArgs: () => formDeclareArgs,
+  formEmbedSnippet: () => formEmbedSnippet,
+  formFromSummary: () => formFromSummary,
+  formLookDocument: () => formLookDocument,
+  formLookFromDocument: () => formLookFromDocument,
+  formPresentation: () => formPresentation,
+  formRoutes: () => formRoutes,
+  hiddenFromLink: () => hiddenFromLink,
+  notifyFromDocument: () => notifyFromDocument,
+  pipeAnswers: () => pipeAnswers,
+  publicReadOf: () => publicReadOf,
+  submissionStamp: () => submissionStamp,
+  thankYouDocument: () => thankYouDocument,
+  thankYouFromDocument: () => thankYouFromDocument,
+  themeDocument: () => themeDocument,
+  themeFromDocument: () => themeFromDocument,
+  typedAnswersFor: () => typedAnswersFor,
+  welcomeDocument: () => welcomeDocument,
+  welcomeFromDocument: () => welcomeFromDocument
+});
+module.exports = __toCommonJS(forms_exports);
+
+// src/portal.ts
+var PORTAL_ACCENTS = ["slate", "green", "amber", "red", "blue", "violet", "teal"];
+function isPortalAccent(word) {
+  return typeof word === "string" && PORTAL_ACCENTS.includes(word);
+}
+
+// src/forms/forms.ts
+var FORM_STATE_WORDS = {
+  draft: "Not published \u2014 the link does not answer yet.",
+  open: "Open \u2014 anyone with the link can answer it.",
+  closed: "Closed \u2014 it keeps its answers and takes no more.",
+  full: "Full \u2014 it has all the answers it was set up to take."
+};
+var FORM_FLOWS = ["one-at-a-time", "single-page"];
+function formPresentation(spec) {
+  return {
+    intro: spec.intro ?? null,
+    flow: spec.flow ?? "one-at-a-time",
+    thank_you: thankYouDocument(spec.thankYou ?? null),
+    submit_label: spec.submitLabel ?? null,
+    look: formLookDocument(spec.look ?? null),
+    welcome: welcomeDocument(spec.welcome ?? null),
+    endings: (spec.endings ?? []).map(endingDocument),
+    hidden_fields: spec.hiddenFields ?? [],
+    theme: themeDocument(spec.theme ?? null),
+    ...typeof spec.showOwnerHeader === "boolean" ? { show_owner_header: spec.showOwnerHeader } : {},
+    ...typeof spec.autoAdvance === "boolean" ? { auto_advance: spec.autoAdvance } : {},
+    ...spec.notify && (spec.notify.webhookUrl || spec.notify.webhookAutomationId || spec.notify.emailRespondent) ? {
+      notify: strip({
+        webhook_url: text(spec.notify.webhookUrl),
+        webhook_automation_id: text(spec.notify.webhookAutomationId),
+        email_respondent: spec.notify.emailRespondent ? true : null,
+        respondent_field: spec.notify.emailRespondent ? text(spec.notify.respondentField) : null
+      })
+    } : {}
+  };
+}
+function notifyFromDocument(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const d = raw;
+  const n = {
+    webhookUrl: text(d["webhook_url"]),
+    webhookAutomationId: text(d["webhook_automation_id"]),
+    emailRespondent: d["email_respondent"] === true ? true : null,
+    respondentField: text(d["respondent_field"])
+  };
+  return n.webhookUrl || n.webhookAutomationId || n.emailRespondent ? n : null;
+}
+var bool = (v) => typeof v === "boolean" ? v : null;
+function answerRefusal(kind, required, value) {
+  const empty = value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
+  if (empty) return required ? "This field is required" : null;
+  if (typeof value !== "string") return null;
+  const v = value.trim();
+  if (kind === "email" && !/^[^\s@]+@[^\s@]+\.[^\s@]{2,}$/.test(v)) return "Enter a valid email";
+  if (kind === "phone" && (v.replace(/\D/g, "").length < 7 || /[^\d\s()+.\-x]/i.test(v))) return "Enter a valid phone number";
+  if (kind === "url" && !/^(https?:\/\/)?[^\s.\/]+(\.[^\s.\/]+)+(\/\S*)?$/i.test(v)) return "Enter a valid link";
+  return null;
+}
+function pipeAnswers(text2, answers, questions, labelOf) {
+  if (!text2.includes("{{")) return text2;
+  return text2.replace(/\{\{\s*([^{}]+?)\s*\}\}/g, (_all, name) => {
+    const wanted = name.trim().toLowerCase();
+    const q = questions.find((x) => x.key.toLowerCase() === wanted) ?? questions.find((x) => (x.ask ?? "").trim().toLowerCase() === wanted);
+    if (!q) return "";
+    const value = answers[q.key];
+    if (value === void 0 || value === null) return "";
+    const one = (v) => labelOf?.(q.key, v) ?? String(v);
+    return Array.isArray(value) ? value.map(one).join(", ") : one(value);
+  });
+}
+var text = (v) => typeof v === "string" && v.trim() !== "" ? v.trim() : null;
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+var strip = (doc) => Object.fromEntries(Object.entries(doc).filter(([, v]) => v !== null && v !== void 0));
+function themeDocument(theme) {
+  if (!theme) return {};
+  return strip({
+    accent: theme.accent ?? null,
+    align: theme.align ?? null,
+    font: text(theme.font),
+    button: text(theme.button),
+    background: text(theme.background),
+    background_file_id: text(theme.backgroundFileId)
+  });
+}
+function themeFromDocument(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const d = raw;
+  const align = d["align"] === "center" ? "center" : d["align"] === "left" ? "left" : null;
+  return {
+    accent: text(d["accent"]),
+    align,
+    font: text(d["font"]),
+    button: text(d["button"]),
+    background: text(d["background"]),
+    backgroundFileId: text(d["background_file_id"]),
+    backgroundUrl: text(d["background_url"])
+  };
+}
+function welcomeDocument(welcome) {
+  if (!welcome) return null;
+  const doc = strip({
+    title: text(welcome.title),
+    body: text(welcome.body),
+    picture_file_id: text(welcome.pictureFileId),
+    button_label: text(welcome.buttonLabel)
+  });
+  return Object.keys(doc).length > 0 ? doc : null;
+}
+function welcomeFromDocument(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const d = raw;
+  const w = {
+    title: text(d["title"]),
+    body: text(d["body"]),
+    pictureFileId: text(d["picture_file_id"]),
+    pictureUrl: text(d["picture_url"]),
+    buttonLabel: text(d["button_label"])
+  };
+  return w.title || w.body || w.pictureFileId || w.pictureUrl || w.buttonLabel ? w : null;
+}
+function endingDocument(ending) {
+  return strip({
+    id: ending.id,
+    title: text(ending.title),
+    body: text(ending.body),
+    picture_file_id: text(ending.pictureFileId),
+    button_label: text(ending.buttonLabel),
+    redirect_url: text(ending.redirectUrl),
+    when: ending.when ?? null,
+    score_min: num(ending.scoreMin),
+    score_max: num(ending.scoreMax)
+  });
+}
+function endingsFromDocument(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.filter((e) => !!e && typeof e === "object" && typeof e["id"] === "string").map((d) => ({
+    id: String(d["id"]),
+    title: text(d["title"]),
+    body: text(d["body"]),
+    pictureFileId: text(d["picture_file_id"]),
+    pictureUrl: text(d["picture_url"]),
+    buttonLabel: text(d["button_label"]),
+    redirectUrl: text(d["redirect_url"]),
+    when: d["when"] ?? null,
+    scoreMin: num(d["score_min"]),
+    scoreMax: num(d["score_max"])
+  }));
+}
+function hiddenFromLink(hiddenFields, params) {
+  const out = {};
+  for (const key of hiddenFields ?? []) {
+    const raw = params[key];
+    const one = Array.isArray(raw) ? raw[raw.length - 1] : raw;
+    if (typeof one === "string" && one.trim() !== "") out[key] = one.trim().slice(0, 500);
+  }
+  return out;
+}
+function formRoutes(form) {
+  return (form.questions ?? []).some((q) => q.showIf || q.jumps && q.jumps.length > 0 || q.points) || (form.endings ?? []).length > 0;
+}
+var FORM_EMBEDS = ["inline", "popup", "slider"];
+function formEmbedSnippet(kind, formUrl, options) {
+  const url = new URL(formUrl);
+  url.searchParams.set("embed", "1");
+  const src = url.toString();
+  const label = (options?.label ?? "").trim() || "Open the form";
+  const esc = (v) => v.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+  if (kind === "inline") {
+    const height = options?.height && options.height > 0 ? Math.round(options.height) : 640;
+    return `<iframe src="${esc(src)}" title="${esc(label)}" style="width:100%;height:${height}px;border:0" loading="lazy" allow="clipboard-write"></iframe>`;
+  }
+  const script = `${url.origin}/embed/form.js`;
+  return `<button type="button" data-matrx-form="${esc(src)}" data-matrx-form-mode="${kind}">${esc(label)}</button>
+<script src="${esc(script)}" async><\/script>`;
+}
+function formLookDocument(look) {
+  if (!look) return null;
+  const out = {};
+  if (look.accent) out["accent"] = look.accent;
+  if (look.logoFileId) out["logo_file_id"] = look.logoFileId;
+  if (look.coverFileId) out["cover_file_id"] = look.coverFileId;
+  return Object.keys(out).length > 0 ? out : null;
+}
+function formLookFromDocument(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const doc = raw;
+  const id = (v) => typeof v === "string" && v.trim() !== "" ? v : null;
+  const look = {
+    accent: isPortalAccent(doc["accent"]) ? doc["accent"] : null,
+    logoFileId: id(doc["logo_file_id"]),
+    coverFileId: id(doc["cover_file_id"])
+  };
+  return look.accent || look.logoFileId || look.coverFileId ? look : null;
+}
+function thankYouDocument(thankYou) {
+  if (!thankYou) return null;
+  const title = thankYou.title?.trim() || null;
+  const body = thankYou.body?.trim() || null;
+  const redirect = thankYou.redirectUrl?.trim() || null;
+  if (!title && !body && !redirect) return null;
+  return { title, body, ...redirect ? { redirect_url: redirect } : {} };
+}
+function thankYouFromDocument(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const doc = raw;
+  const text2 = (v) => typeof v === "string" && v.trim() !== "" ? v : null;
+  const thankYou = {
+    title: text2(doc["title"]),
+    body: text2(doc["body"]),
+    redirectUrl: text2(doc["redirect_url"] ?? doc["redirectUrl"])
+  };
+  return thankYou.title || thankYou.body || thankYou.redirectUrl ? thankYou : null;
+}
+function formDeclareArgs(form) {
+  const saved = form;
+  return {
+    table_id: form.subject,
+    title: form.name,
+    questions: form.questions ?? [],
+    presentation: formPresentation(form),
+    submission_cap: saved.submissionCap ?? null,
+    quarantine_rule_id: saved.quarantineRuleId ?? null,
+    notify_rule_id: saved.notifyRuleId ?? null,
+    form_id: saved.id ?? null,
+    slug: saved.slug ?? null
+  };
+}
+function formFromSummary(summary) {
+  const presentation = summary.presentation ?? {};
+  const flow = String(presentation["flow"] ?? "one-at-a-time");
+  return {
+    id: summary.form_id,
+    name: summary.title ?? summary.slug,
+    subject: summary.table_id,
+    intro: presentation["intro"] ?? null,
+    questions: readQuestions(presentation["questions"]),
+    flow: FORM_FLOWS.includes(flow) ? flow : "one-at-a-time",
+    theme: themeFromDocument(presentation["theme"]),
+    welcome: welcomeFromDocument(presentation["welcome"]),
+    endings: endingsFromDocument(presentation["endings"]),
+    hiddenFields: Array.isArray(presentation["hidden_fields"]) ? presentation["hidden_fields"].filter((k) => typeof k === "string") : [],
+    thankYou: thankYouFromDocument(presentation["thank_you"]),
+    look: formLookFromDocument(presentation["look"]),
+    submitLabel: presentation["submit_label"] ?? null,
+    showOwnerHeader: bool(presentation["show_owner_header"]),
+    autoAdvance: bool(presentation["auto_advance"]),
+    notify: notifyFromDocument(presentation["notify"]),
+    // A form is public when the store says it is OPEN. A screen never decides
+    // this from a flag of its own: the link answers or it does not.
+    isPublic: summary.state === "open",
+    state: summary.state,
+    slug: summary.slug,
+    submissionCap: summary.submission_cap,
+    quarantineRuleId: summary.quarantine_rule_id ?? null,
+    notifyRuleId: summary.notify_rule_id ?? null
+  };
+}
+function readQuestions(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object") continue;
+    const q = entry;
+    const field = String(q["field"] ?? q["key"] ?? "").trim();
+    if (field === "") continue;
+    out.push({
+      field,
+      ask: q["ask"] ?? null,
+      help: q["help"] ?? null,
+      required: q["required"] ?? null,
+      showIf: q["showIf"] ?? q["show_if"] ?? null,
+      jumps: Array.isArray(q["jumps"]) ? q["jumps"] : null,
+      points: q["points"] && typeof q["points"] === "object" && !Array.isArray(q["points"]) ? q["points"] : null
+    });
+  }
+  return out;
+}
+function submissionStamp(args) {
+  return {
+    _source: {
+      via: "form",
+      form_id: args.formId,
+      form_name: args.formName,
+      at: (/* @__PURE__ */ new Date()).toISOString(),
+      actor: args.actor,
+      ...args.onBehalfOf ? { on_behalf_of: args.onBehalfOf } : {}
+    }
+  };
+}
+
+// src/forms/publicBinding.ts
+function publicReadOf(binding) {
+  if (binding.kind === "table" && binding.table_id) return { read: "table", tableId: binding.table_id };
+  if (binding.kind === "view" && binding.table_id) {
+    return { read: "view", tableId: binding.table_id, viewId: binding.resource_id };
+  }
+  if (binding.kind === "record") return { read: "record", recordId: binding.resource_id };
+  return { read: "unknown" };
+}
+
+// src/button.ts
+function isButtonField(field) {
+  return field?.type === "text" && String(field.format ?? "") === "button";
+}
+
+// src/newerKinds.ts
+var import_format = require("@ai-matrx/kit/format");
+function newerKindOf(field) {
+  const format = String(field.format ?? "");
+  const config = field.config ?? {};
+  switch (field.type) {
+    case "range":
+      if (format === "rating") return "rating";
+      if (format === "duration") return "duration";
+      return null;
+    case "text":
+      if (format === "address") return "address";
+      if (format === "barcode") return "barcode";
+      if (format === "rich_text") return "rich_text";
+      return null;
+    case "list":
+      return format === "status" ? "status" : null;
+    case "formula":
+      if (format === "count" && config["agg"] === "count") return "count";
+      if (config["system"] === "created_by") return "created_by";
+      if (config["system"] === "modified_by") return "modified_by";
+      return null;
+    default:
+      return null;
+  }
+}
+function ratingMaxOf(field) {
+  const rules = field.rules ?? [];
+  const max = rules.find((r) => r?.kind === "max")?.value;
+  const n = typeof max === "number" ? max : typeof max === "string" ? Number(max) : NaN;
+  return Number.isInteger(n) && n >= 1 && n <= 10 ? n : 5;
+}
+function readTypedDuration(text2) {
+  const t = text2.trim().toLowerCase();
+  if (t === "") return null;
+  const clock = /^(\d+):([0-5]?\d)(?::([0-5]?\d))?$/.exec(t);
+  if (clock) return Number(clock[1]) * 3600 + Number(clock[2]) * 60 + Number(clock[3] ?? 0);
+  if (/^\d+(\.\d+)?$/.test(t)) return Math.round(Number(t) * 60);
+  const unitRe = /(\d+(?:\.\d+)?)\s*(h|hr|hrs|hour|hours|m|min|mins|minute|minutes|s|sec|secs|second|seconds)\b/g;
+  let total = 0;
+  let matched = "";
+  for (const m of t.matchAll(unitRe)) {
+    const n = Number(m[1]);
+    const u = m[2];
+    total += u.startsWith("h") ? n * 3600 : u.startsWith("m") ? n * 60 : n;
+    matched += m[0];
+  }
+  if (matched === "" || t.replace(unitRe, "").replace(/[\s,and]+/g, "") !== "") return null;
+  return Math.round(total);
+}
+function addressFromText(text2) {
+  const t = text2.trim();
+  if (t === "") return null;
+  const bits = t.split(",").map((b) => b.trim()).filter(Boolean);
+  if (bits.length >= 3) {
+    const [street, city, regionPostal, ...rest] = bits;
+    const rp = /^(.*?)\s*([A-Za-z0-9-]*\d[A-Za-z0-9 -]*)?$/.exec(regionPostal ?? "");
+    const out = { street, city };
+    if (rp?.[1]) out.region = rp[1];
+    if (rp?.[2]) out.postal_code = rp[2].trim();
+    if (rest.length > 0) out.country = rest.join(", ");
+    return out;
+  }
+  return { street: t };
+}
+
+// src/typedDate.ts
+var MONTHS = {
+  jan: 1,
+  january: 1,
+  feb: 2,
+  february: 2,
+  mar: 3,
+  march: 3,
+  apr: 4,
+  april: 4,
+  may: 5,
+  jun: 6,
+  june: 6,
+  jul: 7,
+  july: 7,
+  aug: 8,
+  august: 8,
+  sep: 9,
+  sept: 9,
+  september: 9,
+  oct: 10,
+  october: 10,
+  nov: 11,
+  november: 11,
+  dec: 12,
+  december: 12
+};
+var WEEKDAYS = /\b(mon|tue|tues|wed|thu|thur|thurs|fri|sat|sun)(day|nesday|sday|urday)?\b\.?,?/gi;
+function localeDateOrder(locale) {
+  try {
+    const parts = new Intl.DateTimeFormat(locale, { year: "numeric", month: "2-digit", day: "2-digit" }).formatToParts(
+      new Date(2026, 10, 22)
+    );
+    const order = parts.filter((p) => p.type === "year" || p.type === "month" || p.type === "day").map((p) => p.type.charAt(0)).join("");
+    if (order === "mdy" || order === "dmy" || order === "ymd") return order;
+  } catch {
+  }
+  return "mdy";
+}
+function pad(n, width = 2) {
+  return String(n).padStart(width, "0");
+}
+function daysIn(year, month) {
+  return new Date(Date.UTC(year, month, 0)).getUTCDate();
+}
+var HOW = "Write it as 2026-10-03, or with the year in full the way your spreadsheet writes dates.";
+function twoDigitYear(yy) {
+  return yy < 30 ? 2e3 + yy : 1900 + yy;
+}
+function checkDay(year, month, day, raw) {
+  if (year < 1e3 || year > 9999) return `\u201C${raw}\u201D has no four-digit year. ${HOW}`;
+  if (month < 1 || month > 12) return `\u201C${raw}\u201D names no month (month ${month}). ${HOW}`;
+  if (day < 1 || day > daysIn(year, month)) return `\u201C${raw}\u201D is not a day on the calendar. ${HOW}`;
+  return null;
+}
+var TIME_HOW = "Write it like 2:30 PM or 14:30.";
+var MERIDIEM = String.raw`([ap])\.?\s*(?:m\.?)?`;
+var CLOCK = new RegExp(String.raw`^(\d{1,2})(?::(\d{2})(?::(\d{2}))?)?\s*(?:${MERIDIEM})?$`, "i");
+var COMPACT = new RegExp(String.raw`^(\d{3,4})\s*(?:${MERIDIEM})?$`, "i");
+function readTypedTime(raw) {
+  const text2 = raw.trim();
+  if (text2 === "") return { ok: false, why: "Nothing was typed." };
+  let h;
+  let m;
+  let s = null;
+  let meridiem;
+  const clock = CLOCK.exec(text2);
+  const compact = clock ? null : COMPACT.exec(text2);
+  if (clock) {
+    h = Number(clock[1]);
+    meridiem = clock[4]?.toLowerCase();
+    if (clock[2] === void 0 && !meridiem) {
+      return { ok: false, why: `\u201C${raw}\u201D could be in the morning or the evening. ${TIME_HOW}` };
+    }
+    m = clock[2] === void 0 ? 0 : Number(clock[2]);
+    if (clock[3] !== void 0) s = Number(clock[3]);
+  } else if (compact) {
+    const digits = compact[1];
+    meridiem = compact[2]?.toLowerCase();
+    if (digits.length === 3 && !meridiem) {
+      return { ok: false, why: `\u201C${raw}\u201D could be in the morning or the evening. ${TIME_HOW}` };
+    }
+    h = Number(digits.slice(0, digits.length - 2));
+    m = Number(digits.slice(-2));
+  } else {
+    return { ok: false, why: `\u201C${raw}\u201D is not a time of day. ${TIME_HOW}` };
+  }
+  if (meridiem) {
+    if (h < 1 || h > 12) return { ok: false, why: `\u201C${raw}\u201D is not a time of day. ${TIME_HOW}` };
+    if (meridiem === "p" && h !== 12) h += 12;
+    if (meridiem === "a" && h === 12) h = 0;
+  }
+  if (h > 23 || m > 59 || s !== null && s > 59) return { ok: false, why: `\u201C${raw}\u201D is not a time of day. ${TIME_HOW}` };
+  return { ok: true, value: [h, m, ...s === null ? [] : [s]].map((n) => pad(n)).join(":") };
+}
+function splitTime(text2) {
+  const match = /(?:^|[\sT,]+)(?:at\s+)?(\d{1,4}(?::\d{2}){0,2}\s*(?:[ap]\.?\s*(?:m\.?)?)?)$/i.exec(text2);
+  if (!match) return { date: text2, time: null, bad: false };
+  const token = match[1];
+  if (!/:|[ap]\.?\s*(?:m\.?)?$/i.test(token)) return { date: text2, time: null, bad: false };
+  const read = readTypedTime(token);
+  if (!read.ok) return { date: text2, time: null, bad: true };
+  const [h, m, s] = read.value.split(":").map(Number);
+  return { date: text2.slice(0, match.index).replace(/[\s,]+$/, ""), time: { h, m, s: s ?? 0 }, bad: false };
+}
+function readTypedDate(raw, opts = {}) {
+  const text2 = raw.trim();
+  if (text2 === "") return { ok: false, why: "Nothing was typed." };
+  const iso = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.\d+)?)?(Z|[+-]\d{2}:?\d{2})$/i.exec(text2);
+  if (iso) {
+    const bad2 = checkDay(Number(iso[1]), Number(iso[2]), Number(iso[3]), raw);
+    if (bad2) return { ok: false, why: bad2 };
+    const at = new Date(Date.parse(text2));
+    if (Number.isNaN(at.getTime())) return { ok: false, why: `\u201C${raw}\u201D is not a moment this can read. ${HOW}` };
+    const day2 = `${at.getFullYear()}-${pad(at.getMonth() + 1)}-${pad(at.getDate())}`;
+    return { ok: true, day: day2, instant: opts.withTime ? at.toISOString() : null };
+  }
+  const split = splitTime(text2.replace(/(\d)T(\d)/, "$1 $2"));
+  if (split.bad) return { ok: false, why: `\u201C${raw}\u201D has a time of day that is not one. Write it as 14:30 or 2:30 PM.` };
+  const dateText = split.date.replace(WEEKDAYS, " ").replace(/\s+/g, " ").trim();
+  let year = null;
+  let month = null;
+  let day = null;
+  const numeric = /^(\d{1,4})[/.\-](\d{1,2})[/.\-](\d{1,4})$/.exec(dateText);
+  const compact = /^(\d{8}|\d{6})$/.exec(dateText);
+  if (compact) {
+    const digits = compact[1];
+    const order = localeDateOrder(opts.locale);
+    const first2 = Number(digits.slice(0, 2));
+    const mid2 = Number(digits.slice(2, 4));
+    if (digits.length === 6) {
+      year = twoDigitYear(Number(digits.slice(4)));
+      if (order === "dmy") {
+        day = first2;
+        month = mid2;
+      } else {
+        month = first2;
+        day = mid2;
+      }
+    } else {
+      const yearLast = Number(digits.slice(4));
+      const yearFirst = Number(digits.slice(0, 4));
+      const localeReading = () => order === "dmy" ? [yearLast, mid2, first2] : [yearLast, first2, mid2];
+      const [ly, lm, ld] = localeReading();
+      const isoReading = [yearFirst, Number(digits.slice(4, 6)), Number(digits.slice(6))];
+      const fits = (y, m, d) => checkDay(y, m, d, raw) === null;
+      const useIso = order === "ymd" || !fits(ly, lm, ld) && fits(...isoReading);
+      [year, month, day] = useIso ? isoReading : [ly, lm, ld];
+    }
+  } else if (numeric) {
+    const [a, b, c] = [numeric[1], numeric[2], numeric[3]];
+    if (a.length === 4) {
+      year = Number(a);
+      month = Number(b);
+      day = Number(c);
+    } else {
+      if (c.length !== 4 && c.length !== 2) {
+        return { ok: false, why: `\u201C${raw}\u201D has no four-digit year. ${HOW}` };
+      }
+      const order = localeDateOrder(opts.locale);
+      year = c.length === 2 ? twoDigitYear(Number(c)) : Number(c);
+      if (order === "dmy") {
+        day = Number(a);
+        month = Number(b);
+      } else {
+        month = Number(a);
+        day = Number(b);
+      }
+    }
+  } else {
+    const tokens = dateText.toLowerCase().replace(/,/g, " ").split(/[\s/.\-]+/).filter(Boolean);
+    const numbers = [];
+    for (const token of tokens) {
+      const word = token.replace(/\.$/, "");
+      if (/^\d+(st|nd|rd|th)?$/.test(word)) numbers.push(word.replace(/\D/g, ""));
+      else if (word in MONTHS) {
+        if (month !== null) return { ok: false, why: `\u201C${raw}\u201D names two months. ${HOW}` };
+        month = MONTHS[word];
+      } else if (word !== "of" && word !== "the") {
+        return { ok: false, why: `\u201C${raw}\u201D is not a date this can read. ${HOW}` };
+      }
+    }
+    if (month === null) return { ok: false, why: `\u201C${raw}\u201D is not a date this can read. ${HOW}` };
+    const years = numbers.filter((n) => n.length === 4);
+    const days = numbers.filter((n) => n.length <= 2);
+    if (years.length === 0) {
+      return {
+        ok: false,
+        why: numbers.some((n) => n.length === 3) ? `\u201C${raw}\u201D has no four-digit year. ${HOW}` : `\u201C${raw}\u201D has no year, and which year it means is a guess. Write the year too (${days[0] ?? "3"} ${Object.keys(MONTHS).find((k) => MONTHS[k] === month && k.length > 3) ?? "October"} 2026).`
+      };
+    }
+    if (years.length > 1 || days.length !== 1 || numbers.length !== 2) {
+      return { ok: false, why: `\u201C${raw}\u201D is not a date this can read. ${HOW}` };
+    }
+    year = Number(years[0]);
+    day = Number(days[0]);
+  }
+  const bad = checkDay(year, month, day, raw);
+  if (bad) return { ok: false, why: bad };
+  const dayText = `${pad(year, 4)}-${pad(month)}-${pad(day)}`;
+  if (!opts.withTime) return { ok: true, day: dayText, instant: null };
+  const t = split.time ?? { h: 0, m: 0, s: 0 };
+  const local = new Date(year, month - 1, day, t.h, t.m, t.s);
+  return { ok: true, day: dayText, instant: local.toISOString() };
+}
+
+// src/typedNumber.ts
+function readTypedNumber(raw) {
+  const text2 = raw.trim();
+  if (text2 === "") return { ok: false, why: "Nothing was typed." };
+  const bracketed = /^\(.*\)$/.test(text2);
+  const inner = (bracketed ? text2.slice(1, -1) : text2).replace(/[\s,]/g, "");
+  const head = /^[^\d.]*/.exec(inner)?.[0] ?? "";
+  const bare = inner.slice(head.length).replace(/[^\d.eE+-]+$/, "");
+  const minus = (head.match(/[-−]/g) ?? []).length % 2 === 1;
+  const n = Number(bare);
+  if (bare === "" || Number.isNaN(n) || /[\d]/.test(head)) {
+    return {
+      ok: false,
+      why: `\u201C${raw}\u201D is not a number. Write digits, like 1,250.50 \u2014 a currency symbol, a percent sign, commas and a minus sign or brackets for a negative are all fine.`
+    };
+  }
+  return { ok: true, value: bracketed !== minus ? -n : n };
+}
+
+// src/coerce.ts
+var import_uuid = require("@ai-matrx/kit/uuid");
+function fieldKindFor(field, kernel) {
+  const format = (field.format ?? "").toLowerCase();
+  const config = field.config ?? {};
+  switch (field.type) {
+    case "boolean":
+      return "checkbox";
+    case "text":
+      if (format === "email") return "email";
+      if (format === "phone") return "phone";
+      if (format === "url") return "url";
+      if (format === "json" || config["json"] === true) return "json";
+      if (format === "long" || config["multiline"] === true) return "long_text";
+      return "text";
+    case "range": {
+      const kind = String(config["kind"] ?? "number");
+      if (kind === "date" || kind === "datetime") return "datetime";
+      if (format === "currency") return "currency";
+      if (format === "percent" || field.unit === "%") return "percent";
+      return "number";
+    }
+    case "list":
+      return field.multi ? "multi_select" : "select";
+    case "relation": {
+      if (isEntityReferenceConfig(config)) return "entity_reference";
+      const parity = String(config["parity"] ?? "");
+      if (parity === "attachment" || parity === "member") return parity;
+      if (kernel?.file && field.relation_target === kernel.file) return "attachment";
+      if (kernel?.person && field.relation_target === kernel.person) return "member";
+      return "relation";
+    }
+    case "formula": {
+      const via = config["via"];
+      if (via && config["agg"]) return "rollup";
+      if (via) return "lookup";
+      return "formula";
+    }
+    default:
+      return "text";
+  }
+}
+function relationNameKey(name) {
+  return name.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function splitListCell(text2) {
+  return text2.split(/\s*[;,|]\s*/).map((w) => w.trim()).filter((w) => w.length > 0);
+}
+var MONEY_SYMBOLS = { $: "USD", "\u20AC": "EUR", "\xA3": "GBP", "\u20B9": "INR", "\u20A9": "KRW", "\u20AA": "ILS", "\u20BA": "TRY", "\u20BD": "RUB" };
+function columnCurrency(unit) {
+  const u = (unit ?? "").trim();
+  if (u === "") return null;
+  if (MONEY_SYMBOLS[u]) return MONEY_SYMBOLS[u];
+  return /^[A-Za-z]{3}$/.test(u) ? u.toUpperCase() : null;
+}
+function foreignUnit(kind, text2, label, raw, unit, showsAsPercent) {
+  const hasPercent = /%/.test(text2);
+  const symbols = [...text2].filter((ch) => ch in MONEY_SYMBOLS);
+  if (kind === "percent" || showsAsPercent) {
+    if (symbols.length > 0) return `${label} holds a percent, and \u201C${raw}\u201D is an amount of money. Write it like 45%.`;
+    return null;
+  }
+  if (hasPercent) {
+    return kind === "currency" ? `${label} holds an amount of money, and \u201C${raw}\u201D is a percent. Write the amount, like $1,250.50.` : `${label} holds a number, and \u201C${raw}\u201D is a percent, which this column does not show. Write 45 or 0.45 \u2014 or make the column show as a percent.`;
+  }
+  if (kind === "currency") {
+    const own = columnCurrency(unit);
+    const typed = symbols.map((ch) => MONEY_SYMBOLS[ch]);
+    if (own && typed.some((code) => code !== own)) {
+      return `${label} holds an amount in ${own}, and \u201C${raw}\u201D is written in ${typed.find((code) => code !== own)}. Write the amount in ${own}.`;
+    }
+  }
+  return null;
+}
+function isEntityReferenceConfig(config) {
+  const allowed = config?.["allowed_types"];
+  return Array.isArray(allowed) && allowed.length > 0;
+}
+function entityReferenceKindsOf(field) {
+  const allowed = field.config?.["allowed_types"];
+  return Array.isArray(allowed) ? allowed.map((k) => String(k).trim().toLowerCase()).filter(Boolean) : [];
+}
+var TRUE_WORDS = /* @__PURE__ */ new Set(["true", "yes", "y", "1", "\u2713", "x", "checked", "on"]);
+var FALSE_WORDS = /* @__PURE__ */ new Set(["false", "no", "n", "0", "", "unchecked", "off"]);
+function coercionLabel(field) {
+  const label = (field.label ?? "").trim();
+  if (label !== "") return label;
+  const name = (field.name ?? "").trim();
+  if (name !== "") return name;
+  return field.key.replace(/[_-]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()).trim();
+}
+function optionsFromPublicChoices(field) {
+  const offered = field.public_choices;
+  if (!Array.isArray(offered) || offered.length === 0) return null;
+  const byWord = /* @__PURE__ */ new Map();
+  const labels = [];
+  for (const c of offered) {
+    const key = typeof c?.key === "string" ? c.key : null;
+    if (!key) continue;
+    const words = c.label;
+    const choiceLabel = typeof words === "string" && words.trim() !== "" ? words.trim() : key;
+    byWord.set(key.toLowerCase(), key);
+    byWord.set(choiceLabel.toLowerCase(), key);
+    labels.push(choiceLabel);
+  }
+  return labels.length > 0 ? { byWord, labels } : null;
+}
+function coerceTypedAnswer(field, raw, opts = {}) {
+  const label = opts.label ?? coercionLabel(field);
+  const text2 = raw.trim();
+  const kind = fieldKindFor(field, opts.kernel);
+  if (text2 === "" && kind !== "checkbox") return { value: null };
+  if (isButtonField(field)) return { refusal: `${label} is a button: it is pressed, and holds nothing to type.` };
+  const newer = newerKindOf(field);
+  if (newer === "rating") {
+    const max = ratingMaxOf(field);
+    const n = Number(text2);
+    if (Number.isInteger(n) && n >= 0 && n <= max) return { value: n };
+    return { refusal: `${label} is a whole number of stars from 0 to ${max}, and \u201C${raw}\u201D is not one.` };
+  }
+  if (newer === "duration") {
+    const seconds = readTypedDuration(text2);
+    if (seconds === null || seconds < 0) {
+      return { refusal: `${label} is a length of time, and \u201C${raw}\u201D is not one. Write it like 45 min, 1:30 or 1h 30m.` };
+    }
+    if (seconds > 315576e3) return { refusal: `${label} is longer than ten years, and a length of time here is at most ten years.` };
+    return { value: seconds };
+  }
+  if (newer === "address") return { value: addressFromText(text2) };
+  if (newer === "barcode") return { value: text2 };
+  switch (kind) {
+    case "checkbox": {
+      const word = text2.toLowerCase();
+      if (TRUE_WORDS.has(word)) return { value: true };
+      if (FALSE_WORDS.has(word)) return { value: word === "" ? null : false };
+      return {
+        refusal: `${label} is a tick box, so it takes yes or no \u2014 \u201C${raw}\u201D is neither. Write TRUE/FALSE, yes/no or 1/0.`
+      };
+    }
+    case "number":
+    case "currency":
+    case "percent": {
+      const read = readTypedNumber(text2);
+      if (!read.ok) {
+        return {
+          refusal: `${label} holds a number, and \u201C${raw}\u201D is not one. Write digits, like 1,250.50 \u2014 a currency symbol, a percent sign, commas and a minus sign or brackets for a negative are all fine.`
+        };
+      }
+      const foreign = foreignUnit(kind, text2, label, raw, field.unit, opts.showsAsPercent === true);
+      if (foreign) return { refusal: foreign };
+      return { value: read.value };
+    }
+    case "datetime": {
+      const wantsTime = String(field.config?.["kind"] ?? "date") === "datetime";
+      const read = readTypedDate(text2, { withTime: wantsTime, ...opts.locale ? { locale: opts.locale } : {} });
+      if (!read.ok) return { refusal: `${label} holds a date, and ${read.why}` };
+      return { value: wantsTime ? read.instant : read.day };
+    }
+    case "json": {
+      try {
+        return { value: JSON.parse(text2) };
+      } catch {
+        return {
+          refusal: `${label} holds a document, and \u201C${raw}\u201D is not valid JSON. Write the whole object, braces and all.`
+        };
+      }
+    }
+    case "select":
+    case "multi_select": {
+      const options = opts.options ?? optionsFromPublicChoices(field);
+      if (!options) {
+        return {
+          refusal: `${label} is a list and its options have not been read yet, so nothing can be matched to \u201C${raw}\u201D. Try again once the column's choices have loaded.`
+        };
+      }
+      const wanted = kind === "multi_select" ? text2.split(/[,;]/).map((w) => w.trim()).filter((w) => w.length > 0) : [text2];
+      if (wanted.length === 0) return { value: kind === "multi_select" ? [] : null };
+      const matched = [];
+      const unmatched = [];
+      for (const word of wanted) {
+        const hit = options.byWord.get(word.toLowerCase());
+        if (hit === void 0) unmatched.push(word);
+        else matched.push(hit);
+      }
+      if (unmatched.length > 0) {
+        const offered = options.labels.length > 0 ? options.labels.join(", ") : "it has none yet";
+        return {
+          refusal: `${label} does not have ${unmatched.map((w) => `\u201C${w}\u201D`).join(" or ")} among its options. It offers: ${offered}.`,
+          unmatched
+        };
+      }
+      return { value: kind === "multi_select" ? matched : matched[0] };
+    }
+    // AN IDENTITY IS NOT A WORD. Writing the word would put a string where an
+    // id belongs, and every filter, colour and rollup built on that column
+    // would stop agreeing with it. So it is refused and the person is told
+    // which control does hold it.
+    //
+    // BUT AN ID IS AN IDENTITY (RELATION-TARGETS, 2026-09-23). A Person or File
+    // column holds the kernel Person / File record, and the store itself now
+    // turns the id a writer actually holds — a member's user id, an uploaded
+    // file's id, or the record's own id — into that record at every write door
+    // (`custom.relation_kernel_record`), refusing anything else in its own
+    // words ("… names someone who is not a member of …"). So an import column
+    // of member ids, or an agent handing over the file it just uploaded, is a
+    // value and not a refusal; the store, not this mirror, decides whether the
+    // id is somebody here.
+    case "member":
+      if ((0, import_uuid.isUuidShape)(text2)) return { value: text2.toLowerCase() };
+      return {
+        refusal: `${label} names a person in this organization, so it is chosen rather than typed. Open it and pick them.`
+      };
+    case "attachment":
+      if ((0, import_uuid.isUuidShape)(text2)) return { value: text2.toLowerCase() };
+      return {
+        refusal: `${label} holds a file, which cannot arrive as typed-in text. Open it and attach the file.`
+      };
+    case "relation": {
+      const parts = field.multi ? splitListCell(text2) : [text2];
+      const ids = [];
+      const words = [];
+      const none = [];
+      const many = [];
+      for (const part of parts) {
+        if ((0, import_uuid.isUuidShape)(part)) {
+          if (!ids.includes(part.toLowerCase())) ids.push(part.toLowerCase());
+          continue;
+        }
+        if (!opts.relationNames) {
+          return {
+            refusal: `${label} points at another record, so it is chosen rather than typed. Open it and pick the record.`
+          };
+        }
+        const hits = opts.relationNames.byName.get(relationNameKey(part)) ?? [];
+        if (hits.length === 0) none.push(part);
+        else if (hits.length > 1) many.push(part);
+        else if (!ids.includes(hits[0].id)) {
+          ids.push(hits[0].id);
+          words.push(hits[0].words);
+        }
+      }
+      if (none.length > 0 || many.length > 0) {
+        const table = opts.relationNames?.tableName ?? "that table";
+        const said = many.length > 0 ? `${many.map((w) => `\u201C${w}\u201D`).join(", ")} names more than one record in ${table}.` : `${table} has no record called ${none.map((w) => `\u201C${w}\u201D`).join(" or ")}.`;
+        return { refusal: `${label}: ${said}`, unmatchedNames: none, ambiguousNames: many };
+      }
+      if (ids.length === 0) return { value: field.multi ? [] : null };
+      return { value: field.multi ? ids : ids[0], ...words.length > 0 ? { words: words.join(", ") } : {} };
+    }
+    // SC-R / P12. An entity reference names a platform thing by kind and id.
+    // An import or an agent may hand over `note:<id>` — or a bare id when the
+    // column allows exactly one kind; the store then decides whether the thing
+    // is there and whether the writer may open it. Words are chosen, not typed.
+    case "entity_reference": {
+      const allowed = entityReferenceKindsOf(field);
+      const [maybeToken, maybeId] = text2.includes(":") ? text2.split(/:(.*)/s, 2) : ["", text2];
+      const token = (maybeToken ?? "").trim().toLowerCase() || (allowed.length === 1 ? allowed[0] : "");
+      const id = (maybeId ?? "").trim();
+      if (token && (0, import_uuid.isUuidShape)(id)) {
+        const ref = { token, id: id.toLowerCase() };
+        return { value: field.multi ? [ref] : ref };
+      }
+      return {
+        refusal: `${label} points at something on the platform, so it is chosen rather than typed. Open it and pick it.`
+      };
+    }
+    case "formula":
+    case "lookup":
+    case "rollup":
+      return {
+        refusal: `${label} is worked out by the system, so nothing can be written into it.`
+      };
+    // A LINK AND AN EMAIL ARE READ, THE WAY AIRTABLE READS THEM (merged-grid review 2, A9).
+    // "company.com" is a link a person meant: it is kept as https://company.com. Words that
+    // cannot be one are refused NAMING THE KIND, WITH ONE EXAMPLE — never "not written the way
+    // this field expects". Any further format Rule on the column is still the store's to judge.
+    case "url": {
+      if (/^[a-z][a-z0-9+.-]*:\/\//i.test(text2) || /^mailto:/i.test(text2)) return { value: text2 };
+      if (!/\s/.test(text2) && /^[^./@\s]+(\.[^./\s]+)+(\/.*)?$/.test(text2)) return { value: `https://${text2}` };
+      return { refusal: `${label} holds a link, and \u201C${raw}\u201D is not one. A link looks like company.com or https://company.com/page.` };
+    }
+    case "email": {
+      if (/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(text2)) return { value: text2 };
+      return { refusal: `${label} holds an email address, and \u201C${raw}\u201D is not one. An email looks like name@company.com.` };
+    }
+    default:
+      return { value: raw };
+  }
+}
+function coerceTypedAnswers(fields, answers, opts = {}) {
+  const byKey = new Map(fields.map((f) => [f.key, f]));
+  const values = {};
+  const refusals = {};
+  const unknownKeys = [];
+  for (const [key, given] of Object.entries(answers)) {
+    const field = byKey.get(key);
+    if (!field) {
+      unknownKeys.push(key);
+      values[key] = given;
+      continue;
+    }
+    if (typeof given !== "string") {
+      values[key] = given;
+      continue;
+    }
+    const opt = {};
+    const choices = opts.options?.get(key);
+    if (choices) opt.options = choices;
+    const named = opts.relationNames?.get(key);
+    if (named) opt.relationNames = named;
+    if (opts.kernel) opt.kernel = opts.kernel;
+    const label = opts.labels?.[key];
+    if (label) opt.label = label;
+    const answered = coerceTypedAnswer(field, given, opt);
+    if ("refusal" in answered) refusals[key] = answered.refusal;
+    else values[key] = answered.value;
+  }
+  return { values, refusals, unknownKeys };
+}
+
+// src/forms/typedAnswers.ts
+function typedAnswersFor(fields, values) {
+  if (!Array.isArray(fields) || fields.length === 0) {
+    return { values, refusal: null, byKey: {} };
+  }
+  const coerced = coerceTypedAnswers(fields, values);
+  const keys = Object.keys(coerced.refusals);
+  if (keys.length === 0) return { values: coerced.values, refusal: null, byKey: {} };
+  const order = new Map(fields.map((f, at) => [String(f.key ?? ""), at]));
+  keys.sort((a, b) => (order.get(a) ?? 0) - (order.get(b) ?? 0));
+  return {
+    values: coerced.values,
+    refusal: keys.map((k) => coerced.refusals[k]).join(" "),
+    byKey: coerced.refusals
+  };
+}
+//# sourceMappingURL=index.cjs.map