@frt-platform/report-core 1.4.0 → 1.5.0

package/dist/index.js

@@ -60,7 +60,6 @@ var REPORT_TEMPLATE_FIELD_TYPES = [
   "singleSelect",
   "multiSelect",
   "repeatGroup"
-  // NEW FIELD TYPE
 ];
 var Condition = import_zod.z.lazy(
   () => import_zod.z.union([
@@ -87,15 +86,17 @@ var BaseFieldSchema = import_zod.z.object({
     /^[a-z0-9_-]+$/,
     "Use lowercase letters, numbers, underscores, or dashes for field identifiers."
   ),
-  type: import_zod.z.enum([
-    "shortText",
-    "longText",
-    "number",
-    "date",
-    "checkbox",
-    "singleSelect",
-    "multiSelect"
-  ]),
+  type: import_zod.z.enum(
+    [
+      "shortText",
+      "longText",
+      "number",
+      "date",
+      "checkbox",
+      "singleSelect",
+      "multiSelect"
+    ]
+  ),
   label: import_zod.z.string().min(1, "Field labels cannot be empty.").max(200, "Field labels must be 200 characters or fewer."),
   required: import_zod.z.boolean().optional(),
   description: import_zod.z.string().max(400, "Descriptions must be 400 characters or fewer.").optional(),
@@ -125,7 +126,9 @@ var BaseFieldSchema = import_zod.z.object({
   minSelections: import_zod.z.number().int().min(0).optional(),
   maxSelections: import_zod.z.number().int().min(0).optional(),
   // Privacy
-  dataClassification: import_zod.z.enum(["none", "personal", "special"]).optional()
+  dataClassification: import_zod.z.enum(["none", "personal", "special"]).optional(),
+  // Computed expression (backend/platform evaluated)
+  computed: import_zod.z.string().max(200, "Computed expressions must be 200 characters or fewer.").optional()
 });
 var RepeatGroupFieldSchema = import_zod.z.lazy(
   () => import_zod.z.object({
@@ -138,24 +141,19 @@ var RepeatGroupFieldSchema = import_zod.z.lazy(
     // Conditional logic for the whole group
     visibleIf: Condition.optional(),
     requiredIf: Condition.optional(),
-    // NEW: Dynamic and static min/max
+    // Static + dynamic min/max
     min: import_zod.z.number().int().min(0).optional(),
     max: import_zod.z.number().int().min(1).optional(),
     minIf: Condition.optional(),
     maxIf: Condition.optional(),
     // Contents: nested fields (recursive)
-    fields: import_zod.z.array(
-      import_zod.z.lazy(() => ReportTemplateFieldSchema)
-    ).min(1, "Repeat groups must contain at least one field."),
+    fields: import_zod.z.array(import_zod.z.lazy(() => ReportTemplateFieldSchema)).min(1, "Repeat groups must contain at least one field."),
     // Pre-populated rows allowed
     defaultValue: import_zod.z.array(import_zod.z.record(import_zod.z.any())).optional()
   })
 );
 var ReportTemplateFieldSchema = import_zod.z.lazy(
-  () => import_zod.z.union([
-    BaseFieldSchema,
-    RepeatGroupFieldSchema
-  ])
+  () => import_zod.z.union([BaseFieldSchema, RepeatGroupFieldSchema])
 );
 var ReportTemplateSectionSchema = import_zod.z.object({
   id: import_zod.z.string().min(1, "Section identifiers cannot be empty.").max(60, "Section identifiers must be 60 characters or fewer.").regex(
@@ -173,62 +171,82 @@ var ReportTemplateSchemaValidator = import_zod.z.object({
   sections: import_zod.z.array(ReportTemplateSectionSchema).max(25, "Templates can include at most 25 sections.").default([])
 });
 
+// src/template/ids.ts
+function createUniqueId(prefix, existing) {
+  const used = new Set(existing);
+  let attempt = used.size + 1;
+  let candidate = `${prefix}-${attempt}`;
+  while (used.has(candidate)) {
+    attempt += 1;
+    candidate = `${prefix}-${attempt}`;
+  }
+  return candidate;
+}
+
 // src/template/migrate.ts
-var LEGACY_FIELD_TYPE_MAP = {
-  shorttext: "shortText",
-  text: "shortText",
-  "text-box": "shortText",
-  longtext: "longText",
-  textarea: "longText",
-  paragraph: "longText",
-  number: "number",
-  numeric: "number",
-  date: "date",
-  checkbox: "checkbox",
-  boolean: "checkbox",
-  singleselect: "singleSelect",
-  select: "singleSelect",
-  dropdown: "singleSelect",
-  radio: "singleSelect",
-  "multi-select": "multiSelect",
-  multiselect: "multiSelect",
-  checkboxes: "multiSelect"
-};
+function mapLegacyFieldType(type) {
+  if (!type) return "shortText";
+  const t = type.toLowerCase();
+  if (t === "text" || t === "short_text" || t === "input") return "shortText";
+  if (t === "textarea" || t === "long_text") return "longText";
+  if (t === "number" || t === "numeric") return "number";
+  if (t === "date" || t === "datetime" || t === "datetime-local") return "date";
+  if (t === "checkbox") return "checkbox";
+  if (t === "checkboxes" || t === "multi_select" || t === "multiselect") {
+    return "multiSelect";
+  }
+  if (t === "select" || t === "single_select" || t === "dropdown") {
+    return "singleSelect";
+  }
+  return type;
+}
 function migrateLegacySchema(raw) {
-  if (!raw || typeof raw !== "object") return raw;
-  const obj = structuredClone(raw);
-  if (obj.fields) {
-    obj.sections = [
+  if (!raw || typeof raw !== "object") {
+    return {
+      version: REPORT_TEMPLATE_VERSION,
+      sections: []
+    };
+  }
+  const legacy = raw;
+  const version = typeof legacy.version === "number" ? legacy.version : REPORT_TEMPLATE_VERSION;
+  function mapFields(fields) {
+    if (!Array.isArray(fields)) return [];
+    let counter = 0;
+    return fields.map((field) => {
+      counter += 1;
+      const fallbackId = `field_${counter}`;
+      return {
+        ...field,
+        id: field.id ?? fallbackId,
+        type: mapLegacyFieldType(field.type)
+      };
+    });
+  }
+  let sections;
+  if (Array.isArray(legacy.sections)) {
+    sections = legacy.sections.map((sec, index) => ({
+      id: sec.id ?? `section_${index + 1}`,
+      title: sec.title ?? legacy.title,
+      description: sec.description ?? legacy.description,
+      fields: mapFields(sec.fields)
+    }));
+  } else if (Array.isArray(legacy.fields)) {
+    sections = [
       {
         id: "section_1",
-        // ⬅ underscore to match normalizer/tests
-        title: obj.title,
-        description: obj.description,
-        fields: obj.fields.map((f, i) => ({
-          ...f,
-          id: f.id || `field_${i + 1}`,
-          // ⬅ underscore here too
-          type: LEGACY_FIELD_TYPE_MAP[f.type?.toLowerCase()] ?? f.type
-        }))
+        title: legacy.title,
+        description: legacy.description,
+        fields: mapFields(legacy.fields)
       }
     ];
-    delete obj.fields;
-    return obj;
-  }
-  if (Array.isArray(obj.sections)) {
-    obj.sections = obj.sections.map((sec, i) => ({
-      ...sec,
-      id: sec.id || `section_${i + 1}`,
-      // ⬅ underscore
-      fields: (sec.fields || []).map((f, idx) => ({
-        ...f,
-        id: f.id || `field_${idx + 1}`,
-        // ⬅ underscore
-        type: LEGACY_FIELD_TYPE_MAP[f.type?.toLowerCase()] ?? f.type
-      }))
-    }));
+  } else {
+    sections = legacy.sections ?? [];
   }
-  return obj;
+  return {
+    ...legacy,
+    version,
+    sections
+  };
 }
 
 // src/template/normalize.ts
@@ -340,27 +358,8 @@ function serializeReportTemplateSchema(schema, options = {}) {
 }
 
 // src/template/diff.ts
-function indexById(items) {
-  const map = {};
-  items.forEach((item, i) => map[item.id] = i);
-  return map;
-}
-function diffObjectProperties(before, after, ignoreKeys = []) {
-  const changes = [];
-  const keys = /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)]);
-  for (const key of keys) {
-    if (ignoreKeys.includes(key)) continue;
-    const b = before[key];
-    const a = after[key];
-    const changed = Array.isArray(b) && Array.isArray(a) ? JSON.stringify(b) !== JSON.stringify(a) : b !== a;
-    if (changed) {
-      changes.push({ key, before: b, after: a });
-    }
-  }
-  return changes;
-}
-function diffRepeatGroupFields(beforeFields, afterFields, sectionId, groupId) {
-  const empty = {
+function createEmptyDiff() {
+  return {
     addedSections: [],
     removedSections: [],
     reorderedSections: [],
@@ -371,137 +370,191 @@ function diffRepeatGroupFields(beforeFields, afterFields, sectionId, groupId) {
     modifiedFields: [],
     nestedFieldDiffs: []
   };
-  const beforeIndex = indexById(beforeFields);
-  const afterIndex = indexById(afterFields);
-  for (const f of afterFields) {
-    if (!(f.id in beforeIndex)) {
-      empty.addedFields.push({ sectionId, fieldId: f.id, index: afterIndex[f.id] });
+}
+function shallowDiff(before, after, ignoreKeys) {
+  const changes = [];
+  const keys = /* @__PURE__ */ new Set([
+    ...Object.keys(before ?? {}),
+    ...Object.keys(after ?? {})
+  ]);
+  for (const key of keys) {
+    if (ignoreKeys.has(key)) continue;
+    const beforeVal = before[key];
+    const afterVal = after[key];
+    if (beforeVal !== afterVal) {
+      changes.push({ key, before: beforeVal, after: afterVal });
     }
   }
-  for (const f of beforeFields) {
-    if (!(f.id in afterIndex)) {
-      empty.removedFields.push({ sectionId, fieldId: f.id, index: beforeIndex[f.id] });
+  return changes;
+}
+function diffTemplates(before, after) {
+  const diff = createEmptyDiff();
+  const beforeSections = before.sections ?? [];
+  const afterSections = after.sections ?? [];
+  const beforeSectionIndex = /* @__PURE__ */ new Map();
+  const afterSectionIndex = /* @__PURE__ */ new Map();
+  beforeSections.forEach((s, idx) => beforeSectionIndex.set(s.id, idx));
+  afterSections.forEach((s, idx) => afterSectionIndex.set(s.id, idx));
+  for (const [id, idx] of afterSectionIndex) {
+    if (!beforeSectionIndex.has(id)) {
+      diff.addedSections.push({ sectionId: id, index: idx });
     }
   }
-  for (const f of afterFields) {
-    if (f.id in beforeIndex) {
-      const from = beforeIndex[f.id];
-      const to = afterIndex[f.id];
-      if (from !== to) {
-        empty.reorderedFields.push({
-          sectionId,
-          fieldId: f.id,
-          from,
-          to
-        });
-      }
+  for (const [id, idx] of beforeSectionIndex) {
+    if (!afterSectionIndex.has(id)) {
+      diff.removedSections.push({ sectionId: id, index: idx });
     }
   }
-  for (const f of afterFields) {
-    const idx = beforeIndex[f.id];
-    if (idx == null) continue;
-    const before = beforeFields[idx];
-    const changes = diffObjectProperties(before, f, ["id", "fields"]);
-    if (changes.length > 0) {
-      empty.modifiedFields.push({
-        sectionId,
-        fieldId: f.id,
-        before,
-        after: f,
-        changes
+  for (const [id, beforeIdx] of beforeSectionIndex) {
+    const afterIdx = afterSectionIndex.get(id);
+    if (afterIdx != null && afterIdx !== beforeIdx) {
+      diff.reorderedSections.push({
+        sectionId: id,
+        from: beforeIdx,
+        to: afterIdx
       });
     }
-    if (f.type === "repeatGroup" && Array.isArray(f.fields)) {
-      const innerBefore = before.fields ?? [];
-      const innerAfter = f.fields;
-      const nested = diffRepeatGroupFields(
-        innerBefore,
-        innerAfter,
-        sectionId,
-        f.id
+  }
+  function getSectionById(sections, id) {
+    return sections.find((s) => s.id === id);
+  }
+  for (const [id] of beforeSectionIndex) {
+    if (!afterSectionIndex.has(id)) continue;
+    const beforeSec = getSectionById(beforeSections, id);
+    const afterSec = getSectionById(afterSections, id);
+    const changes = shallowDiff(
+      beforeSec,
+      afterSec,
+      /* @__PURE__ */ new Set(["id", "fields"])
+    );
+    if (changes.length > 0) {
+      diff.modifiedSections.push({ sectionId: id, changes });
+    }
+  }
+  function diffFieldsForSection(sectionId, beforeFields, afterFields) {
+    const beforeIndex = /* @__PURE__ */ new Map();
+    const afterIndex = /* @__PURE__ */ new Map();
+    beforeFields.forEach((f, idx) => beforeIndex.set(f.id, idx));
+    afterFields.forEach((f, idx) => afterIndex.set(f.id, idx));
+    for (const [fieldId, idx] of afterIndex) {
+      if (!beforeIndex.has(fieldId)) {
+        diff.addedFields.push({ sectionId, fieldId, index: idx });
+      }
+    }
+    for (const [fieldId, idx] of beforeIndex) {
+      if (!afterIndex.has(fieldId)) {
+        diff.removedFields.push({ sectionId, fieldId, index: idx });
+      }
+    }
+    for (const [fieldId, beforeIdx] of beforeIndex) {
+      const afterIdx = afterIndex.get(fieldId);
+      if (afterIdx != null && afterIdx !== beforeIdx) {
+        diff.reorderedFields.push({
+          sectionId,
+          fieldId,
+          from: beforeIdx,
+          to: afterIdx
+        });
+      }
+    }
+    const ignoreFieldKeys = /* @__PURE__ */ new Set(["id", "fields"]);
+    const getField = (fields, id) => fields.find((f) => f.id === id);
+    for (const [fieldId] of beforeIndex) {
+      if (!afterIndex.has(fieldId)) continue;
+      const beforeField = getField(beforeFields, fieldId);
+      const afterField = getField(afterFields, fieldId);
+      const changes = shallowDiff(
+        beforeField,
+        afterField,
+        ignoreFieldKeys
       );
-      if (nested.addedFields.length > 0 || nested.removedFields.length > 0 || nested.reorderedFields.length > 0 || nested.modifiedFields.length > 0) {
-        empty.nestedFieldDiffs.push({
+      if (changes.length > 0) {
+        diff.modifiedFields.push({
           sectionId,
-          groupId: f.id,
-          diffs: nested
+          fieldId,
+          changes
         });
       }
+      if (beforeField.type === "repeatGroup" && afterField.type === "repeatGroup") {
+        const nestedBeforeFields = beforeField.fields ?? [];
+        const nestedAfterFields = afterField.fields ?? [];
+        const nestedDiff = createEmptyDiff();
+        diffFieldsInto(
+          sectionId,
+          fieldId,
+          nestedBeforeFields,
+          nestedAfterFields,
+          nestedDiff
+        );
+        if (hasAnyFieldDiff(nestedDiff)) {
+          diff.nestedFieldDiffs.push({
+            sectionId,
+            groupId: fieldId,
+            diffs: nestedDiff
+          });
+        }
+      }
     }
   }
-  return empty;
-}
-function diffTemplates(before, after) {
-  const diff = {
-    addedSections: [],
-    removedSections: [],
-    reorderedSections: [],
-    modifiedSections: [],
-    addedFields: [],
-    removedFields: [],
-    reorderedFields: [],
-    modifiedFields: [],
-    nestedFieldDiffs: []
-  };
-  const beforeSections = before.sections;
-  const afterSections = after.sections;
-  const beforeSecIndex = indexById(beforeSections);
-  const afterSecIndex = indexById(afterSections);
-  for (const sec of afterSections) {
-    if (!(sec.id in beforeSecIndex)) {
-      diff.addedSections.push({
-        sectionId: sec.id,
-        index: afterSecIndex[sec.id]
-      });
+  function diffFieldsInto(sectionId, groupId, beforeFields, afterFields, target) {
+    const beforeIndex = /* @__PURE__ */ new Map();
+    const afterIndex = /* @__PURE__ */ new Map();
+    beforeFields.forEach((f, idx) => beforeIndex.set(f.id, idx));
+    afterFields.forEach((f, idx) => afterIndex.set(f.id, idx));
+    for (const [fieldId, idx] of afterIndex) {
+      if (!beforeIndex.has(fieldId)) {
+        target.addedFields.push({ sectionId, fieldId, index: idx });
+      }
     }
-  }
-  for (const sec of beforeSections) {
-    if (!(sec.id in afterSecIndex)) {
-      diff.removedSections.push({
-        sectionId: sec.id,
-        index: beforeSecIndex[sec.id]
-      });
+    for (const [fieldId, idx] of beforeIndex) {
+      if (!afterIndex.has(fieldId)) {
+        target.removedFields.push({ sectionId, fieldId, index: idx });
+      }
     }
-  }
-  for (const sec of afterSections) {
-    if (sec.id in beforeSecIndex) {
-      const from = beforeSecIndex[sec.id];
-      const to = afterSecIndex[sec.id];
-      if (from !== to) {
-        diff.reorderedSections.push({ sectionId: sec.id, from, to });
+    for (const [fieldId, beforeIdx] of beforeIndex) {
+      const afterIdx = afterIndex.get(fieldId);
+      if (afterIdx != null && afterIdx !== beforeIdx) {
+        target.reorderedFields.push({
+          sectionId,
+          fieldId,
+          from: beforeIdx,
+          to: afterIdx
+        });
       }
     }
-  }
-  for (const sec of afterSections) {
-    const idx = beforeSecIndex[sec.id];
-    if (idx == null) continue;
-    const beforeSec = beforeSections[idx];
-    const changes = diffObjectProperties(beforeSec, sec, ["id", "fields"]);
-    if (changes.length > 0) {
-      diff.modifiedSections.push({
-        sectionId: sec.id,
-        changes
-      });
+    const ignoreFieldKeys = /* @__PURE__ */ new Set(["id", "fields"]);
+    const getField = (fields, id) => fields.find((f) => f.id === id);
+    for (const [fieldId] of beforeIndex) {
+      if (!afterIndex.has(fieldId)) continue;
+      const beforeField = getField(beforeFields, fieldId);
+      const afterField = getField(afterFields, fieldId);
+      const changes = shallowDiff(
+        beforeField,
+        afterField,
+        ignoreFieldKeys
+      );
+      if (changes.length > 0) {
+        target.modifiedFields.push({
+          sectionId,
+          fieldId,
+          changes
+        });
+      }
     }
   }
-  for (const afterSec of afterSections) {
-    const secId = afterSec.id;
-    const beforeIdx = beforeSecIndex[secId];
-    if (beforeIdx == null) continue;
+  function hasAnyFieldDiff(d) {
+    return d.addedFields.length > 0 || d.removedFields.length > 0 || d.reorderedFields.length > 0 || d.modifiedFields.length > 0 || d.addedSections.length > 0 || d.removedSections.length > 0 || d.reorderedSections.length > 0 || d.modifiedSections.length > 0 || d.nestedFieldDiffs.length > 0;
+  }
+  for (const [id, beforeIdx] of beforeSectionIndex) {
+    const afterIdx = afterSectionIndex.get(id);
+    if (afterIdx == null) continue;
     const beforeSec = beforeSections[beforeIdx];
-    const beforeFields = beforeSec.fields ?? [];
-    const afterFields = afterSec.fields ?? [];
-    const nestedDiff = diffRepeatGroupFields(
-      beforeFields,
-      afterFields,
-      secId,
-      ""
+    const afterSec = afterSections[afterIdx];
+    diffFieldsForSection(
+      id,
+      beforeSec.fields ?? [],
+      afterSec.fields ?? []
     );
-    diff.addedFields.push(...nestedDiff.addedFields);
-    diff.removedFields.push(...nestedDiff.removedFields);
-    diff.reorderedFields.push(...nestedDiff.reorderedFields);
-    diff.modifiedFields.push(...nestedDiff.modifiedFields);
-    diff.nestedFieldDiffs.push(...nestedDiff.nestedFieldDiffs);
   }
   return diff;
 }
@@ -515,7 +568,9 @@ function mapFieldTypeToJSONSchemaCore(field) {
     "x-frt-placeholder": field.placeholder,
     "x-frt-dataClassification": field.dataClassification,
     "x-frt-visibleIf": field.visibleIf,
-    "x-frt-requiredIf": field.requiredIf
+    "x-frt-requiredIf": field.requiredIf,
+    // ⭐ surface computed expression as vendor extension
+    "x-frt-computed": field.computed
   };
   switch (field.type) {
     case "shortText":
@@ -659,58 +714,86 @@ function exportJSONSchema(template) {
   return schema;
 }
 
+// src/validation/conditions.ts
+function evaluateCondition(condition, response) {
+  if (!condition) return true;
+  if ("equals" in condition) {
+    const entries = Object.entries(condition.equals ?? {});
+    if (entries.length === 0) return true;
+    return entries.every(([key, expected]) => {
+      const value = response[key];
+      return value === expected;
+    });
+  }
+  if ("any" in condition) {
+    const children = condition.any ?? [];
+    if (children.length === 0) return false;
+    return children.some(
+      (child) => evaluateCondition(child, response)
+    );
+  }
+  if ("all" in condition) {
+    const children = condition.all ?? [];
+    if (children.length === 0) return true;
+    return children.every(
+      (child) => evaluateCondition(child, response)
+    );
+  }
+  if ("not" in condition) {
+    return !evaluateCondition(condition.not, response);
+  }
+  return true;
+}
+
+// src/validation/baseSchema.ts
+var import_zod2 = require("zod");
+
 // src/fields/defaults.ts
-var DEFAULT_FIELD_LABEL = "Untitled question";
+var DEFAULT_FIELD_LABEL = "Untitled field";
 var CORE_FIELD_DEFAULTS = {
   shortText: {
+    type: "shortText",
     label: DEFAULT_FIELD_LABEL,
     placeholder: "Short answer text"
   },
   longText: {
+    type: "longText",
     label: DEFAULT_FIELD_LABEL,
     placeholder: "Long answer text"
   },
   number: {
+    type: "number",
     label: DEFAULT_FIELD_LABEL,
     placeholder: "123"
   },
   date: {
+    type: "date",
     label: DEFAULT_FIELD_LABEL
   },
   checkbox: {
-    label: DEFAULT_FIELD_LABEL,
-    placeholder: "Check to confirm"
+    type: "checkbox",
+    label: DEFAULT_FIELD_LABEL
   },
   singleSelect: {
+    type: "singleSelect",
     label: DEFAULT_FIELD_LABEL,
     options: ["Option 1", "Option 2", "Option 3"]
   },
   multiSelect: {
+    type: "multiSelect",
     label: DEFAULT_FIELD_LABEL,
     options: ["Option 1", "Option 2", "Option 3"],
     allowOther: false
   },
   repeatGroup: {
-    // Minimal safe defaults – your builder UI is expected
-    // to configure nested fields + min/max as needed.
+    type: "repeatGroup",
     label: DEFAULT_FIELD_LABEL,
+    // The actual shape is filled in by the builder;
+    // for tests we just need this to be an array.
     fields: []
-    // nested fields go here in the UI layer
   }
 };
 
-// src/fields/ids.ts
-function createUniqueId(prefix, existing) {
-  const used = new Set(existing);
-  let attempt = used.size + 1;
-  let candidate = `${prefix}-${attempt}`;
-  while (used.has(candidate)) {
-    attempt++;
-    candidate = `${prefix}-${attempt}`;
-  }
-  return candidate;
-}
-
 // src/fields/registry.ts
 var FieldRegistryClass = class {
   constructor() {
@@ -734,52 +817,191 @@ var FieldRegistryClass = class {
   }
 };
 var FieldRegistry = new FieldRegistryClass();
-var CORE_TYPES = [
-  "shortText",
-  "longText",
-  "number",
-  "date",
-  "checkbox",
-  "singleSelect",
-  "multiSelect",
-  "repeatGroup"
-];
-for (const type of CORE_TYPES) {
+for (const type of REPORT_TEMPLATE_FIELD_TYPES) {
   FieldRegistry.register(type, {
     defaults: CORE_FIELD_DEFAULTS[type]
     // Core types rely on existing validation logic.
-    // buildResponseSchema is optional — fallback handles it.
+    // buildResponseSchema is optional — the validation engine provides
+    // built-in handlers for all core types.
   });
 }
 
-// src/validation/conditions.ts
-function evaluateCondition(condition, response) {
-  if ("equals" in condition) {
-    return Object.entries(condition.equals).every(([key, val]) => {
-      return response[key] === val;
-    });
+// src/validation/baseSchema.ts
+function buildBaseFieldSchema(field) {
+  const isRequired = Boolean(field.required);
+  const registry = FieldRegistry.get(field.type);
+  if (registry?.buildResponseSchema) {
+    return registry.buildResponseSchema(field);
   }
-  if ("any" in condition) {
-    return condition.any.some(
-      (sub) => evaluateCondition(sub, response)
-    );
+  switch (field.type) {
+    case "shortText":
+    case "longText": {
+      let schema = import_zod2.z.string();
+      if (typeof field.minLength === "number") {
+        schema = schema.min(field.minLength);
+      }
+      if (typeof field.maxLength === "number") {
+        schema = schema.max(field.maxLength);
+      }
+      return isRequired ? schema : schema.optional();
+    }
+    case "number": {
+      let schema = import_zod2.z.number();
+      if (typeof field.minValue === "number") {
+        schema = schema.min(field.minValue);
+      }
+      if (typeof field.maxValue === "number") {
+        schema = schema.max(field.maxValue);
+      }
+      return isRequired ? schema : schema.optional();
+    }
+    case "date": {
+      const schema = import_zod2.z.string();
+      return isRequired ? schema : schema.optional();
+    }
+    case "checkbox": {
+      if (isRequired) return import_zod2.z.literal(true);
+      return import_zod2.z.boolean().optional();
+    }
+    case "singleSelect": {
+      let schema = import_zod2.z.string();
+      const opts = field.options;
+      const hasOptions = Array.isArray(opts) && opts.length > 0;
+      if (hasOptions && !field.allowOther) {
+        const allowed = new Set(opts);
+        schema = schema.refine(
+          (value) => allowed.has(value),
+          "Value must be one of the defined options."
+        );
+      }
+      return isRequired ? schema : schema.optional();
+    }
+    case "multiSelect": {
+      let schema = import_zod2.z.array(import_zod2.z.string());
+      const opts = field.options;
+      const hasOptions = Array.isArray(opts) && opts.length > 0;
+      if (hasOptions && !field.allowOther) {
+        const allowed = new Set(opts);
+        schema = schema.refine(
+          (values) => values.every((v) => allowed.has(v)),
+          "All values must be among the defined options."
+        );
+      }
+      if (typeof field.minSelections === "number") {
+        schema = schema.min(
+          field.minSelections,
+          `Select at least ${field.minSelections} option(s).`
+        );
+      } else if (isRequired) {
+        schema = schema.min(
+          1,
+          "Select at least one option."
+        );
+      }
+      if (typeof field.maxSelections === "number") {
+        schema = schema.max(
+          field.maxSelections,
+          `Select at most ${field.maxSelections} option(s).`
+        );
+      }
+      return isRequired ? schema : schema.optional();
+    }
+    case "repeatGroup": {
+      return import_zod2.z.any();
+    }
+    default:
+      return import_zod2.z.any();
   }
-  if ("all" in condition) {
-    return condition.all.every(
-      (sub) => evaluateCondition(sub, response)
+}
+
+// src/validation/responses.ts
+var import_zod4 = require("zod");
+
+// src/validation/errors.ts
+var import_zod3 = require("zod");
+function mapZodIssueToFieldErrorCode(issue) {
+  switch (issue.code) {
+    case import_zod3.z.ZodIssueCode.invalid_type:
+      return "field.invalid_type";
+    case import_zod3.z.ZodIssueCode.too_small:
+      return "field.too_small";
+    case import_zod3.z.ZodIssueCode.too_big:
+      return "field.too_big";
+    case import_zod3.z.ZodIssueCode.invalid_enum_value:
+    case import_zod3.z.ZodIssueCode.invalid_literal:
+      return "field.invalid_option";
+    case import_zod3.z.ZodIssueCode.custom:
+      return "field.custom";
+    default:
+      return "field.custom";
+  }
+}
+function buildFieldMetadataLookup(template) {
+  const map = /* @__PURE__ */ new Map();
+  for (const section of template.sections) {
+    for (const field of section.fields) {
+      map.set(field.id, {
+        sectionId: section.id,
+        sectionTitle: section.title,
+        label: field.label
+      });
+    }
+  }
+  return map;
+}
+function mapZodIssuesToResponseErrors(template, issues) {
+  const fieldMeta = buildFieldMetadataLookup(template);
+  const errors = [];
+  for (const issue of issues) {
+    const path = issue.path ?? [];
+    const topLevelFieldId = path.find(
+      (p) => typeof p === "string"
+    );
+    const rowIndex = path.find(
+      (p) => typeof p === "number"
     );
+    const nestedFieldId = path.length >= 3 && typeof path[path.length - 1] === "string" ? path[path.length - 1] : void 0;
+    const fieldId = topLevelFieldId ?? "";
+    const meta = fieldId ? fieldMeta.get(fieldId) : void 0;
+    const code = mapZodIssueToFieldErrorCode(issue);
+    const sectionLabel = meta?.sectionTitle ?? meta?.sectionId;
+    const fieldLabel = meta?.label ?? fieldId;
+    let message;
+    if (rowIndex != null && nestedFieldId && meta && sectionLabel) {
+      message = `Section "${sectionLabel}" \u2192 "${meta.label}" (row ${rowIndex + 1}, field "${nestedFieldId}"): ${issue.message}`;
+    } else if (meta && sectionLabel && fieldLabel) {
+      message = `Section "${sectionLabel}" \u2192 Field "${fieldLabel}": ${issue.message}`;
+    } else if (fieldLabel) {
+      message = `Field "${fieldLabel}": ${issue.message}`;
+    } else {
+      message = issue.message;
+    }
+    errors.push({
+      fieldId,
+      sectionId: meta?.sectionId,
+      sectionTitle: meta?.sectionTitle,
+      label: meta?.label,
+      code,
+      message,
+      rawIssue: issue
+    });
   }
-  if ("not" in condition) {
-    const sub = condition.not;
-    return !evaluateCondition(sub, response);
+  return errors;
+}
+function explainValidationError(template, error) {
+  if (error instanceof import_zod3.ZodError) {
+    return mapZodIssuesToResponseErrors(template, error.issues);
   }
-  return false;
+  return null;
 }
 
 // src/validation/responses.ts
-var import_zod2 = require("zod");
-function buildBaseFieldSchema(field) {
+function buildBaseFieldSchema2(field) {
   const isRequired = Boolean(field.required);
+  const isComputed = Boolean(field.computed);
+  if (isComputed) {
+    return import_zod4.z.any().optional();
+  }
   const registry = FieldRegistry.get(field.type);
   if (registry?.buildResponseSchema) {
     return registry.buildResponseSchema(field);
@@ -787,7 +1009,7 @@ function buildBaseFieldSchema(field) {
   switch (field.type) {
     case "shortText":
     case "longText": {
-      let schema = import_zod2.z.string();
+      let schema = import_zod4.z.string();
       if (typeof field.minLength === "number") {
         schema = schema.min(field.minLength);
       }
@@ -797,7 +1019,7 @@ function buildBaseFieldSchema(field) {
       return isRequired ? schema : schema.optional();
     }
     case "number": {
-      let schema = import_zod2.z.number();
+      let schema = import_zod4.z.number();
       if (typeof field.minValue === "number") {
         schema = schema.min(field.minValue);
       }
@@ -807,15 +1029,15 @@ function buildBaseFieldSchema(field) {
       return isRequired ? schema : schema.optional();
     }
     case "date": {
-      let schema = import_zod2.z.string();
+      let schema = import_zod4.z.string();
       return isRequired ? schema : schema.optional();
     }
     case "checkbox": {
-      if (isRequired) return import_zod2.z.literal(true);
-      return import_zod2.z.boolean().optional();
+      if (isRequired) return import_zod4.z.literal(true);
+      return import_zod4.z.boolean().optional();
     }
     case "singleSelect": {
-      let schema = import_zod2.z.string();
+      let schema = import_zod4.z.string();
       if (Array.isArray(field.options) && field.options.length > 0) {
         const allowed = new Set(field.options);
         schema = schema.refine(
@@ -826,11 +1048,13 @@ function buildBaseFieldSchema(field) {
       return isRequired ? schema : schema.optional();
     }
     case "multiSelect": {
-      let schema = import_zod2.z.array(import_zod2.z.string());
+      let schema = import_zod4.z.array(import_zod4.z.string());
       if (Array.isArray(field.options) && field.options.length > 0 && !field.allowOther) {
         const allowed = new Set(field.options);
         schema = schema.refine(
-          (values) => values.every((value) => allowed.has(value)),
+          (values) => values.every(
+            (value) => allowed.has(value)
+          ),
           "All values must be among the defined options."
         );
       }
@@ -857,11 +1081,11 @@ function buildBaseFieldSchema(field) {
       const nestedFields = Array.isArray(field.fields) ? field.fields : [];
       const rowShape = {};
       for (const nested of nestedFields) {
-        rowShape[nested.id] = buildBaseFieldSchema(
+        rowShape[nested.id] = buildBaseFieldSchema2(
           nested
         );
       }
-      let schema = import_zod2.z.array(import_zod2.z.object(rowShape));
+      let schema = import_zod4.z.array(import_zod4.z.object(rowShape));
       if (typeof field.min === "number") {
         schema = schema.min(
           field.min,
@@ -877,12 +1101,11 @@ function buildBaseFieldSchema(field) {
       return isRequired ? schema : schema.optional();
     }
     default: {
-      return import_zod2.z.any();
+      return import_zod4.z.any();
     }
   }
 }
 function buildRepeatGroupSchemaWithConditions(field, response) {
-  const isRequired = Boolean(field.required);
   const nestedFields = Array.isArray(field.fields) ? field.fields : [];
   const rowShape = {};
   for (const nested of nestedFields) {
@@ -891,48 +1114,58 @@ function buildRepeatGroupSchemaWithConditions(field, response) {
       response
     );
   }
-  let schema = import_zod2.z.array(import_zod2.z.object(rowShape));
+  let schema = import_zod4.z.array(import_zod4.z.object(rowShape));
   const hasStaticMin = typeof field.min === "number";
-  const hasMinIf = Boolean(field.minIf);
-  const minIfCondition = field.minIf;
-  const shouldEnforceMin = hasStaticMin && (!hasMinIf || evaluateCondition(minIfCondition, response));
-  if (shouldEnforceMin) {
-    const minValue = field.min;
+  const hasStaticMax = typeof field.max === "number";
+  let effectiveMin = hasStaticMin ? field.min : void 0;
+  let effectiveMax = hasStaticMax ? field.max : void 0;
+  if (field.minIf) {
+    const applyDynamicMin = evaluateCondition(field.minIf, response);
+    if (applyDynamicMin && typeof field.min === "number") {
+      effectiveMin = field.min;
+    } else if (!applyDynamicMin) {
+      effectiveMin = void 0;
+    }
+  }
+  if (field.maxIf) {
+    const applyDynamicMax = evaluateCondition(field.maxIf, response);
+    if (applyDynamicMax && typeof field.max === "number") {
+      effectiveMax = field.max;
+    } else if (!applyDynamicMax) {
+      effectiveMax = void 0;
+    }
+  }
+  if (typeof effectiveMin === "number") {
     schema = schema.min(
-      minValue,
-      `Add at least ${minValue} item(s).`
+      effectiveMin,
+      `Add at least ${effectiveMin} item(s).`
     );
   }
-  const hasStaticMax = typeof field.max === "number";
-  const hasMaxIf = Boolean(field.maxIf);
-  const maxIfCondition = field.maxIf;
-  const shouldEnforceMax = hasStaticMax && (!hasMaxIf || evaluateCondition(maxIfCondition, response));
-  if (shouldEnforceMax) {
-    const maxValue = field.max;
+  if (typeof effectiveMax === "number") {
     schema = schema.max(
-      maxValue,
-      `Add at most ${maxValue} item(s).`
+      effectiveMax,
+      `Add at most ${effectiveMax} item(s).`
     );
   }
-  return isRequired ? schema : schema.optional();
+  return schema;
 }
 function buildConditionalFieldSchema(field, response) {
   if (field.visibleIf) {
     const visible = evaluateCondition(field.visibleIf, response);
     if (!visible) {
-      return import_zod2.z.any().optional();
+      return import_zod4.z.any().optional();
     }
   }
   let schema;
   if (field.type === "repeatGroup") {
     schema = buildRepeatGroupSchemaWithConditions(field, response);
   } else {
-    schema = buildBaseFieldSchema(field);
+    schema = buildBaseFieldSchema2(field);
   }
   if (field.requiredIf) {
     const shouldBeRequired = evaluateCondition(field.requiredIf, response);
     if (shouldBeRequired) {
-      if (schema instanceof import_zod2.z.ZodOptional) {
+      if (schema instanceof import_zod4.z.ZodOptional) {
         schema = schema.unwrap();
       }
     }
@@ -946,18 +1179,12 @@ function buildResponseSchemaWithConditions(template, response) {
       shape[field.id] = buildConditionalFieldSchema(field, response);
     }
   }
-  return import_zod2.z.object(shape);
+  return import_zod4.z.object(shape);
 }
 function buildResponseSchema(template) {
   return buildResponseSchemaWithConditions(template, {});
 }
-function validateReportResponse(template, data) {
-  if (typeof data !== "object" || data === null) {
-    throw new Error("Response must be an object");
-  }
-  const response = data;
-  const schema = buildResponseSchemaWithConditions(template, response);
-  const parsed = schema.parse(response);
+function stripInvisibleFields(template, response, parsed) {
   for (const section of template.sections) {
     for (const field of section.fields) {
       if (field.visibleIf) {
@@ -968,76 +1195,38 @@ function validateReportResponse(template, data) {
       }
     }
   }
-  return parsed;
-}
-function mapZodIssueToFieldErrorCode(issue) {
-  switch (issue.code) {
-    case import_zod2.z.ZodIssueCode.invalid_type:
-      return "field.invalid_type";
-    case import_zod2.z.ZodIssueCode.too_small:
-      return "field.too_small";
-    case import_zod2.z.ZodIssueCode.too_big:
-      return "field.too_big";
-    case import_zod2.z.ZodIssueCode.invalid_enum_value:
-    case import_zod2.z.ZodIssueCode.invalid_literal:
-      return "field.invalid_option";
-    case import_zod2.z.ZodIssueCode.custom:
-      return "field.custom";
-    default:
-      return "field.custom";
-  }
 }
-function buildFieldMetadataLookup(template) {
-  const map = /* @__PURE__ */ new Map();
+function stripComputedFields(template, parsed) {
   for (const section of template.sections) {
     for (const field of section.fields) {
-      map.set(field.id, {
-        sectionId: section.id,
-        sectionTitle: section.title,
-        label: field.label
-      });
+      if (field.computed) {
+        delete parsed[field.id];
+      }
+      if (field.type === "repeatGroup" && Array.isArray(parsed[field.id])) {
+        const rows = parsed[field.id];
+        const nestedFields = Array.isArray(field.fields) ? field.fields : [];
+        for (const row of rows) {
+          if (!row || typeof row !== "object") continue;
+          for (const nested of nestedFields) {
+            if (nested.computed) {
+              delete row[nested.id];
+            }
+          }
+        }
+      }
     }
   }
-  return map;
 }
-function mapZodIssuesToResponseErrors(template, issues) {
-  const fieldMeta = buildFieldMetadataLookup(template);
-  const errors = [];
-  for (const issue of issues) {
-    const path = issue.path ?? [];
-    const topLevelFieldId = path.find(
-      (p) => typeof p === "string"
-    );
-    const rowIndex = path.find(
-      (p) => typeof p === "number"
-    );
-    const nestedFieldId = path.length >= 3 && typeof path[path.length - 1] === "string" ? path[path.length - 1] : void 0;
-    const fieldId = topLevelFieldId ?? "";
-    const meta = fieldId ? fieldMeta.get(fieldId) : void 0;
-    const code = mapZodIssueToFieldErrorCode(issue);
-    const sectionLabel = meta?.sectionTitle ?? meta?.sectionId;
-    const fieldLabel = meta?.label ?? fieldId;
-    let message;
-    if (rowIndex != null && nestedFieldId && meta && sectionLabel) {
-      message = `Section "${sectionLabel}" \u2192 "${meta.label}" (row ${rowIndex + 1}, field "${nestedFieldId}"): ${issue.message}`;
-    } else if (meta && sectionLabel && fieldLabel) {
-      message = `Section "${sectionLabel}" \u2192 Field "${fieldLabel}": ${issue.message}`;
-    } else if (fieldLabel) {
-      message = `Field "${fieldLabel}": ${issue.message}`;
-    } else {
-      message = issue.message;
-    }
-    errors.push({
-      fieldId,
-      sectionId: meta?.sectionId,
-      sectionTitle: meta?.sectionTitle,
-      label: meta?.label,
-      code,
-      message,
-      rawIssue: issue
-    });
+function validateReportResponse(template, data) {
+  if (typeof data !== "object" || data === null) {
+    throw new Error("Response must be an object");
   }
-  return errors;
+  const response = data;
+  const schema = buildResponseSchemaWithConditions(template, response);
+  const parsed = schema.parse(response);
+  stripInvisibleFields(template, response, parsed);
+  stripComputedFields(template, parsed);
+  return parsed;
 }
 function validateReportResponseDetailed(template, data) {
   if (typeof data !== "object" || data === null) {
@@ -1057,27 +1246,13 @@ function validateReportResponseDetailed(template, data) {
   const result = schema.safeParse(response);
   if (result.success) {
     const parsed = { ...result.data };
-    for (const section of template.sections) {
-      for (const field of section.fields) {
-        if (field.visibleIf) {
-          const visible = evaluateCondition(field.visibleIf, response);
-          if (!visible) {
-            delete parsed[field.id];
-          }
-        }
-      }
-    }
+    stripInvisibleFields(template, response, parsed);
+    stripComputedFields(template, parsed);
     return { success: true, value: parsed };
   }
   const errors = mapZodIssuesToResponseErrors(template, result.error.issues);
   return { success: false, errors };
 }
-function explainValidationError(template, error) {
-  if (error instanceof import_zod2.ZodError) {
-    return mapZodIssuesToResponseErrors(template, error.issues);
-  }
-  return null;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CORE_FIELD_DEFAULTS,