@adcops/autocore-react 3.3.115 → 3.3.116

package/src/components/tis/TestFieldRow.tsx

@@ -0,0 +1,297 @@
+/*
+ * Copyright (C) 2026 Automated Design Corp. All Rights Reserved.
+ *
+ * The one place a TIS `TestField` becomes an input.
+ *
+ * Test Configuration (<TestSetupForm>, per-test) and Cycle Configuration
+ * (<CycleConfigForm>, per-row) render the same declarative field schema
+ * with the same display/raw unit convention, the same emptiness and range
+ * rules, and the same 4-column `ac-form-grid` row shape. They differ only
+ * in where the value is stored and when it is committed, so the rendering
+ * and the validation rules live here and both forms call in.
+ *
+ * Storage is always RAW; `scale` converts only at the boundary:
+ *   display = raw * scale     raw = display / scale
+ */
+
+import React from 'react';
+import { Button } from 'primereact/button';
+import { Dropdown } from 'primereact/dropdown';
+import { ValueInput } from '../ValueInput';
+import { TextInput } from '../TextInput';
+
+/**
+ * One field in a test method's schema. Mirrors the Rust `TestField`
+ * (autocore-ams `config.rs`) — the same shape backs project_fields,
+ * config_fields, cycle_config_fields, cycle_fields and results_fields.
+ */
+export interface TestFieldDef {
+    /** Canonical key — wire format, generated code, on-disk JSON. */
+    name: string;
+    type: string;
+    units?: string;
+    required?: boolean;
+    source?: string;
+    /** Pretty label rendered by the form. Falls back to `name`. Units
+     *  are appended automatically; don't pre-format `[mm]` into label. */
+    label?: string;
+    /** Long-form guidance surfaced as a hover tooltip on an info icon. */
+    description?: string;
+    /** Seed value applied when the operator selects this test method.
+     *  For source-bound fields the default is written to the GM tag so
+     *  the control program sees it; for non-source fields it's stashed
+     *  straight into stagedConfig. Operator edits override per-stage,
+     *  but the schema default never mutates — re-selecting the method
+     *  re-applies the default. **Authored in display units** when
+     *  `scale` is set — the form divides by `scale` before writing to
+     *  GM / stagedConfig so the underlying storage stays raw. */
+    default?: any;
+    /** Optional unit-conversion multiplier. Mirrors AutoCoreTagContext:
+     *  ```
+     *  display = raw * scale
+     *  raw     = display / scale
+     *  ```
+     *  Example: backend stores degrees, operator enters revolutions →
+     *  `scale: 0.00277778`. None / 1.0 = no conversion.
+     *
+     *  Storage stays raw — the form scales only on input and display.
+     *  Cycle and results values are scaled by the corresponding paths
+     *  in TestDataView; the server scales CSV exports too. */
+    scale?: number;
+    /** Optional inclusive bounds (display units, same convention as `default`
+     *  and `scale`) for the operator's numeric entry. The numeric input
+     *  rejects values outside `[min, max]`; non-numeric fields ignore them. */
+    min?: number;
+    max?: number;
+    /** Optional fixed set of choices. When present, the field renders
+     *  as a dropdown and the operator must pick one of the declared
+     *  values rather than typing freely. Each entry is either a bare
+     *  scalar (label === value) or an explicit `{ label, value }` pair
+     *  when the displayed text should differ from the stored value.
+     *  Works with any `type`; like `default`, values are authored in
+     *  display units when `scale` is set. */
+    options?: Array<
+        | string
+        | number
+        | boolean
+        | { label?: string; value: string | number | boolean }
+    >;
+    /** Operator-editable after recording. Meaningful on `cycle_fields`;
+     *  `cycle_config_fields` are always editable (they're annotation, not
+     *  measurement) and don't need the flag. */
+    editable?: boolean;
+    /** `cycle_config_fields` only: clear this entry once a row has recorded
+     *  it, so the next row can't silently inherit a stale annotation. Fires
+     *  at the method's `cycle_config_scope` boundary. */
+    autoclear?: boolean;
+}
+
+/**
+ * Which boundary an operator annotates `cycle_config_fields` at. Mirrors
+ * the Rust `CycleConfigScope`.
+ *
+ *   `'run'`    one latch per Start — the same values stamp every cycle of
+ *              the run and clear when it closes. Default, and the only
+ *              correct choice for a machine that records many cycles from
+ *              one Start.
+ *   `'cycle'`  one latch per cycle — values clear after each recorded row
+ *              and the gate re-arms, so the operator annotates every one.
+ */
+export type CycleConfigScope = 'run' | 'cycle';
+
+// -------------------------------------------------------------------------
+// Display ↔ raw boundary
+// -------------------------------------------------------------------------
+
+/**
+ * Convention: `display = raw * scale`, `raw = display / scale`. Matches
+ * AutoCoreTagContext. Default scale = 1.0 (no conversion). Non-numeric
+ * values (string, null, undefined, NaN) pass through unchanged — the
+ * forms share one change handler across fields of every type.
+ *
+ * Storage (config map, GM, on-disk JSON) always holds the raw value. Only
+ * the inputs the operator looks at and the cells in TestDataView use the
+ * display value, so scales can change in project.json without
+ * invalidating historical records.
+ */
+export const rawToDisplay = (raw: any, scale: number | undefined): any => {
+    if (!scale || scale === 1) return raw;
+    if (typeof raw !== 'number' || !Number.isFinite(raw)) return raw;
+    return raw * scale;
+};
+
+export const displayToRaw = (display: any, scale: number | undefined): any => {
+    if (!scale || scale === 1) return display;
+    if (typeof display !== 'number' || !Number.isFinite(display)) return display;
+    return display / scale;
+};
+
+/** Field label with `[units]` appended when declared. */
+export const labelOf = (f: TestFieldDef): string => {
+    const base = f.label && f.label.length > 0 ? f.label : f.name;
+    return f.units ? `${base} [${f.units}]` : base;
+};
+
+export const hasDescription = (f: TestFieldDef): boolean =>
+    typeof f.description === 'string' && f.description.length > 0;
+
+/**
+ * "Not entered." Mirrors the server's `cycle_config_value_is_empty`
+ * (autocore-tis `config.rs`) so the HMI gate and the GM gate can never
+ * disagree about whether a field is filled in: absent, null, or an
+ * empty/whitespace string. Numeric zero and `false` are entries.
+ */
+export const fieldValueIsEmpty = (v: any): boolean =>
+    v === undefined || v === null || (typeof v === 'string' && v.trim() === '');
+
+/**
+ * Range check for a numeric field's stored RAW value against its declared
+ * `min`/`max` (authored in DISPLAY units). Returns a short human-readable
+ * reason ("must be ≥ 5") when out of range, or null when in range / not
+ * applicable (empty value, no bounds, or non-numeric).
+ */
+export const rangeIssue = (f: TestFieldDef, raw: any): string | null => {
+    if (fieldValueIsEmpty(raw) || raw === '') return null;
+    if (f.min == null && f.max == null) return null;
+    const disp = Number(rawToDisplay(Number(raw), f.scale));
+    if (!Number.isFinite(disp)) return null;
+    // Bounds form an unordered interval — an author may write the range in
+    // magnitude order (min:-50, max:-1000), which is numerically inverted.
+    const lo = f.min != null && f.max != null ? Math.min(f.min, f.max) : f.min;
+    const hi = f.min != null && f.max != null ? Math.max(f.min, f.max) : f.max;
+    if (lo != null && disp < lo) return `must be ≥ ${lo}`;
+    if (hi != null && disp > hi) return `must be ≤ ${hi}`;
+    return null;
+};
+
+/**
+ * The single validity rule for an operator-entered field: required-and-empty,
+ * or out of range. Returns a human-readable reason, or null when the value
+ * is acceptable. Both forms build their issue lists and their per-field red
+ * markers from this, so the summary dialog and the field icons always agree.
+ */
+export const fieldIssue = (f: TestFieldDef, raw: any): string | null => {
+    if (f.required && fieldValueIsEmpty(raw)) return 'is required';
+    return rangeIssue(f, raw);
+};
+
+export const fieldIsValid = (f: TestFieldDef, raw: any): boolean =>
+    fieldIssue(f, raw) === null;
+
+/**
+ * Normalise a field's `options` (bare scalars and/or `{label, value}`
+ * pairs) into the `{ label, value }[]` shape PrimeReact's Dropdown wants.
+ * Bare scalars use their stringified form as the label.
+ */
+export const normalizeOptions = (
+    opts: TestFieldDef['options'],
+): { label: string; value: string | number | boolean }[] =>
+    (opts ?? []).map((o) =>
+        o !== null && typeof o === 'object'
+            ? { label: String(o.label ?? o.value), value: o.value }
+            : { label: String(o), value: o },
+    );
+
+// -------------------------------------------------------------------------
+// Rendering
+// -------------------------------------------------------------------------
+
+export interface TestFieldRowProps {
+    field: TestFieldDef;
+    /** Stored RAW value. */
+    value: any;
+    /** Receives the RAW value (the row converts from display for you). */
+    onChange: (raw: any) => void;
+    /** Marks the control invalid. Defaults to `fieldIsValid(field, value)`. */
+    valid?: boolean;
+    /** Read-only rendering — used while a cycle is in flight and its
+     *  annotation is already latched. */
+    disabled?: boolean;
+    /**
+     * Replaces the schema-derived input for this field. Used by
+     * <TestSetupForm> for config fields an AMS `asset_ref` claims, where
+     * the picker is sourced from the asset registry rather than the field
+     * declaration.
+     */
+    control?: React.ReactNode;
+    /** Opens the host form's shared info dialog. When omitted, fields with
+     *  a `description` render no info affordance. */
+    onInfo?: (field: TestFieldDef) => void;
+}
+
+/**
+ * One row of a 4-column `ac-form-grid`: label, control, info button,
+ * validity icon. Returns a Fragment, so the caller owns the grid.
+ */
+export const TestFieldRow: React.FC<TestFieldRowProps> = ({
+    field, value, onChange, valid, disabled, control, onInfo,
+}) => {
+    const ok = valid ?? fieldIsValid(field, value);
+    const dropdownOptions = !control && Array.isArray(field.options) && field.options.length > 0
+        ? normalizeOptions(field.options)
+        : null;
+    const isNum = !control && !dropdownOptions
+        && field.type !== 'string' && field.type !== 'bool';
+
+    const input = control ?? (dropdownOptions ? (
+        <Dropdown
+            value={value ?? null}
+            options={dropdownOptions}
+            onChange={(e) => onChange(e.value)}
+            placeholder={`Select ${field.label ?? field.name}…`}
+            className={`ac-dropdown-clearable${!ok ? ' p-invalid' : ''}`}
+            showClear={!field.required}
+            disabled={disabled}
+        />
+    ) : isNum ? (
+        <ValueInput
+            label={undefined}
+            // Storage is RAW; render the DISPLAY value so the operator sees
+            // the units they configured. The change handler runs the inverse
+            // before committing back to storage.
+            value={value != null ? Number(rawToDisplay(Number(value), field.scale)) : null}
+            // min/max are authored in display units, matching the value
+            // rendered above — ValueInput rejects out-of-range entries.
+            min={field.min}
+            max={field.max}
+            onValueChanged={(val) => onChange(displayToRaw(val, field.scale))}
+            className={!ok ? 'p-invalid' : ''}
+            disabled={disabled}
+        />
+    ) : (
+        <TextInput
+            label={undefined}
+            value={value != null ? String(value) : ''}
+            onValueChanged={(val) => onChange(val)}
+            className={!ok ? 'p-invalid' : ''}
+            disabled={disabled}
+        />
+    ));
+
+    return (
+        <React.Fragment>
+            <span className="ac-form-label">{labelOf(field)}</span>
+            {input}
+            {onInfo && hasDescription(field) ? (
+                <Button
+                    icon="pi pi-info-circle"
+                    text
+                    rounded
+                    aria-label={`About ${labelOf(field)}`}
+                    // Replaces a hover Tooltip — touch-friendly. The
+                    // description is shown in the host form's info dialog.
+                    onClick={() => onInfo(field)}
+                />
+            ) : (
+                <span aria-hidden="true" />
+            )}
+            <span style={{
+                color: ok ? 'var(--green-500)' : 'var(--red-500)',
+                display: 'flex',
+                alignItems: 'center',
+            }}>
+                <i className={ok ? 'pi pi-check' : 'pi pi-times'} />
+            </span>
+        </React.Fragment>
+    );
+};

package/src/components/tis/TestSetupForm.tsx

@@ -6,12 +6,26 @@ import { Dialog } from 'primereact/dialog';
 import { EventEmitterContext } from '../../core/EventEmitterContext';
 import { AutoCoreTagContext } from '../../core/AutoCoreTagContext';
 import { MessageType } from '../../hub/CommandMessage';
-import { ValueInput } from '../ValueInput';
 import { TextInput } from '../TextInput';
 import { useTis } from './TisProvider';
 import { useAmsAssets, useAmsRoles, type AmsAssetEntry } from '../ams/AmsProvider';
 import { TestMethodDialog } from './TestMethodDialog';
 import { ConfigurationDialog, configLabelOf } from './ConfigurationDialog';
+import {
+    TestFieldRow,
+    displayToRaw,
+    fieldIsValid,
+    fieldIssue,
+    labelOf,
+    type CycleConfigScope,
+    type TestFieldDef,
+} from './TestFieldRow';
+
+// The field schema and its display/raw + validation helpers are shared with
+// <CycleConfigForm> — see TestFieldRow.tsx. Re-exported here because this
+// module has been the public home of `TestFieldDef` since before Cycle
+// Configuration existed.
+export type { TestFieldDef } from './TestFieldRow';
 
 /**
  * One asset_ref declared on a test method. We only consume the subset
@@ -27,64 +41,24 @@ interface TisAssetRef {
     location?: string;
 }
 
-export interface TestFieldDef {
-    /** Canonical key — wire format, generated code, on-disk JSON. */
-    name: string;
-    type: string;
-    units?: string;
-    required?: boolean;
-    source?: string;
-    /** Pretty label rendered by the form. Falls back to `name`. Units
-     *  are appended automatically; don't pre-format `[mm]` into label. */
-    label?: string;
-    /** Long-form guidance surfaced as a hover tooltip on an info icon. */
-    description?: string;
-    /** Seed value applied when the operator selects this test method.
-     *  For source-bound fields the default is written to the GM tag so
-     *  the control program sees it; for non-source fields it's stashed
-     *  straight into stagedConfig. Operator edits override per-stage,
-     *  but the schema default never mutates — re-selecting the method
-     *  re-applies the default. **Authored in display units** when
-     *  `scale` is set — the form divides by `scale` before writing to
-     *  GM / stagedConfig so the underlying storage stays raw. */
-    default?: any;
-    /** Optional unit-conversion multiplier. Mirrors AutoCoreTagContext:
-     *  ```
-     *  display = raw * scale
-     *  raw     = display / scale
-     *  ```
-     *  Example: backend stores degrees, operator enters revolutions →
-     *  `scale: 0.00277778`. None / 1.0 = no conversion.
-     *
-     *  Storage stays raw — the form scales only on input and display.
-     *  Cycle and results values are scaled by the corresponding paths
-     *  in TestDataView; the server scales CSV exports too. */
-    scale?: number;
-    /** Optional inclusive bounds (display units, same convention as `default`
-     *  and `scale`) for the operator's numeric entry. The numeric input
-     *  rejects values outside `[min, max]`; non-numeric fields ignore them. */
-    min?: number;
-    max?: number;
-    /** Optional fixed set of choices. When present, the field renders
-     *  as a dropdown and the operator must pick one of the declared
-     *  values rather than typing freely. Each entry is either a bare
-     *  scalar (label === value) or an explicit `{ label, value }` pair
-     *  when the displayed text should differ from the stored value.
-     *  Works with any `type`; like `default`, values are authored in
-     *  display units when `scale` is set. */
-    options?: Array<
-        | string
-        | number
-        | boolean
-        | { label?: string; value: string | number | boolean }
-    >;
-}
-
 export interface TestMethod {
     project_fields: TestFieldDef[];
     config_fields: TestFieldDef[];
     cycle_fields: TestFieldDef[];
     results_fields: TestFieldDef[];
+    /**
+     * Operator-entered per-row annotation, rendered on the Cycle tab by
+     * <CycleConfigForm> rather than by this form. Declared here so a
+     * generated schema literal typechecks against `TestMethod`.
+     */
+    cycle_config_fields?: TestFieldDef[];
+    /** Which boundary the operator annotates at: `'run'` (default — one
+     *  latch per Start, stamping every cycle of the run) or `'cycle'`
+     *  (one latch per cycle, re-gated between cycles). */
+    cycle_config_scope?: CycleConfigScope;
+    /** Open the Cycle Configuration dialog at the boundary instead of
+     *  relying on the operator having filled the Cycle tab. */
+    prompt_before_cycle?: boolean;
     /**
      * AMS asset references resolved at start_test. The form scans these
      * for `select=by_id_field` entries pointing at a config field
@@ -159,38 +133,6 @@ export interface TestSetupFormProps {
 // Helpers
 // -------------------------------------------------------------------------
 
-const labelOf = (f: TestFieldDef): string => {
-    const base = f.label && f.label.length > 0 ? f.label : f.name;
-    return f.units ? `${base} [${f.units}]` : base;
-};
-
-/**
- * Two helpers for the display ↔ raw boundary on numeric fields.
- *
- * Convention: `display = raw * scale`, `raw = display / scale`. Matches
- * AutoCoreTagContext. Default scale = 1.0 (no conversion). Non-numeric
- * input values (string, null, undefined, NaN) pass through unchanged
- * — the form has fields of other types that share the change handler.
- *
- * Storage (config map, GM, on-disk JSON) always holds the raw value.
- * Only the inputs the operator looks at and the cells in TestDataView
- * use the display value. This way scales can change in project.json
- * without invalidating historical records.
- */
-const rawToDisplay = (raw: any, scale: number | undefined): any => {
-    if (!scale || scale === 1) return raw;
-    if (typeof raw !== 'number' || !Number.isFinite(raw)) return raw;
-    return raw * scale;
-};
-const displayToRaw = (display: any, scale: number | undefined): any => {
-    if (!scale || scale === 1) return display;
-    if (typeof display !== 'number' || !Number.isFinite(display)) return display;
-    return display / scale;
-};
-
-const hasDescription = (f: TestFieldDef): boolean =>
-    typeof f.description === 'string' && f.description.length > 0;
-
 /** Matches an FQDN default token like `${gm.safe_speed}` (whole-string). */
 const DEFAULT_TOKEN_RE = /^\$\{\s*([^}]+?)\s*\}$/;
 
@@ -230,41 +172,6 @@ const resolveDefaultRaw = (
     return { raw: displayToRaw(d, field.scale), ok: true };
 };
 
-/**
- * Range check for a numeric field's stored RAW value against its declared
- * `min`/`max` (authored in DISPLAY units). Returns a short human-readable
- * reason ("must be ≥ 5") when out of range, or null when in range / not
- * applicable (empty value, no bounds, or non-numeric). Storage is raw, so we
- * convert to display first to compare against the author's display-unit bounds.
- */
-const rangeIssue = (f: TestFieldDef, raw: any): string | null => {
-    if (raw === undefined || raw === '' || raw === null) return null;
-    if (f.min == null && f.max == null) return null;
-    const disp = Number(rawToDisplay(Number(raw), f.scale));
-    if (!Number.isFinite(disp)) return null;
-    // Bounds form an unordered interval — an author may write the range in
-    // magnitude order (min:-50, max:-1000), which is numerically inverted.
-    const lo = f.min != null && f.max != null ? Math.min(f.min, f.max) : f.min;
-    const hi = f.min != null && f.max != null ? Math.max(f.min, f.max) : f.max;
-    if (lo != null && disp < lo) return `must be ≥ ${lo}`;
-    if (hi != null && disp > hi) return `must be ≤ ${hi}`;
-    return null;
-};
-
-/**
- * Normalise a field's `options` (bare scalars and/or `{label, value}`
- * pairs) into the `{ label, value }[]` shape PrimeReact's Dropdown
- * wants. Bare scalars use their stringified form as the label.
- */
-const normalizeOptions = (
-    opts: TestFieldDef['options'],
-): { label: string; value: string | number | boolean }[] =>
-    (opts ?? []).map((o) =>
-        o !== null && typeof o === 'object'
-            ? { label: String(o.label ?? o.value), value: o.value }
-            : { label: String(o), value: o },
-    );
-
 const methodLabelOf = (methodId: string, schema: TestMethod | undefined): string =>
     (schema?.label && schema.label.length > 0) ? schema.label : methodId;
 
@@ -550,10 +457,7 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
 
         for (const field of schema.config_fields) {
             if (field.name === 'sample_id') continue;
-            const v = config[field.name];
-            const empty = v === undefined || v === '' || v === null;
-            if (field.required && empty) { valid = false; break; }
-            if (rangeIssue(field, v)) { valid = false; break; }
+            if (fieldIssue(field, config[field.name])) { valid = false; break; }
         }
 
         setIsValid(valid);
@@ -583,23 +487,15 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
         onValidationChange, invoke,
     ]);
 
-    const isFieldValid = (field: TestFieldDef) => {
-        const v = config[field.name];
-        const empty = v === undefined || v === '' || v === null;
-        if (field.required && empty) return false;
-        if (rangeIssue(field, v)) return false;
-        return true;
-    };
+    const isFieldValid = (field: TestFieldDef) => fieldIsValid(field, config[field.name]);
 
     const handleSampleIdChange = (value: string) => {
         setSampleIdLocal(value);
     };
 
-    const handleFieldChange = async (field: TestFieldDef, val: any) => {
-        // The operator typed a DISPLAY value; convert to RAW before
-        // storing or writing to GM. Non-numeric fields and identity
-        // scales pass through unchanged via the helper.
-        const rawVal = displayToRaw(val, field.scale);
+    const handleFieldChange = async (field: TestFieldDef, rawVal: any) => {
+        // <TestFieldRow> has already converted the operator's DISPLAY entry
+        // to RAW; storage and GM always hold raw.
         setConfig({ ...config, [field.name]: rawVal });
         if (field.source) {
             try { await write(field.source, rawVal); }
@@ -642,81 +538,31 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
     const renderConfigField = (field: TestFieldDef) => {
         if (field.name === 'sample_id') return null;
         const valid = isFieldValid(field);
+        // A field an AMS asset_ref claims gets its picker from the registry
+        // instead of from the field declaration; everything else is rendered
+        // from the schema by <TestFieldRow>, exactly as the Cycle tab does.
         const assetType = assetTypeForField(field);
-        // A schema-declared `options` list turns the field into a
-        // dropdown (skipped when an asset_ref already claims the field
-        // — that picker is sourced from AMS, not the static list).
-        const dropdownOptions = !assetType && Array.isArray(field.options) && field.options.length > 0
-            ? normalizeOptions(field.options)
-            : null;
-        const isNum = !assetType && !dropdownOptions
-            && field.type !== 'string' && field.type !== 'bool';
         return (
-            <React.Fragment key={field.name}>
-                <span className="ac-form-label">{labelOf(field)}</span>
-                {assetType ? (
+            <TestFieldRow
+                key={field.name}
+                field={field}
+                value={config[field.name]}
+                valid={valid}
+                onChange={(raw) => handleFieldChange(field, raw)}
+                onInfo={(f) => setInfoDialog({
+                    open: true,
+                    title: labelOf(f),
+                    body: <p style={{ margin: 0, whiteSpace: 'pre-wrap' }}>{f.description}</p>,
+                })}
+                control={assetType ? (
                     <AssetIdPicker
                         assetType={assetType}
                         value={config[field.name] != null ? String(config[field.name]) : ''}
                         onChange={(val) => handleFieldChange(field, val)}
                         invalid={!valid}
                     />
-                ) : dropdownOptions ? (
-                    <Dropdown
-                        value={config[field.name] ?? null}
-                        options={dropdownOptions}
-                        onChange={(e) => handleFieldChange(field, e.value)}
-                        placeholder={`Select ${field.label ?? field.name}…`}
-                        className={`ac-dropdown-clearable${!valid ? ' p-invalid' : ''}`}
-                        showClear={!field.required}
-                    />
-                ) : isNum ? (
-                    <ValueInput
-                        label={undefined}
-                        // Storage is RAW; render the DISPLAY value so
-                        // operator sees the units they configured. The
-                        // change handler runs the inverse before
-                        // committing back to storage.
-                        value={config[field.name] != null
-                            ? Number(rawToDisplay(Number(config[field.name]), field.scale))
-                            : null}
-                        // min/max are authored in display units, matching the
-                        // value rendered above — ValueInput rejects out-of-range
-                        // entries on accept.
-                        min={field.min}
-                        max={field.max}
-                        onValueChanged={(val) => handleFieldChange(field, val)}
-                        className={!valid ? 'p-invalid' : ''}
-                    />
-                ) : (
-                    <TextInput
-                        label={undefined}
-                        value={config[field.name] != null ? String(config[field.name]) : ''}
-                        onValueChanged={(val) => handleFieldChange(field, val)}
-                        className={!valid ? 'p-invalid' : ''}
-                    />
-                )}
-                {hasDescription(field) ? (
-                    <Button
-                        icon="pi pi-info-circle"
-                        text
-                        rounded
-                        aria-label={`About ${labelOf(field)}`}
-                        onClick={() => setInfoDialog({
-                            open: true,
-                            title: labelOf(field),
-                            body: <p style={{ margin: 0, whiteSpace: 'pre-wrap' }}>{field.description}</p>,
-                        })}
-                        // Replaces a hover Tooltip — touch-friendly. The
-                        // description is shown in the shared info dialog.
-                    />
-                ) : (
-                    <span aria-hidden="true" />
-                )}
-                <span style={{ color: valid ? 'var(--green-500)' : 'var(--red-500)', display: 'flex', alignItems: 'center' }}>
-                    <i className={valid ? 'pi pi-check' : 'pi pi-times'} />
-                </span>
-            </React.Fragment>
+                ) : undefined}
+            />
         );
     };
 
@@ -772,14 +618,8 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
         if (schema) {
             for (const field of schema.config_fields) {
                 if (field.name === 'sample_id') continue;
-                const v = config[field.name];
-                const empty = v === undefined || v === '' || v === null;
-                if (field.required && empty) {
-                    issues.push(`Required field "${labelOf(field)}" is empty.`);
-                    continue;
-                }
-                const re = rangeIssue(field, v);
-                if (re) issues.push(`"${labelOf(field)}" ${re}.`);
+                const issue = fieldIssue(field, config[field.name]);
+                if (issue) issues.push(`"${labelOf(field)}" ${issue}.`);
             }
         }
         return issues;