bank20baht-validator 0.1.3 → 0.2.0

package/README.md

@@ -44,9 +44,16 @@ POST /api/submissions {"id":"todo-form","data":{"title":"ab"}}
 → 422 {"errors":[{"ref":"title","message":"Must be at least 3 characters"}]}
 ```
 
+## Compatibility
+
+Peers on `bank20baht-ui` **0.2.x** (the `FieldType` union — including `password` since 0.2.2 —
+comes from there). In a workspace that also builds `bank20baht-ui`, keep the peer range in
+step with the core version or the validator's `tsc` build resolves a stale copy from npm.
+
 ## What it enforces
 
-- Every declarative validator of the field descriptors: `required`, `minLength`, `maxLength`, `min`, `max`, `pattern`, `email`, and `custom` (via a `Registry`).
+- Every declarative validator of the field descriptors: `required`, `min_length`, `max_length`, `min`, `max`, `pattern`, `email`, and `custom` (via a `Registry`).
+- Value **shape** per field type before any validator runs — a `password`/`text` must be a string, a `number` a finite number, a `dropdown` one of its option keys — so `{"$gt":""}` from a raw API call is rejected, not treated as "non-empty".
 - **Workflow rules first** (`evaluate` from `bank20baht-ui/engine`): fields hidden by rules are excluded and smuggled values are cleared; `required` derived from rules is enforced; `setValue` results are computed.
 - Approval steps: a `decision` must be present, and the comment policy (`required` / `requireOnReject`) is honored.
 
@@ -60,4 +67,4 @@ POST /api/submissions {"id":"todo-form","data":{"title":"ab"}}
 | `parseSchema(json)` | structural gate for storing builder output (throws on bad input) |
 | `isFormDefinition` / `isWorkflowDefinition` | schema kind guards |
 
-All results are `{ valid, issues, data }`; issues are `{ ref, message }` where `ref` is the field key (forms) or `formName.key` (workflows).
+All results are `{ valid, issues, data }`; issues are `{ ref, message }` where `ref` is the field key (forms) or `form_name.key` (workflows).

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { applyFlags, approvalFields, defaultValue, evaluate, resolveViewFields, setLocale, validateField, type FormDefinition, type Locale, type NestedData, type Registry, type WorkflowDefinition, type WorkflowForm } from 'bank20baht-ui/engine';
 export type SchemaDefinition = FormDefinition | WorkflowDefinition;
-/** One violation. `ref` is the field key for forms, `formName.key` for workflows. */
+/** One violation. `ref` is the field key for forms, `form_name.key` for workflows. */
 export interface ValidationIssue {
     ref: string;
     message: string;
@@ -30,7 +30,7 @@ export declare function validateFormData(form: FormDefinition, input: unknown, r
  * enforces across its steps: rules are evaluated first (`evaluate`), invisible
  * forms/fields are excluded, rule-derived `required` overrides the descriptor,
  * approval steps demand a decision plus their comment policy, and a rejected
- * approval with `onReject: end` (the default) stops validation there — the
+ * approval with `on_reject: end` (the default) stops validation there — the
  * client fires `baht-complete { status: 'rejected' }` immediately, so later
  * forms are never visited.
  */
@@ -49,7 +49,7 @@ export declare function validateSubmission(schema: SchemaDefinition, data: unkno
  * render. Throws with a human-readable message on bad input.
  *
  * Beyond shape it validates referential integrity (rule targets, condition
- * refs, transition endpoints, onReject.goto) and compiles every `pattern`
+ * refs, transition endpoints, on_reject.goto) and compiles every `pattern`
  * validator, so authoring defects surface at store time — not as a 500 or a
  * submission that can never pass.
  */

package/dist/index.js

@@ -13,7 +13,7 @@
 // every value must have the shape the UI control could actually emit before
 // the authored validators run.
 // ---------------------------------------------------------------------------
-import { applyFlags, approvalFields, defaultValue, evaluate, getCatalog, resolveViewFields, setCatalog, setLocale, t, validateField, walkPath, } from 'bank20baht-ui/engine';
+import { applyFlags, approvalFields, defaultValue, evaluate, getCatalog, parseDisabledEntry, parseIsoDate, resolveViewFields, setCatalog, setLocale, t, validateField, walkPath, normalizeLegacySchema, } from 'bank20baht-ui/engine';
 /**
  * Run `fn` with the catalog switched to `locale`, restoring the previous
  * catalog after. The engine catalog is module-global; validation is fully
@@ -34,6 +34,7 @@ function withLocale(locale, fn) {
 }
 /** Keys that write through Object.prototype — never valid as field/form names. */
 const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+const DATE_MODES = new Set(['single', 'range', 'multiple']);
 const FIELD_TYPES = new Set([
     'text',
     'textarea',
@@ -52,16 +53,16 @@ const FIELD_TYPES = new Set([
 ]);
 export function isWorkflowDefinition(schema) {
     return (isRecord(schema) &&
-        typeof schema['workflowId'] === 'string' &&
+        typeof schema['workflow_id'] === 'string' &&
         Array.isArray(schema['forms']) &&
         Array.isArray(schema['rules']));
 }
 export function isFormDefinition(schema) {
     return (isRecord(schema) &&
         !isWorkflowDefinition(schema) &&
-        typeof schema['formId'] === 'string' &&
-        typeof schema['formName'] === 'string' &&
-        Array.isArray(schema['field_data']));
+        typeof schema['form_id'] === 'string' &&
+        typeof schema['form_name'] === 'string' &&
+        Array.isArray(schema['fields']));
 }
 function isRecord(v) {
     return typeof v === 'object' && v !== null && !Array.isArray(v);
@@ -82,15 +83,28 @@ function sorted(fields) {
 function typeIssue(field, value) {
     if (value === null || value === undefined)
         return null;
-    // dynamic options (optionsFrom) can't be checked without the registry fetch
-    const optionKeys = field.optionsFrom ? null : field.options?.map((o) => o.key);
+    // dynamic options (options_from) can't be checked without the registry fetch
+    const optionKeys = field.options_from ? null : field.options?.map((o) => o.key);
     switch (field.type) {
         case 'text':
         case 'textarea':
         case 'email':
         case 'password':
-        case 'date':
             return typeof value === 'string' ? null : t('pattern');
+        case 'date': {
+            // value shape follows date_mode; every day must be a real ISO calendar day
+            const isDay = (v) => parseIsoDate(v) !== null;
+            switch (field.date_mode ?? 'single') {
+                case 'range':
+                    return Array.isArray(value) && value.length === 2 && value.every(isDay)
+                        ? null
+                        : t('pattern');
+                case 'multiple':
+                    return Array.isArray(value) && value.every(isDay) ? null : t('pattern');
+                default:
+                    return isDay(value) ? null : t('pattern');
+            }
+        }
         case 'number':
             return typeof value === 'number' && Number.isFinite(value) ? null : t('pattern');
         case 'checkbox':
@@ -163,7 +177,7 @@ function formDataResult(form, input, registry) {
     }
     const issues = [];
     const fields = [];
-    for (const f of sorted(form.field_data)) {
+    for (const f of sorted(form.fields)) {
         if (f.type === 'label')
             continue;
         if (UNSAFE_KEYS.has(f.key)) {
@@ -197,7 +211,7 @@ function formDataResult(form, input, registry) {
  * enforces across its steps: rules are evaluated first (`evaluate`), invisible
  * forms/fields are excluded, rule-derived `required` overrides the descriptor,
  * approval steps demand a decision plus their comment policy, and a rejected
- * approval with `onReject: end` (the default) stops validation there — the
+ * approval with `on_reject: end` (the default) stops validation there — the
  * client fires `baht-complete { status: 'rejected' }` immediately, so later
  * forms are never visited.
  */
@@ -239,19 +253,19 @@ function workflowDataResult(workflow, input, registry) {
     }
     // Forms in the order the client visits them: path order in graph mode,
     // ascending `order` among visible forms in linear mode.
-    const byName = new Map(workflow.forms.map((f) => [f.formName, f]));
+    const byName = new Map(workflow.forms.map((f) => [f.form_name, f]));
     const ordered = pathList
         ? pathList.map((n) => byName.get(n)).filter((f) => f !== undefined)
         : [...workflow.forms]
             .sort((a, b) => a.order - b.order)
-            .filter((f) => derived.forms[f.formName]?.visible !== false);
+            .filter((f) => derived.forms[f.form_name]?.visible !== false);
     // Rejection cut: everything after a rejected end-on-reject approval is
     // unvisited on the client and must not be demanded here.
     const cut = ordered.findIndex((form) => {
         if (form.kind !== 'approval')
             return false;
-        const onReject = form.approval?.onReject ?? { action: 'end' };
-        return onReject.action === 'end' && derived.data[form.formName]?.['decision'] === 'rejected';
+        const on_reject = form.approval?.on_reject ?? { action: 'end' };
+        return on_reject.action === 'end' && derived.data[form.form_name]?.['decision'] === 'rejected';
     });
     const visited = cut >= 0 ? ordered.slice(0, cut + 1) : ordered;
     for (const form of visited) {
@@ -259,10 +273,10 @@ function workflowDataResult(workflow, input, registry) {
             issues.push(...approvalIssues(form, derived.data));
             continue;
         }
-        for (const field of sorted(form.field_data)) {
+        for (const field of sorted(form.fields)) {
             if (field.type === 'label')
                 continue;
-            const ref = `${form.formName}.${field.key}`;
+            const ref = `${form.form_name}.${field.key}`;
             if (UNSAFE_KEYS.has(field.key)) {
                 issues.push({ ref, message: 'unsafe field key' });
                 continue;
@@ -270,7 +284,7 @@ function workflowDataResult(workflow, input, registry) {
             const state = derived.fields[ref];
             if (state && !state.visible)
                 continue; // hidden fields excluded (spec 02 §5)
-            const formData = derived.data[form.formName] ?? {};
+            const formData = derived.data[form.form_name] ?? {};
             const shape = shapeIssues(field, formData[field.key], ref);
             if (shape.length > 0) {
                 issues.push(...shape);
@@ -289,15 +303,15 @@ function workflowDataResult(workflow, input, registry) {
 /** Approval step checks — same gate `<baht-workflow>.decide()` applies. */
 function approvalIssues(form, data) {
     const issues = [];
-    const values = data[form.formName] ?? {};
+    const values = data[form.form_name] ?? {};
     const decision = values['decision'];
     if (decision !== 'approved' && decision !== 'rejected') {
-        issues.push({ ref: `${form.formName}.decision`, message: t('decisionRequired') });
+        issues.push({ ref: `${form.form_name}.decision`, message: t('decisionRequired') });
     }
     const mode = form.approval?.comment ?? 'optional';
     const commentRequired = mode === 'required' || (mode === 'requireOnReject' && decision === 'rejected');
     if (commentRequired && String(values['comment'] ?? '').trim() === '') {
-        issues.push({ ref: `${form.formName}.comment`, message: t('commentRequired') });
+        issues.push({ ref: `${form.form_name}.comment`, message: t('commentRequired') });
     }
     return issues;
 }
@@ -325,38 +339,44 @@ export function validateSubmission(schema, data, registry, locale) {
  * render. Throws with a human-readable message on bad input.
  *
  * Beyond shape it validates referential integrity (rule targets, condition
- * refs, transition endpoints, onReject.goto) and compiles every `pattern`
+ * refs, transition endpoints, on_reject.goto) and compiles every `pattern`
  * validator, so authoring defects surface at store time — not as a 500 or a
  * submission that can never pass.
  */
 export function parseSchema(json) {
-    const parsed = typeof json === 'string' ? JSON.parse(json) : json;
-    if (!isRecord(parsed))
+    const raw = typeof json === 'string' ? JSON.parse(json) : json;
+    if (!isRecord(raw))
         throw new Error('not an object');
+    // pre-0.3 JSON (formId / field_data / maxLength …) still parses — keys are
+    // migrated forward; the returned schema is always the current spelling.
+    const { schema: parsed, renamed } = normalizeLegacySchema(raw);
+    if (renamed.length > 0) {
+        console.warn(`[bank20baht-validator] legacy camelCase schema keys migrated (${renamed.length}): ${renamed.slice(0, 5).join(', ')}${renamed.length > 5 ? ', …' : ''} — re-save the schema with snake_case keys.`);
+    }
     if (isWorkflowDefinition(parsed)) {
         for (const f of parsed.forms) {
             if (!isRecord(f))
                 throw new Error('invalid form: expected an object');
-            if (typeof f.formName !== 'string' || f.formName === '' || !Array.isArray(f.field_data)) {
-                throw new Error(`invalid form ${JSON.stringify(f.formId)}`);
+            if (typeof f.form_name !== 'string' || f.form_name === '' || !Array.isArray(f.fields)) {
+                throw new Error(`invalid form ${JSON.stringify(f.form_id)}`);
             }
-            if (UNSAFE_KEYS.has(f.formName) || f.formName.includes('.')) {
-                throw new Error(`invalid formName ${JSON.stringify(f.formName)}`);
+            if (UNSAFE_KEYS.has(f.form_name) || f.form_name.includes('.')) {
+                throw new Error(`invalid form_name ${JSON.stringify(f.form_name)}`);
             }
             if (typeof f.order !== 'number' || !Number.isFinite(f.order)) {
-                throw new Error(`form ${f.formName} needs a numeric order`);
+                throw new Error(`form ${f.form_name} needs a numeric order`);
             }
             if (f.kind !== undefined && f.kind !== 'form' && f.kind !== 'approval') {
-                throw new Error(`invalid form kind ${JSON.stringify(f.kind)} on ${f.formName}`);
+                throw new Error(`invalid form kind ${JSON.stringify(f.kind)} on ${f.form_name}`);
             }
             assertValidFields(f);
             assertValidViews(f);
             assertValidRepeaters(f);
             if (f.view !== undefined && !f.views?.some((v) => v.name === f.view)) {
-                throw new Error(`step view ${JSON.stringify(f.view)} on ${f.formName} matches no view`);
+                throw new Error(`step view ${JSON.stringify(f.view)} on ${f.form_name} matches no view`);
             }
         }
-        const names = parsed.forms.map((f) => f.formName);
+        const names = parsed.forms.map((f) => f.form_name);
         if (new Set(names).size !== names.length) {
             throw new Error('formName must be unique in a workflow');
         }
@@ -367,16 +387,16 @@ export function parseSchema(json) {
             if (approval === undefined)
                 continue;
             if (!isRecord(approval))
-                throw new Error(`invalid approval config on ${f.formName}`);
-            const onReject = approval.onReject;
-            if (onReject === undefined)
+                throw new Error(`invalid approval config on ${f.form_name}`);
+            const on_reject = approval.on_reject;
+            if (on_reject === undefined)
                 continue;
-            if (!isRecord(onReject) || (onReject.action !== 'end' && onReject.action !== 'goto')) {
-                throw new Error(`invalid onReject on ${f.formName}`);
+            if (!isRecord(on_reject) || (on_reject.action !== 'end' && on_reject.action !== 'goto')) {
+                throw new Error(`invalid on_reject on ${f.form_name}`);
             }
-            if (onReject.action === 'goto' &&
-                (typeof onReject.form !== 'string' || !nameSet.has(onReject.form))) {
-                throw new Error(`onReject.goto targets unknown form ${JSON.stringify(onReject.form)} on ${f.formName}`);
+            if (on_reject.action === 'goto' &&
+                (typeof on_reject.form !== 'string' || !nameSet.has(on_reject.form))) {
+                throw new Error(`on_reject.goto targets unknown form ${JSON.stringify(on_reject.form)} on ${f.form_name}`);
             }
         }
         assertValidRules(parsed, nameSet, refs);
@@ -404,43 +424,43 @@ export function parseSchema(json) {
         assertValidRepeaters(parsed);
         return parsed;
     }
-    throw new Error('missing workflowId/forms/rules (workflow) or formId/formName/field_data (form)');
+    throw new Error('missing workflow_id/forms/rules (workflow) or form_id/form_name/fields (form)');
 }
 // ---- parseSchema internals ----------------------------------------------------
 /** Every addressable "formName.key" a rule/condition/expression may reference. */
 function fieldRefs(wf) {
     const refs = new Set();
     for (const form of wf.forms) {
-        for (const field of [...form.field_data, ...approvalFields(form)]) {
+        for (const field of [...form.fields, ...approvalFields(form)]) {
             if (field.type === 'label')
                 continue;
-            refs.add(`${form.formName}.${field.key}`);
+            refs.add(`${form.form_name}.${field.key}`);
         }
     }
     return refs;
 }
 function assertValidFields(form) {
     const seen = new Set();
-    for (const raw of form.field_data) {
+    for (const raw of form.fields) {
         if (!isRecord(raw))
-            throw new Error(`invalid field on ${form.formName}: expected an object`);
+            throw new Error(`invalid field on ${form.form_name}: expected an object`);
         const field = raw;
-        assertFieldShape(field, form.formName);
+        assertFieldShape(field, form.form_name);
         if (field.key !== undefined) {
             if (seen.has(field.key)) {
-                throw new Error(`duplicate field key ${JSON.stringify(field.key)} on ${form.formName}`);
+                throw new Error(`duplicate field key ${JSON.stringify(field.key)} on ${form.form_name}`);
             }
             seen.add(field.key);
         }
         if (field.fields !== undefined) {
             if (!Array.isArray(field.fields)) {
-                throw new Error(`fields[] on ${form.formName}.${field.key} must be an array`);
+                throw new Error(`fields[] on ${form.form_name}.${field.key} must be an array`);
             }
             for (const sub of field.fields) {
                 if (!isRecord(sub)) {
-                    throw new Error(`invalid sub-field on ${form.formName}.${field.key}: expected an object`);
+                    throw new Error(`invalid sub-field on ${form.form_name}.${field.key}: expected an object`);
                 }
-                assertFieldShape(sub, form.formName);
+                assertFieldShape(sub, form.form_name);
             }
         }
     }
@@ -464,32 +484,34 @@ function hasNestedUnboundedQuantifier(pattern) {
     const unbounded = '(?:[*+]|\\{\\d+,\\})';
     return new RegExp(`\\((?:\\?:)?[^()|]${unbounded}\\??\\)${unbounded}`).test(stripped);
 }
-function assertFieldShape(field, formName) {
+function assertFieldShape(field, form_name) {
     if (typeof field.type !== 'string' || !FIELD_TYPES.has(field.type)) {
-        throw new Error(`unknown field type ${JSON.stringify(field.type)} on ${formName}`);
+        throw new Error(`unknown field type ${JSON.stringify(field.type)} on ${form_name}`);
     }
     // labels are static blocks and may omit the key; everything else needs one
     if (field.type !== 'label' || field.key !== undefined) {
         if (typeof field.key !== 'string' || field.key === '') {
-            throw new Error(`field on ${formName} needs a non-empty string key`);
+            throw new Error(`field on ${form_name} needs a non-empty string key`);
         }
         if (UNSAFE_KEYS.has(field.key) || field.key.includes('.')) {
-            throw new Error(`invalid field key ${JSON.stringify(field.key)} on ${formName}`);
+            throw new Error(`invalid field key ${JSON.stringify(field.key)} on ${form_name}`);
         }
     }
+    if (field.type === 'date')
+        assertDateProps(field, form_name);
     if (field.options !== undefined) {
         if (!Array.isArray(field.options) ||
             field.options.some((o) => !isRecord(o) || typeof o.key !== 'string')) {
-            throw new Error(`invalid options on ${formName}.${field.key}: expected { key, label } items`);
+            throw new Error(`invalid options on ${form_name}.${field.key}: expected { key, label } items`);
         }
     }
     if (field.validators !== undefined) {
         if (!Array.isArray(field.validators)) {
-            throw new Error(`validators on ${formName}.${field.key} must be an array`);
+            throw new Error(`validators on ${form_name}.${field.key} must be an array`);
         }
         for (const v of field.validators) {
             if (!isRecord(v) || typeof v.type !== 'string') {
-                throw new Error(`invalid validator on ${formName}.${field.key}`);
+                throw new Error(`invalid validator on ${form_name}.${field.key}`);
             }
             if (v.type === 'pattern') {
                 // compile now — an invalid regex would otherwise throw (or hang, if
@@ -499,10 +521,10 @@ function assertFieldShape(field, formName) {
                     new RegExp(pattern);
                 }
                 catch {
-                    throw new Error(`invalid pattern ${JSON.stringify(v.value)} on ${formName}.${field.key}`);
+                    throw new Error(`invalid pattern ${JSON.stringify(v.value)} on ${form_name}.${field.key}`);
                 }
                 if (hasNestedUnboundedQuantifier(pattern)) {
-                    throw new Error(`pattern on ${formName}.${field.key} nests unbounded quantifiers ` +
+                    throw new Error(`pattern on ${form_name}.${field.key} nests unbounded quantifiers ` +
                         `(e.g. "(a+)+") — this backtracks catastrophically on hostile input; ` +
                         `an equivalent single quantifier matches the same strings`);
                 }
@@ -510,6 +532,32 @@ function assertFieldShape(field, formName) {
         }
     }
 }
+/** Calendar constraints must be well-formed or the picker silently ignores them. */
+function assertDateProps(field, form_name) {
+    const where = `${form_name}.${field.key}`;
+    if (field.date_mode !== undefined && !DATE_MODES.has(field.date_mode)) {
+        throw new Error(`invalid date_mode ${JSON.stringify(field.date_mode)} on ${where}`);
+    }
+    for (const bound of ['min', 'max']) {
+        const v = field[bound];
+        if (v !== undefined && parseIsoDate(v) === null) {
+            throw new Error(`${bound} on ${where} must be an ISO date (yyyy-mm-dd)`);
+        }
+    }
+    if (field.disabled_dates !== undefined) {
+        const bad = !Array.isArray(field.disabled_dates) ||
+            field.disabled_dates.some((d) => typeof d !== 'string' || parseDisabledEntry(d) === null);
+        if (bad) {
+            throw new Error(`disabled_dates on ${where} must be ISO days ("2026-04-13") or intervals ("2026-04-13/2026-04-15")`);
+        }
+    }
+    if (field.disabled_weekdays !== undefined) {
+        const bad = !Array.isArray(field.disabled_weekdays) ||
+            field.disabled_weekdays.some((d) => !Number.isInteger(d) || d < 0 || d > 6);
+        if (bad)
+            throw new Error(`disabled_weekdays on ${where} must be integers 0 (Sun) … 6 (Sat)`);
+    }
+}
 function assertValidRules(wf, formNames, refs) {
     wf.rules.forEach((raw, i) => {
         if (!isRecord(raw))
@@ -573,9 +621,9 @@ function assertValidCondition(cond, refs, where) {
     if (typeof cond['field'] !== 'string' || !refs.has(cond['field'])) {
         throw new Error(`${where} references unknown field ${JSON.stringify(cond['field'])}`);
     }
-    const valueField = cond['valueField'];
-    if (valueField !== undefined && (typeof valueField !== 'string' || !refs.has(valueField))) {
-        throw new Error(`${where} references unknown field ${JSON.stringify(valueField)}`);
+    const value_field = cond['value_field'];
+    if (value_field !== undefined && (typeof value_field !== 'string' || !refs.has(value_field))) {
+        throw new Error(`${where} references unknown field ${JSON.stringify(value_field)}`);
     }
 }
 function assertValidExpr(expr, refs, where) {
@@ -612,7 +660,7 @@ function assertValidExpr(expr, refs, where) {
 /**
  * View integrity — views are client-side display projections, but a stored
  * one must always resolve on the client: names unique and shaped right, every
- * listed key present in field_data. Catches builder typos at store time
+ * listed key present in fields. Catches builder typos at store time
  * instead of as a silently empty form.
  */
 /**
@@ -620,18 +668,18 @@ function assertValidExpr(expr, refs, where) {
  * unique keys, and repeaters never nest.
  */
 function assertValidRepeaters(form) {
-    for (const field of form.field_data) {
+    for (const field of form.fields) {
         if (field.type !== 'repeater')
             continue;
         if (!Array.isArray(field.fields) || field.fields.length === 0) {
-            throw new Error(`repeater ${JSON.stringify(field.key)} on ${form.formName} needs fields[]`);
+            throw new Error(`repeater ${JSON.stringify(field.key)} on ${form.form_name} needs fields[]`);
         }
         const keys = field.fields.map((f) => f.key);
         if (new Set(keys).size !== keys.length) {
-            throw new Error(`repeater ${JSON.stringify(field.key)} on ${form.formName} has duplicate sub-keys`);
+            throw new Error(`repeater ${JSON.stringify(field.key)} on ${form.form_name} has duplicate sub-keys`);
         }
         if (field.fields.some((f) => f.type === 'repeater')) {
-            throw new Error(`repeater ${JSON.stringify(field.key)} on ${form.formName} nests a repeater`);
+            throw new Error(`repeater ${JSON.stringify(field.key)} on ${form.form_name} nests a repeater`);
         }
     }
 }
@@ -639,20 +687,20 @@ function assertValidViews(form) {
     if (form.views === undefined)
         return;
     if (!Array.isArray(form.views))
-        throw new Error(`views must be an array on ${form.formName}`);
-    const keys = new Set(form.field_data.map((f) => f.key));
+        throw new Error(`views must be an array on ${form.form_name}`);
+    const keys = new Set(form.fields.map((f) => f.key));
     const names = new Set();
     for (const view of form.views) {
         if (!isRecord(view) || typeof view.name !== 'string' || !Array.isArray(view.fields)) {
-            throw new Error(`invalid view on ${form.formName}: expected { name, fields[] }`);
+            throw new Error(`invalid view on ${form.form_name}: expected { name, fields[] }`);
         }
         if (names.has(view.name)) {
-            throw new Error(`view names must be unique on ${form.formName}: ${JSON.stringify(view.name)}`);
+            throw new Error(`view names must be unique on ${form.form_name}: ${JSON.stringify(view.name)}`);
         }
         names.add(view.name);
         for (const key of view.fields) {
             if (typeof key !== 'string' || !keys.has(key)) {
-                throw new Error(`view ${JSON.stringify(view.name)} on ${form.formName} references unknown field ${JSON.stringify(key)}`);
+                throw new Error(`view ${JSON.stringify(view.name)} on ${form.form_name} references unknown field ${JSON.stringify(key)}`);
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bank20baht-validator",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "type": "module",
   "description": "Runtime validation for bahtui form/workflow JSON — the exact engine rules the client runs, on the server.",
   "license": "MIT",
@@ -40,12 +40,12 @@
     "test:watch": "vitest"
   },
   "devDependencies": {
-    "bank20baht-ui": "^0.2.2",
+    "bank20baht-ui": "^0.3.0",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4"
   },
   "peerDependencies": {
-    "bank20baht-ui": ">=0.2.2 <0.3.0"
+    "bank20baht-ui": ">=0.3.0 <0.4.0"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",