@adcops/autocore-react 3.3.123 → 3.5.3

package/src/components/tis/TestDataView.tsx

@@ -43,6 +43,9 @@ import { Line } from 'react-chartjs-2';
 import { EventEmitterContext } from '../../core/EventEmitterContext';
 import { MessageType } from '../../hub/CommandMessage';
 import { useTis } from './TisProvider';
+import { AutoCoreTagContext } from '../../core/AutoCoreTagContext';
+import { formatScaled } from '../../core/formatScaled';
+import type { ScaleConfig } from '../../core/AutoCoreTagTypes';
 import { useRawCycleData } from './useRawCycleData';
 import { ScienceTable } from './ScienceTable';
 import type { ScienceColumn } from './ScienceTable';
@@ -67,10 +70,22 @@ export interface TestFieldDef {
      *  prefer it over `name`; a header reading `cycle_count` is the wire
      *  key leaking into a screen that says "Cycles" everywhere else. */
     label?: string;
-    /** Optional display-time scale multiplier. `display = raw * scale`,
-     *  default 1.0 = no conversion. Cycle Data and Results panels
-     *  apply this when formatting numeric cells. Charts plot raw
-     *  values (axis labels already carry units). Storage stays raw. */
+    /**
+     * The QUANTITY this field measures — a scale-group name from the machine's
+     * `units.json` ("force", "position", …).
+     *
+     * When set, Cycle Data / Results render the value in the operator's ACTIVE
+     * unit system, at that system's precision, and the column header carries the
+     * active label. This is what makes a test run in Imperial read out in
+     * Imperial. Storage is untouched — conversion is a rendering step only.
+     *
+     * Takes precedence over `scale`/`units` below.
+     */
+    quantity?: string;
+    /**
+     * Legacy display-time scale multiplier. `display = raw * scale`, default
+     * 1.0. Superseded by `quantity`; kept for methods not yet annotated.
+     */
     scale?: number;
     /** Dropdown choices for this field. Each entry is either a bare scalar
      *  (label === stored value) or an explicit { label, value } pair.
@@ -145,6 +160,17 @@ export interface ChartView  {
      * count. Ignored when `smooth` is false.
      */
     smoothWindow?: number;
+    /**
+     * Maximum decimal places shown on X-axis tick labels. Default
+     * [`DEFAULT_X_DECIMALS`].
+     *
+     * Without a cap the labels print the stored double verbatim, so a value
+     * that is only *nearly* round — 0.30000000000000004, the ordinary result of
+     * accumulating a 0.1 step — renders as a 17-character tick and the axis
+     * becomes unreadable. This is a display cap only: the underlying data,
+     * table, CSV export and every calculation still see the full value.
+     */
+    x_decimals?: number;
     /**
      * Optional shaded X-range bands drawn over the plot, declared per view
      * in project.json (static). These are drawn on every cycle.
@@ -227,6 +253,10 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
     const schema    = props.schema    ?? (methodId ? (tis.schemas[methodId] as TestMethod) : undefined);
     const { throttleMs = 100, cycleTableHeight = '400px', chartHeight = '320px' } = props;
     const { invoke, subscribe, unsubscribe } = useContext(EventEmitterContext);
+    // The machine's resolved units table (quantity -> the active system's
+    // label/scalar/precision). Comes from the tag provider, so a live
+    // Metric/Imperial switch re-renders these tables with no reload.
+    const { scales: unitScales } = useContext(AutoCoreTagContext);
 
     const [meta, setMeta]       = useState<any>(null);
     const [cycles, setCycles]   = useState<any[]>([]);
@@ -523,10 +553,24 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
             const xField = selectedViewDef.x.field;
             if (!xField) return null;
             const asc = [...cycles].reverse(); // state is newest-first; charts want oldest-first
-            const xs = asc.map(c => c[xField]);
+            // cycle_scatter uses a CATEGORY x axis, so chart.js prints each
+            // label verbatim — an unrounded double lands on the axis with all
+            // 17 of its digits. Round here, at the point the label is made.
+            //
+            // Values are converted into the operator's active system first: the
+            // tables already followed the unit switch, so a chart left in
+            // backend units disagreed with the table beside it.
+            const xScale = unitScales?.[quantityOfField(schema, xField) ?? ''];
+            const decimals = selectedViewDef.x_decimals
+                ?? xScale?.precision
+                ?? DEFAULT_X_DECIMALS;
+            const xs = asc.map(c => formatAxisTick(toDisplayValue(c[xField], xScale), decimals));
             const datasets = selectedViewDef.y.map((s, idx) => ({
                 label: s.label ?? s.field,
-                data: asc.map(c => c[s.field!]),
+                data: asc.map(c => toDisplayValue(
+                    c[s.field!],
+                    unitScales?.[quantityOfField(schema, s.field) ?? ''],
+                )),
                 yAxisID: s.y_axis === 'right' ? 'y1' : 'y',
                 borderColor:  palette(idx),
                 backgroundColor: palette(idx),
@@ -539,12 +583,18 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
             if (!traceFetch.raw) return null;
             const xCol = selectedViewDef.x.column;
             if (!xCol) return null;
-            const xs = traceFetch.raw[xCol] ?? [];
+            const xTraceScale = unitScales?.[quantityOfColumn(schema, xCol) ?? ''];
+            const rawXs = traceFetch.raw[xCol] ?? [];
+            const xs = xTraceScale
+                ? (rawXs as number[]).map(v => toDisplayValue(v, xTraceScale))
+                : rawXs;
             // Display-only smoothing (default on). Leaves traceFetch.raw
             // untouched — only what chart.js draws changes.
             const smoothOn = selectedViewDef.smooth !== false;
             const datasets = selectedViewDef.y.map((s, idx) => {
-                const ys = (traceFetch.raw![s.column!] ?? []) as number[];
+                const yScale = unitScales?.[quantityOfColumn(schema, s.column) ?? ''];
+                const rawYs = (traceFetch.raw![s.column!] ?? []) as number[];
+                const ys = yScale ? rawYs.map(v => toDisplayValue(v, yScale) as number) : rawYs;
                 const data = smoothOn
                     ? smoothTraceForDisplay(xs, ys, selectedViewDef.smoothWindow)
                     : ys.map((y, i) => ({ x: xs[i], y }));
@@ -565,7 +615,7 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
             return { datasets };
         }
         return null;
-    }, [selectedViewDef, cycles, traceFetch.raw]);
+    }, [selectedViewDef, cycles, traceFetch.raw, unitScales, schema]);
 
     const usesRightAxis = selectedViewDef?.y.some(s => s.y_axis === 'right') ?? false;
 
@@ -593,6 +643,32 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
 
     const chartOptions = useMemo(() => {
         const isTrace = selectedViewDef?.type === 'raw_trace';
+        // Unit for one series, from whichever side of the schema it reads.
+        const unitForSeries = (sr: ChartSeries): string | undefined => {
+            const q = isTrace
+                ? quantityOfColumn(schema, sr.column)
+                : quantityOfField(schema, sr.field);
+            return q ? unitScales?.[q]?.label : undefined;
+        };
+        const xQuantity = isTrace
+            ? quantityOfColumn(schema, selectedViewDef?.x.column)
+            : quantityOfField(schema, selectedViewDef?.x.field);
+        const xUnit = xQuantity ? unitScales?.[xQuantity]?.label : undefined;
+        const xTitle = selectedViewDef?.x.label
+            ? (xUnit ? `${selectedViewDef.x.label} [${xUnit}]` : selectedViewDef.x.label)
+            : undefined;
+        const xDecimals = selectedViewDef?.x_decimals
+            ?? (xQuantity ? unitScales?.[xQuantity]?.precision : undefined)
+            ?? DEFAULT_X_DECIMALS;
+        // A linear axis picks its own tick values, and zooming in drives them
+        // to arbitrary precision — so cap them here too, not just on the
+        // category labels built in `chartData`.
+        const xTicks = {
+            callback(this: any, value: any) {
+                const raw = isTrace ? value : this?.getLabelForValue?.(value) ?? value;
+                return formatAxisTick(raw, xDecimals);
+            },
+        };
         return {
             responsive: true,
             maintainAspectRatio: false,
@@ -604,14 +680,16 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
             scales: {
                 x: isTrace
                     ? { type: 'linear' as const,
-                        title: { display: !!selectedViewDef?.x.label, text: selectedViewDef?.x.label } }
-                    : { title: { display: !!selectedViewDef?.x.label, text: selectedViewDef?.x.label } },
+                        ticks: xTicks,
+                        title: { display: !!xTitle, text: xTitle } }
+                    : { ticks: xTicks,
+                        title: { display: !!xTitle, text: xTitle } },
                 y: { position: 'left' as const,
-                     title: { display: true, text: leftAxisLabel(selectedViewDef) } },
+                     title: { display: true, text: axisLabel(selectedViewDef, 'left', unitForSeries) } },
                 ...(usesRightAxis ? {
                     y1: { position: 'right' as const,
                           grid: { drawOnChartArea: false },
-                          title: { display: true, text: rightAxisLabel(selectedViewDef) } },
+                          title: { display: true, text: axisLabel(selectedViewDef, 'right', unitForSeries) } },
                 } : {}),
             },
             plugins: {
@@ -632,7 +710,7 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
                 },
             },
         };
-    }, [selectedViewDef, usesRightAxis, activeRegions]);
+    }, [selectedViewDef, usesRightAxis, activeRegions, unitScales, schema]);
 
     // -----------------------------------------------------------------
     // View Raw Data dialog: lazy-fetch raw + filtered blobs the first
@@ -855,14 +933,19 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
                 // without an `editable` flag), while measured columns still
                 // have to opt in.
                 const cycleColumns: ScienceColumn[] = [
-                    ...(schema.cycle_config_fields ?? []).map(f => toScienceColumn(f, true)),
-                    ...(schema.cycle_fields ?? []).map(f => toScienceColumn(f, !!f.editable)),
+                    ...(schema.cycle_config_fields ?? []).map(f => toScienceColumn(f, true, unitScales)),
+                    ...(schema.cycle_fields ?? []).map(f => toScienceColumn(f, !!f.editable, unitScales)),
                 ];
                 return (
                     <ScienceTable
                         title={`Cycle Data (${cycles.length})`}
                         columns={cycleColumns}
                         rows={cycles}
+                        // `cycles` is newest-first, so the index has to count
+                        // down: the top row is the latest cycle and carries the
+                        // highest number. Ascending here would label the newest
+                        // cycle "1" and renumber every row on each arrival.
+                        indexOrder="descending"
                         scrollable={useVirtual}
                         scrollHeight={useVirtual ? cycleTableHeight : undefined}
                         emptyMessage="No cycles yet."
@@ -879,7 +962,7 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
                 const values = { ...results, ...sampleSummary };
                 const hasValues = Object.keys(values).length > 0;
                 const resultFields = schema.results_fields ?? [];
-                const resultColumns: ScienceColumn[] = resultFields.map(f => toScienceColumn(f));
+                const resultColumns: ScienceColumn[] = resultFields.map(f => toScienceColumn(f, false, unitScales));
                 const hasProjectScoped = resultFields.some(isProjectScoped);
                 return (
                     <>
@@ -1466,11 +1549,67 @@ const ChartOverlay: React.FC<{ children: React.ReactNode }> = ({ children }) =>
 // Axis labels work for both scatter (s.field) and raw_trace (s.column)
 // series. Whichever the view declared, that's what's used as a label
 // fallback when the explicit `label` is absent.
+/**
+ * Decimal places on X-axis tick labels when a view doesn't say otherwise.
+ * Two is enough to separate adjacent ticks on every axis this renders
+ * (time in seconds, position in mm, load in N) without printing float noise.
+ */
+export const DEFAULT_X_DECIMALS = 2;
+
+/**
+ * Cap a tick label's decimals without padding it.
+ *
+ * `toFixed` alone would turn a clean 0, 1, 2 axis into "0.00", "1.00", "2.00";
+ * re-parsing drops the trailing zeros, so this caps precision rather than
+ * fixing it. Non-numeric labels (a category axis over strings) pass through.
+ */
+const formatAxisTick = (v: unknown, decimals: number): string => {
+    const n = typeof v === 'number' ? v : Number(v);
+    if (!Number.isFinite(n)) return v == null ? '' : String(v);
+    return Number.parseFloat(n.toFixed(decimals)).toString();
+};
+
+/**
+ * The quantity a cycle/results FIELD declares, if any.
+ *
+ * Derived from the method schema rather than a new key on the chart view, so a
+ * method annotated once (for the tables) automatically gets converted charts.
+ */
+const quantityOfField = (schema: TestMethod | undefined, name?: string): string | undefined => {
+    if (!schema || !name) return undefined;
+    for (const arr of [schema.cycle_config_fields, schema.cycle_fields, schema.results_fields]) {
+        const hit = (arr ?? []).find(f => f.name === name);
+        if (hit?.quantity) return hit.quantity;
+    }
+    return undefined;
+};
+
+/** The quantity a raw_data COLUMN declares, if any. */
+const quantityOfColumn = (schema: TestMethod | undefined, name?: string): string | undefined => {
+    if (!schema || !name) return undefined;
+    return (schema.raw_data?.columns?.[name] as any)?.quantity;
+};
+
+/** backend -> display for a resolved scale (identity when there is none). */
+const toDisplayValue = (v: any, scale?: ScaleConfig): any =>
+    scale && typeof v === 'number' && Number.isFinite(v)
+        ? v * scale.scale + (scale.offset ?? 0)
+        : v;
+
 const seriesLabel = (s: ChartSeries) => s.label ?? s.field ?? s.column ?? '';
-const leftAxisLabel = (v?: ChartView) =>
-    v?.y.filter(s => s.y_axis !== 'right').map(seriesLabel).join(' / ') ?? '';
-const rightAxisLabel = (v?: ChartView) =>
-    v?.y.filter(s => s.y_axis === 'right').map(seriesLabel).join(' / ') ?? '';
+/** Series names for one side, with the active unit appended when they share one. */
+const axisLabel = (
+    v: ChartView | undefined,
+    side: 'left' | 'right',
+    unitFor: (s: ChartSeries) => string | undefined,
+): string => {
+    const series = v?.y.filter(s => (s.y_axis === 'right') === (side === 'right')) ?? [];
+    const names = series.map(seriesLabel).join(' / ');
+    const units = Array.from(new Set(series.map(unitFor).filter(Boolean)));
+    // Only label the axis when every series on it shares a unit — a mixed axis
+    // must not claim one.
+    return units.length === 1 ? `${names} [${units[0]}]` : names;
+};
 
 /**
  * Format one value for a cycle / results / config cell.
@@ -1490,19 +1629,50 @@ const rightAxisLabel = (v?: ChartView) =>
  */
 const isProjectScoped = (f: TestFieldDef): boolean => f.aggregate?.scope === 'project';
 
-const toScienceColumn = (f: TestFieldDef, editable = false): ScienceColumn => ({
-    field: f.name,
-    // A project-scoped rollup sits in the same row as this test's own
-    // numbers, so it has to say so. Marked here and explained in a note
-    // under the table — never in a tooltip.
-    label: (f.label && f.label.length > 0 ? f.label : f.name) + (isProjectScoped(f) ? ' *' : ''),
-    units: f.units,
-    editable,
-    body: (row) => formatCell(row[f.name], f.type, f.scale),
-});
-
-const formatCell = (v: any, type: string, scale?: number): string => {
+/**
+ * One schema field -> one <ScienceTable> column.
+ *
+ * `unitScales` is the machine's resolved units table (quantity -> active
+ * system's treatment). When the field declares a `quantity` present there, both
+ * the header unit AND the cell values come from it, so the column can never show
+ * a value in one unit under a header naming another.
+ */
+const toScienceColumn = (
+    f: TestFieldDef,
+    editable = false,
+    unitScales?: Record<string, ScaleConfig>,
+): ScienceColumn => {
+    const unitScale = f.quantity ? unitScales?.[f.quantity] : undefined;
+    return {
+        field: f.name,
+        // A project-scoped rollup sits in the same row as this test's own
+        // numbers, so it has to say so. Marked here and explained in a note
+        // under the table — never in a tooltip.
+        label: (f.label && f.label.length > 0 ? f.label : f.name) + (isProjectScoped(f) ? ' *' : ''),
+        units: unitScale ? unitScale.label : f.units,
+        editable,
+        body: (row) => formatCell(row[f.name], f.type, f.scale, unitScale),
+    };
+};
+
+/**
+ * Render one stored (backend) value for display.
+ *
+ * When the field declares a `quantity` and the machine has a units table, the
+ * value is converted into the operator's active system and formatted at that
+ * system's precision — so switching Metric/Imperial re-renders the table without
+ * touching a byte on disk. Otherwise the legacy `scale` multiplier applies.
+ */
+const formatCell = (
+    v: any,
+    type: string,
+    scale?: number,
+    unitScale?: ScaleConfig,
+): string => {
     if (v === null || v === undefined) return '';
+    if (unitScale && typeof v === 'number' && Number.isFinite(v)) {
+        return formatScaled(v * unitScale.scale + (unitScale.offset ?? 0), unitScale);
+    }
     if (scale && scale !== 1 && typeof v === 'number' && Number.isFinite(v)) {
         v = v * scale;
     }

package/src/components/tis/TestFieldRow.tsx

@@ -14,7 +14,8 @@
  *   display = raw * scale     raw = display / scale
  */
 
-import React from 'react';
+import React, { useContext } from 'react';
+import { AutoCoreTagContext } from '../../core/AutoCoreTagContext';
 import { Button } from 'primereact/button';
 import { Dropdown } from 'primereact/dropdown';
 import { ValueInput } from '../ValueInput';
@@ -29,6 +30,13 @@ export interface TestFieldDef {
     /** Canonical key — wire format, generated code, on-disk JSON. */
     name: string;
     type: string;
+    /**
+     * Scale-group name from the machine's `units.json` ("force", "position", …).
+     * When set, this field is displayed and entered in the operator's ACTIVE
+     * unit system and its label carries that unit; storage stays backend.
+     * Supersedes `units` / `scale` below.
+     */
+    quantity?: string;
     units?: string;
     required?: boolean;
     source?: string;
@@ -59,11 +67,20 @@ export interface TestFieldDef {
      *  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 inclusive bounds for the operator's numeric entry. The numeric
+     *  input rejects values outside `[min, max]`; non-numeric fields ignore them.
+     *
+     *  A `number` is authored in DISPLAY units (same convention as `default`
+     *  and `scale`). A `string` is an FQDN token `"${gm.<var>}"`, resolved LIVE
+     *  from that tag — for a bound that belongs to the MACHINE rather than the
+     *  method, the load-cell force ceiling being the motivating case: hard-code
+     *  it and it is wrong the moment a different cell is fitted, and the
+     *  operator hits a wall the machine could have moved for them.
+     *
+     *  `effectiveField` resolves tokens, so everything downstream of it
+     *  (`rangeIssue`, the input's bounds) only ever sees numbers. */
+    min?: number | string;
+    max?: number | string;
     /** 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
@@ -115,16 +132,92 @@ export type CycleConfigScope = 'run' | 'cycle';
  * 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;
+export const rawToDisplay = (raw: any, scale: number | undefined, offset = 0): any => {
+    if ((!scale || scale === 1) && !offset) return raw;
     if (typeof raw !== 'number' || !Number.isFinite(raw)) return raw;
-    return raw * scale;
+    return raw * (scale ?? 1) + offset;
 };
 
-export const displayToRaw = (display: any, scale: number | undefined): any => {
-    if (!scale || scale === 1) return display;
+export const displayToRaw = (display: any, scale: number | undefined, offset = 0): any => {
+    if ((!scale || scale === 1) && !offset) return display;
     if (typeof display !== 'number' || !Number.isFinite(display)) return display;
-    return display / scale;
+    return (display - offset) / (scale ?? 1);
+};
+
+/**
+ * Resolve a field against the machine's units table.
+ *
+ * Returns the field with `scale` / `units` overridden by the operator's ACTIVE
+ * unit system when it declares a `quantity`. Doing it this way means every
+ * existing `rawToDisplay(v, f.scale)` / `labelOf(f)` call site keeps working and
+ * automatically follows a Metric/Imperial switch — the alternative was threading
+ * a units argument through a dozen call sites.
+ *
+ * A field with no `quantity` (or a machine with no units table) is returned
+ * unchanged, so an un-annotated method behaves exactly as before.
+ */
+export const effectiveField = (
+    f: TestFieldDef,
+    unitScales?: Record<string, { scale: number; label: string; offset?: number }>,
+    tags?: TagLookup,
+): EffectiveField => {
+    const u = f.quantity ? unitScales?.[f.quantity] : undefined;
+    const scale = u ? u.scale : f.scale;
+    const offset = u ? u.offset ?? 0 : 0;
+    const base = u ? { ...f, scale, units: u.label, unitOffset: offset } : { ...f };
+    return {
+        ...base,
+        min: resolveBound(f.min, scale, offset, tags),
+        max: resolveBound(f.max, scale, offset, tags),
+    };
+};
+
+/** What `effectiveField` needs to resolve an `${fqdn}` bound. */
+export interface TagLookup {
+    findTagByFqdn: (fqdn: string) => { tagName: string } | undefined;
+    rawValues: Record<string, unknown>;
+}
+
+/** Matches a bound token like `${gm.press_force_min_n}` (whole-string). */
+const BOUND_TOKEN_RE = /^\$\{\s*([^}]+?)\s*\}$/;
+
+/**
+ * A declared bound resolved to a plain DISPLAY-unit number, or `undefined` for
+ * "no bound".
+ *
+ * A number passes through — it was already authored in display units. A token
+ * is looked up as a tag, whose value is RAW, and converted with the same scale
+ * and offset as the value it will be compared against; otherwise an imperial or
+ * affine field would compare two numbers from different spaces.
+ *
+ * An unresolvable token yields `undefined`, i.e. NO bound — never zero, which
+ * would silently reject every entry. Fail-open is deliberate here: this is an
+ * authoring aid, and walling off a field because a tag has not arrived yet would
+ * make a machine unusable at startup. The interlock that matters lives in the
+ * machine, not in this form.
+ */
+export const resolveBound = (
+    bound: number | string | undefined,
+    scale: number | undefined,
+    offset: number,
+    tags?: TagLookup,
+): number | undefined => {
+    if (typeof bound === 'number') return bound;
+    if (typeof bound !== 'string' || !tags) return undefined;
+    const m = bound.match(BOUND_TOKEN_RE);
+    if (!m) return undefined;
+    const tag = tags.findTagByFqdn(m[1]);
+    const raw = tag ? tags.rawValues[tag.tagName] : undefined;
+    if (typeof raw !== 'number' || !Number.isFinite(raw)) return undefined;
+    const disp = Number(rawToDisplay(raw, scale, offset));
+    return Number.isFinite(disp) ? disp : undefined;
+};
+
+/** A field with its units applied and its bounds resolved to numbers. */
+export type EffectiveField = TestFieldDef & {
+    unitOffset?: number;
+    min?: number;
+    max?: number;
 };
 
 /** Field label with `[units]` appended when declared. */
@@ -153,13 +246,20 @@ export const fieldValueIsEmpty = (v: any): boolean =>
  */
 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));
+    // Only NUMERIC bounds constrain anything. A field that still carries an
+    // unresolved `${fqdn}` token has not been through `effectiveField`, and the
+    // honest answer is "unbounded" rather than a comparison against a string.
+    const min = typeof f.min === 'number' ? f.min : undefined;
+    const max = typeof f.max === 'number' ? f.max : undefined;
+    if (min == null && max == null) return null;
+    // Same offset the input uses, so an affine quantity (temperature) compares
+    // in one space rather than two.
+    const disp = Number(rawToDisplay(Number(raw), f.scale, (f as any).unitOffset ?? 0));
     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;
+    const lo = min != null && max != null ? Math.min(min, max) : min;
+    const hi = min != null && max != null ? Math.max(min, max) : max;
     if (lo != null && disp < lo) return `must be ≥ ${lo}`;
     if (hi != null && disp > hi) return `must be ≤ ${hi}`;
     return null;
@@ -225,8 +325,15 @@ export interface TestFieldRowProps {
  * validity icon. Returns a Fragment, so the caller owns the grid.
  */
 export const TestFieldRow: React.FC<TestFieldRowProps> = ({
-    field, value, onChange, valid, disabled, control, onInfo,
+    field: declaredField, value, onChange, valid, disabled, control, onInfo,
 }) => {
+    // Resolve the field against the machine's active unit system, so a config
+    // field annotated with a `quantity` is entered and displayed in the
+    // operator's units instead of always in backend units. Every consumer of
+    // this row gets that for free.
+    const { scales: unitScales, rawValues, findTagByFqdn } = useContext(AutoCoreTagContext);
+    const field = effectiveField(declaredField, unitScales as any, { findTagByFqdn, rawValues });
+    const unitOffset = (field as any).unitOffset ?? 0;
     const ok = valid ?? fieldIsValid(field, value);
     const dropdownOptions = !control && Array.isArray(field.options) && field.options.length > 0
         ? normalizeOptions(field.options)
@@ -250,12 +357,12 @@ export const TestFieldRow: React.FC<TestFieldRowProps> = ({
             // 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}
+            value={value != null ? Number(rawToDisplay(Number(value), field.scale, unitOffset)) : 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))}
+            onValueChanged={(val) => onChange(displayToRaw(val, field.scale, unitOffset))}
             className={!ok ? 'p-invalid' : ''}
             disabled={disabled}
         />

package/src/components/tis/TestSetupForm.tsx

@@ -14,6 +14,7 @@ import { ConfigurationDialog, configLabelOf } from './ConfigurationDialog';
 import {
     TestFieldRow,
     displayToRaw,
+    effectiveField,
     fieldIsValid,
     fieldIssue,
     labelOf,
@@ -239,7 +240,7 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
 }) => {
     const tis = useTis();
     const { invoke, write } = useContext(EventEmitterContext);
-    const { rawValues, findTagByFqdn } = useContext(AutoCoreTagContext);
+    const { rawValues, findTagByFqdn, scales: unitScales } = useContext(AutoCoreTagContext);
 
     const methodIds = useMemo(() => Object.keys(tis.schemas), [tis.schemas]);
 
@@ -276,8 +277,14 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
     const applyConfigOverridesInto = (cfg: TestConfiguration, target: any): any => {
         for (const [fieldName, val] of Object.entries(cfg.defaults ?? {})) {
             if (fieldName === 'sample_id') continue;
-            const field = schema?.config_fields.find((f: TestFieldDef) => f.name === fieldName);
-            const rawVal = displayToRaw(val, field?.scale);
+            const declared = schema?.config_fields.find((f: TestFieldDef) => f.name === fieldName);
+            // Resolve against the active unit system: a configuration's defaults
+            // are authored in display units, so they must be converted with the
+            // same scale the operator is looking at.
+            const field = declared
+                ? effectiveField(declared, unitScales as any, { findTagByFqdn, rawValues })
+                : undefined;
+            const rawVal = displayToRaw(val, field?.scale, (field as any)?.unitOffset ?? 0);
             target[fieldName] = rawVal;
             if (field?.source) {
                 void Promise.resolve()
@@ -457,7 +464,7 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
 
         for (const field of schema.config_fields) {
             if (field.name === 'sample_id') continue;
-            if (fieldIssue(field, config[field.name])) { valid = false; break; }
+            if (fieldIssue(effective(field), config[field.name])) { valid = false; break; }
         }
 
         setIsValid(valid);
@@ -480,6 +487,13 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
                 config:     mergedConfig,
             } as any).catch(e => console.error('[TestSetupForm] stage_test failed:', e));
         }
+        // `rawValues` is deliberately NOT a dependency even though `effective`
+        // reads it: this effect calls `tis.stage_test` on every valid run, so
+        // waking it on every tag update would be an IPC storm. The closure is
+        // rebuilt each render, so a resolved bound is current whenever the
+        // operator touches anything — which is when the gate matters. The only
+        // gap is a bound that moves while a staged test sits untouched, and the
+        // machine refuses an out-of-range move regardless.
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [
         config, schema, projectId, methodId, sampleId,
@@ -487,7 +501,21 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
         onValidationChange, invoke,
     ]);
 
-    const isFieldValid = (field: TestFieldDef) => fieldIsValid(field, config[field.name]);
+    /**
+     * A declared field with its active units applied and its `${fqdn}` bounds
+     * resolved — the form's single view of what a field actually allows.
+     *
+     * Every validity check goes through this, not the raw `schema.config_fields`
+     * entry. Two reasons: a token bound is a string until resolved, so an
+     * unresolved field reads as unbounded and the gate would disagree with the
+     * input that IS enforcing it; and the bounds are authored in display units,
+     * so a field whose scale comes from the active unit system has to be
+     * resolved before anything compares against them.
+     */
+    const effective = (f: TestFieldDef) =>
+        effectiveField(f, unitScales as any, { findTagByFqdn, rawValues });
+
+    const isFieldValid = (field: TestFieldDef) => fieldIsValid(effective(field), config[field.name]);
 
     const handleSampleIdChange = (value: string) => {
         setSampleIdLocal(value);
@@ -618,8 +646,8 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
         if (schema) {
             for (const field of schema.config_fields) {
                 if (field.name === 'sample_id') continue;
-                const issue = fieldIssue(field, config[field.name]);
-                if (issue) issues.push(`"${labelOf(field)}" ${issue}.`);
+                const issue = fieldIssue(effective(field), config[field.name]);
+                if (issue) issues.push(`"${labelOf(effective(field))}" ${issue}.`);
             }
         }
         return issues;