@jini-ai/admin 0.4.12 → 0.4.13

package/dist/forms/adapters/memory.js

@@ -1,21 +1,38 @@
 import { AdminApiError } from '../../core/transport/errors.js';
+// The contract excludes slug; runtime callers cannot smuggle it through a cast either.
+const PATCHABLE_KEYS = ['name', 'fields', 'notify', 'status', 'mode', 'html'];
+/** The allowlisted patch keys the caller actually supplied (an explicit `undefined` is not a value). */
+function suppliedPatch(patch) {
+    return Object.fromEntries(PATCHABLE_KEYS.filter(key => patch[key] !== undefined).map(key => [key, patch[key]]));
+}
+/** The core contract's add/edit-only invariant: a fields replacement must keep every current id. */
+function assertNoFieldRemoved({ current, patch }) {
+    if (!patch.fields)
+        return;
+    const incomingIds = new Set(patch.fields.map(field => field.id));
+    if (current.fields.some(field => !incomingIds.has(field.id))) {
+        throw new AdminApiError({ message: 'existing form fields cannot be removed', status: 400 }, { code: 'FORMS_FIELD_VALIDATION_ERROR' });
+    }
+}
 /** A scoped, deterministic in-memory API with the core contract's add/edit-only invariant. */
 export function createMemoryFormsApi(_required = {}, { forms = [], submissions = [], now = () => new Date(0).toISOString(), nextId } = {}) {
     const definitions = structuredClone([...forms]);
     const answers = structuredClone([...submissions]);
     let sequence = definitions.length;
-    const missing = (id) => { throw new AdminApiError({ message: `form definition '${id}' was not found`, status: 404 }); };
+    const missing = (id, { kind = 'form definition' } = {}) => {
+        throw new AdminApiError({ message: `${kind} '${id}' was not found`, status: 404 });
+    };
     const find = (id) => definitions.find(form => form.slug === id) ?? definitions.find(form => form.id === id) ?? missing(id);
     const definitionId = (id) => definitions.find(form => form.slug === id)?.id ?? id;
     const findSubmission = (formId, id) => {
         const resolvedId = definitionId(formId);
-        return answers.find(item => item.id === id && item.formDefinitionId === resolvedId && item.status !== 'trash') ?? missing(id);
+        return answers.find(item => item.id === id && item.formDefinitionId === resolvedId && item.status !== 'trash') ?? missing(id, { kind: 'form submission' });
     };
     const remove = (type, id) => {
         const rows = type === 'form' ? definitions : answers;
         const index = rows.findIndex(row => row.id === id);
         if (index < 0)
-            missing(id);
+            missing(id, { kind: type === 'form' ? 'form definition' : 'form submission' });
         // The fixture retains submission payloads just as the generic Trash owner does. Definitions
         // keep their existing separate fixture projection; the core has no definition-delete method.
         if (type === 'form_submission')
@@ -42,14 +59,8 @@ export function createMemoryFormsApi(_required = {}, { forms = [], submissions =
         },
         async updateFormDefinition({ id }, patch = {}) {
             const current = definitions.find(form => form.id === id) ?? missing(id);
-            const incomingIds = patch.fields ? new Set(patch.fields.map(field => field.id)) : null;
-            if (incomingIds && current.fields.some(field => !incomingIds.has(field.id))) {
-                throw new AdminApiError({ message: 'existing form fields cannot be removed', status: 400 }, { code: 'FORMS_FIELD_VALIDATION_ERROR' });
-            }
-            // The contract excludes slug; runtime callers cannot smuggle it through a cast either.
-            const { name, fields, notify, status, mode, html } = patch;
-            const applied = { ...(name !== undefined ? { name } : {}), ...(fields !== undefined ? { fields } : {}), ...(notify !== undefined ? { notify } : {}), ...(status !== undefined ? { status } : {}), ...(mode !== undefined ? { mode } : {}), ...(html !== undefined ? { html } : {}) };
-            const updated = { ...current, ...structuredClone(applied), updatedAt: now() };
+            assertNoFieldRemoved({ current, patch });
+            const updated = { ...current, ...structuredClone(suppliedPatch(patch)), updatedAt: now() };
             definitions[definitions.indexOf(current)] = updated;
             return structuredClone(updated);
         },

package/dist/forms/conformance/forms-api.conformance.d.ts

@@ -3,15 +3,17 @@ export interface FormsConformanceResult {
     readonly passed: number;
     readonly failures: readonly string[];
 }
+type SubmissionSeed = {
+    formId: string;
+    submissionId: string;
+};
 /** Run on an isolated API: creates definitions and trashes seeded submissions.
  * The host provides a disposable seed so conformance never touches an operator's live data. */
 export declare function runFormsApiConformance({ api }: {
     api: AdminFormsPort;
 }, { slug, submission }?: {
     slug?: string;
-    submission?: {
-        formId: string;
-        submissionId: string;
-    };
+    submission?: SubmissionSeed;
 }): Promise<FormsConformanceResult>;
+export {};
 //# sourceMappingURL=forms-api.conformance.d.ts.map

package/dist/forms/conformance/forms-api.conformance.js

@@ -7,6 +7,23 @@ export async function runFormsApiConformance({ api }, { slug = 'forms-conformanc
         passed++;
     else
         failures.push(name); };
+    const created = await checkCreateAndRead({ api, slug, check });
+    await checkUpdates({ api, created, check });
+    if (submission)
+        await checkSubmissions({ api, created, submission, check });
+    return { passed, failures };
+}
+/** Resolves true when the operation is refused; only that probe's rejection is absorbed. */
+async function rejects({ operation }) {
+    try {
+        await operation();
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+async function checkCreateAndRead({ api, slug, check }) {
     const field = { id: 'email', label: 'Email', type: 'email', required: true, className: 'wide', attributes: { 'aria-label': 'Email' } };
     const created = await api.createFormDefinition({ name: 'Contact', slug, fields: [field] }, { notify: { enabled: true, recipients: ['owner@example.com'] } });
     check('create returns requested definition', created.name === 'Contact' && created.slug === slug && created.status === 'active');
@@ -16,56 +33,35 @@ export async function runFormsApiConformance({ api }, { slug = 'forms-conformanc
     const snapshot = await api.getFormDefinition({ id: created.id });
     Object.assign(snapshot.fields[0], { label: 'Changed only in the read snapshot' });
     check('read snapshots cannot mutate stored fields', (await api.getFormDefinition({ id: created.id })).fields[0]?.label === 'Email');
-    const updated = await api.updateFormDefinition({ id: created.id }, { name: 'Renamed', fields: [...created.fields, { id: 'message', label: 'Message', type: 'textarea', required: false }] });
+    return created;
+}
+async function checkUpdates({ api, created, check }) {
+    const { id } = created;
+    const updated = await api.updateFormDefinition({ id }, { name: 'Renamed', fields: [...created.fields, { id: 'message', label: 'Message', type: 'textarea', required: false }] });
     check('name patch and added field persist', updated.name === 'Renamed' && updated.fields.length === 2);
     check('untouched notify survives update', updated.notify.enabled && updated.notify.recipients[0] === 'owner@example.com');
-    let refused = false;
-    try {
-        await api.updateFormDefinition({ id: created.id }, { fields: [] });
-    }
-    catch {
-        refused = true;
-    }
-    check('existing fields cannot be removed', refused);
-    check('rejected removal leaves fields intact', (await api.getFormDefinition({ id: created.id })).fields.length === 2);
-    const disabled = await api.updateFormDefinition({ id: created.id }, { status: 'disabled' });
-    check('definition disable is reversible', disabled.status === 'disabled' && (await api.updateFormDefinition({ id: created.id }, { status: 'active' })).status === 'active');
-    const html = await api.updateFormDefinition({ id: created.id }, { mode: 'html', html: '<input name="email">' });
+    check('existing fields cannot be removed', await rejects({ operation: () => api.updateFormDefinition({ id }, { fields: [] }) }));
+    check('rejected removal leaves fields intact', (await api.getFormDefinition({ id })).fields.length === 2);
+    const disabled = await api.updateFormDefinition({ id }, { status: 'disabled' });
+    check('definition disable is reversible', disabled.status === 'disabled' && (await api.updateFormDefinition({ id }, { status: 'active' })).status === 'active');
+    const html = await api.updateFormDefinition({ id }, { mode: 'html', html: '<input name="email">' });
     check('HTML authoring survives update', html.mode === 'html' && html.html === '<input name="email">');
-    check('builder switch is explicit', (await api.updateFormDefinition({ id: created.id }, { mode: 'builder' })).mode === 'builder');
-    check('empty submission page has null cursor', (await api.listFormSubmissions({ formId: created.id })).nextCursor === null);
+    check('builder switch is explicit', (await api.updateFormDefinition({ id }, { mode: 'builder' })).mode === 'builder');
+    check('empty submission page has null cursor', (await api.listFormSubmissions({ formId: id })).nextCursor === null);
     check('definition has no delete operation', !('deleteFormDefinition' in api));
-    if (submission) {
-        const page = await api.listFormSubmissions({ formId: submission.formId }, { limit: 1 });
-        check('submission page is form scoped', page.items.every(item => item.formDefinitionId === submission.formId));
-        check('submission detail is scoped', (await api.getFormSubmission(submission)).formDefinitionId === submission.formId);
-        let wrongFormRejected = false;
-        try {
-            await api.getFormSubmission({ formId: created.id, submissionId: submission.submissionId });
-        }
-        catch {
-            wrongFormRejected = true;
-        }
-        check('a submission of another form is unavailable', wrongFormRejected);
-        let wrongFormDeleteRejected = false;
-        try {
-            await api.deleteFormSubmission({ formId: created.id, submissionId: submission.submissionId });
-        }
-        catch {
-            wrongFormDeleteRejected = true;
-        }
-        check('cross-form trash is rejected without removing the submission', wrongFormDeleteRejected && (await api.getFormSubmission(submission)).id === submission.submissionId);
+}
+async function checkSubmissions({ api, created, submission, check }) {
+    const crossForm = { formId: created.id, submissionId: submission.submissionId };
+    const page = await api.listFormSubmissions({ formId: submission.formId }, { limit: 1 });
+    check('submission page is form scoped', page.items.every(item => item.formDefinitionId === submission.formId));
+    check('submission detail is scoped', (await api.getFormSubmission(submission)).formDefinitionId === submission.formId);
+    check('a submission of another form is unavailable', await rejects({ operation: () => api.getFormSubmission(crossForm) }));
+    const wrongFormDeleteRejected = await rejects({ operation: () => api.deleteFormSubmission(crossForm) });
+    const submissionRetained = await api.getFormSubmission(submission).then(item => item.id === submission.submissionId, () => false);
+    check('cross-form trash is rejected without removing the submission', wrongFormDeleteRejected && submissionRetained);
+    if (submissionRetained)
         await api.deleteFormSubmission(submission);
-        let missing = false;
-        try {
-            await api.getFormSubmission(submission);
-        }
-        catch {
-            missing = true;
-        }
-        check('trashed submission detail is unavailable', missing);
-        check('trashed submission is absent from active pages', !(await api.listFormSubmissions({ formId: submission.formId })).items.some(item => item.id === submission.submissionId));
-    }
-    return { passed, failures };
+    check('trashed submission detail is unavailable', await rejects({ operation: () => api.getFormSubmission(submission) }));
+    check('trashed submission is absent from active pages', !(await api.listFormSubmissions({ formId: submission.formId })).items.some(item => item.id === submission.submissionId));
 }
 //# sourceMappingURL=forms-api.conformance.js.map

package/dist/forms/field-settings.js

@@ -23,6 +23,20 @@ function defaultKindOf(kind) {
         return "temporal";
     return kind.control === "textarea" ? "textarea" : "text";
 }
+const isNumeric = ({ kind }) => kind.htmlType === "number" || kind.htmlType === "range";
+/** Native input type for a kind's min/max; number and range share numeric bounds. */
+function boundsOf({ kind }) {
+    if (!BOUNDS.has(kind.htmlType))
+        return null;
+    return isNumeric({ kind }) ? "number" : kind.htmlType;
+}
+/** Whether a (non-hidden) kind shows a placeholder. */
+function takesPlaceholder({ kind }) {
+    // A single-choice select shows its placeholder as the empty first option.
+    if (kind.control === "select")
+        return !kind.multiple;
+    return kind.textual === true || kind.htmlType === "number";
+}
 /**
  * Settings for one type, from its registry kind. Unknown (legacy or host-added) types get help
  * text only, so the editor never offers a setting the server would refuse.
@@ -33,15 +47,13 @@ export function fieldSettingsFor({ type }, _optional = {}) {
     if (!kind)
         return NO_SETTINGS;
     const hidden = kind.htmlType === "hidden";
-    const numeric = kind.htmlType === "number" || kind.htmlType === "range";
-    const bounds = BOUNDS.has(kind.htmlType) ? (numeric ? "number" : kind.htmlType) : null;
+    const numeric = isNumeric({ kind });
     return {
-        // A single-choice select shows its placeholder as the empty first option.
-        placeholder: !hidden && ((kind.textual === true && kind.control !== "select") || kind.htmlType === "number" || (kind.control === "select" && !kind.multiple)),
+        placeholder: !hidden && takesPlaceholder({ kind }),
         helpText: !hidden,
         length: kind.textual === true,
         pattern: kind.textual === true && !hidden,
-        bounds,
+        bounds: boundsOf({ kind }),
         step: numeric,
         options: kind.choices === true,
         multiple: kind.multiple === true,
@@ -96,53 +108,45 @@ const SEED_OPTIONS = [{ value: "Option 1", label: "Option 1" }, { value: "Option
 export function retypeField({ field, type }, _optional = {}) {
     const before = fieldSettingsFor({ type: field.type });
     const after = fieldSettingsFor({ type });
-    const next = { id: field.id, label: field.label, type, required: after.helpText ? field.required : false };
-    if (after.helpText && field.helpText !== undefined)
-        next.helpText = field.helpText;
-    if (field.className !== undefined)
-        next.className = field.className;
-    if (field.attributes !== undefined)
-        next.attributes = { ...field.attributes };
-    if (after.placeholder && field.placeholder !== undefined)
-        next.placeholder = field.placeholder;
-    if (after.length) {
-        if (field.maxLength != null)
-            next.maxLength = field.maxLength;
-        if (field.minLength !== undefined)
-            next.minLength = field.minLength;
-    }
-    if (after.pattern && field.pattern !== undefined)
-        next.pattern = field.pattern;
-    if (after.bounds && after.bounds === before.bounds) {
-        if (field.min !== undefined)
-            next.min = field.min;
-        if (field.max !== undefined)
-            next.max = field.max;
-    }
-    if (after.step && field.step !== undefined)
-        next.step = field.step;
-    if (after.options)
-        next.options = field.options?.length ? field.options.map((option) => ({ ...option })) : SEED_OPTIONS.map((option) => ({ ...option }));
-    if (after.upload) {
-        if (field.accept !== undefined)
-            next.accept = [...field.accept];
-        if (field.maxFileSize !== undefined)
-            next.maxFileSize = field.maxFileSize;
+    return {
+        id: field.id, label: field.label, type, required: after.helpText ? field.required : false,
+        ...setKeys({ field, keys: retainedKeys({ field, before, after }) }),
+        ...(after.options ? { options: (field.options?.length ? field.options : SEED_OPTIONS).map((option) => ({ ...option })) } : {}),
+        ...setKeys({ field, keys: after.upload ? ["accept", "maxFileSize"] : [] }),
+        // A default only survives when its shape is unchanged (text to text, one choice to one choice).
+        ...(keepsDefault({ before, after }) && field.default !== undefined ? { default: field.default } : {}),
+    };
+}
+const when = (applies, keys) => (applies ? keys : []);
+/** The settings before the options that a retype keeps, in the field's key order. */
+function retainedKeys({ field, before, after }) {
+    return [
+        ...when(after.helpText, ["helpText"]), "className", "attributes", ...when(after.placeholder, ["placeholder"]),
+        // A null max length (the wire's "cleared") is dropped rather than carried.
+        ...when(after.length && field.maxLength != null, ["maxLength"]), ...when(after.length, ["minLength"]),
+        ...when(after.pattern, ["pattern"]),
+        ...when(after.bounds !== null && after.bounds === before.bounds, ["min", "max"]),
+        ...when(after.step, ["step"]),
+    ];
+}
+const keepsDefault = ({ before, after }) => after.defaultKind !== null && after.defaultKind === before.defaultKind && after.bounds === before.bounds;
+/** The listed keys the field has set, in order; attribute maps and accept lists are copied, not shared. */
+function setKeys({ field, keys }) {
+    const kept = {};
+    for (const key of keys) {
+        const value = field[key];
+        if (value === undefined)
+            continue;
+        Object.assign(kept, { [key]: Array.isArray(value) ? [...value] : typeof value === "object" && value !== null ? { ...value } : value });
     }
-    // A default only survives when its shape is unchanged (text to text, one choice to one choice).
-    if (field.default !== undefined && after.defaultKind !== null && after.defaultKind === before.defaultKind && after.bounds === before.bounds)
-        next.default = field.default;
-    return next;
+    return kept;
 }
 const text = (value) => (value === undefined || value === null ? "" : String(value));
 /** Seed the draft from a stored field. @complexity O(o) in options. */
 export function settingsFormFromField({ field }, _optional = {}) {
-    const defaults = field.default;
     return {
         placeholder: text(field.placeholder), helpText: text(field.helpText),
-        defaultText: typeof defaults === "boolean" || Array.isArray(defaults) ? "" : text(defaults),
-        defaultChecked: defaults === true || (field.checkboxValue !== undefined && defaults === field.checkboxValue),
-        defaultChoices: Array.isArray(defaults) ? [...defaults] : typeof defaults === "string" && fieldSettingsFor({ type: field.type }).options ? [defaults] : [],
+        ...defaultDraft({ field }),
         minLength: text(field.minLength), maxLength: text(field.maxLength), pattern: text(field.pattern),
         min: text(field.min), max: text(field.max), step: text(field.step),
         options: (field.options ?? []).map((option, index) => ({ _rowId: index, value: option.value, label: option.label })),
@@ -150,6 +154,21 @@ export function settingsFormFromField({ field }, _optional = {}) {
         maxFileSizeMb: field.maxFileSize === undefined ? "" : String(Math.round((field.maxFileSize / 1024 / 1024) * 100) / 100),
     };
 }
+/** The stored default as the dialog's three default controls. */
+function defaultDraft({ field }) {
+    const defaults = field.default;
+    return {
+        defaultText: typeof defaults === "boolean" || Array.isArray(defaults) ? "" : text(defaults),
+        defaultChecked: defaults === true || (field.checkboxValue !== undefined && defaults === field.checkboxValue),
+        defaultChoices: defaultChoicesOf({ field }),
+    };
+}
+function defaultChoicesOf({ field }) {
+    const defaults = field.default;
+    if (Array.isArray(defaults))
+        return [...defaults];
+    return typeof defaults === "string" && fieldSettingsFor({ type: field.type }).options ? [defaults] : [];
+}
 /**
  * Edit one option row. A value that still mirrors its label follows label edits, so typing labels
  * is enough for most forms; an edited value stays put.
@@ -199,59 +218,74 @@ function optionalNumber(value, error, { integer = false } = {}) {
     return Number.isFinite(number) && (!integer || (Number.isInteger(number) && number >= 0)) ? { ok: true, value: number } : { ok: false, error };
 }
 /** Text length, pattern and placeholder settings. */
-function textPatch(form, settings) {
-    const patch = { placeholder: settings.placeholder && !isBlank(form.placeholder) ? form.placeholder : undefined, pattern: undefined, minLength: undefined };
-    if (settings.length) {
-        const min = optionalNumber(form.minLength, "Length must be a whole number.", { integer: true });
-        const max = optionalNumber(form.maxLength, "Length must be a whole number.", { integer: true });
-        if (!min.ok)
-            return min;
-        if (!max.ok)
-            return max;
-        if (min.value !== undefined && max.value !== undefined && min.value > max.value)
-            return { ok: false, error: "Minimum must not be above maximum." };
-        patch.minLength = min.value;
-        // The wire contract clears a text length with null; unsupported types omit the key entirely.
-        patch.maxLength = max.value ?? null;
-    }
-    if (settings.pattern && !isBlank(form.pattern)) {
-        // Browser-safe too: a `v`-flag-invalid pattern is silently ignored by browsers (2026-10-11).
-        if (!isBrowserSafeFieldPattern({ pattern: form.pattern }))
-            return { ok: false, error: "That pattern isn't supported." };
-        patch.pattern = form.pattern;
-    }
-    return { ok: true, value: patch };
+function textPatch({ form, settings }) {
+    const length = settings.length ? lengthPatch({ form }) : { ok: true, value: {} };
+    if (!length.ok)
+        return length;
+    const pattern = settings.pattern ? patternOf({ form }) : { ok: true, value: undefined };
+    if (!pattern.ok)
+        return pattern;
+    return { ok: true, value: {
+            placeholder: settings.placeholder && !isBlank(form.placeholder) ? form.placeholder : undefined,
+            pattern: pattern.value, minLength: undefined, ...length.value,
+        } };
+}
+const MIN_ABOVE_MAX = { ok: false, error: "Minimum must not be above maximum." };
+const isAbove = (min, max) => min !== undefined && max !== undefined && min > max;
+function lengthPatch({ form }) {
+    const min = optionalNumber(form.minLength, "Length must be a whole number.", { integer: true });
+    const max = optionalNumber(form.maxLength, "Length must be a whole number.", { integer: true });
+    if (!min.ok)
+        return min;
+    if (!max.ok)
+        return max;
+    if (isAbove(min.value, max.value))
+        return MIN_ABOVE_MAX;
+    // The wire contract clears a text length with null; unsupported types omit the key entirely.
+    return { ok: true, value: { minLength: min.value, maxLength: max.value ?? null } };
+}
+function patternOf({ form }) {
+    if (isBlank(form.pattern))
+        return { ok: true, value: undefined };
+    // Browser-safe too: a `v`-flag-invalid pattern is silently ignored by browsers (2026-10-11).
+    if (!isBrowserSafeFieldPattern({ pattern: form.pattern }))
+        return { ok: false, error: "That pattern isn't supported." };
+    return { ok: true, value: form.pattern };
 }
 /** Numeric or date/time bounds, plus a numeric step. Native date/time strings compare as text. */
-function boundsPatch(form, settings) {
-    const patch = { min: undefined, max: undefined, step: undefined };
-    if (settings.bounds === "number") {
-        const min = optionalNumber(form.min, "Enter numbers for min, max and step.");
-        const max = optionalNumber(form.max, "Enter numbers for min, max and step.");
-        const step = optionalNumber(form.step, "Enter numbers for min, max and step.");
-        if (!min.ok)
-            return min;
-        if (!max.ok)
-            return max;
-        if (!step.ok)
-            return step;
-        if (step.value !== undefined && step.value <= 0)
-            return { ok: false, error: "Step must be above 0." };
-        if (min.value !== undefined && max.value !== undefined && min.value > max.value)
-            return { ok: false, error: "Minimum must not be above maximum." };
-        return { ok: true, value: { min: min.value, max: max.value, step: step.value } };
-    }
-    if (settings.bounds) {
-        const min = isBlank(form.min) ? undefined : form.min;
-        const max = isBlank(form.max) ? undefined : form.max;
-        if (min !== undefined && max !== undefined && min > max)
-            return { ok: false, error: "Minimum must not be above maximum." };
-        return { ok: true, value: { min, max } };
-    }
-    return { ok: true, value: patch };
+function boundsPatch({ form, settings }) {
+    if (settings.bounds === "number")
+        return numberBoundsPatch({ form });
+    if (settings.bounds)
+        return textBoundsPatch({ form });
+    return { ok: true, value: { min: undefined, max: undefined, step: undefined } };
+}
+function numberBoundsPatch({ form }) {
+    const error = "Enter numbers for min, max and step.";
+    const min = optionalNumber(form.min, error);
+    const max = optionalNumber(form.max, error);
+    const step = optionalNumber(form.step, error);
+    if (!min.ok)
+        return min;
+    if (!max.ok)
+        return max;
+    if (!step.ok)
+        return step;
+    if (step.value !== undefined && step.value <= 0)
+        return { ok: false, error: "Step must be above 0." };
+    if (isAbove(min.value, max.value))
+        return MIN_ABOVE_MAX;
+    return { ok: true, value: { min: min.value, max: max.value, step: step.value } };
+}
+function textBoundsPatch({ form }) {
+    const min = isBlank(form.min) ? undefined : form.min;
+    const max = isBlank(form.max) ? undefined : form.max;
+    if (isAbove(min, max))
+        return MIN_ABOVE_MAX;
+    return { ok: true, value: { min, max } };
 }
 /** Choice options: blank rows are skipped; the rest need a label and a unique value. */
-function optionsPatch(form, settings) {
+function optionsPatch({ form, settings }) {
     if (!settings.options)
         return { ok: true, value: undefined };
     const options = form.options.filter((row) => !(isBlank(row.value) && isBlank(row.label))).map((row) => ({ value: row.value.trim(), label: row.label.trim() }));
@@ -262,26 +296,27 @@ function optionsPatch(form, settings) {
     }
     return { ok: true, value: options };
 }
+const typedDefault = ({ form }) => ({ ok: true, value: isBlank(form.defaultText) ? undefined : form.defaultText });
+const DEFAULT_READERS = {
+    // A box with an authored value submits that value, so its "checked" default is that value too.
+    boolean: ({ form, checkboxValue }) => ({ ok: true, value: form.defaultChecked ? checkboxValue ?? true : undefined }),
+    choice: ({ form, offered }) => ({ ok: true, value: form.defaultChoices.find((value) => offered.has(value)) }),
+    choices: ({ form, offered }) => {
+        const chosen = form.defaultChoices.filter((value) => offered.has(value));
+        return { ok: true, value: chosen.length ? chosen : undefined };
+    },
+    number: ({ form }) => optionalNumber(form.defaultText, "Default must be a number."),
+    text: typedDefault, textarea: typedDefault, temporal: typedDefault,
+};
 /** The default in the stored shape for its kind; choices drop values no longer offered. */
-function defaultValue(form, settings, { options, checkboxValue }) {
+function defaultValue({ form, settings }, { options, checkboxValue }) {
+    if (settings.defaultKind === null)
+        return { ok: true, value: undefined };
     const offered = new Set((options ?? []).map((option) => option.value));
-    switch (settings.defaultKind) {
-        // A box with an authored value submits that value, so its "checked" default is that value too.
-        case "boolean": return { ok: true, value: form.defaultChecked ? checkboxValue ?? true : undefined };
-        case "choice": return { ok: true, value: form.defaultChoices.find((value) => offered.has(value)) };
-        case "choices": {
-            const chosen = form.defaultChoices.filter((value) => offered.has(value));
-            return { ok: true, value: chosen.length ? chosen : undefined };
-        }
-        case "number": return optionalNumber(form.defaultText, "Default must be a number.");
-        case "text":
-        case "textarea":
-        case "temporal": return { ok: true, value: isBlank(form.defaultText) ? undefined : form.defaultText };
-        default: return { ok: true, value: undefined };
-    }
+    return DEFAULT_READERS[settings.defaultKind]({ form, offered, checkboxValue });
 }
 /** Upload limits: no boxes ticked means every safe type; size is whole megabytes up to the cap. */
-function uploadPatch(form, settings) {
+function uploadPatch({ form, settings }) {
     if (!settings.upload)
         return { ok: true, value: {} };
     const size = optionalNumber(form.maxFileSizeMb, "Max size must be up to 10 MB.");
@@ -302,19 +337,19 @@ function uploadPatch(form, settings) {
  */
 export function buildFieldSettingsPatch({ form, field }, _optional = {}) {
     const settings = fieldSettingsFor({ type: field.type });
-    const textual = textPatch(form, settings);
+    const textual = textPatch({ form, settings });
     if (!textual.ok)
         return textual;
-    const bounds = boundsPatch(form, settings);
+    const bounds = boundsPatch({ form, settings });
     if (!bounds.ok)
         return bounds;
-    const options = optionsPatch(form, settings);
+    const options = optionsPatch({ form, settings });
     if (!options.ok)
         return options;
-    const fallback = defaultValue(form, settings, { options: options.value, checkboxValue: field.checkboxValue });
+    const fallback = defaultValue({ form, settings }, { options: options.value, checkboxValue: field.checkboxValue });
     if (!fallback.ok)
         return fallback;
-    const upload = uploadPatch(form, settings);
+    const upload = uploadPatch({ form, settings });
     if (!upload.ok)
         return upload;
     return { ok: true, patch: {