@frt-platform/report-core 1.0.1 → 1.2.0

package/dist/index.js

@@ -21,18 +21,28 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   CORE_FIELD_DEFAULTS: () => CORE_FIELD_DEFAULTS,
+  Condition: () => Condition,
   DEFAULT_FIELD_LABEL: () => DEFAULT_FIELD_LABEL,
+  FieldRegistry: () => FieldRegistry,
   REPORT_TEMPLATE_FIELD_TYPES: () => REPORT_TEMPLATE_FIELD_TYPES,
   REPORT_TEMPLATE_VERSION: () => REPORT_TEMPLATE_VERSION,
+  RepeatGroupFieldSchema: () => RepeatGroupFieldSchema,
   ReportTemplateFieldSchema: () => ReportTemplateFieldSchema,
   ReportTemplateSchemaValidator: () => ReportTemplateSchemaValidator,
   ReportTemplateSectionSchema: () => ReportTemplateSectionSchema,
+  buildBaseFieldSchema: () => buildBaseFieldSchema,
+  buildResponseSchemaWithConditions: () => buildResponseSchemaWithConditions,
   createUniqueId: () => createUniqueId,
+  diffTemplates: () => diffTemplates,
+  evaluateCondition: () => evaluateCondition,
+  exportJSONSchema: () => exportJSONSchema,
   migrateLegacySchema: () => migrateLegacySchema,
   normalizeReportTemplateSchema: () => normalizeReportTemplateSchema,
   parseReportTemplateSchema: () => parseReportTemplateSchema,
   parseReportTemplateSchemaFromString: () => parseReportTemplateSchemaFromString,
-  serializeReportTemplateSchema: () => serializeReportTemplateSchema
+  serializeReportTemplateSchema: () => serializeReportTemplateSchema,
+  validateReportResponse: () => validateReportResponse,
+  validateReportResponseDetailed: () => validateReportResponseDetailed
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -46,16 +56,51 @@ var REPORT_TEMPLATE_FIELD_TYPES = [
   "date",
   "checkbox",
   "singleSelect",
-  "multiSelect"
+  "multiSelect",
+  "repeatGroup"
+  // NEW FIELD TYPE
 ];
-var ReportTemplateFieldSchema = import_zod.z.object({
-  id: import_zod.z.string().min(1).max(60).regex(/^[a-z0-9_-]+$/),
-  type: import_zod.z.string(),
-  label: import_zod.z.string().min(1).max(200),
+var Condition = import_zod.z.lazy(
+  () => import_zod.z.union([
+    // equals: { equals: { fieldId: value } }
+    import_zod.z.object({
+      equals: import_zod.z.record(import_zod.z.any())
+    }),
+    // any: { any: [cond, cond] }
+    import_zod.z.object({
+      any: import_zod.z.array(Condition)
+    }),
+    // all: { all: [cond, cond] }
+    import_zod.z.object({
+      all: import_zod.z.array(Condition)
+    }),
+    // not: { not: cond }
+    import_zod.z.object({
+      not: Condition
+    })
+  ])
+);
+var BaseFieldSchema = import_zod.z.object({
+  id: import_zod.z.string().min(1, "Field identifiers cannot be empty.").max(60, "Field identifiers must be 60 characters or fewer.").regex(
+    /^[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"
+  ]),
+  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).optional(),
-  placeholder: import_zod.z.string().max(200).optional(),
-  options: import_zod.z.array(import_zod.z.string().min(1).max(120)).optional(),
+  description: import_zod.z.string().max(400, "Descriptions must be 400 characters or fewer.").optional(),
+  placeholder: import_zod.z.string().max(200, "Placeholders must be 200 characters or fewer.").optional(),
+  options: import_zod.z.array(
+    import_zod.z.string().min(1, "Options cannot be empty.").max(120, "Options must be 120 characters or fewer.")
+  ).optional(),
   allowOther: import_zod.z.boolean().optional(),
   defaultValue: import_zod.z.union([
     import_zod.z.string(),
@@ -64,36 +109,90 @@ var ReportTemplateFieldSchema = import_zod.z.object({
     import_zod.z.array(import_zod.z.string()),
     import_zod.z.null()
   ]).optional(),
+  // Conditional logic
+  visibleIf: Condition.optional(),
+  requiredIf: Condition.optional(),
+  // Text constraints
   minLength: import_zod.z.number().int().min(0).optional(),
   maxLength: import_zod.z.number().int().min(0).optional(),
+  // Number constraints
   minValue: import_zod.z.number().optional(),
   maxValue: import_zod.z.number().optional(),
   step: import_zod.z.number().nonnegative().optional(),
+  // Multi-select constraints
   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()
 });
+var RepeatGroupFieldSchema = import_zod.z.lazy(
+  () => import_zod.z.object({
+    id: import_zod.z.string().min(1).max(60).regex(
+      /^[a-z0-9_-]+$/,
+      "Use lowercase letters, numbers, underscores, or dashes for field identifiers."
+    ),
+    type: import_zod.z.literal("repeatGroup"),
+    label: import_zod.z.string().min(1).max(200),
+    // Conditional logic for the whole group
+    visibleIf: Condition.optional(),
+    requiredIf: Condition.optional(),
+    // NEW: Dynamic and static 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."),
+    // 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
+  ])
+);
 var ReportTemplateSectionSchema = import_zod.z.object({
-  id: import_zod.z.string().min(1).max(60).regex(/^[a-z0-9_-]+$/),
-  title: import_zod.z.string().max(200).optional(),
-  description: import_zod.z.string().max(500).optional(),
-  fields: import_zod.z.array(ReportTemplateFieldSchema).default([])
+  id: import_zod.z.string().min(1, "Section identifiers cannot be empty.").max(60, "Section identifiers must be 60 characters or fewer.").regex(
+    /^[a-z0-9_-]+$/,
+    "Use lowercase letters, numbers, underscores, or dashes for section identifiers."
+  ),
+  title: import_zod.z.string().max(200, "Section titles must be 200 characters or fewer.").optional(),
+  description: import_zod.z.string().max(500, "Section descriptions must be 500 characters or fewer.").optional(),
+  fields: import_zod.z.array(ReportTemplateFieldSchema).max(50, "Sections can include at most 50 fields.").default([])
 });
 var ReportTemplateSchemaValidator = import_zod.z.object({
-  version: import_zod.z.number().int().min(1).default(REPORT_TEMPLATE_VERSION),
-  title: import_zod.z.string().max(200).optional(),
-  description: import_zod.z.string().max(500).optional(),
-  sections: import_zod.z.array(ReportTemplateSectionSchema).max(25).default([])
+  version: import_zod.z.number().int().min(1).max(REPORT_TEMPLATE_VERSION).default(REPORT_TEMPLATE_VERSION),
+  title: import_zod.z.string().max(200, "Template titles must be 200 characters or fewer.").optional(),
+  description: import_zod.z.string().max(500, "Template descriptions must be 500 characters or fewer.").optional(),
+  sections: import_zod.z.array(ReportTemplateSectionSchema).max(25, "Templates can include at most 25 sections.").default([])
 });
 
 // src/fields.ts
 var DEFAULT_FIELD_LABEL = "Untitled question";
 var CORE_FIELD_DEFAULTS = {
-  shortText: { label: DEFAULT_FIELD_LABEL, placeholder: "Short answer text" },
-  longText: { label: DEFAULT_FIELD_LABEL, placeholder: "Long answer text" },
-  number: { label: DEFAULT_FIELD_LABEL, placeholder: "123" },
-  date: { label: DEFAULT_FIELD_LABEL },
-  checkbox: { label: DEFAULT_FIELD_LABEL, placeholder: "Check to confirm" },
+  shortText: {
+    label: DEFAULT_FIELD_LABEL,
+    placeholder: "Short answer text"
+  },
+  longText: {
+    label: DEFAULT_FIELD_LABEL,
+    placeholder: "Long answer text"
+  },
+  number: {
+    label: DEFAULT_FIELD_LABEL,
+    placeholder: "123"
+  },
+  date: {
+    label: DEFAULT_FIELD_LABEL
+  },
+  checkbox: {
+    label: DEFAULT_FIELD_LABEL,
+    placeholder: "Check to confirm"
+  },
   singleSelect: {
     label: DEFAULT_FIELD_LABEL,
     options: ["Option 1", "Option 2", "Option 3"]
@@ -102,6 +201,13 @@ var CORE_FIELD_DEFAULTS = {
     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.
+    label: DEFAULT_FIELD_LABEL,
+    fields: []
+    // nested fields go here in the UI layer
   }
 };
 
@@ -121,16 +227,20 @@ function createUniqueId(prefix, existing) {
 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"
 };
@@ -168,63 +278,678 @@ function migrateLegacySchema(raw) {
 }
 
 // src/normalize.ts
-function parseReportTemplateSchema(raw) {
-  const migrated = migrateLegacySchema(raw);
-  const parsed = ReportTemplateSchemaValidator.parse(migrated);
-  return normalizeReportTemplateSchema(parsed);
+function normalizeId(raw, fallback) {
+  if (!raw || typeof raw !== "string") return fallback;
+  const cleaned = raw.trim().toLowerCase().replace(/\s+/g, "_").replace(/[^a-z0-9_-]/g, "");
+  return cleaned.length > 0 ? cleaned : fallback;
+}
+function ensureUniqueId(id, used) {
+  let final = id;
+  let counter = 1;
+  while (used.has(final)) {
+    final = `${id}-${counter++}`;
+  }
+  used.add(final);
+  return final;
+}
+function normalizeField(field, usedFieldIds, index) {
+  const fallbackId = `field_${index + 1}`;
+  const normalizedId = normalizeId(field.id, fallbackId);
+  const uniqueId = ensureUniqueId(normalizedId, usedFieldIds);
+  const base = {
+    ...field,
+    id: uniqueId
+  };
+  if (field.type === "repeatGroup") {
+    const nestedUsed = /* @__PURE__ */ new Set();
+    const nestedFields = Array.isArray(field.fields) ? field.fields : [];
+    base.fields = nestedFields.map(
+      (inner, idx) => normalizeField(inner, nestedUsed, idx)
+    );
+  }
+  return base;
+}
+function normalizeSection(section, sectionIndex) {
+  const fallbackId = `section_${sectionIndex + 1}`;
+  const normalizedId = normalizeId(section.id, fallbackId);
+  const base = {
+    ...section,
+    id: normalizedId
+  };
+  const usedFieldIds = /* @__PURE__ */ new Set();
+  base.fields = (section.fields ?? []).map(
+    (field, idx) => normalizeField(field, usedFieldIds, idx)
+  );
+  return base;
 }
 function normalizeReportTemplateSchema(schema) {
   const sections = schema.sections.length > 0 ? schema.sections : [
     {
-      id: "section-1",
+      id: "section_1",
       title: "",
       description: "",
       fields: []
     }
   ];
-  const normalizedSections = sections.map((sec, i) => {
-    const seen = /* @__PURE__ */ new Set();
-    const safeSectionId = sec.id.trim() || `section-${i + 1}`;
-    const fields = sec.fields.map((field, idx) => {
-      const trimmed = field.id.trim() || `field-${idx + 1}`;
-      const safeId = seen.has(trimmed) ? `field-${idx + 1}` : trimmed;
-      seen.add(safeId);
-      return {
-        ...field,
-        id: safeId
-      };
-    });
-    return {
-      ...sec,
-      id: safeSectionId,
-      fields
-    };
+  const usedSectionIds = /* @__PURE__ */ new Set();
+  const normalizedSections = sections.map((section, idx) => {
+    const normalized = normalizeSection(section, idx);
+    normalized.id = ensureUniqueId(normalized.id, usedSectionIds);
+    return normalized;
   });
   return {
     ...schema,
     sections: normalizedSections
   };
 }
+function parseReportTemplateSchema(raw) {
+  const migrated = migrateLegacySchema(raw);
+  const parsed = ReportTemplateSchemaValidator.parse(migrated);
+  return normalizeReportTemplateSchema(parsed);
+}
 function parseReportTemplateSchemaFromString(raw) {
-  const obj = JSON.parse(raw);
-  return parseReportTemplateSchema(obj);
+  return parseReportTemplateSchema(JSON.parse(raw));
 }
 function serializeReportTemplateSchema(schema) {
   return JSON.stringify(schema, null, 2);
 }
+
+// src/responses.ts
+var import_zod2 = require("zod");
+
+// src/fieldRegistry.ts
+var FieldRegistryClass = class {
+  constructor() {
+    this.registry = /* @__PURE__ */ new Map();
+  }
+  /** Register or override a field type. */
+  register(type, entry) {
+    this.registry.set(type, entry);
+  }
+  /** Get registry entry for a field type. */
+  get(type) {
+    return this.registry.get(type);
+  }
+  /** Check if field type is registered. */
+  has(type) {
+    return this.registry.has(type);
+  }
+  /** Return all field types currently registered. */
+  list() {
+    return [...this.registry.keys()];
+  }
+};
+var FieldRegistry = new FieldRegistryClass();
+var CORE_TYPES = [
+  "shortText",
+  "longText",
+  "number",
+  "date",
+  "checkbox",
+  "singleSelect",
+  "multiSelect"
+];
+for (const type of CORE_TYPES) {
+  FieldRegistry.register(type, {
+    defaults: CORE_FIELD_DEFAULTS[type]
+    // Core types rely on existing validation logic.
+    // buildResponseSchema is optional — fallback handles it.
+  });
+}
+
+// src/conditions.ts
+function evaluateCondition(condition, response) {
+  if ("equals" in condition) {
+    return Object.entries(condition.equals).every(([key, val]) => {
+      return response[key] === val;
+    });
+  }
+  if ("any" in condition) {
+    return condition.any.some(
+      (sub) => evaluateCondition(sub, response)
+    );
+  }
+  if ("all" in condition) {
+    return condition.all.every(
+      (sub) => evaluateCondition(sub, response)
+    );
+  }
+  if ("not" in condition) {
+    const sub = condition.not;
+    return !evaluateCondition(sub, response);
+  }
+  return false;
+}
+
+// src/responses.ts
+function buildBaseFieldSchema(field) {
+  const isRequired = Boolean(field.required);
+  const registry = FieldRegistry.get(field.type);
+  if (registry?.buildResponseSchema) {
+    return registry.buildResponseSchema(field);
+  }
+  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": {
+      let 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();
+      if (Array.isArray(field.options) && field.options.length > 0) {
+        const allowed = new Set(field.options);
+        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());
+      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)),
+          "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();
+    }
+    default: {
+      return import_zod2.z.any();
+    }
+  }
+}
+function buildConditionalFieldSchema(field, response) {
+  if (field.visibleIf) {
+    const visible = evaluateCondition(field.visibleIf, response);
+    if (!visible) {
+      return import_zod2.z.any().optional();
+    }
+  }
+  let schema = buildBaseFieldSchema(field);
+  if (field.requiredIf) {
+    const shouldBeRequired = evaluateCondition(field.requiredIf, response);
+    if (shouldBeRequired) {
+      if (schema instanceof import_zod2.z.ZodOptional) {
+        schema = schema.unwrap();
+      }
+    }
+  }
+  return schema;
+}
+function buildResponseSchemaWithConditions(template, response) {
+  const shape = {};
+  for (const section of template.sections) {
+    for (const field of section.fields) {
+      shape[field.id] = buildConditionalFieldSchema(field, response);
+    }
+  }
+  return import_zod2.z.object(shape);
+}
+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);
+  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];
+        }
+      }
+    }
+  }
+  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();
+  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 validateReportResponseDetailed(template, data) {
+  if (typeof data !== "object" || data === null) {
+    return {
+      success: false,
+      errors: [
+        {
+          fieldId: "",
+          code: "response.invalid_root",
+          message: "Response must be an object."
+        }
+      ]
+    };
+  }
+  const response = data;
+  const schema = buildResponseSchemaWithConditions(template, response);
+  const fieldMeta = buildFieldMetadataLookup(template);
+  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];
+          }
+        }
+      }
+    }
+    return { success: true, value: parsed };
+  }
+  const errors = [];
+  for (const issue of result.error.issues) {
+    const path = issue.path ?? [];
+    const fieldId = typeof path[0] === "string" ? path[0] : "";
+    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 (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
+    });
+  }
+  return { success: false, errors };
+}
+
+// src/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 = {
+    addedSections: [],
+    removedSections: [],
+    reorderedSections: [],
+    modifiedSections: [],
+    addedFields: [],
+    removedFields: [],
+    reorderedFields: [],
+    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] });
+    }
+  }
+  for (const f of beforeFields) {
+    if (!(f.id in afterIndex)) {
+      empty.removedFields.push({ sectionId, fieldId: f.id, index: beforeIndex[f.id] });
+    }
+  }
+  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 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
+      });
+    }
+    if (f.type === "repeatGroup" && Array.isArray(f.fields)) {
+      const innerBefore = before.fields ?? [];
+      const innerAfter = f.fields;
+      const nested = diffRepeatGroupFields(
+        innerBefore,
+        innerAfter,
+        sectionId,
+        f.id
+      );
+      if (nested.addedFields.length > 0 || nested.removedFields.length > 0 || nested.reorderedFields.length > 0 || nested.modifiedFields.length > 0) {
+        empty.nestedFieldDiffs.push({
+          sectionId,
+          groupId: f.id,
+          diffs: nested
+        });
+      }
+    }
+  }
+  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]
+      });
+    }
+  }
+  for (const sec of beforeSections) {
+    if (!(sec.id in afterSecIndex)) {
+      diff.removedSections.push({
+        sectionId: sec.id,
+        index: beforeSecIndex[sec.id]
+      });
+    }
+  }
+  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 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
+      });
+    }
+  }
+  for (const afterSec of afterSections) {
+    const secId = afterSec.id;
+    const beforeIdx = beforeSecIndex[secId];
+    if (beforeIdx == null) continue;
+    const beforeSec = beforeSections[beforeIdx];
+    const beforeFields = beforeSec.fields ?? [];
+    const afterFields = afterSec.fields ?? [];
+    const nestedDiff = diffRepeatGroupFields(
+      beforeFields,
+      afterFields,
+      secId,
+      ""
+    );
+    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;
+}
+
+// src/jsonSchema.ts
+function mapFieldTypeToJSONSchemaCore(field) {
+  const common = {
+    title: field.label,
+    description: field.description,
+    default: field.defaultValue ?? void 0,
+    "x-frt-placeholder": field.placeholder,
+    "x-frt-dataClassification": field.dataClassification,
+    "x-frt-visibleIf": field.visibleIf,
+    "x-frt-requiredIf": field.requiredIf
+  };
+  switch (field.type) {
+    case "shortText":
+    case "longText": {
+      const schema = {
+        ...common,
+        type: "string"
+      };
+      if (typeof field.minLength === "number") {
+        schema.minLength = field.minLength;
+      }
+      if (typeof field.maxLength === "number") {
+        schema.maxLength = field.maxLength;
+      }
+      return schema;
+    }
+    case "number": {
+      const schema = {
+        ...common,
+        type: "number"
+      };
+      if (typeof field.minValue === "number") {
+        schema.minimum = field.minValue;
+      }
+      if (typeof field.maxValue === "number") {
+        schema.maximum = field.maxValue;
+      }
+      return schema;
+    }
+    case "date": {
+      const schema = {
+        ...common,
+        type: "string",
+        format: "date-time"
+      };
+      return schema;
+    }
+    case "checkbox": {
+      const schema = {
+        ...common,
+        type: "boolean"
+      };
+      if (field.required && !field.requiredIf) {
+        schema.const = true;
+      }
+      return schema;
+    }
+    case "singleSelect": {
+      const schema = {
+        ...common,
+        type: "string"
+      };
+      if (Array.isArray(field.options) && field.options.length > 0) {
+        schema.enum = field.options;
+      }
+      return schema;
+    }
+    case "multiSelect": {
+      const schema = {
+        ...common,
+        type: "array",
+        items: {
+          type: "string"
+        }
+      };
+      const hasOptions = Array.isArray(field.options) && field.options.length > 0;
+      if (hasOptions && !field.allowOther) {
+        schema.items = {
+          type: "string",
+          enum: field.options
+        };
+      }
+      if (typeof field.minSelections === "number") {
+        schema.minItems = field.minSelections;
+      }
+      if (typeof field.maxSelections === "number") {
+        schema.maxItems = field.maxSelections;
+      }
+      return schema;
+    }
+    default: {
+      return {
+        ...common
+      };
+    }
+  }
+}
+function exportJSONSchema(template) {
+  const properties = {};
+  const required = [];
+  for (const section of template.sections) {
+    for (const field of section.fields) {
+      properties[field.id] = mapFieldTypeToJSONSchemaCore(field);
+      if (field.required === true && !field.requiredIf && !field.visibleIf) {
+        required.push(field.id);
+      }
+    }
+  }
+  const schema = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    type: "object",
+    properties,
+    additionalProperties: false,
+    "x-frt-templateTitle": template.title,
+    "x-frt-templateDescription": template.description,
+    "x-frt-version": template.version
+  };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  return schema;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CORE_FIELD_DEFAULTS,
+  Condition,
   DEFAULT_FIELD_LABEL,
+  FieldRegistry,
   REPORT_TEMPLATE_FIELD_TYPES,
   REPORT_TEMPLATE_VERSION,
+  RepeatGroupFieldSchema,
   ReportTemplateFieldSchema,
   ReportTemplateSchemaValidator,
   ReportTemplateSectionSchema,
+  buildBaseFieldSchema,
+  buildResponseSchemaWithConditions,
   createUniqueId,
+  diffTemplates,
+  evaluateCondition,
+  exportJSONSchema,
   migrateLegacySchema,
   normalizeReportTemplateSchema,
   parseReportTemplateSchema,
   parseReportTemplateSchemaFromString,
-  serializeReportTemplateSchema
+  serializeReportTemplateSchema,
+  validateReportResponse,
+  validateReportResponseDetailed
 });