udp-stencil-component-library 26.5.0-beta.2 → 26.5.0-beta.21

package/dist/cjs/codecs-Z6GTnUYS.js

@@ -0,0 +1,2424 @@
+'use strict';
+
+var types = require('./types-mjOM5U2F.js');
+var makeApiCall = require('./makeApiCall-CFfg9gI0.js');
+var tenantUtils = require('./tenantUtils-BCKSE0vq.js');
+var configService = require('./configService-D-lDX-f_.js');
+
+var __rest = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+/**
+ * Thrown when the wire describe response is structurally invalid. The form is
+ * unusable past this point — the host should surface a "could not load this
+ * form" state rather than trying to render against malformed input.
+ */
+class FormParseError extends Error {
+    constructor(message, questionId) {
+        super(message);
+        this.questionId = questionId;
+        this.name = 'FormParseError';
+    }
+}
+function parseForm(response) {
+    var _a, _b;
+    const form = {
+        id: response.id,
+        version: response.version,
+        type: response.type,
+        isPrivate: response.isPrivate,
+        isActive: response.isActive,
+        name: response.name,
+        description: (_a = response.description) !== null && _a !== void 0 ? _a : null,
+        tenantId: response.tenantId,
+        styleOverrides: parseStyleOverrides(response.styleOverrides),
+        createdOn: response.createdOn,
+    };
+    const sectionsSorted = response.udpFormUdpFormSection
+        .map(parseSection)
+        .sort((a, b) => a.order - b.order);
+    const questionsBySectionId = new Map();
+    for (const raw of response.formQuestions) {
+        const question = parseQuestion(raw);
+        if (question.formSectionId == null)
+            continue;
+        const list = (_b = questionsBySectionId.get(question.formSectionId)) !== null && _b !== void 0 ? _b : [];
+        list.push(question);
+        questionsBySectionId.set(question.formSectionId, list);
+    }
+    for (const list of questionsBySectionId.values()) {
+        list.sort((a, b) => a.questionOrder - b.questionOrder);
+    }
+    const sections = sectionsSorted.map(section => {
+        var _a;
+        return (Object.assign(Object.assign({}, section), { questions: (_a = questionsBySectionId.get(section.id)) !== null && _a !== void 0 ? _a : [] }));
+    });
+    return { form, sections };
+}
+function parseSection(raw) {
+    var _a, _b, _c;
+    return {
+        id: raw.id,
+        formId: raw.formId,
+        formVersion: raw.formVersion,
+        title: (_a = raw.title) !== null && _a !== void 0 ? _a : null,
+        sectionText: (_b = raw.sectionText) !== null && _b !== void 0 ? _b : null,
+        order: raw.order,
+        sectionProperties: parseSectionProperties(raw.sectionProperties),
+        name: raw.name,
+        referenceCode: (_c = raw.referenceCode) !== null && _c !== void 0 ? _c : null,
+    };
+}
+function parseQuestion(raw) {
+    var _a, _b, _c;
+    // Lightweight structural guard at the trust boundary:
+    //   1. `fieldTypeId` must be a known enum value. An unknown id means the
+    //      backend is ahead of the renderer (or vice versa) — better to fail
+    //      loud at load than render the wrong control or crash inside a codec.
+    //   2. `fieldProperties` must be an object (not array, not primitive). The
+    //      typed union below trusts the per-key shape; we don't validate every
+    //      property here (the codec / type-specific renderer narrows further),
+    //      but we do reject anything that isn't a property bag at all so a
+    //      stray string or number can't make it into the form engine.
+    if (!isKnownFieldTypeId(raw.fieldTypeId)) {
+        throw new FormParseError(`Question ${raw.id}: unknown fieldTypeId ${raw.fieldTypeId}. The schema may be from a newer form version than this renderer supports.`, raw.id);
+    }
+    const fp = raw.fieldProperties;
+    if (fp != null && (typeof fp !== 'object' || Array.isArray(fp))) {
+        throw new FormParseError(`Question ${raw.id}: fieldProperties must be an object, got ${Array.isArray(fp) ? 'array' : typeof fp}.`, raw.id);
+    }
+    // Normalise the lookup enrichment to the items ⊕ lookupId invariant. The
+    // backend's /describe resolves a lookup server-side and returns BOTH the
+    // `lookupId` AND a resolved `items` array. The rest of the code assumes the
+    // two are mutually exclusive (mode is derived from `items`, the schema
+    // engine's XOR drops one on commit), so a both-present question would render
+    // as a manual list of raw lookup values and — worse — lose its `lookupId`
+    // on the next save. We keep `lookupId` as the source of truth and lift the
+    // resolved options into `lookupItems` (a display-only field, never
+    // serialized) so renderers can still show them.
+    const { fieldProperties, lookupItems } = normaliseLookupFieldProperties(fp !== null && fp !== void 0 ? fp : {});
+    // Past the guards the wire shape is trusted to match the discriminator.
+    // Cast at this single boundary so the rest of the renderer can rely on the
+    // typed union.
+    return Object.assign({ id: raw.id, formId: raw.formId, formVersion: raw.formVersion, formSectionId: ((_a = raw.formSectionId) !== null && _a !== void 0 ? _a : null), name: raw.name, questionText: raw.questionText, fieldTypeId: raw.fieldTypeId, fieldProperties: fieldProperties, helperText: (_b = raw.helperText) !== null && _b !== void 0 ? _b : null, questionOrder: raw.questionOrder, required: raw.required, referenceCode: (_c = raw.referenceCode) !== null && _c !== void 0 ? _c : null }, (lookupItems ? { lookupItems } : {}));
+}
+/**
+ * When a question carries a non-empty `lookupId`, strip the backend-resolved
+ * `items` out of `fieldProperties` and return them separately as the
+ * display-only `lookupItems`. Anything else passes through untouched (manual
+ * questions keep their authored `items`).
+ */
+function normaliseLookupFieldProperties(fp) {
+    const lookupId = fp.lookupId;
+    const hasLookup = typeof lookupId === 'string' && lookupId.length > 0;
+    if (!hasLookup || !Array.isArray(fp.items)) {
+        return { fieldProperties: fp };
+    }
+    const { items } = fp, rest = __rest(fp, ["items"]);
+    return { fieldProperties: rest, lookupItems: items };
+}
+function isKnownFieldTypeId(id) {
+    // FieldTypeId is a numeric enum, so the reverse map gives us O(1) lookup
+    // without enumerating every variant by hand. Stays in sync automatically
+    // when a new field type is added to the enum.
+    return Object.prototype.hasOwnProperty.call(types.FieldTypeId, String(id));
+}
+function parseStyleOverrides(raw) {
+    if (!raw)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        // Defensive: a malformed styleOverrides JSON from the server shouldn't crash
+        // the form load, but losing the styles silently masks server-side bugs.
+        // eslint-disable-next-line no-console
+        console.warn('[udp-question-form] Failed to parse form.styleOverrides JSON; defaulting to null.', { raw, err });
+        return null;
+    }
+}
+function parseSectionProperties(raw) {
+    if (!raw)
+        return {};
+    try {
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        // eslint-disable-next-line no-console
+        console.warn('[udp-question-form] Failed to parse section.sectionProperties JSON; defaulting to {}.', { raw, err });
+        return {};
+    }
+}
+
+/**
+ * Shared "this field has no value" predicate. Single source of truth so the
+ * required rule, the progress tracker, and any future surface that needs
+ * "is this answered?" stay in lockstep. Add a new structured value shape
+ * (Signature, Location, Table, …) here once — everything else picks it up.
+ */
+function isValueEmpty(value) {
+    if (value == null)
+        return true;
+    if (typeof value === 'string')
+        return value.trim() === '';
+    if (Array.isArray(value))
+        return value.length === 0;
+    if (typeof value === 'object') {
+        // Signature value: empty when there's no drawn-or-stored file. A typed
+        // fullName alone doesn't satisfy required — the canvas is the primary input.
+        if ('file' in value && 'fullName' in value) {
+            const file = value.file;
+            return !(file instanceof File);
+        }
+        // Location: empty when no map pin is set — a typed-but-not-resolved
+        // address alone doesn't satisfy required.
+        if ('latitude' in value && 'longitude' in value) {
+            const v = value;
+            return v.latitude == null && v.longitude == null;
+        }
+        // Table: empty when no rows.
+        if ('rows' in value && Array.isArray(value.rows)) {
+            return value.rows.length === 0;
+        }
+    }
+    return false;
+}
+
+/**
+ * Required rule. Stored on `question.required` (top-level boolean) — unlike
+ * every other rule it doesn't live in `fieldProperties`. That's a wire-format
+ * concession to legacy; functionally it behaves identically to the rest.
+ */
+const requiredRule = {
+    ruleType: 'required',
+    appliesTo: [
+        types.FieldTypeId.SingleLineText,
+        types.FieldTypeId.MultiLineText,
+        types.FieldTypeId.Checkbox,
+        types.FieldTypeId.RadioButton,
+        types.FieldTypeId.DropdownSingleSelect,
+        types.FieldTypeId.DropdownMultipleSelect,
+        types.FieldTypeId.ListMultiSelect,
+        types.FieldTypeId.DateSelector,
+        types.FieldTypeId.TimeSelector,
+        types.FieldTypeId.DateTimeSelector,
+        types.FieldTypeId.FileUpload,
+        types.FieldTypeId.YesNo,
+        types.FieldTypeId.Signature,
+        types.FieldTypeId.Number,
+        types.FieldTypeId.ImageUpload,
+        types.FieldTypeId.Location,
+        types.FieldTypeId.Table,
+    ],
+    // Unlike most rules, required runs even when the value is empty — that's
+    // the whole point.
+    runOnEmpty: true,
+    readParams: question => (question.required === true ? true : null),
+    validateParams: () => null,
+    check: (value, _params) => (isValueEmpty(value) ? { message: 'Required' } : null),
+    defaultMessage: () => 'Required',
+    builder: {
+        label: 'Required',
+        description: 'Block submit unless the user provides a value.',
+        params: [],
+        defaultParams: true,
+        enable: set => set('required', true),
+        disable: set => set('required', false),
+    },
+};
+
+const minLengthRule = {
+    ruleType: 'minLength',
+    appliesTo: [types.FieldTypeId.SingleLineText, types.FieldTypeId.MultiLineText],
+    // `undefined` → rule off; a finite/parseable value → rule on with that value;
+    // anything else present → rule on with NaN, which keeps the card mounted
+    // while `validateParams` surfaces a fix-the-input error and blocks Update.
+    readParams: question => {
+        const v = question.fieldProperties.minCharacter;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => {
+        if (!Number.isFinite(n))
+            return 'Enter a minimum length.';
+        if (n < 0)
+            return 'Minimum length must be 0 or greater.';
+        return null;
+    },
+    check: (value, min) => {
+        const len = typeof value === 'string' ? value.length : 0;
+        return len < min ? { message: `Must be at least ${min} characters` } : null;
+    },
+    defaultMessage: n => `Must be at least ${n} characters`,
+    builder: {
+        label: 'Minimum length',
+        params: [{ key: 'value', formPath: 'fieldProperties.minCharacter', label: 'Minimum characters', type: 'number', min: 0 }],
+        defaultParams: 1,
+        enable: set => set('fieldProperties.minCharacter', 1),
+        disable: set => set('fieldProperties.minCharacter', undefined),
+    },
+};
+
+const maxLengthRule = {
+    ruleType: 'maxLength',
+    appliesTo: [types.FieldTypeId.SingleLineText, types.FieldTypeId.MultiLineText],
+    // See min-length.ts for the three-state activation rationale.
+    readParams: question => {
+        const v = question.fieldProperties.maxCharacter;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => {
+        if (!Number.isFinite(n))
+            return 'Enter a maximum length.';
+        if (n < 0)
+            return 'Maximum length must be 0 or greater.';
+        return null;
+    },
+    check: (value, max) => {
+        const len = typeof value === 'string' ? value.length : 0;
+        return len > max ? { message: `Must be at most ${max} characters` } : null;
+    },
+    defaultMessage: n => `Must be at most ${n} characters`,
+    builder: {
+        label: 'Maximum length',
+        params: [{ key: 'value', formPath: 'fieldProperties.maxCharacter', label: 'Maximum characters', type: 'number', min: 0 }],
+        defaultParams: 100,
+        enable: set => set('fieldProperties.maxCharacter', 100),
+        disable: set => set('fieldProperties.maxCharacter', undefined),
+    },
+};
+
+/**
+ * Regex pattern rule. Stored as `fieldProperties.pattern: string` (new key —
+ * absent on legacy forms, so the rule simply doesn't fire there). When the
+ * author provides a `patternMessage`, it surfaces instead of the generic
+ * default — better UX than "Must match the required pattern" for typed
+ * formats like ID codes or postal codes.
+ *
+ * The pattern is compiled once on check and cached per-call. Bad patterns
+ * fail at `validateParams` time (drawer surfaces inline) so the renderer
+ * never sees an invalid regex at submit time.
+ */
+const patternRule = {
+    ruleType: 'pattern',
+    appliesTo: [types.FieldTypeId.SingleLineText, types.FieldTypeId.MultiLineText],
+    readParams: question => {
+        const fp = question.fieldProperties;
+        const pattern = fp === null || fp === void 0 ? void 0 : fp.pattern;
+        if (typeof pattern !== 'string' || pattern.length === 0)
+            return null;
+        const message = typeof (fp === null || fp === void 0 ? void 0 : fp.patternMessage) === 'string' ? fp.patternMessage : undefined;
+        return { pattern, message };
+    },
+    validateParams: ({ pattern }) => {
+        try {
+            return null;
+        }
+        catch (e) {
+            return `Invalid pattern: ${e.message}`;
+        }
+    },
+    check: (value, params) => {
+        var _a;
+        const s = typeof value === 'string' ? value : String(value !== null && value !== void 0 ? value : '');
+        let regex;
+        try {
+            regex = new RegExp(params.pattern);
+        }
+        catch (_b) {
+            // validateParams should have caught this — but if a malformed pattern
+            // slipped through, fail safe (don't block submit on engine error).
+            return null;
+        }
+        return regex.test(s) ? null : { message: (_a = params.message) !== null && _a !== void 0 ? _a : 'Does not match the required format' };
+    },
+    defaultMessage: params => { var _a; return (_a = params.message) !== null && _a !== void 0 ? _a : 'Does not match the required format'; },
+    builder: {
+        label: 'Pattern (regex)',
+        description: 'Block submit unless the value matches a regular expression.',
+        params: [
+            { key: 'pattern', formPath: 'fieldProperties.pattern', label: 'Regular expression', type: 'regex' },
+            { key: 'message', formPath: 'fieldProperties.patternMessage', label: 'Error message (optional)', type: 'string' },
+        ],
+        defaultParams: { pattern: '' },
+        // Seed with a permissive default the author can tighten — empty would
+        // fail `readParams`'s non-empty check and flick the toggle right back off.
+        enable: set => set('fieldProperties.pattern', '.*'),
+        disable: set => {
+            set('fieldProperties.pattern', undefined);
+            set('fieldProperties.patternMessage', undefined);
+        },
+    },
+};
+
+const minValueRule = {
+    ruleType: 'minValue',
+    appliesTo: [types.FieldTypeId.Number],
+    // Same three-state pattern as min-length: `undefined` is off, a finite or
+    // parseable value is active, anything else present is NaN (active-but-invalid)
+    // so the card survives an empty input while `validateParams` blocks Update.
+    readParams: question => {
+        const v = question.fieldProperties.minValue;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => (Number.isFinite(n) ? null : 'Enter a minimum value.'),
+    check: (value, min) => {
+        const n = typeof value === 'number' ? value : Number(value);
+        if (!Number.isFinite(n))
+            return null;
+        return n < min ? { message: `Must be at least ${min}` } : null;
+    },
+    defaultMessage: n => `Must be at least ${n}`,
+    builder: {
+        label: 'Minimum value',
+        params: [{ key: 'value', formPath: 'fieldProperties.minValue', label: 'Minimum value', type: 'number' }],
+        defaultParams: 0,
+        enable: set => set('fieldProperties.minValue', 0),
+        disable: set => set('fieldProperties.minValue', undefined),
+    },
+};
+
+const maxValueRule = {
+    ruleType: 'maxValue',
+    appliesTo: [types.FieldTypeId.Number],
+    // See min-value.ts for the three-state activation rationale.
+    readParams: question => {
+        const v = question.fieldProperties.maxValue;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => (Number.isFinite(n) ? null : 'Enter a maximum value.'),
+    check: (value, max) => {
+        const n = typeof value === 'number' ? value : Number(value);
+        if (!Number.isFinite(n))
+            return null;
+        return n > max ? { message: `Must be at most ${max}` } : null;
+    },
+    defaultMessage: n => `Must be at most ${n}`,
+    builder: {
+        label: 'Maximum value',
+        params: [{ key: 'value', formPath: 'fieldProperties.maxValue', label: 'Maximum value', type: 'number' }],
+        defaultParams: 100,
+        enable: set => set('fieldProperties.maxValue', 100),
+        disable: set => set('fieldProperties.maxValue', undefined),
+    },
+};
+
+const ISO_DATE$1 = /^\d{4}-\d{2}-\d{2}$/;
+const minDateRule = {
+    ruleType: 'minDate',
+    appliesTo: [types.FieldTypeId.DateSelector],
+    readParams: question => {
+        var _a;
+        const v = (_a = question.fieldProperties) === null || _a === void 0 ? void 0 : _a.minDate;
+        return typeof v === 'string' && ISO_DATE$1.test(v) ? v : null;
+    },
+    validateParams: v => (ISO_DATE$1.test(v) ? null : 'Must be a YYYY-MM-DD date.'),
+    check: (value, min) => {
+        const v = typeof value === 'string' ? value : '';
+        return v < min ? { message: `Must be on or after ${min}` } : null;
+    },
+    defaultMessage: min => `Must be on or after ${min}`,
+    builder: {
+        label: 'Earliest date',
+        params: [{ key: 'value', formPath: 'fieldProperties.minDate', label: 'Earliest allowed date', type: 'date' }],
+        defaultParams: '',
+        enable: set => set('fieldProperties.minDate', new Date().toISOString().slice(0, 10)),
+        disable: set => set('fieldProperties.minDate', undefined),
+    },
+};
+
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+const maxDateRule = {
+    ruleType: 'maxDate',
+    appliesTo: [types.FieldTypeId.DateSelector],
+    readParams: question => {
+        var _a;
+        const v = (_a = question.fieldProperties) === null || _a === void 0 ? void 0 : _a.maxDate;
+        return typeof v === 'string' && ISO_DATE.test(v) ? v : null;
+    },
+    validateParams: v => (ISO_DATE.test(v) ? null : 'Must be a YYYY-MM-DD date.'),
+    check: (value, max) => {
+        const v = typeof value === 'string' ? value : '';
+        return v > max ? { message: `Must be on or before ${max}` } : null;
+    },
+    defaultMessage: max => `Must be on or before ${max}`,
+    builder: {
+        label: 'Latest date',
+        params: [{ key: 'value', formPath: 'fieldProperties.maxDate', label: 'Latest allowed date', type: 'date' }],
+        defaultParams: '',
+        enable: set => set('fieldProperties.maxDate', new Date().toISOString().slice(0, 10)),
+        disable: set => set('fieldProperties.maxDate', undefined),
+    },
+};
+
+/**
+ * Active when `noFutureDate === true`. The legacy `allowFutureDate` key is
+ * deliberately NOT consulted: the legacy builder wrote `allowFutureDate:
+ * false` on every date question by default, but the legacy renderer never
+ * enforced it — keying off it would suddenly reject future dates on
+ * virtually every form authored in the old builder.
+ */
+const noFutureDateRule = {
+    ruleType: 'noFutureDate',
+    appliesTo: [types.FieldTypeId.DateSelector],
+    readParams: question => {
+        var _a;
+        const v = (_a = question.fieldProperties) === null || _a === void 0 ? void 0 : _a.noFutureDate;
+        return v === true ? true : null;
+    },
+    validateParams: () => null,
+    check: (value, _params, _question, ctx) => {
+        const v = typeof value === 'string' ? value : '';
+        const today = ctx.now().toISOString().slice(0, 10);
+        return v > today ? { message: 'Future dates are not allowed' } : null;
+    },
+    defaultMessage: () => 'Future dates are not allowed',
+    builder: {
+        label: 'Disallow future dates',
+        params: [],
+        defaultParams: true,
+        enable: set => set('fieldProperties.noFutureDate', true),
+        disable: set => set('fieldProperties.noFutureDate', undefined),
+    },
+};
+
+// HH:mm or HH:mm:ss. We compare lexicographically after normalizing both
+// sides to HH:mm:ss — legacy fieldProperties store bounds WITH seconds
+// ('09:00:00') while submission values come in WITHOUT ('09:00'), and a raw
+// compare would fail the exact-boundary case ('09:00' < '09:00:00').
+const TIME_RE$1 = /^\d{2}:\d{2}(?::\d{2})?$/;
+const withSeconds$1 = (t) => (t.length === 5 ? `${t}:00` : t);
+const minTimeRule = {
+    ruleType: 'minTime',
+    appliesTo: [types.FieldTypeId.TimeSelector],
+    readParams: question => {
+        var _a;
+        const v = (_a = question.fieldProperties) === null || _a === void 0 ? void 0 : _a.minTime;
+        return typeof v === 'string' && TIME_RE$1.test(v) ? v : null;
+    },
+    validateParams: v => (TIME_RE$1.test(v) ? null : 'Must be a HH:mm[:ss] time.'),
+    check: (value, min) => {
+        const v = typeof value === 'string' ? value : '';
+        return withSeconds$1(v) < withSeconds$1(min)
+            ? { message: `Must be at or after ${min}` }
+            : null;
+    },
+    defaultMessage: min => `Must be at or after ${min}`,
+    builder: {
+        label: 'Earliest time',
+        params: [{ key: 'value', formPath: 'fieldProperties.minTime', label: 'Earliest allowed time', type: 'time' }],
+        defaultParams: '',
+        enable: set => set('fieldProperties.minTime', '00:00'),
+        disable: set => set('fieldProperties.minTime', undefined),
+    },
+};
+
+const TIME_RE = /^\d{2}:\d{2}(?::\d{2})?$/;
+// Normalize to HH:mm:ss so legacy seconds-bearing bounds compare correctly
+// against HH:mm submission values (see min-time.ts).
+const withSeconds = (t) => (t.length === 5 ? `${t}:00` : t);
+const maxTimeRule = {
+    ruleType: 'maxTime',
+    appliesTo: [types.FieldTypeId.TimeSelector],
+    readParams: question => {
+        var _a;
+        const v = (_a = question.fieldProperties) === null || _a === void 0 ? void 0 : _a.maxTime;
+        return typeof v === 'string' && TIME_RE.test(v) ? v : null;
+    },
+    validateParams: v => (TIME_RE.test(v) ? null : 'Must be a HH:mm[:ss] time.'),
+    check: (value, max) => {
+        const v = typeof value === 'string' ? value : '';
+        return withSeconds(v) > withSeconds(max)
+            ? { message: `Must be at or before ${max}` }
+            : null;
+    },
+    defaultMessage: max => `Must be at or before ${max}`,
+    builder: {
+        label: 'Latest time',
+        params: [{ key: 'value', formPath: 'fieldProperties.maxTime', label: 'Latest allowed time', type: 'time' }],
+        defaultParams: '',
+        enable: set => set('fieldProperties.maxTime', '23:59'),
+        disable: set => set('fieldProperties.maxTime', undefined),
+    },
+};
+
+const DATETIME_RE$1 = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}(?::\d{2})?$/;
+// Normalize a datetime string for lexicographic comparison: legacy bounds
+// use a space separator and carry seconds ('1980-01-01 00:00:00') while
+// submission values are T-separated without seconds ('1980-01-01T00:00').
+// Unify the separator and pad missing seconds so equal instants compare equal.
+const normalizeDateTime$1 = (s) => {
+    const t = s.replace(' ', 'T');
+    return t.length === 16 ? `${t}:00` : t;
+};
+const minDateTimeRule = {
+    ruleType: 'minDateTime',
+    appliesTo: [types.FieldTypeId.DateTimeSelector],
+    readParams: question => {
+        var _a;
+        const v = (_a = question.fieldProperties) === null || _a === void 0 ? void 0 : _a.minDateTime;
+        return typeof v === 'string' && DATETIME_RE$1.test(v) ? v : null;
+    },
+    validateParams: v => (DATETIME_RE$1.test(v) ? null : 'Must be a YYYY-MM-DD HH:mm[:ss] datetime.'),
+    check: (value, min) => {
+        const v = typeof value === 'string' ? value : '';
+        return normalizeDateTime$1(v) < normalizeDateTime$1(min)
+            ? { message: `Must be on or after ${min}` }
+            : null;
+    },
+    defaultMessage: min => `Must be on or after ${min}`,
+    builder: {
+        label: 'Earliest date/time',
+        params: [{ key: 'value', formPath: 'fieldProperties.minDateTime', label: 'Earliest allowed date/time', type: 'datetime' }],
+        defaultParams: '',
+        enable: set => set('fieldProperties.minDateTime', `${new Date().toISOString().slice(0, 10)}T00:00`),
+        disable: set => set('fieldProperties.minDateTime', undefined),
+    },
+};
+
+const DATETIME_RE = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}(?::\d{2})?$/;
+// Normalize a datetime string for lexicographic comparison: legacy bounds
+// use a space separator and carry seconds ('1980-01-01 00:00:00') while
+// submission values are T-separated without seconds ('1980-01-01T00:00').
+// Unify the separator and pad missing seconds so equal instants compare equal.
+const normalizeDateTime = (s) => {
+    const t = s.replace(' ', 'T');
+    return t.length === 16 ? `${t}:00` : t;
+};
+const maxDateTimeRule = {
+    ruleType: 'maxDateTime',
+    appliesTo: [types.FieldTypeId.DateTimeSelector],
+    readParams: question => {
+        var _a;
+        const v = (_a = question.fieldProperties) === null || _a === void 0 ? void 0 : _a.maxDateTime;
+        return typeof v === 'string' && DATETIME_RE.test(v) ? v : null;
+    },
+    validateParams: v => (DATETIME_RE.test(v) ? null : 'Must be a YYYY-MM-DD HH:mm[:ss] datetime.'),
+    check: (value, max) => {
+        const v = typeof value === 'string' ? value : '';
+        return normalizeDateTime(v) > normalizeDateTime(max)
+            ? { message: `Must be on or before ${max}` }
+            : null;
+    },
+    defaultMessage: max => `Must be on or before ${max}`,
+    builder: {
+        label: 'Latest date/time',
+        params: [{ key: 'value', formPath: 'fieldProperties.maxDateTime', label: 'Latest allowed date/time', type: 'datetime' }],
+        defaultParams: '',
+        enable: set => set('fieldProperties.maxDateTime', `${new Date().toISOString().slice(0, 10)}T23:59`),
+        disable: set => set('fieldProperties.maxDateTime', undefined),
+    },
+};
+
+/**
+ * DateTime equivalent of `noFutureDate`. Compares the date portion only,
+ * matching legacy renderer behavior (a 23:59 value today is allowed even
+ * though the wall clock has already passed earlier moments today).
+ */
+const noFutureDateTimeRule = {
+    ruleType: 'noFutureDateTime',
+    appliesTo: [types.FieldTypeId.DateTimeSelector],
+    // Keyed on the dedicated `noFutureDate` toggle — the legacy
+    // `allowFutureDate` key was never enforced by the old renderer (see
+    // no-future-date.ts) so it stays inert here too.
+    readParams: question => {
+        var _a;
+        const v = (_a = question.fieldProperties) === null || _a === void 0 ? void 0 : _a.noFutureDate;
+        return v === true ? true : null;
+    },
+    validateParams: () => null,
+    check: (value, _params, _question, ctx) => {
+        const v = typeof value === 'string' ? value : '';
+        const today = ctx.now().toISOString().slice(0, 10);
+        return v.slice(0, 10) > today ? { message: 'Future dates are not allowed' } : null;
+    },
+    defaultMessage: () => 'Future dates are not allowed',
+    builder: {
+        label: 'Disallow future dates',
+        params: [],
+        defaultParams: true,
+        enable: set => set('fieldProperties.noFutureDate', true),
+        disable: set => set('fieldProperties.noFutureDate', undefined),
+    },
+};
+
+/**
+ * Lower bound on how many options a multi-select must have. Number-keyed with
+ * the same NaN-sentinel activation as min-value: `undefined` is off, a
+ * parseable number is active, and present-but-unparseable returns NaN
+ * (active-but-invalid) so the builder card survives an in-flight empty input
+ * while `validateParams` blocks the Update.
+ */
+const minSelectionsRule = {
+    ruleType: 'minSelections',
+    appliesTo: [types.FieldTypeId.Checkbox, types.FieldTypeId.DropdownMultipleSelect, types.FieldTypeId.ListMultiSelect],
+    // A count minimum is mandatory by nature: an empty selection (0) violates
+    // "at least N", so run even when empty rather than skipping like length/value.
+    runOnEmpty: true,
+    readParams: question => {
+        const v = question.fieldProperties.minSelections;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => (Number.isFinite(n) ? null : 'Enter a minimum number of selections.'),
+    check: (value, min) => {
+        if (!Number.isFinite(min))
+            return null;
+        const count = Array.isArray(value) ? value.length : 0;
+        return count < min ? { message: message$7(min) } : null;
+    },
+    defaultMessage: message$7,
+    builder: {
+        label: 'Minimum selections',
+        description: 'Require at least N options to be selected.',
+        params: [
+            {
+                key: 'value',
+                formPath: 'fieldProperties.minSelections',
+                label: 'Minimum selections',
+                type: 'number',
+                min: 0,
+            },
+        ],
+        defaultParams: 1,
+        enable: set => set('fieldProperties.minSelections', 1),
+        disable: set => set('fieldProperties.minSelections', undefined),
+    },
+};
+function message$7(min) {
+    return `Select at least ${min} option${min === 1 ? '' : 's'}`;
+}
+
+/**
+ * Upper bound on how many options a multi-select may have. Number-keyed with
+ * the same NaN-sentinel activation as max-value (see min-selections for the
+ * rationale).
+ */
+const maxSelectionsRule = {
+    ruleType: 'maxSelections',
+    appliesTo: [types.FieldTypeId.Checkbox, types.FieldTypeId.DropdownMultipleSelect, types.FieldTypeId.ListMultiSelect],
+    readParams: question => {
+        const v = question.fieldProperties.maxSelections;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => (Number.isFinite(n) ? null : 'Enter a maximum number of selections.'),
+    check: (value, max) => {
+        if (!Number.isFinite(max))
+            return null;
+        const count = Array.isArray(value) ? value.length : 0;
+        return count > max ? { message: message$6(max) } : null;
+    },
+    defaultMessage: message$6,
+    builder: {
+        label: 'Maximum selections',
+        description: 'Limit how many options may be selected.',
+        params: [
+            {
+                key: 'value',
+                formPath: 'fieldProperties.maxSelections',
+                label: 'Maximum selections',
+                type: 'number',
+                min: 1,
+            },
+        ],
+        defaultParams: 1,
+        enable: set => set('fieldProperties.maxSelections', 1),
+        disable: set => set('fieldProperties.maxSelections', undefined),
+    },
+};
+function message$6(max) {
+    return `Select at most ${max} option${max === 1 ? '' : 's'}`;
+}
+
+/**
+ * Lower bound on a table's row count. The Table value is `{ rows: [...] }`
+ * (see the table intrinsic rule). Number-keyed with the same NaN-sentinel
+ * activation as min-value. Note `required` already enforces "at least one
+ * row"; this rule is for explicit minimums (e.g. "add at least 3 line items").
+ */
+const minRowsRule = {
+    ruleType: 'minRows',
+    appliesTo: [types.FieldTypeId.Table],
+    // A row minimum is mandatory by nature: an empty table (0 rows) violates
+    // "at least N", so run even when empty rather than skipping.
+    runOnEmpty: true,
+    readParams: question => {
+        const v = question.fieldProperties.minRows;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => (Number.isFinite(n) ? null : 'Enter a minimum number of rows.'),
+    check: (value, min) => {
+        if (!Number.isFinite(min))
+            return null;
+        const count = rowCount$1(value);
+        return count < min ? { message: message$5(min) } : null;
+    },
+    defaultMessage: message$5,
+    builder: {
+        label: 'Minimum rows',
+        description: 'Require at least N rows in the table.',
+        params: [
+            {
+                key: 'value',
+                formPath: 'fieldProperties.minRows',
+                label: 'Minimum rows',
+                type: 'number',
+                min: 0,
+            },
+        ],
+        defaultParams: 1,
+        enable: set => set('fieldProperties.minRows', 1),
+        disable: set => set('fieldProperties.minRows', undefined),
+    },
+};
+function rowCount$1(value) {
+    const rows = value === null || value === void 0 ? void 0 : value.rows;
+    return Array.isArray(rows) ? rows.length : 0;
+}
+function message$5(min) {
+    return `Add at least ${min} row${min === 1 ? '' : 's'}`;
+}
+
+/**
+ * Upper bound on a table's row count. The Table value is `{ rows: [...] }`.
+ * Number-keyed with the same NaN-sentinel activation as max-value.
+ */
+const maxRowsRule = {
+    ruleType: 'maxRows',
+    appliesTo: [types.FieldTypeId.Table],
+    readParams: question => {
+        const v = question.fieldProperties.maxRows;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => (Number.isFinite(n) ? null : 'Enter a maximum number of rows.'),
+    check: (value, max) => {
+        if (!Number.isFinite(max))
+            return null;
+        const count = rowCount(value);
+        return count > max ? { message: message$4(max) } : null;
+    },
+    defaultMessage: message$4,
+    builder: {
+        label: 'Maximum rows',
+        description: 'Limit how many rows the table may contain.',
+        params: [
+            {
+                key: 'value',
+                formPath: 'fieldProperties.maxRows',
+                label: 'Maximum rows',
+                type: 'number',
+                min: 1,
+            },
+        ],
+        defaultParams: 1,
+        enable: set => set('fieldProperties.maxRows', 1),
+        disable: set => set('fieldProperties.maxRows', undefined),
+    },
+};
+function rowCount(value) {
+    const rows = value === null || value === void 0 ? void 0 : value.rows;
+    return Array.isArray(rows) ? rows.length : 0;
+}
+function message$4(max) {
+    return `No more than ${max} row${max === 1 ? '' : 's'} allowed`;
+}
+
+/**
+ * Value must be a multiple of `step` (e.g. increments of 0.5 or 5). Number-keyed
+ * with NaN-sentinel activation. Float-safe via a ratio + epsilon comparison.
+ */
+const stepRule = {
+    ruleType: 'step',
+    appliesTo: [types.FieldTypeId.Number],
+    readParams: question => {
+        const v = question.fieldProperties.step;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => (Number.isFinite(n) && n > 0 ? null : 'Enter a positive step value.'),
+    check: (value, step) => {
+        if (!Number.isFinite(step) || step <= 0)
+            return null;
+        const n = typeof value === 'number' ? value : Number(value);
+        if (!Number.isFinite(n))
+            return null;
+        const ratio = n / step;
+        const off = Math.abs(ratio - Math.round(ratio));
+        return off > 1e-9 ? { message: message$3(step) } : null;
+    },
+    defaultMessage: message$3,
+    builder: {
+        label: 'Step (multiple of)',
+        description: 'Require the value to be a multiple of a given step.',
+        params: [
+            { key: 'value', formPath: 'fieldProperties.step', label: 'Step', type: 'number', min: 0 },
+        ],
+        defaultParams: 1,
+        enable: set => set('fieldProperties.step', 1),
+        disable: set => set('fieldProperties.step', undefined),
+    },
+};
+function message$3(step) {
+    return `Must be a multiple of ${step}`;
+}
+
+/**
+ * Value may have at most `maxDecimalPlaces` digits after the decimal point
+ * (e.g. currency = 2). Number-keyed with NaN-sentinel activation; the param
+ * itself must be a non-negative integer.
+ */
+const maxDecimalPlacesRule = {
+    ruleType: 'maxDecimalPlaces',
+    appliesTo: [types.FieldTypeId.Number],
+    readParams: question => {
+        const v = question.fieldProperties.maxDecimalPlaces;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => Number.isInteger(n) && n >= 0 ? null : 'Enter a whole number of decimal places (0 or more).',
+    check: (value, max) => {
+        if (!Number.isInteger(max) || max < 0)
+            return null;
+        const n = typeof value === 'number' ? value : Number(value);
+        if (!Number.isFinite(n))
+            return null;
+        return decimalPlaces(n) > max ? { message: message$2(max) } : null;
+    },
+    defaultMessage: message$2,
+    builder: {
+        label: 'Maximum decimal places',
+        description: 'Limit how many digits may follow the decimal point.',
+        params: [
+            {
+                key: 'value',
+                formPath: 'fieldProperties.maxDecimalPlaces',
+                label: 'Maximum decimal places',
+                type: 'number',
+                min: 0,
+            },
+        ],
+        defaultParams: 2,
+        enable: set => set('fieldProperties.maxDecimalPlaces', 2),
+        disable: set => set('fieldProperties.maxDecimalPlaces', undefined),
+    },
+};
+function decimalPlaces(n) {
+    var _a;
+    if (Number.isInteger(n))
+        return 0;
+    const s = Math.abs(n).toString();
+    const e = s.indexOf('e');
+    if (e !== -1) {
+        // Scientific notation (very small/large) — derive places from the exponent.
+        const exp = Number(s.slice(e + 1));
+        const fracDigits = ((_a = s.slice(0, e).split('.')[1]) !== null && _a !== void 0 ? _a : '').length;
+        return Math.max(0, fracDigits - exp);
+    }
+    const dot = s.indexOf('.');
+    return dot === -1 ? 0 : s.length - dot - 1;
+}
+function message$2(max) {
+    return `Must have at most ${max} decimal place${max === 1 ? '' : 's'}`;
+}
+
+/**
+ * Whole-years age from a `YYYY-MM-DD` date-of-birth string relative to `now`.
+ * Returns `null` for a malformed/empty value so age rules skip it (the date
+ * format itself isn't this rule's concern). Uses calendar parts (not Date
+ * arithmetic) to stay timezone-safe.
+ */
+function ageFromDob(value, now) {
+    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value))
+        return null;
+    const [y, m, d] = value.split('-').map(Number);
+    let age = now.getFullYear() - y;
+    const monthDelta = now.getMonth() + 1 - m;
+    if (monthDelta < 0 || (monthDelta === 0 && now.getDate() < d))
+        age--;
+    return age;
+}
+
+/**
+ * Minimum age in whole years, computed from a date-of-birth value against the
+ * injectable clock (`ctx.now()`). Number-keyed with NaN-sentinel activation.
+ * Empty-skip like the other date rules — an unanswered DOB doesn't fire; pair
+ * with Required to make the date mandatory.
+ */
+const minAgeRule = {
+    ruleType: 'minAge',
+    appliesTo: [types.FieldTypeId.DateSelector],
+    readParams: question => {
+        const v = question.fieldProperties.minAge;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => (Number.isFinite(n) && n >= 0 ? null : 'Enter a minimum age.'),
+    check: (value, min, _question, ctx) => {
+        if (!Number.isFinite(min))
+            return null;
+        const age = ageFromDob(value, ctx.now());
+        if (age == null)
+            return null;
+        return age < min ? { message: message$1(min) } : null;
+    },
+    defaultMessage: message$1,
+    builder: {
+        label: 'Minimum age',
+        description: 'Require the date of birth to be at least N years ago.',
+        params: [
+            {
+                key: 'value',
+                formPath: 'fieldProperties.minAge',
+                label: 'Minimum age (years)',
+                type: 'number',
+                min: 0,
+            },
+        ],
+        defaultParams: 18,
+        enable: set => set('fieldProperties.minAge', 18),
+        disable: set => set('fieldProperties.minAge', undefined),
+    },
+};
+function message$1(min) {
+    return `Must be at least ${min} year${min === 1 ? '' : 's'} old`;
+}
+
+/**
+ * Maximum age in whole years, computed from a date-of-birth value against the
+ * injectable clock (`ctx.now()`). Number-keyed with NaN-sentinel activation.
+ */
+const maxAgeRule = {
+    ruleType: 'maxAge',
+    appliesTo: [types.FieldTypeId.DateSelector],
+    readParams: question => {
+        const v = question.fieldProperties.maxAge;
+        if (v === undefined)
+            return null;
+        if (typeof v === 'number' && Number.isFinite(v))
+            return v;
+        if (typeof v === 'string' && v.trim() !== '') {
+            const n = Number(v);
+            if (Number.isFinite(n))
+                return n;
+        }
+        return Number.NaN;
+    },
+    validateParams: n => (Number.isFinite(n) && n >= 0 ? null : 'Enter a maximum age.'),
+    check: (value, max, _question, ctx) => {
+        if (!Number.isFinite(max))
+            return null;
+        const age = ageFromDob(value, ctx.now());
+        if (age == null)
+            return null;
+        return age > max ? { message: message(max) } : null;
+    },
+    defaultMessage: message,
+    builder: {
+        label: 'Maximum age',
+        description: 'Require the date of birth to be at most N years ago.',
+        params: [
+            {
+                key: 'value',
+                formPath: 'fieldProperties.maxAge',
+                label: 'Maximum age (years)',
+                type: 'number',
+                min: 0,
+            },
+        ],
+        defaultParams: 120,
+        enable: set => set('fieldProperties.maxAge', 120),
+        disable: set => set('fieldProperties.maxAge', undefined),
+    },
+};
+function message(max) {
+    return `Must be at most ${max} year${max === 1 ? '' : 's'} old`;
+}
+
+/**
+ * Reject values with a fractional part (whole numbers only). Boolean-keyed:
+ * active when `integerOnly === true`.
+ */
+const integerOnlyRule = {
+    ruleType: 'integerOnly',
+    appliesTo: [types.FieldTypeId.Number],
+    readParams: question => question.fieldProperties.integerOnly === true ? true : null,
+    validateParams: () => null,
+    check: value => {
+        const n = typeof value === 'number' ? value : Number(value);
+        if (!Number.isFinite(n))
+            return null;
+        return Number.isInteger(n) ? null : { message: 'Must be a whole number' };
+    },
+    defaultMessage: () => 'Must be a whole number',
+    builder: {
+        label: 'Whole numbers only',
+        description: 'Reject values with a decimal part.',
+        params: [],
+        defaultParams: true,
+        enable: set => set('fieldProperties.integerOnly', true),
+        disable: set => set('fieldProperties.integerOnly', undefined),
+    },
+};
+
+/**
+ * Mirror of `noFutureDate`: disallow dates before today. Stored as
+ * `noPastDate: true` (active when true; absent = off). Note this uses the
+ * cleaner active-when-true convention rather than `noFutureDate`'s legacy
+ * `allowFutureDate: false` — there's no legacy "past" key to stay compatible
+ * with, so the new key reads positively.
+ */
+const noPastDateRule = {
+    ruleType: 'noPastDate',
+    appliesTo: [types.FieldTypeId.DateSelector],
+    readParams: question => { var _a; return ((_a = question.fieldProperties) === null || _a === void 0 ? void 0 : _a.noPastDate) === true ? true : null; },
+    validateParams: () => null,
+    check: (value, _params, _question, ctx) => {
+        const v = typeof value === 'string' ? value : '';
+        const today = ctx.now().toISOString().slice(0, 10);
+        return v !== '' && v < today ? { message: 'Past dates are not allowed' } : null;
+    },
+    defaultMessage: () => 'Past dates are not allowed',
+    builder: {
+        label: 'Disallow past dates',
+        params: [],
+        defaultParams: true,
+        enable: set => set('fieldProperties.noPastDate', true),
+        disable: set => set('fieldProperties.noPastDate', undefined),
+    },
+};
+
+/**
+ * DateTime equivalent of `noPastDate`. Compares the date portion only (matching
+ * `noFutureDateTime`), so any time today is allowed. Stored as `noPastDate: true`
+ * (active-when-true; shares the key name with the DateSelector rule, just as
+ * `noFutureDateTime` shares `allowFutureDate`).
+ */
+const noPastDateTimeRule = {
+    ruleType: 'noPastDateTime',
+    appliesTo: [types.FieldTypeId.DateTimeSelector],
+    readParams: question => { var _a; return ((_a = question.fieldProperties) === null || _a === void 0 ? void 0 : _a.noPastDate) === true ? true : null; },
+    validateParams: () => null,
+    check: (value, _params, _question, ctx) => {
+        const v = typeof value === 'string' ? value : '';
+        const today = ctx.now().toISOString().slice(0, 10);
+        return v !== '' && v.slice(0, 10) < today ? { message: 'Past dates are not allowed' } : null;
+    },
+    defaultMessage: () => 'Past dates are not allowed',
+    builder: {
+        label: 'Disallow past dates',
+        params: [],
+        defaultParams: true,
+        enable: set => set('fieldProperties.noPastDate', true),
+        disable: set => set('fieldProperties.noPastDate', undefined),
+    },
+};
+
+/**
+ * Require a Yes/No to be set to Yes (e.g. attestation/consent). `required`
+ * alone treats a 'false' / 'na' answer as answered, so this is the rule
+ * that forces the affirmative. Boolean-keyed; runs on empty.
+ */
+const mustBeYesRule = {
+    ruleType: 'mustBeYes',
+    appliesTo: [types.FieldTypeId.YesNo],
+    runOnEmpty: true,
+    readParams: question => question.fieldProperties.mustBeYes === true ? true : null,
+    validateParams: () => null,
+    check: value => value === 'true' || value === true ? null : { message: 'This must be set to Yes' },
+    defaultMessage: () => 'This must be set to Yes',
+    builder: {
+        label: 'Must be Yes',
+        description: 'Require the answer to be Yes (e.g. consent / attestation).',
+        params: [],
+        defaultParams: true,
+        enable: set => set('fieldProperties.mustBeYes', true),
+        disable: set => set('fieldProperties.mustBeYes', undefined),
+    },
+};
+
+const BUILTIN_RULES = [
+    requiredRule,
+    minLengthRule,
+    maxLengthRule,
+    patternRule,
+    minValueRule,
+    maxValueRule,
+    minDateRule,
+    maxDateRule,
+    noFutureDateRule,
+    minTimeRule,
+    maxTimeRule,
+    minDateTimeRule,
+    maxDateTimeRule,
+    noFutureDateTimeRule,
+    minSelectionsRule,
+    maxSelectionsRule,
+    minRowsRule,
+    maxRowsRule,
+    stepRule,
+    maxDecimalPlacesRule,
+    minAgeRule,
+    maxAgeRule,
+    integerOnlyRule,
+    noPastDateRule,
+    noPastDateTimeRule,
+    mustBeYesRule,
+];
+
+function resolveAllowedOptionValues(props, ctx) {
+    if (Array.isArray(props.items) && props.items.length > 0) {
+        return new Set(props.items.map(i => String(i.value)));
+    }
+    if (typeof props.lookupId === 'string' && props.lookupId.length > 0) {
+        const resolved = ctx.resolveLookupOptions(props.lookupId);
+        return resolved ? new Set(resolved.map(String)) : null;
+    }
+    return null;
+}
+const singleChoiceMembership = {
+    ruleType: 'choice.singleMembership',
+    appliesTo: [types.FieldTypeId.RadioButton, types.FieldTypeId.DropdownSingleSelect],
+    check: (value, question, ctx) => {
+        const allowed = resolveAllowedOptionValues(question.fieldProperties, ctx);
+        if (!allowed)
+            return null;
+        return allowed.has(String(value)) ? null : { message: 'Selected option is no longer valid' };
+    },
+};
+const multiChoiceMembership = {
+    ruleType: 'choice.multiMembership',
+    appliesTo: [
+        types.FieldTypeId.Checkbox,
+        types.FieldTypeId.DropdownMultipleSelect,
+        types.FieldTypeId.ListMultiSelect,
+    ],
+    check: (value, question, ctx) => {
+        const allowed = resolveAllowedOptionValues(question.fieldProperties, ctx);
+        if (!allowed)
+            return null;
+        if (!Array.isArray(value))
+            return null;
+        for (const v of value) {
+            if (!allowed.has(String(v))) {
+                return { message: 'One or more selected options are no longer valid' };
+            }
+        }
+        return null;
+    },
+};
+const tableCellShape = {
+    ruleType: 'table.cellShape',
+    appliesTo: [types.FieldTypeId.Table],
+    check: (value, question) => {
+        var _a, _b;
+        const columns = (_a = question.fieldProperties.columns) !== null && _a !== void 0 ? _a : [];
+        const rows = Array.isArray(value === null || value === void 0 ? void 0 : value.rows) ? value.rows : [];
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            for (const col of columns) {
+                const key = (_b = col.id) !== null && _b !== void 0 ? _b : col.name;
+                if (!key)
+                    continue;
+                const cell = row === null || row === void 0 ? void 0 : row[key];
+                const empty = cell == null || (typeof cell === 'string' && cell.trim() === '');
+                if (col.required && empty) {
+                    return { message: `Row ${i + 1}: ${col.name} is required` };
+                }
+                if (col.type === 'number' && !empty) {
+                    const n = typeof cell === 'number' ? cell : Number(cell);
+                    if (!Number.isFinite(n)) {
+                        return { message: `Row ${i + 1}: ${col.name} must be a number` };
+                    }
+                }
+            }
+        }
+        return null;
+    },
+};
+/**
+ * Catalog of built-in intrinsic rules. Exported as a used array so it
+ * survives tree-shaking — see `rules/index.ts` for the same rationale.
+ */
+const BUILTIN_INTRINSIC_RULES = [
+    singleChoiceMembership,
+    multiChoiceMembership,
+    tableCellShape,
+];
+
+/**
+ * Mutable rule registry. Process-wide singleton — there's only ever one
+ * rule catalog for one validation engine.
+ *
+ * **Built-in rules auto-register on this module's first evaluation.** We do
+ * the registration here (instead of in `validation/index.ts`) so it's
+ * impossible for a bundler to bypass: any consumer that imports
+ * `getAuthorRulesFor`, `getRule`, etc. transitively loads `registry.ts`,
+ * which forces the rule-module imports below to run, which forces each
+ * rule's module-level definition to evaluate. The earlier "side-effect
+ * import in `validation/index.ts`" approach failed because Rollup traces
+ * through re-exports and bundles the leaf module only — skipping any
+ * sibling module whose exports aren't directly used by the consumer.
+ *
+ * Custom rules can still be registered at runtime by callers via
+ * `registerRule(...)` — they land alongside the built-ins.
+ */
+const authorRules = new Map();
+const intrinsicRules = [];
+/**
+ * Register an author-configurable rule. Idempotent on `ruleType`: re-registering
+ * the same ruleType replaces the previous registration (useful for tests that
+ * stub a rule, harmless in production where each rule registers exactly once).
+ */
+function registerRule(rule) {
+    authorRules.set(rule.ruleType, rule);
+}
+/**
+ * Register an intrinsic (always-on) rule. Not addressable by ruleType because
+ * intrinsic rules can't be toggled — they're a property of the field type.
+ */
+function registerIntrinsicRule(rule) {
+    intrinsicRules.push(rule);
+}
+function getRule(ruleType) {
+    return authorRules.get(ruleType);
+}
+/**
+ * Author rules applicable to a given field type. The validation tab in the
+ * builder walks this to render the row list. Order is registration order —
+ * keep it stable by registering in deterministic order in `rules/index.ts`.
+ */
+function getAuthorRulesFor(fieldTypeId) {
+    const result = [];
+    for (const rule of authorRules.values()) {
+        if (rule.appliesTo.includes(fieldTypeId))
+            result.push(rule);
+    }
+    return result;
+}
+/**
+ * Intrinsic rules applicable to a given field type. Engine walks these
+ * before author rules.
+ */
+function getIntrinsicRulesFor(fieldTypeId) {
+    return intrinsicRules.filter(r => r.appliesTo.includes(fieldTypeId));
+}
+// --- Built-in registration -------------------------------------------------
+// Must run at module-evaluation time so the registry is populated before any
+// caller queries it. The catalog modules (`./rules`, `./intrinsic`) export
+// arrays of definitions — iterating them here keeps the bundler from
+// tree-shaking the catalog files (the iteration is an unmistakable use).
+for (const rule of BUILTIN_RULES)
+    registerRule(rule);
+for (const rule of BUILTIN_INTRINSIC_RULES)
+    registerIntrinsicRule(rule);
+
+const isNumericTableColumnType = (type) => type === 'number';
+const createTableColumnUiKey = () => `table-col-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+const slugifyTableColumnName = (name) => {
+    const slug = String(name || '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return slug || 'column';
+};
+const buildUniqueTableColumnId = (order, name, usedIds) => {
+    const baseId = `${order}-${slugifyTableColumnName(name)}`;
+    let candidate = baseId;
+    let suffix = 2;
+    while (usedIds.has(candidate)) {
+        candidate = `${baseId}-${suffix}`;
+        suffix += 1;
+    }
+    usedIds.add(candidate);
+    return candidate;
+};
+/**
+ * Stamps `uiKey` and `id` on any column that's missing one, preserving
+ * existing values verbatim. Both identifiers must be stable across the
+ * column's lifetime — rows in the submission wire payload are keyed by
+ * `column.id`, so regenerating ids on reorder/rename would silently orphan
+ * existing row cells. `uiKey` already followed this pattern; `id` now
+ * matches.
+ */
+const ensureTableColumnIds = (columns) => {
+    const usedIds = new Set();
+    for (const column of columns || []) {
+        if (typeof (column === null || column === void 0 ? void 0 : column.id) === 'string' && column.id.length > 0)
+            usedIds.add(column.id);
+    }
+    return (columns || []).map((column, index) => (Object.assign(Object.assign({}, column), { uiKey: (column === null || column === void 0 ? void 0 : column.uiKey) || createTableColumnUiKey(), id: typeof (column === null || column === void 0 ? void 0 : column.id) === 'string' && column.id.length > 0
+            ? column.id
+            : buildUniqueTableColumnId(index + 1, column === null || column === void 0 ? void 0 : column.name, usedIds) })));
+};
+const createDefaultTableColumn = () => ({
+    name: 'Column 1',
+    type: 'text',
+    required: false,
+});
+// === Templates ===
+const questionTemplates = [
+    {
+        fieldTypeId: types.FieldTypeId.Hidden,
+        questionTypeName: 'Hidden',
+        icon: 'eye-off',
+        category: 'Display',
+        keywords: ['hidden', 'metadata', 'system'],
+        defaultFieldProperties: { allowComments: false, allowFollowUpForms: false, readOnly: false },
+    },
+    {
+        // New questions are born with NO validation rules. Authors opt in via
+        // the validation tab — see `core/validation/`. Storage is presence-based:
+        // setting `minCharacter` activates the minLength rule; clearing it
+        // deactivates. Old forms loaded from the wire continue to carry these
+        // keys and the corresponding rules continue to fire — back-compat is
+        // automatic because the engine reads what the data says.
+        fieldTypeId: types.FieldTypeId.SingleLineText,
+        questionTypeName: 'Single Line Text',
+        icon: 'text-font',
+        category: 'Text',
+        keywords: ['text', 'short', 'input', 'single line'],
+        defaultFieldProperties: {
+            allowComments: false,
+            allowFollowUpForms: false,
+            readOnly: false,
+        },
+    },
+    {
+        fieldTypeId: types.FieldTypeId.MultiLineText,
+        questionTypeName: 'Multi Line Text',
+        icon: 'text-paragraph',
+        category: 'Text',
+        keywords: ['text', 'long', 'textarea', 'multiline', 'paragraph'],
+        defaultFieldProperties: {
+            allowComments: false,
+            allowFollowUpForms: false,
+            readOnly: false,
+        },
+    },
+    {
+        fieldTypeId: types.FieldTypeId.Checkbox,
+        questionTypeName: 'Checkbox',
+        icon: 'checkbox-checked',
+        category: 'Choice',
+        keywords: ['checkbox', 'check', 'multi', 'options', 'list'],
+        isContainsOptionItems: true,
+        defaultFieldProperties: {
+            allowComments: false,
+            allowFollowUpForms: false,
+            items: [{ display: '', value: '' }],
+            readOnly: false,
+        },
+    },
+    {
+        fieldTypeId: types.FieldTypeId.RadioButton,
+        questionTypeName: 'Radio Button',
+        icon: 'radio-button',
+        category: 'Choice',
+        keywords: ['option', 'select', 'radio', 'single'],
+        isContainsOptionItems: true,
+        defaultFieldProperties: {
+            allowComments: false,
+            allowFollowUpForms: false,
+            items: [{ display: '', value: '' }],
+            readOnly: false,
+        },
+    },
+    {
+        fieldTypeId: types.FieldTypeId.DropdownSingleSelect,
+        questionTypeName: 'Single Select Dropdown',
+        icon: 'chevron-down',
+        category: 'Choice',
+        keywords: ['dropdown', 'select', 'single', 'pick'],
+        isContainsOptionItems: true,
+        defaultFieldProperties: {
+            allowComments: false,
+            allowFollowUpForms: false,
+            items: [{ display: '', value: '' }],
+            readOnly: false,
+        },
+    },
+    {
+        fieldTypeId: types.FieldTypeId.DropdownMultipleSelect,
+        questionTypeName: 'Multiselect Dropdown',
+        icon: 'list',
+        category: 'Choice',
+        keywords: ['dropdown', 'select', 'multiple', 'pick'],
+        isContainsOptionItems: true,
+        defaultFieldProperties: {
+            allowComments: false,
+            allowFollowUpForms: false,
+            items: [{ display: '', value: '' }],
+            readOnly: false,
+        },
+    },
+    {
+        fieldTypeId: types.FieldTypeId.ListMultiSelect,
+        questionTypeName: 'List',
+        icon: 'apps-list-detail',
+        category: 'Choice',
+        keywords: ['list', 'select', 'multiple', 'options'],
+        isContainsOptionItems: true,
+        defaultFieldProperties: {
+            allowComments: false,
+            allowFollowUpForms: false,
+            items: [{ display: '', value: '' }],
+            readOnly: false,
+        },
+    },
+    {
+        fieldTypeId: types.FieldTypeId.DateSelector,
+        questionTypeName: 'Date Selector',
+        icon: 'calendar',
+        category: 'Date & Time',
+        keywords: ['date', 'calendar', 'day'],
+        defaultFieldProperties: {
+            allowComments: false,
+            allowFollowUpForms: false,
+            readOnly: false,
+        },
+    },
+    {
+        fieldTypeId: types.FieldTypeId.TimeSelector,
+        questionTypeName: 'Time Selector',
+        icon: 'clock',
+        category: 'Date & Time',
+        keywords: ['time', 'clock', 'hour'],
+        defaultFieldProperties: {
+            allowComments: false,
+            allowFollowUpForms: false,
+            readOnly: false,
+        },
+    },
+    {
+        fieldTypeId: types.FieldTypeId.DateTimeSelector,
+        questionTypeName: 'DateTime Selector',
+        icon: 'calendar-clock',
+        category: 'Date & Time',
+        keywords: ['date', 'time', 'datetime', 'calendar'],
+        defaultFieldProperties: {
+            allowComments: false,
+            allowFollowUpForms: false,
+            readOnly: false,
+        },
+    },
+    {
+        fieldTypeId: types.FieldTypeId.FileUpload,
+        questionTypeName: 'File Upload',
+        icon: 'cloud-upload',
+        category: 'File & Signature',
+        keywords: ['file', 'upload', 'attachment', 'document'],
+        defaultFieldProperties: {
+            allowComments: false,
+            allowFollowUpForms: false,
+            displayUploadTime: false,
+            hideDragAndDrop: false,
+            hideButton: false,
+            readOnly: false,
+            allowMultiple: false,
+        },
+    },
+    {
+        fieldTypeId: types.FieldTypeId.YesNo,
+        questionTypeName: 'Yes/No',
+        icon: 'checkmark',
+        category: 'Choice',
+        keywords: ['yes', 'no', 'boolean', 'toggle', 'binary'],
+        defaultFieldProperties: { allowComments: false, allowFollowUpForms: false, readOnly: false },
+    },
+    {
+        fieldTypeId: types.FieldTypeId.Signature,
+        questionTypeName: 'Signature',
+        icon: 'document',
+        category: 'File & Signature',
+        keywords: ['signature', 'sign', 'capture'],
+        defaultFieldProperties: {
+            allowComments: false,
+            allowFollowUpForms: false,
+            includeLocation: false,
+            readOnly: false,
+        },
+    },
+    {
+        fieldTypeId: types.FieldTypeId.Tally,
+        questionTypeName: 'Tally Display',
+        icon: 'apps-list',
+        category: 'Display',
+        keywords: ['tally', 'count', 'display', 'read-only', 'number'],
+        defaultFieldProperties: {
+            allowComments: false,
+            allowFollowUpForms: false,
+            ignoreRequiredConfig: true,
+            readOnly: false,
+            tallyMode: 'all',
+            includeFields: [],
+            excludeFields: [],
+        },
+    },
+    {
+        fieldTypeId: types.FieldTypeId.Number,
+        questionTypeName: 'Numeric',
+        icon: 'number',
+        category: 'Text',
+        keywords: ['number', 'numeric', 'integer', 'quantity'],
+        defaultFieldProperties: { allowComments: false, allowFollowUpForms: false, readOnly: false },
+    },
+    {
+        fieldTypeId: types.FieldTypeId.Paragraph,
+        questionTypeName: 'Paragraph',
+        icon: 'text-paragraph',
+        category: 'Text',
+        keywords: ['paragraph', 'static', 'display', 'content', 'richtext'],
+        defaultFieldProperties: { paragraphText: '' },
+        questionTextOptional: true,
+    },
+    {
+        fieldTypeId: types.FieldTypeId.ImageUpload,
+        questionTypeName: 'Image Upload',
+        icon: 'cloud-upload',
+        category: 'File & Signature',
+        keywords: ['image', 'photo', 'picture', 'upload'],
+        defaultFieldProperties: {
+            hideDragAndDrop: false,
+            allowComments: false,
+            allowFollowUpForms: false,
+            displayUploadTime: false,
+            hideButton: false,
+            readOnly: false,
+            allowMultiple: false,
+        },
+    },
+    {
+        fieldTypeId: types.FieldTypeId.FormMetadataDisplay,
+        questionTypeName: 'Form Metadata Display',
+        icon: 'person',
+        category: 'Display',
+        keywords: ['metadata', 'submitter', 'owner', 'submission date', 'display'],
+        defaultFieldProperties: {
+            displayOwnerFullName: true,
+            displayOwnerEmail: true,
+            displaySubmissionDate: true,
+            allowComments: false,
+            allowFollowUpForms: false,
+            readOnly: false,
+        },
+    },
+    {
+        fieldTypeId: types.FieldTypeId.Location,
+        questionTypeName: 'Location',
+        icon: 'location',
+        category: 'Location',
+        keywords: ['address', 'location', 'map', 'geolocation', 'place'],
+        defaultFieldProperties: { readOnly: false },
+    },
+    {
+        fieldTypeId: types.FieldTypeId.Table,
+        questionTypeName: 'Table',
+        icon: 'table',
+        category: 'Display',
+        keywords: ['table', 'columns', 'grid', 'rows', 'data'],
+        defaultFieldProperties: {
+            allowComments: false,
+            allowFollowUpForms: false,
+            readOnly: false,
+            columns: ensureTableColumnIds([createDefaultTableColumn()]),
+        },
+    },
+];
+
+const formItemTypes = questionTemplates;
+function getType(fieldTypeId) {
+    return formItemTypes.find(q => q.fieldTypeId === fieldTypeId);
+}
+
+/**
+ * Validates the manual options of a choice question. Returns a human-readable
+ * problem, or `null` when the options are well-formed. Shared by the form-save
+ * validator (`validateQuestionItem`) and the builder's List Options inline
+ * feedback so both surfaces agree on the rules. An empty array is treated as
+ * valid here — the "needs at least one option, or a lookup source" check is
+ * the caller's concern (it has the lookup context).
+ */
+function validateChoiceItems(items) {
+    var _a;
+    if (items.some(item => { var _a, _b; return !((_a = item.display) === null || _a === void 0 ? void 0 : _a.trim()) || !((_b = item.value) === null || _b === void 0 ? void 0 : _b.trim()); })) {
+        return 'Every option needs both a display label and a value.';
+    }
+    const seen = new Set();
+    for (const item of items) {
+        const value = ((_a = item.value) !== null && _a !== void 0 ? _a : '').trim();
+        if (seen.has(value)) {
+            return 'Each option must have a unique value.';
+        }
+        seen.add(value);
+    }
+    return null;
+}
+/**
+ * Validates form metadata (e.g. form name required). Pure function.
+ */
+function validateFormMetadata(form) {
+    var _a;
+    if (!((_a = form.name) === null || _a === void 0 ? void 0 : _a.trim())) {
+        return { valid: false, firstError: 'Please enter a form name.' };
+    }
+    return { valid: true };
+}
+/**
+ * Validates that there is at least one section and each section has at least one question.
+ */
+function validateFormSections(sections) {
+    var _a;
+    if (sections.length < 1) {
+        return { valid: false, firstError: 'Please add at least one section to the form.' };
+    }
+    for (let sIndex = 0; sIndex < sections.length; sIndex++) {
+        const section = sections[sIndex];
+        if (((_a = section === null || section === void 0 ? void 0 : section.questions) !== null && _a !== void 0 ? _a : []).length < 1) {
+            const sectionTitle = (section === null || section === void 0 ? void 0 : section.title) ? `"${section.title}"` : `#${sIndex + 1}`;
+            return {
+                valid: false,
+                firstError: `Section ${sectionTitle} must contain at least one question.`,
+            };
+        }
+    }
+    return { valid: true };
+}
+/**
+ * Validates a single question against its item type definition. Returns a
+ * human-readable reason on failure, or `null` if the question is valid.
+ *
+ * Callers that just need a yes/no — e.g. the per-question badge in
+ * `section-card.tsx` — should compare against `null` themselves
+ * (`validateQuestionItem(q, getType) === null`). Surfacing a specific reason
+ * is the whole point of the refactor; never collapse the message at a
+ * lower layer.
+ */
+function validateQuestionItem(question, getItemType) {
+    var _a, _b;
+    const template = getItemType(question.fieldTypeId);
+    const requiresQuestionText = !(template && template.questionTextOptional);
+    if (requiresQuestionText && !((_a = question.questionText) === null || _a === void 0 ? void 0 : _a.trim())) {
+        return 'Question text is required.';
+    }
+    if (template === null || template === void 0 ? void 0 : template.isContainsOptionItems) {
+        const fp = ((_b = question.fieldProperties) !== null && _b !== void 0 ? _b : {});
+        if (!fp.lookupId) {
+            if (!Array.isArray(fp.items) || fp.items.length === 0) {
+                return 'This choice question needs at least one option, or a lookup source.';
+            }
+            const itemError = validateChoiceItems(fp.items);
+            if (itemError)
+                return itemError;
+        }
+    }
+    if (template === null || template === void 0 ? void 0 : template.validate) {
+        const message = template.validate(question);
+        if (message)
+            return message;
+    }
+    return null;
+}
+/**
+ * Validates all questions across all sections. The first failing question's
+ * reason is bubbled up with its section + question coordinates so the save
+ * snackbar can point the author at exactly what to fix.
+ */
+function validateAllQuestions(sections, getItemType) {
+    var _a, _b, _c;
+    for (let s = 0; s < sections.length; s++) {
+        const section = sections[s];
+        const questions = (_a = section.questions) !== null && _a !== void 0 ? _a : [];
+        for (let q = 0; q < questions.length; q++) {
+            const question = questions[q];
+            const reason = validateQuestionItem(question, getItemType);
+            if (reason) {
+                const sectionLabel = ((_b = section.title) === null || _b === void 0 ? void 0 : _b.trim()) ? `"${section.title}"` : `#${s + 1}`;
+                const questionLabel = ((_c = question.questionText) === null || _c === void 0 ? void 0 : _c.trim())
+                    ? `"${question.questionText}"`
+                    : `#${q + 1}`;
+                return {
+                    valid: false,
+                    firstError: `Section ${sectionLabel}, question ${questionLabel}: ${reason}`,
+                };
+            }
+        }
+    }
+    return { valid: true };
+}
+/**
+ * Runs full form validation (metadata, sections, all questions).
+ */
+function validateForm(form, sections, getItemType) {
+    const meta = validateFormMetadata(form);
+    if (!meta.valid)
+        return meta;
+    const structure = validateFormSections(sections);
+    if (!structure.valid)
+        return structure;
+    return validateAllQuestions(sections, getItemType);
+}
+
+/**
+ * Shared follow-up-forms fetch used by both the builder (per-question allowlist
+ * picker) and the renderer (per-question launch dialog). Lives at the form
+ * root so neither side has to depend on the other's internals.
+ */
+/**
+ * Maximum follow-up forms to surface in the picker. Tenants with more than
+ * this are an edge case we'll handle with search/typeahead if it materializes.
+ */
+const FOLLOW_UP_FORM_LIST_LIMIT = 200;
+function extractFollowUpFormItems(raw) {
+    if (Array.isArray(raw))
+        return raw;
+    if (raw && typeof raw === 'object') {
+        // The /search endpoint's body is `{ pageList, total }` — `makeApiCall`
+        // already unwraps axios's `response.data`, so `pageList` sits at the top
+        // level here (the legacy renderer reads `response.data.pageList` for the
+        // same reason). Check that first.
+        if ('pageList' in raw && Array.isArray(raw.pageList)) {
+            return raw.pageList;
+        }
+        if ('data' in raw) {
+            const data = raw.data;
+            if (Array.isArray(data))
+                return data;
+            if (data && typeof data === 'object' && 'pageList' in data) {
+                const pageList = data.pageList;
+                if (Array.isArray(pageList))
+                    return pageList;
+            }
+        }
+    }
+    return [];
+}
+/**
+ * Fetch the list of forms tagged `type: FollowUp`. Returns `{ value: formId,
+ * label: formName }`. Returns `[]` on failure (non-blocking — the picker
+ * just shows "no follow-up forms available").
+ *
+ * Backend filter shape matches the legacy renderer's side-sheet fetch
+ * (`searchField: 'type', searchValue: FormType.FollowUp`). Hits the
+ * latest-version view so each form id appears once at its newest version.
+ */
+async function fetchFollowUpFormsList() {
+    try {
+        const tenantId = tenantUtils.getCurrentTenantId();
+        const response = await makeApiCall.makeApiCall('POST', `${configService.ConfigService.productV1ApiUrl}/UdpFormLatestVersionView/search`, {
+            eagerLoad: false,
+            pageNumber: 1,
+            pageSize: FOLLOW_UP_FORM_LIST_LIMIT,
+            filterElements: [
+                { searchField: 'type', searchOperator: '=', searchValue: types.FormType.FollowUp },
+                { searchField: 'tenantId', searchOperator: '=', searchValue: tenantId },
+            ],
+            orderElements: [{ sortColumn: 'name', sortDirection: 'ASC' }],
+        });
+        return extractFollowUpFormItems(response)
+            .filter((item) => typeof (item === null || item === void 0 ? void 0 : item.id) === 'string' && item.id.length > 0)
+            .map(item => {
+            var _a;
+            return ({
+                value: item.id,
+                label: ((_a = item.name) === null || _a === void 0 ? void 0 : _a.trim()) || '(untitled form)',
+            });
+        });
+    }
+    catch (_a) {
+        return [];
+    }
+}
+
+/** Type guard for the runtime-tagged `driveFileId` on a placeholder signature File. */
+function getDriveFileId(file) {
+    if (!(file instanceof File))
+        return null;
+    const id = file.driveFileId;
+    return typeof id === 'string' && id.length > 0 ? id : null;
+}
+exports.SubmissionStatus = void 0;
+(function (SubmissionStatus) {
+    SubmissionStatus[SubmissionStatus["InProgress"] = 1] = "InProgress";
+    SubmissionStatus[SubmissionStatus["Submitted"] = 2] = "Submitted";
+    SubmissionStatus[SubmissionStatus["Created"] = 3] = "Created";
+})(exports.SubmissionStatus || (exports.SubmissionStatus = {}));
+
+/** Display-only types — no user input, no codec needed. Decoded value is always null. */
+const noopCodec = {
+    decode: () => null,
+    encode: () => '',
+};
+const stringCodec = {
+    decode: wire => (wire == null || wire === '' ? null : wire),
+    encode: value => value !== null && value !== void 0 ? value : '',
+};
+const numberCodec = {
+    decode: wire => {
+        if (wire == null || wire === '')
+            return null;
+        const n = Number(wire);
+        return Number.isFinite(n) ? n : null;
+    },
+    encode: value => (value == null ? '' : String(value)),
+};
+const yesNoCodec = {
+    decode: wire => wire === 'true' || wire === 'false' || wire === 'na' ? wire : null,
+    encode: value => {
+        if (value == null)
+            return '';
+        if (typeof value === 'boolean')
+            return value ? 'true' : 'false';
+        return value === 'true' || value === 'false' || value === 'na' ? value : '';
+    },
+};
+/**
+ * Multi-select encoding observed in legacy submissions stores a single selection as the bare
+ * value string (e.g. `"one"`). The encoding for *multiple* selections is unverified — likely
+ * CSV. Decoder splits on `,` and trims; encoder joins with `,`. Revisit once we have a real
+ * multi-selection submission to confirm.
+ *
+ * TODO: verify against a real multi-selection submission.
+ */
+const multiSelectCodec = {
+    decode: wire => {
+        if (wire == null || wire === '')
+            return null;
+        return wire.split(',').map(s => s.trim()).filter(s => s.length > 0);
+    },
+    encode: value => (value == null || value.length === 0 ? '' : value.join(',')),
+};
+const locationCodec = {
+    decode: wire => {
+        var _a, _b, _c, _d;
+        if (wire == null || wire === '')
+            return null;
+        let parsed;
+        try {
+            parsed = JSON.parse(wire);
+        }
+        catch (_e) {
+            return null;
+        }
+        const freeform = (_a = parsed.address) !== null && _a !== void 0 ? _a : '';
+        const hasAddress = freeform.length > 0 ||
+            parsed.streetNumber != null ||
+            parsed.streetName != null ||
+            parsed.municipality != null ||
+            parsed.countrySubdivisionName != null ||
+            parsed.postalCode != null ||
+            parsed.country != null;
+        const address = hasAddress
+            ? {
+                freeformAddress: freeform,
+                streetNumber: parsed.streetNumber,
+                streetName: parsed.streetName,
+                municipality: parsed.municipality,
+                countrySubdivisionName: parsed.countrySubdivisionName,
+                postalCode: parsed.postalCode,
+                country: parsed.country,
+            }
+            : null;
+        return {
+            latitude: (_b = parsed.latitude) !== null && _b !== void 0 ? _b : null,
+            longitude: (_c = parsed.longitude) !== null && _c !== void 0 ? _c : null,
+            address,
+            timestamp: (_d = parsed.timestamp) !== null && _d !== void 0 ? _d : null,
+        };
+    },
+    encode: value => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        if (value == null)
+            return '';
+        if (value.latitude == null && value.longitude == null && !value.address)
+            return '';
+        const wire = {
+            latitude: (_a = value.latitude) !== null && _a !== void 0 ? _a : null,
+            longitude: (_b = value.longitude) !== null && _b !== void 0 ? _b : null,
+            address: (_d = (_c = value.address) === null || _c === void 0 ? void 0 : _c.freeformAddress) !== null && _d !== void 0 ? _d : null,
+            streetNumber: (_e = value.address) === null || _e === void 0 ? void 0 : _e.streetNumber,
+            streetName: (_f = value.address) === null || _f === void 0 ? void 0 : _f.streetName,
+            municipality: (_g = value.address) === null || _g === void 0 ? void 0 : _g.municipality,
+            countrySubdivisionName: (_h = value.address) === null || _h === void 0 ? void 0 : _h.countrySubdivisionName,
+            postalCode: (_j = value.address) === null || _j === void 0 ? void 0 : _j.postalCode,
+            country: (_k = value.address) === null || _k === void 0 ? void 0 : _k.country,
+            timestamp: (_l = value.timestamp) !== null && _l !== void 0 ? _l : null,
+        };
+        return JSON.stringify(wire);
+    },
+};
+/**
+ * File / image upload wire format (matches legacy renderer):
+ *   - Comma-joined list of tokens
+ *   - Each token is `<urlencoded-filename>|udp:<driveFileId>` for an already-
+ *     stored file, or a bare `<urlencoded-filename>` for a pending upload (the
+ *     server rewrites bare names to `|udp:<id>` form during the multipart
+ *     POST/PUT and persists the rewritten value).
+ *   - Legacy also produces `|b64:<data>` for inline-base64 fallbacks; pass-1
+ *     decodes those as stored items without bytes (the user has to re-upload
+ *     if they want to keep the file). Out of scope to round-trip b64 inline.
+ *
+ * The actual `File` bytes for a pending upload are stored on the
+ * `UdpFileItem.file` field and extracted from the form-engine values map by
+ * `extractFilesFromValues()` (called by the wire adapter) — they never travel
+ * through the codec's string-only encode/decode.
+ */
+const fileListCodec = {
+    decode: wire => {
+        if (wire == null || wire === '')
+            return null;
+        const tokens = wire.split(',').map(t => t.trim()).filter(t => t.length > 0);
+        if (tokens.length === 0)
+            return null;
+        const items = [];
+        for (const token of tokens) {
+            const item = parseFileToken(token);
+            if (item)
+                items.push(item);
+        }
+        return items.length > 0 ? items : null;
+    },
+    encode: value => {
+        if (value == null || value.length === 0)
+            return '';
+        return value
+            .map(item => {
+            if (item.kind === 'pending')
+                return encodeURIComponent(item.file.name);
+            return `${encodeURIComponent(item.name)}|udp:${item.driveFileId}`;
+        })
+            .join(',');
+    },
+};
+function parseFileToken(token) {
+    const pipeIdx = token.indexOf('|');
+    if (pipeIdx < 0) {
+        // Bare filename — shouldn't appear on load (server rewrites), but tolerate.
+        let name = token;
+        try {
+            name = decodeURIComponent(token);
+        }
+        catch (_a) {
+            /* fall through with raw token */
+        }
+        return { kind: 'stored', name, driveFileId: '' };
+    }
+    const encodedName = token.slice(0, pipeIdx);
+    const dataRef = token.slice(pipeIdx + 1);
+    let name = encodedName;
+    try {
+        name = decodeURIComponent(encodedName);
+    }
+    catch (_b) {
+        name = encodedName;
+    }
+    if (dataRef.startsWith('udp:')) {
+        return { kind: 'stored', name, driveFileId: dataRef.slice(4) };
+    }
+    if (dataRef.startsWith('b64:')) {
+        // Pass-1: surface as a stored placeholder with no driveFileId. Round-trip
+        // is best-effort; a re-save will drop the inline bytes.
+        return { kind: 'stored', name, driveFileId: '' };
+    }
+    return null;
+}
+/**
+ * Signature wire format: single file token (`<filename>|udp:<guid>` or bare
+ * `<filename>`). `fullName` + lat/lng/timestamp live in `metadata.signature`,
+ * not in the value string — they're merged onto the decoded value by
+ * `hydrateValueWithMetadata()`.
+ *
+ * Stored signatures decode to a placeholder `File` tagged with `driveFileId`
+ * (legacy convention). This keeps round-trip data inside the standard
+ * `SignatureValue` shape so it survives the component's `valueChanged` emits,
+ * which reconstruct the value via object spread of known keys only — a sidecar
+ * field on `SignatureValue` would be dropped the first time the user edited
+ * `fullName` without re-drawing.
+ */
+const signatureCodec = {
+    decode: wire => {
+        if (wire == null || wire === '')
+            return null;
+        const placeholder = buildSignaturePlaceholderFile(wire);
+        return {
+            file: placeholder,
+            fullName: null,
+            metadata: null,
+        };
+    },
+    encode: value => {
+        if (value == null)
+            return '';
+        if (!(value.file instanceof File))
+            return '';
+        const driveFileId = getDriveFileId(value.file);
+        if (driveFileId) {
+            // Untouched stored signature — round-trip the existing wire token.
+            return `${encodeURIComponent(value.file.name)}|udp:${driveFileId}`;
+        }
+        // Freshly-drawn (or replaced) signature — bare filename; server rewrites
+        // to `|udp:<id>` after upload via `FormFiles`.
+        return encodeURIComponent(value.file.name);
+    },
+};
+function buildSignaturePlaceholderFile(wire) {
+    const pipeIdx = wire.indexOf('|');
+    let encodedName = wire;
+    let driveFileId = '';
+    if (pipeIdx >= 0) {
+        encodedName = wire.slice(0, pipeIdx);
+        const dataRef = wire.slice(pipeIdx + 1);
+        if (dataRef.startsWith('udp:'))
+            driveFileId = dataRef.slice(4);
+    }
+    let name = encodedName;
+    try {
+        name = decodeURIComponent(encodedName);
+    }
+    catch (_a) {
+        name = encodedName;
+    }
+    const blob = new Blob([''], { type: 'image/png' });
+    const file = new File([blob], name, { type: 'image/png' });
+    if (driveFileId)
+        file.driveFileId = driveFileId;
+    return file;
+}
+const tableCodec = {
+    decode: wire => {
+        var _a;
+        if (wire == null || wire === '')
+            return { rows: [] };
+        let parsed;
+        try {
+            parsed = JSON.parse(wire);
+        }
+        catch (_b) {
+            return { rows: [] };
+        }
+        const raw = (_a = parsed === null || parsed === void 0 ? void 0 : parsed.rows) !== null && _a !== void 0 ? _a : parsed === null || parsed === void 0 ? void 0 : parsed.Rows;
+        if (!Array.isArray(raw))
+            return { rows: [] };
+        const rows = raw.filter((r) => r != null && typeof r === 'object' && !Array.isArray(r));
+        return { rows };
+    },
+    encode: value => {
+        if (!value || !Array.isArray(value.rows) || value.rows.length === 0)
+            return '';
+        return JSON.stringify({ rows: value.rows });
+    },
+};
+/**
+ * Pass-1 codec map. Only types we render in pass 1 + the display-only types that round-trip
+ * empty values.
+ */
+const codecsByFieldType = {
+    // Hidden — not rendered, but legacy submissions carry real values here
+    // (URL-seeded context, API-written data). String passthrough keeps the
+    // stored value flowing decode → form values → encode so a re-save never
+    // wipes it, and `?udpf_seed_…` params can seed hidden fields (legacy parity).
+    [types.FieldTypeId.Hidden]: stringCodec,
+    // Display-only types — round-trip null/empty. (Paragraph's wire value is
+    // written from `fieldProperties.paragraphText` by the serializer so legacy
+    // renderers, which display the stored VALUE, keep showing the prose.)
+    [types.FieldTypeId.Paragraph]: noopCodec,
+    [types.FieldTypeId.Tally]: noopCodec,
+    [types.FieldTypeId.FormMetadataDisplay]: noopCodec,
+    // Text input
+    [types.FieldTypeId.SingleLineText]: stringCodec,
+    [types.FieldTypeId.MultiLineText]: stringCodec,
+    // Single-value choice
+    [types.FieldTypeId.RadioButton]: stringCodec,
+    [types.FieldTypeId.DropdownSingleSelect]: stringCodec,
+    // Tri-state yes/no ('true' | 'false' | 'na') — legacy radio semantics.
+    [types.FieldTypeId.YesNo]: yesNoCodec,
+    // Multi-value choice — CSV of selected option values (legacy
+    // `selectable-list` joined selections with ','). Checkbox is the legacy
+    // multi-select checkbox list, NOT a single boolean.
+    [types.FieldTypeId.Checkbox]: multiSelectCodec,
+    [types.FieldTypeId.DropdownMultipleSelect]: multiSelectCodec,
+    [types.FieldTypeId.ListMultiSelect]: multiSelectCodec,
+    // Number
+    [types.FieldTypeId.Number]: numberCodec,
+    // Date / time — wire format from submissions:
+    //   DateSelector:     "YYYY-MM-DD"
+    //   TimeSelector:     "HH:mm"           (no seconds, despite field-properties min/max using HH:mm:ss)
+    //   DateTimeSelector: "YYYY-MM-DDTHH:mm" (T separator, no seconds)
+    // Pass-through for now; field renderers parse to Date/etc. as needed.
+    [types.FieldTypeId.DateSelector]: stringCodec,
+    [types.FieldTypeId.TimeSelector]: stringCodec,
+    [types.FieldTypeId.DateTimeSelector]: stringCodec,
+    // Location — JSON-stringified object (see locationCodec docs above).
+    [types.FieldTypeId.Location]: locationCodec,
+    // File / image upload — comma-joined `<filename>|udp:<guid>` tokens.
+    // Pending File bytes are extracted from the form-engine values by the wire
+    // adapter; the codec only handles the string-side of the wire shape.
+    [types.FieldTypeId.FileUpload]: fileListCodec,
+    [types.FieldTypeId.ImageUpload]: fileListCodec,
+    // Signature — single file token + `metadata.signature` sidecar.
+    [types.FieldTypeId.Signature]: signatureCodec,
+    // Table — JSON-stringified `{ rows: TableRow[] }`, keyed by column id.
+    [types.FieldTypeId.Table]: tableCodec,
+};
+/** Decode a wire value using the codec for `fieldTypeId`. Falls back to null for unmapped types. */
+function decodeValue(fieldTypeId, wire) {
+    const codec = codecsByFieldType[fieldTypeId];
+    if (!codec)
+        return null;
+    return codec.decode(wire);
+}
+/** Encode a decoded value using the codec for `fieldTypeId`. Falls back to '' for unmapped types. */
+function encodeValue(fieldTypeId, value) {
+    const codec = codecsByFieldType[fieldTypeId];
+    if (!codec)
+        return '';
+    return codec.encode(value);
+}
+/** Whether a field type is rendered in pass 1. Useful for the field-dispatch fallback. */
+function isPassOneFieldType(fieldTypeId) {
+    return codecsByFieldType[fieldTypeId] !== undefined;
+}
+/**
+ * Merge metadata-sidecar fields onto the decoded value for types where the
+ * "value" string alone isn't the full user-visible state. Today only
+ * `Signature` needs this — `metadata.signature` carries `fullName` and the
+ * lat/lng/timestamp captured at stroke-end. Returns the value untouched for
+ * every other type.
+ */
+function hydrateValueWithMetadata(fieldTypeId, decoded, metadata) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (fieldTypeId !== types.FieldTypeId.Signature)
+        return decoded;
+    const sig = (_a = metadata === null || metadata === void 0 ? void 0 : metadata.signature) !== null && _a !== void 0 ? _a : null;
+    const baseValue = (decoded !== null && decoded !== void 0 ? decoded : null);
+    if (!sig && !baseValue)
+        return null;
+    const next = {
+        file: (_b = baseValue === null || baseValue === void 0 ? void 0 : baseValue.file) !== null && _b !== void 0 ? _b : null,
+        fullName: (_d = (_c = sig === null || sig === void 0 ? void 0 : sig.fullName) !== null && _c !== void 0 ? _c : baseValue === null || baseValue === void 0 ? void 0 : baseValue.fullName) !== null && _d !== void 0 ? _d : null,
+        metadata: sig != null
+            ? {
+                timestamp: (_e = sig.timestamp) !== null && _e !== void 0 ? _e : null,
+                latitude: (_f = sig.latitude) !== null && _f !== void 0 ? _f : null,
+                longitude: (_g = sig.longitude) !== null && _g !== void 0 ? _g : null,
+            }
+            : (_h = baseValue === null || baseValue === void 0 ? void 0 : baseValue.metadata) !== null && _h !== void 0 ? _h : null,
+    };
+    return next;
+}
+/**
+ * Walk a per-question-instance iterator and the values map to collect every
+ * `File` that needs to be uploaded with this submission. The wire adapter
+ * appends these under the `FormFiles` multipart field. The backend then
+ * matches them up with the bare-filename tokens in the JSON `Data` payload
+ * and rewrites those tokens to `<filename>|udp:<guid>` after persisting to
+ * UDP Drive.
+ *
+ * Iterating `(fieldTypeId, value)` pairs (instead of walking a `LoadedForm`
+ * directly) keeps this codec-layer helper free of the runtime expansion
+ * concern — the caller picks: walk the schema for a non-repeatable form,
+ * or walk `DynamicSection[]` so file uploads on copies 2+ of a repeatable
+ * section get collected too.
+ */
+function extractFilesFromValueEntries(entries) {
+    const files = [];
+    for (const { fieldTypeId, value } of entries) {
+        switch (fieldTypeId) {
+            case types.FieldTypeId.FileUpload:
+            case types.FieldTypeId.ImageUpload: {
+                if (!Array.isArray(value))
+                    break;
+                for (const item of value) {
+                    if ((item === null || item === void 0 ? void 0 : item.kind) === 'pending' && item.file instanceof File) {
+                        files.push(item.file);
+                    }
+                }
+                break;
+            }
+            case types.FieldTypeId.Signature: {
+                const sv = value;
+                // Stored signatures carry a placeholder File tagged with driveFileId
+                // — don't re-upload it. Only push when this is a freshly-drawn (or
+                // replaced) signature.
+                if ((sv === null || sv === void 0 ? void 0 : sv.file) instanceof File && getDriveFileId(sv.file) == null) {
+                    files.push(sv.file);
+                }
+                break;
+            }
+        }
+    }
+    return files;
+}
+/**
+ * Schema-aware convenience wrapper used by the submit flow. Walks the
+ * schema, reads each question's value out of the flat values map by the
+ * bare `question.id`, and delegates to `extractFilesFromValueEntries`.
+ *
+ * For non-repeatable forms this is the right walk. For repeatable forms
+ * the caller should iterate `DynamicSection[]` itself and pass the
+ * `(fieldTypeId, value)` pairs into `extractFilesFromValueEntries` — see
+ * `submit.ts`.
+ */
+function extractFilesFromValues(loadedForm, values) {
+    const entries = [];
+    for (const section of loadedForm.sections) {
+        for (const question of section.questions) {
+            entries.push({ fieldTypeId: question.fieldTypeId, value: values[question.id] });
+        }
+    }
+    return extractFilesFromValueEntries(entries);
+}
+/**
+ * Produce the metadata blob to write into the envelope for a given question.
+ * For `Signature`, derives `metadata.signature` from the decoded value
+ * (fullName + lat/lng/timestamp); for every other type, passes through the
+ * existing metadata untouched. Returns `undefined` when nothing should be
+ * written.
+ */
+function buildResponseMetadata(fieldTypeId, decodedValue, existingMetadata) {
+    var _a, _b, _c, _d, _e;
+    if (fieldTypeId !== types.FieldTypeId.Signature)
+        return existingMetadata;
+    const sv = decodedValue;
+    const hasFile = (sv === null || sv === void 0 ? void 0 : sv.file) instanceof File;
+    const fullName = (_a = sv === null || sv === void 0 ? void 0 : sv.fullName) !== null && _a !== void 0 ? _a : null;
+    const meta = (_b = sv === null || sv === void 0 ? void 0 : sv.metadata) !== null && _b !== void 0 ? _b : null;
+    const hasAny = hasFile || (fullName != null && fullName !== '') || meta != null;
+    if (!hasAny)
+        return existingMetadata;
+    const base = existingMetadata != null && typeof existingMetadata === 'object'
+        ? existingMetadata
+        : {};
+    return Object.assign(Object.assign({}, base), { signature: {
+            latitude: (_c = meta === null || meta === void 0 ? void 0 : meta.latitude) !== null && _c !== void 0 ? _c : null,
+            longitude: (_d = meta === null || meta === void 0 ? void 0 : meta.longitude) !== null && _d !== void 0 ? _d : null,
+            timestamp: (_e = meta === null || meta === void 0 ? void 0 : meta.timestamp) !== null && _e !== void 0 ? _e : null,
+            fullName,
+        } });
+}
+
+exports.buildResponseMetadata = buildResponseMetadata;
+exports.createDefaultTableColumn = createDefaultTableColumn;
+exports.decodeValue = decodeValue;
+exports.encodeValue = encodeValue;
+exports.ensureTableColumnIds = ensureTableColumnIds;
+exports.extractFilesFromValueEntries = extractFilesFromValueEntries;
+exports.extractFilesFromValues = extractFilesFromValues;
+exports.fetchFollowUpFormsList = fetchFollowUpFormsList;
+exports.formItemTypes = formItemTypes;
+exports.getAuthorRulesFor = getAuthorRulesFor;
+exports.getDriveFileId = getDriveFileId;
+exports.getIntrinsicRulesFor = getIntrinsicRulesFor;
+exports.getRule = getRule;
+exports.getType = getType;
+exports.hydrateValueWithMetadata = hydrateValueWithMetadata;
+exports.isNumericTableColumnType = isNumericTableColumnType;
+exports.isPassOneFieldType = isPassOneFieldType;
+exports.isValueEmpty = isValueEmpty;
+exports.parseForm = parseForm;
+exports.validateChoiceItems = validateChoiceItems;
+exports.validateForm = validateForm;
+exports.validateQuestionItem = validateQuestionItem;