@open-mercato/core 0.8.1-develop.7296.1.2111d779db → 0.9.0

package/dist/modules/forms/schema/field-type-registry.js

@@ -0,0 +1,625 @@
+import { createHash } from "node:crypto";
+import { testLinearRegex } from "@open-mercato/shared/lib/regex/linear";
+import { FIELD_TYPE_DEFAULT_PATTERNS } from "./field-type-patterns.js";
+import { FILE_TYPE } from "./file-field.js";
+import { SIGNATURE_TYPE } from "./signature-field.js";
+import { GROUP_TYPE } from "./group-field.js";
+const requireString = (value) => typeof value === "string" ? true : "Expected a string value.";
+const requireFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? true : "Expected a finite number.";
+const optionValues = (fieldNode) => {
+  const options = fieldNode["x-om-options"];
+  if (!Array.isArray(options)) return [];
+  return options.map((entry) => entry && typeof entry === "object" ? entry.value : null).filter((value) => typeof value === "string");
+};
+const isIsoDate = (value) => /^\d{4}-\d{2}-\d{2}$/.test(value) && !Number.isNaN(Date.parse(value));
+const isIsoDateTime = (value) => !Number.isNaN(Date.parse(value));
+const TEXT_TYPE = {
+  validator: (value) => typeof value === "string" ? true : "Expected a string.",
+  renderer: null,
+  defaultUiSchema: { widget: "text" },
+  exportAdapter: (value) => typeof value === "string" ? value : "",
+  category: "input",
+  icon: "type",
+  displayNameKey: "forms.studio.palette.input.text"
+};
+const TEXTAREA_TYPE = {
+  validator: (value) => typeof value === "string" ? true : "Expected a multi-line string.",
+  renderer: null,
+  defaultUiSchema: { widget: "textarea", rows: 4 },
+  exportAdapter: (value) => typeof value === "string" ? value : "",
+  category: "input",
+  icon: "align-left",
+  displayNameKey: "forms.studio.palette.input.textarea"
+};
+const NUMBER_TYPE = {
+  validator: (value, fieldNode) => {
+    if (!(typeof value === "number" && Number.isFinite(value))) return "Expected a finite number.";
+    const min = fieldNode["x-om-min"];
+    const max = fieldNode["x-om-max"];
+    if (typeof min === "number" && value < min) return `Value must be >= ${min}.`;
+    if (typeof max === "number" && value > max) return `Value must be <= ${max}.`;
+    return true;
+  },
+  renderer: null,
+  defaultUiSchema: { widget: "number" },
+  exportAdapter: (value) => typeof value === "number" && Number.isFinite(value) ? String(value) : "",
+  category: "input",
+  icon: "hash",
+  displayNameKey: "forms.studio.palette.input.number"
+};
+const INTEGER_TYPE = {
+  validator: (value, fieldNode) => {
+    if (!(typeof value === "number" && Number.isInteger(value))) return "Expected an integer.";
+    const min = fieldNode["x-om-min"];
+    const max = fieldNode["x-om-max"];
+    if (typeof min === "number" && value < min) return `Value must be >= ${min}.`;
+    if (typeof max === "number" && value > max) return `Value must be <= ${max}.`;
+    return true;
+  },
+  renderer: null,
+  defaultUiSchema: { widget: "integer" },
+  exportAdapter: (value) => typeof value === "number" && Number.isInteger(value) ? String(value) : "",
+  category: "input",
+  icon: "hash",
+  displayNameKey: "forms.studio.palette.input.integer"
+};
+const BOOLEAN_TYPE = {
+  validator: (value) => typeof value === "boolean" ? true : "Expected true or false.",
+  renderer: null,
+  defaultUiSchema: { widget: "checkbox" },
+  exportAdapter: (value) => value === true ? "Yes" : value === false ? "No" : "",
+  category: "input",
+  icon: "check-square",
+  displayNameKey: "forms.studio.palette.input.boolean"
+};
+const YES_NO_TYPE = {
+  validator: (value) => typeof value === "boolean" ? true : "Expected true or false.",
+  renderer: null,
+  defaultUiSchema: { widget: "yes_no" },
+  exportAdapter: (value) => value === true ? "Yes" : value === false ? "No" : "",
+  category: "input",
+  icon: "toggle-left",
+  displayNameKey: "forms.studio.palette.input.yesNo"
+};
+const YES_NO_BUTTONS_TYPE = {
+  validator: (value) => typeof value === "boolean" ? true : "Expected true or false.",
+  renderer: null,
+  defaultUiSchema: { widget: "yes_no_buttons" },
+  exportAdapter: (value) => value === true ? "Yes" : value === false ? "No" : "",
+  category: "input",
+  icon: "toggle-right",
+  displayNameKey: "forms.studio.palette.input.yesNoButtons"
+};
+const DATE_TYPE = {
+  validator: (value) => {
+    if (typeof value !== "string") return "Expected an ISO date string (YYYY-MM-DD).";
+    return isIsoDate(value) ? true : "Expected an ISO date string (YYYY-MM-DD).";
+  },
+  renderer: null,
+  defaultUiSchema: { widget: "date" },
+  exportAdapter: (value) => typeof value === "string" ? value : "",
+  category: "input",
+  icon: "calendar",
+  displayNameKey: "forms.studio.palette.input.date"
+};
+const DATETIME_TYPE = {
+  validator: (value) => {
+    if (typeof value !== "string") return "Expected an ISO datetime string.";
+    return isIsoDateTime(value) ? true : "Expected a parseable ISO datetime.";
+  },
+  renderer: null,
+  defaultUiSchema: { widget: "datetime" },
+  exportAdapter: (value) => typeof value === "string" ? value : "",
+  category: "input",
+  icon: "calendar-clock",
+  displayNameKey: "forms.studio.palette.input.datetime"
+};
+const SELECT_ONE_TYPE = {
+  validator: (value, fieldNode) => {
+    const result = requireString(value);
+    if (result !== true) return result;
+    const allowed = optionValues(fieldNode);
+    if (allowed.length === 0) return true;
+    return allowed.includes(value) ? true : `Value must be one of: ${allowed.join(", ")}.`;
+  },
+  renderer: null,
+  defaultUiSchema: { widget: "select" },
+  exportAdapter: (value) => typeof value === "string" ? value : "",
+  category: "input",
+  icon: "list",
+  displayNameKey: "forms.studio.palette.input.selectOne"
+};
+const SELECT_MANY_TYPE = {
+  validator: (value, fieldNode) => {
+    if (!Array.isArray(value)) return "Expected an array of selected values.";
+    const allowed = optionValues(fieldNode);
+    for (const entry of value) {
+      if (typeof entry !== "string") return "Each selected value must be a string.";
+      if (allowed.length > 0 && !allowed.includes(entry)) {
+        return `Each selected value must be one of: ${allowed.join(", ")}.`;
+      }
+    }
+    return true;
+  },
+  renderer: null,
+  defaultUiSchema: { widget: "multiselect" },
+  exportAdapter: (value) => Array.isArray(value) ? value.filter((entry) => typeof entry === "string").join(", ") : "",
+  category: "input",
+  icon: "list-checks",
+  displayNameKey: "forms.studio.palette.input.selectMany"
+};
+const SCALE_TYPE = {
+  validator: (value, fieldNode) => {
+    const result = requireFiniteNumber(value);
+    if (result !== true) return result;
+    if (!Number.isInteger(value)) return "Scale value must be an integer.";
+    const min = typeof fieldNode["x-om-min"] === "number" ? fieldNode["x-om-min"] : 0;
+    const max = typeof fieldNode["x-om-max"] === "number" ? fieldNode["x-om-max"] : 10;
+    if (min > max) return `Scale bounds invalid: min (${min}) must be <= max (${max}).`;
+    if (value < min || value > max) {
+      return `Value must be between ${min} and ${max} (inclusive).`;
+    }
+    return true;
+  },
+  renderer: null,
+  defaultUiSchema: { widget: "scale" },
+  exportAdapter: (value) => typeof value === "number" ? String(value) : "",
+  category: "input",
+  icon: "sliders-horizontal",
+  displayNameKey: "forms.studio.palette.input.scale"
+};
+function makeFormatValidator(format, fallbackMessage) {
+  return (value, fieldNode) => {
+    if (typeof value !== "string") return "Expected a string value.";
+    if (value.length === 0) return true;
+    const overrideRaw = fieldNode["x-om-pattern"];
+    const override = typeof overrideRaw === "string" && overrideRaw.length > 0 ? overrideRaw : null;
+    const source = override ?? FIELD_TYPE_DEFAULT_PATTERNS[format];
+    const result = testLinearRegex(source, value);
+    return result.ok && result.matched ? true : fallbackMessage;
+  };
+}
+const EMAIL_TYPE = {
+  validator: makeFormatValidator("email", "Expected a valid email."),
+  renderer: null,
+  defaultUiSchema: { widget: "email" },
+  exportAdapter: (value) => typeof value === "string" ? value : "",
+  category: "input",
+  icon: "mail",
+  displayNameKey: "forms.studio.palette.survey.email"
+};
+const PHONE_TYPE = {
+  validator: makeFormatValidator("phone", "Expected a valid phone."),
+  renderer: null,
+  defaultUiSchema: { widget: "phone" },
+  exportAdapter: (value) => typeof value === "string" ? value : "",
+  category: "input",
+  icon: "phone",
+  displayNameKey: "forms.studio.palette.survey.phone"
+};
+const WEBSITE_TYPE = {
+  validator: makeFormatValidator("website", "Expected a valid URL."),
+  renderer: null,
+  defaultUiSchema: { widget: "website" },
+  exportAdapter: (value) => typeof value === "string" ? value : "",
+  category: "input",
+  icon: "globe",
+  displayNameKey: "forms.studio.palette.survey.website"
+};
+const ADDRESS_REQUIRED_SUB_FIELDS = ["street1", "city", "country"];
+const ADDRESS_OPTIONAL_SUB_FIELDS = ["street2", "region", "postalCode"];
+const ADDRESS_KNOWN_SUB_FIELDS = /* @__PURE__ */ new Set([
+  ...ADDRESS_REQUIRED_SUB_FIELDS,
+  ...ADDRESS_OPTIONAL_SUB_FIELDS
+]);
+function addressExportSegments(value) {
+  const segments = [];
+  const street1 = typeof value.street1 === "string" ? value.street1.trim() : "";
+  const street2 = typeof value.street2 === "string" ? value.street2.trim() : "";
+  const city = typeof value.city === "string" ? value.city.trim() : "";
+  const region = typeof value.region === "string" ? value.region.trim() : "";
+  const postalCode = typeof value.postalCode === "string" ? value.postalCode.trim() : "";
+  const country = typeof value.country === "string" ? value.country.trim() : "";
+  if (street1) segments.push(street1);
+  if (street2) segments.push(street2);
+  if (city) segments.push(city);
+  const regionPostal = [region, postalCode].filter((entry) => entry.length > 0).join(" ");
+  if (regionPostal) segments.push(regionPostal);
+  if (country) segments.push(country);
+  return segments;
+}
+const ADDRESS_TYPE = {
+  // Runtime UI translates the literal "Please complete the required address
+  // fields." back to `forms.runner.validation.address.required` when present
+  // (the validator has no locale at this layer — see Phase C § Validation
+  // service in the spec).
+  validator: (value) => {
+    if (value === null || value === void 0) return true;
+    if (typeof value !== "object" || Array.isArray(value)) {
+      return "Address must be an object.";
+    }
+    const record = value;
+    for (const key of Object.keys(record)) {
+      if (!ADDRESS_KNOWN_SUB_FIELDS.has(key)) {
+        return "Address contains unknown fields.";
+      }
+    }
+    for (const required of ADDRESS_REQUIRED_SUB_FIELDS) {
+      const entry = record[required];
+      if (typeof entry !== "string" || entry.trim().length === 0) {
+        return "Please complete the required address fields.";
+      }
+    }
+    for (const optional of ADDRESS_OPTIONAL_SUB_FIELDS) {
+      const entry = record[optional];
+      if (entry === void 0) continue;
+      if (typeof entry !== "string") {
+        return "Please complete the required address fields.";
+      }
+    }
+    return true;
+  },
+  renderer: null,
+  defaultUiSchema: { widget: "address" },
+  exportAdapter: (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return "";
+    return addressExportSegments(value).join(", ");
+  },
+  category: "input",
+  icon: "map-pin",
+  displayNameKey: "forms.studio.palette.survey.address"
+};
+function npsBandLabel(value) {
+  if (value <= 6) return "Detractor";
+  if (value <= 8) return "Passive";
+  return "Promoter";
+}
+const NPS_TYPE = {
+  validator: (value) => {
+    const result = requireFiniteNumber(value);
+    if (result !== true) return result;
+    if (!Number.isInteger(value)) return "NPS value must be an integer.";
+    if (value < 0 || value > 10) {
+      return "NPS value must be between 0 and 10 (inclusive).";
+    }
+    return true;
+  },
+  renderer: null,
+  defaultUiSchema: { widget: "nps" },
+  exportAdapter: (value) => {
+    if (typeof value !== "number" || !Number.isInteger(value)) return "";
+    if (value < 0 || value > 10) return "";
+    return `${value} (${npsBandLabel(value)})`;
+  },
+  category: "input",
+  icon: "gauge",
+  displayNameKey: "forms.studio.palette.survey.nps"
+};
+const OPINION_SCALE_TYPE = {
+  validator: (value, fieldNode) => {
+    const result = requireFiniteNumber(value);
+    if (result !== true) return result;
+    if (!Number.isInteger(value)) return "Opinion scale value must be an integer.";
+    const min = typeof fieldNode["x-om-min"] === "number" ? fieldNode["x-om-min"] : 1;
+    const max = typeof fieldNode["x-om-max"] === "number" ? fieldNode["x-om-max"] : 5;
+    if (min > max) return `Opinion scale bounds invalid: min (${min}) must be <= max (${max}).`;
+    if (value < min || value > max) {
+      return `Value must be between ${min} and ${max} (inclusive).`;
+    }
+    return true;
+  },
+  renderer: null,
+  defaultUiSchema: { widget: "opinion_scale" },
+  exportAdapter: (value, fieldNode) => {
+    if (typeof value !== "number" || !Number.isInteger(value)) return "";
+    const max = fieldNode && typeof fieldNode["x-om-max"] === "number" ? fieldNode["x-om-max"] : 5;
+    return `${value}/${max}`;
+  },
+  category: "input",
+  icon: "star",
+  displayNameKey: "forms.studio.palette.survey.opinion"
+};
+const RANKING_TYPE = {
+  validator: (value, fieldNode) => {
+    if (value === null || value === void 0) return true;
+    if (!Array.isArray(value)) return "Expected an array of ranked option values.";
+    const allowed = optionValues(fieldNode);
+    const seen = /* @__PURE__ */ new Set();
+    for (const entry of value) {
+      if (typeof entry !== "string") return "Each ranked entry must be a string.";
+      if (seen.has(entry)) return `Duplicate ranked entry "${entry}".`;
+      seen.add(entry);
+      if (allowed.length > 0 && !allowed.includes(entry)) {
+        return `Each ranked entry must be one of: ${allowed.join(", ")}.`;
+      }
+    }
+    const exhaustive = fieldNode["x-om-ranking-exhaustive"];
+    if (exhaustive === true && value.length !== allowed.length) {
+      return "Please rank every option.";
+    }
+    return true;
+  },
+  renderer: null,
+  defaultUiSchema: { widget: "ranking" },
+  exportAdapter: (value, fieldNode) => {
+    if (!Array.isArray(value)) return "";
+    const ordered = value.filter((entry) => typeof entry === "string");
+    const joined = ordered.join(" > ");
+    if (!fieldNode) return joined;
+    const totalOptions = optionValues(fieldNode).length;
+    const exhaustive = fieldNode["x-om-ranking-exhaustive"] === true;
+    if (totalOptions === 0) return joined;
+    if (exhaustive) return joined;
+    const missing = totalOptions - ordered.length;
+    if (missing > 0) {
+      return `${joined} (partial; ${missing} unranked)`;
+    }
+    return joined;
+  },
+  category: "input",
+  icon: "list-ordered",
+  displayNameKey: "forms.studio.palette.survey.ranking"
+};
+function readMatrixRows(fieldNode) {
+  const raw = fieldNode["x-om-matrix-rows"];
+  if (!Array.isArray(raw)) return [];
+  const result = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+    const candidate = entry;
+    if (typeof candidate.key !== "string") continue;
+    const row = { key: candidate.key };
+    if (candidate.label && typeof candidate.label === "object" && !Array.isArray(candidate.label)) {
+      row.label = candidate.label;
+    }
+    if (typeof candidate.multiple === "boolean") row.multiple = candidate.multiple;
+    if (typeof candidate.required === "boolean") row.required = candidate.required;
+    result.push(row);
+  }
+  return result;
+}
+function readMatrixColumnValues(fieldNode) {
+  const raw = fieldNode["x-om-matrix-columns"];
+  if (!Array.isArray(raw)) return [];
+  const values = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+    const candidate = entry;
+    if (typeof candidate.value === "string" && candidate.value.length > 0) {
+      values.push(candidate.value);
+    }
+  }
+  return values;
+}
+const MATRIX_TYPE = {
+  validator: (value, fieldNode) => {
+    if (value === null || value === void 0) return true;
+    if (typeof value !== "object" || Array.isArray(value)) {
+      return "Matrix value must be an object keyed by row key.";
+    }
+    const record = value;
+    const rows = readMatrixRows(fieldNode);
+    const rowsByKey = /* @__PURE__ */ new Map();
+    for (const row of rows) rowsByKey.set(row.key, row);
+    const columnValues = readMatrixColumnValues(fieldNode);
+    const columnSet = new Set(columnValues);
+    for (const presentKey of Object.keys(record)) {
+      if (!rowsByKey.has(presentKey)) {
+        return `Matrix value references unknown row "${presentKey}".`;
+      }
+    }
+    for (const row of rows) {
+      const entry = record[row.key];
+      const isMissing = entry === void 0 || entry === null || Array.isArray(entry) && entry.length === 0 || typeof entry === "string" && entry.length === 0;
+      if (row.required === true && isMissing) {
+        return "Please answer every required row.";
+      }
+      if (isMissing) continue;
+      if (row.multiple === true) {
+        if (!Array.isArray(entry)) {
+          return `Matrix row "${row.key}" expects an array of selected column values.`;
+        }
+        const seen = /* @__PURE__ */ new Set();
+        for (const inner of entry) {
+          if (typeof inner !== "string") {
+            return `Matrix row "${row.key}" entries must be strings.`;
+          }
+          if (seen.has(inner)) {
+            return `Matrix row "${row.key}" contains duplicate value "${inner}".`;
+          }
+          seen.add(inner);
+          if (columnSet.size > 0 && !columnSet.has(inner)) {
+            return `Matrix row "${row.key}" value "${inner}" is not a declared column.`;
+          }
+        }
+      } else {
+        if (Array.isArray(entry)) {
+          return `Matrix row "${row.key}" expects a single column value, not an array.`;
+        }
+        if (typeof entry !== "string") {
+          return `Matrix row "${row.key}" expects a single column value.`;
+        }
+        if (columnSet.size > 0 && !columnSet.has(entry)) {
+          return `Matrix row "${row.key}" value "${entry}" is not a declared column.`;
+        }
+      }
+    }
+    return true;
+  },
+  renderer: null,
+  defaultUiSchema: { widget: "matrix" },
+  exportAdapter: (value, fieldNode) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return "";
+    const record = value;
+    if (!fieldNode) {
+      const fallback = [];
+      for (const [rowKey, entry] of Object.entries(record)) {
+        if (Array.isArray(entry)) {
+          const joined = entry.filter((inner) => typeof inner === "string").join("+");
+          fallback.push(`${rowKey} \u2192 ${joined.length > 0 ? joined : "\u2014"}`);
+        } else if (typeof entry === "string" && entry.length > 0) {
+          fallback.push(`${rowKey} \u2192 ${entry}`);
+        } else {
+          fallback.push(`${rowKey} \u2192 \u2014`);
+        }
+      }
+      return fallback.join("; ");
+    }
+    const rows = readMatrixRows(fieldNode);
+    const segments = [];
+    for (const row of rows) {
+      const labelEn = row.label?.en ?? row.key;
+      const entry = record[row.key];
+      if (Array.isArray(entry)) {
+        const inner = entry.filter((value2) => typeof value2 === "string");
+        segments.push(`${labelEn} \u2192 ${inner.length > 0 ? inner.join("+") : "\u2014"}`);
+      } else if (typeof entry === "string" && entry.length > 0) {
+        segments.push(`${labelEn} \u2192 ${entry}`);
+      } else {
+        segments.push(`${labelEn} \u2192 \u2014`);
+      }
+    }
+    return segments.join("; ");
+  },
+  category: "input",
+  icon: "grid-3x3",
+  displayNameKey: "forms.studio.palette.survey.matrix"
+};
+const INFO_BLOCK_TYPE = {
+  // Display-only — never produces a submission value, never fails validation.
+  validator: () => true,
+  renderer: null,
+  defaultUiSchema: { widget: "info" },
+  exportAdapter: () => "",
+  // Decision 7a (2026-05-10 grill): info_block is the single LAYOUT entry for
+  // display-only headings/text. No parallel "Heading" primitive.
+  category: "layout",
+  icon: "heading",
+  displayNameKey: "forms.studio.palette.layout.infoBlock"
+};
+const V1_FIELD_TYPES = {
+  text: TEXT_TYPE,
+  textarea: TEXTAREA_TYPE,
+  number: NUMBER_TYPE,
+  integer: INTEGER_TYPE,
+  boolean: BOOLEAN_TYPE,
+  yes_no: YES_NO_TYPE,
+  yes_no_buttons: YES_NO_BUTTONS_TYPE,
+  date: DATE_TYPE,
+  datetime: DATETIME_TYPE,
+  select_one: SELECT_ONE_TYPE,
+  select_many: SELECT_MANY_TYPE,
+  scale: SCALE_TYPE,
+  info_block: INFO_BLOCK_TYPE,
+  // Tier-2 additive entries — Phase B (Survey & Contact group). Despite the
+  // legacy `V1_FIELD_TYPES` name, these are NOT v1-core; the FROZEN v1 list
+  // in `packages/forms/AGENTS.md § "v1 Field Types"` is unchanged.
+  email: EMAIL_TYPE,
+  phone: PHONE_TYPE,
+  website: WEBSITE_TYPE,
+  // Tier-2 additive entry — Phase C (composite address, Decision 1).
+  address: ADDRESS_TYPE,
+  // Tier-2 additive entries — Phase D (survey scales).
+  // Decision 2 — NPS is a distinct registered type, not a `scale` variant.
+  nps: NPS_TYPE,
+  opinion_scale: OPINION_SCALE_TYPE,
+  // Tier-2 additive entry — Phase E (ranking — drag-to-rank list).
+  ranking: RANKING_TYPE,
+  // Tier-2 additive entry — Phase F (matrix / Likert grid).
+  // Decision 5 — per-row `multiple: true` opt-in produces a string[] value.
+  matrix: MATRIX_TYPE,
+  // W4 additive entry — file / photo upload (FA-4 file + SEC-4). Value is an
+  // attachment-reference array; bytes are stored encrypted in
+  // `forms_form_attachment` (`kind = 'user_upload'`).
+  file: FILE_TYPE,
+  // W2 additive entry — e-signature with tamper-evident audit data (CN-1,
+  // FD-4). Value travels in the encrypted revision answers (append-only +
+  // per-tenant encryption); no new storage path.
+  signature: SIGNATURE_TYPE,
+  // W6 additive entry — repeatable group (FA-8). Value is an array of objects
+  // each matching the sub-field shape declared under `items.properties`. The
+  // group is treated atomically by the role-policy service (sub-fields inherit
+  // the group's editable-by / visible-to). Nested groups are out of scope.
+  group: GROUP_TYPE
+};
+class FieldTypeRegistry {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+    this.cachedVersion = null;
+  }
+  register(typeKey, spec) {
+    if (spec.category === "layout") {
+      const validatorResult = spec.validator(void 0, {});
+      if (validatorResult !== true) {
+        throw new Error(
+          `Field type "${typeKey}" registered with category "layout" must accept undefined values; validator returned: ${String(validatorResult)}`
+        );
+      }
+      const exportResult = spec.exportAdapter(void 0);
+      if (exportResult !== "") {
+        throw new Error(
+          `Field type "${typeKey}" registered with category "layout" must export undefined as the empty string; exportAdapter returned: ${JSON.stringify(exportResult)}`
+        );
+      }
+    }
+    this.entries.set(typeKey, spec);
+    this.cachedVersion = null;
+  }
+  setRenderer(typeKey, renderer) {
+    const existing = this.entries.get(typeKey);
+    if (!existing) {
+      throw new Error(`Field type "${typeKey}" is not registered; cannot attach renderer.`);
+    }
+    this.entries.set(typeKey, { ...existing, renderer });
+  }
+  get(typeKey) {
+    return this.entries.get(typeKey);
+  }
+  has(typeKey) {
+    return this.entries.has(typeKey);
+  }
+  keys() {
+    return Array.from(this.entries.keys()).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  }
+  /**
+   * Stable hash over the registered keys. Bumps whenever types are added or
+   * removed; pinned at publish time on `form_version.registry_version`.
+   */
+  getRegistryVersion() {
+    if (this.cachedVersion) return this.cachedVersion;
+    const hash = createHash("sha256").update(this.keys().join("|")).digest("hex").slice(0, 16);
+    this.cachedVersion = `v1:${hash}`;
+    return this.cachedVersion;
+  }
+}
+const defaultFieldTypeRegistry = new FieldTypeRegistry();
+for (const [key, spec] of Object.entries(V1_FIELD_TYPES)) {
+  defaultFieldTypeRegistry.register(key, spec);
+}
+export {
+  ADDRESS_TYPE,
+  BOOLEAN_TYPE,
+  DATETIME_TYPE,
+  DATE_TYPE,
+  EMAIL_TYPE,
+  FieldTypeRegistry,
+  INFO_BLOCK_TYPE,
+  INTEGER_TYPE,
+  MATRIX_TYPE,
+  NPS_TYPE,
+  NUMBER_TYPE,
+  OPINION_SCALE_TYPE,
+  PHONE_TYPE,
+  RANKING_TYPE,
+  SCALE_TYPE,
+  SELECT_MANY_TYPE,
+  SELECT_ONE_TYPE,
+  TEXTAREA_TYPE,
+  TEXT_TYPE,
+  V1_FIELD_TYPES,
+  WEBSITE_TYPE,
+  YES_NO_BUTTONS_TYPE,
+  YES_NO_TYPE,
+  defaultFieldTypeRegistry
+};
+//# sourceMappingURL=field-type-registry.js.map