@adcops/autocore-react 3.3.83 → 3.3.85

package/src/components/ams/index.ts

@@ -10,6 +10,7 @@ export type { AmsRole, AmsRoleRegistry } from './AmsProvider';
 export { AssetRegistryTable } from './AssetRegistryTable';
 export { AssetDetailView } from './AssetDetailView';
 export { CalibrationEntryDialog } from './CalibrationEntryDialog';
+export { AssetEditDialog } from './AssetEditDialog';
 export { SubLocationPicker } from './SubLocationPicker';
 export { PlaceholderHealthPanel } from './PlaceholderHealthPanel';
 export { MissingAssetsBanner } from './MissingAssetsBanner';

package/src/components/network/NetworkPanel.tsx

@@ -118,7 +118,19 @@ export const NetworkPanel: React.FC<NetworkPanelProps> = ({ className }) => {
             }}>
                 <div>
                     <h3 style={{ margin: 0 }}>Network</h3>
-                    {activeWifi ? (
+                    {/* Three states for the status line:
+                     *  - status hasn't loaded yet: "Loading…" — keeps
+                     *    the panel from flashing "No WiFi device" while
+                     *    the initial nw.list_interfaces is in flight.
+                     *  - status loaded, a wifi device exists: show its
+                     *    connection / state / IP.
+                     *  - status loaded, no wifi device: the genuine
+                     *    "No WiFi device detected" message. */}
+                    {!net.statusLoaded ? (
+                        <div style={{ fontSize: '0.875rem', color: '#9ca3af', marginTop: '0.25rem' }}>
+                            Loading network status…
+                        </div>
+                    ) : activeWifi ? (
                         <div style={{ fontSize: '0.875rem', color: '#9ca3af', marginTop: '0.25rem' }}>
                             {activeWifi.state === 'connected'
                                 ? <>Connected to <code>{activeWifi.connection || '(unnamed)'}</code> on <code>{activeWifi.device}</code></>

package/src/components/tis/TestDataView.tsx

@@ -60,6 +60,11 @@ export interface TestFieldDef {
     units?: string;
     required?: boolean;
     source?: 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. */
+    scale?: number;
 }
 
 export interface ChartAxis  { field?: string; column?: string; label?: string; }
@@ -127,6 +132,13 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
     const [rawOpen, setRawOpen] = useState(false);
     const [configOpen, setConfigOpen] = useState(false);
 
+    // Direct handle on the chart.js instance so the toolbar's reset-
+    // zoom button can call chart.resetZoom() — the zoom plugin's only
+    // imperative API. Customers like the wheel/pinch/drag zoom but
+    // can get lost in the chart with no obvious way back; the icon
+    // button in the chart's header row is the escape hatch.
+    const chartRef = useRef<any>(null);
+
     // Lazy-loaded blobs for the View Raw Data dialog. Fetched only
     // when the dialog opens, and re-fetched if the operator pins a
     // different run / cycle while the dialog is closed.
@@ -537,31 +549,63 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
                             </span>
                         </>
                     )}
+                    {/* Spacer pushes the reset-zoom button to the right
+                        edge of the row, opposite the dropdown. The
+                        pi-th-large icon mirrors a "view all" / "fit"
+                        affordance — the chart.js zoom plugin calls
+                        this resetZoom and we wire it on the chartRef
+                        below. Customers wanted the affordance because
+                        the chart's wheel/pinch zoom is easy to lose
+                        track of mid-test. */}
+                    <div style={{ flex: 1 }} />
+                    <Button
+                        icon="pi pi-th-large"
+                        outlined
+                        rounded
+                        size="small"
+                        onClick={() => chartRef.current?.resetZoom?.()}
+                        disabled={!chartData}
+                        tooltip="Reset chart zoom"
+                        tooltipOptions={{ position: 'left' }}
+                        aria-label="Reset chart zoom"
+                    />
                 </div>
                 <div style={{ height: chartHeight, position: 'relative' }}>
                     {isRawTraceView && traceFetch.loading &&
                         <ChartOverlay>Loading raw data…</ChartOverlay>}
                     {isRawTraceView && traceFetch.error &&
                         <ChartOverlay>{traceFetch.error}</ChartOverlay>}
-                    {chartData && <Line data={chartData} options={chartOptions} />}
+                    {chartData && <Line ref={chartRef} data={chartData} options={chartOptions} />}
                 </div>
             </div>
 
             <div className="p-card" style={{ padding: '1rem' }}>
                 <h3 style={{ marginTop: 0 }}>Cycle Data ({cycles.length})</h3>
-                <DataTable
-                    value={cycles}
-                    scrollable
-                    scrollHeight={cycleTableHeight}
-                    virtualScrollerOptions={{ itemSize: 38 }}
-                    emptyMessage="No cycles yet."
-                >
-                    {schema.cycle_fields.map(f => (
-                        <Column key={f.name} field={f.name}
-                                header={f.units ? `${f.name} (${f.units})` : f.name}
-                                body={(row) => formatCell(row[f.name], f.type)} />
-                    ))}
-                </DataTable>
+                {/* Size-to-content for small runs (≤ CYCLE_VIRTUAL_THRESHOLD
+                    rows) so the Results panel below isn't pushed off-screen
+                    on tests with one or two cycles. Larger runs flip to
+                    virtual scrolling against `cycleTableHeight` so a
+                    1000-cycle test doesn't render 1000 row elements at
+                    once. Operators on test methods that always run a
+                    fixed-size short cycle list see no scrollbar at all. */}
+                {(() => {
+                    const useVirtual = cycles.length > CYCLE_VIRTUAL_THRESHOLD;
+                    return (
+                        <DataTable
+                            value={cycles}
+                            scrollable={useVirtual}
+                            scrollHeight={useVirtual ? cycleTableHeight : undefined}
+                            virtualScrollerOptions={useVirtual ? { itemSize: 38 } : undefined}
+                            emptyMessage="No cycles yet."
+                        >
+                            {schema.cycle_fields.map(f => (
+                                <Column key={f.name} field={f.name}
+                                        header={f.units ? `${f.name} (${f.units})` : f.name}
+                                        body={(row) => formatCell(row[f.name], f.type, f.scale)} />
+                            ))}
+                        </DataTable>
+                    );
+                })()}
             </div>
 
             <div className="p-card" style={{ padding: '1rem' }}>
@@ -944,13 +988,22 @@ const ResultsGrid: React.FC<{ schema: TestFieldDef[]; values: any }> = ({ schema
                     <div style={{ fontSize: '0.8em', color: 'var(--text-secondary-color)' }}>
                         {f.name}{f.units ? ` (${f.units})` : ''}
                     </div>
-                    <div>{formatCell(values[f.name], f.type)}</div>
+                    <div>{formatCell(values[f.name], f.type, f.scale)}</div>
                 </div>
             ))}
         </div>
     );
 };
 
+/** Row count above which the Cycle Data table switches into virtual-
+ *  scroll mode with a fixed `cycleTableHeight`. At or below the
+ *  threshold the table sizes to its content so the Results panel
+ *  below doesn't get pushed off-screen on short runs. 30 is enough to
+ *  comfortably show a typical hand-tuned test session without
+ *  scrolling but small enough that virtualization kicks in well
+ *  before performance becomes a concern. */
+const CYCLE_VIRTUAL_THRESHOLD = 30;
+
 const CHART_COLORS = [
     '#4ea8de', '#f59e0b', '#22c55e', '#a855f7',
     '#ef4444', '#14b8a6', '#eab308', '#ec4899',
@@ -977,8 +1030,19 @@ const leftAxisLabel = (v?: ChartView) =>
 const rightAxisLabel = (v?: ChartView) =>
     v?.y.filter(s => s.y_axis === 'right').map(seriesLabel).join(' / ') ?? '';
 
-const formatCell = (v: any, type: string): string => {
+/**
+ * Format one value for a cycle / results / config cell.
+ *
+ * `scale`, when present and != 1, is applied to numeric values so the
+ * cell displays in operator units while storage stays raw. Mirrors
+ * the convention used by AutoCoreTagContext: `display = raw * scale`.
+ * Non-numeric values pass through unchanged.
+ */
+const formatCell = (v: any, type: string, scale?: number): string => {
     if (v === null || v === undefined) return '';
+    if (scale && scale !== 1 && typeof v === 'number' && Number.isFinite(v)) {
+        v = v * scale;
+    }
     if (type === 'f32' || type === 'f64') {
         return typeof v === 'number' ? v.toFixed(4) : String(v);
     }

package/src/components/tis/TestSetupForm.tsx

@@ -43,8 +43,22 @@ export interface TestFieldDef {
      *  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. */
+     *  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;
 }
 
 export interface TestMethod {
@@ -104,6 +118,30 @@ const labelOf = (f: TestFieldDef): string => {
     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;
 
@@ -265,14 +303,20 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
                 if (field.name === 'sample_id') continue;
                 if (field.default === undefined || field.default === null) continue;
                 if (next === prev) next = { ...prev };
-                next[field.name] = field.default;
+                // Schema defaults are authored in DISPLAY units (per
+                // the agreed convention) so the value the author reads
+                // in project.json matches the field's `units` label.
+                // Convert to raw before storing in stagedConfig / GM
+                // so the rest of the pipeline sees the canonical value.
+                const rawDefault = displayToRaw(field.default, field.scale);
+                next[field.name] = rawDefault;
                 if (field.source) {
                     // Mirror handleFieldChange: write to GM so the
                     // control program sees the default. Errors here are
                     // logged but non-fatal — the form still reflects
                     // the default locally.
                     void Promise.resolve()
-                        .then(() => write(field.source!, field.default))
+                        .then(() => write(field.source!, rawDefault))
                         .catch(e => console.error(
                             `[TestSetupForm] Failed to seed default for ${field.name}:`, e));
                 }
@@ -360,9 +404,13 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
     };
 
     const handleFieldChange = async (field: TestFieldDef, val: any) => {
-        setConfig({ ...config, [field.name]: val });
+        // 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);
+        setConfig({ ...config, [field.name]: rawVal });
         if (field.source) {
-            try { await write(field.source, val); }
+            try { await write(field.source, rawVal); }
             catch (e) { console.error('Failed to write to source:', e); }
         }
     };
@@ -417,7 +465,13 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
                 ) : isNum ? (
                     <ValueInput
                         label={undefined}
-                        value={config[field.name] != null ? Number(config[field.name]) : null}
+                        // 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}
                         onValueChanged={(val) => handleFieldChange(field, val)}
                         className={!valid ? 'p-invalid' : ''}
                     />

package/src/components/tis/useRawCycleData.ts

@@ -11,12 +11,27 @@
  *                          (set `enabled` to false to short-circuit while
  *                          a cycle_scatter view is active).
  *
- * Keeping the fetch logic in one place means the two components can't
- * drift in how they discover cycles, default to "latest cycle", or
- * unwrap the per-cycle envelope.
+ * Live updates
+ * ------------
+ * The hook subscribes to the `tis.raw_data_added` broadcast and refreshes
+ * the cycle list whenever a new raw blob lands on disk for the matching
+ * (project, method, run, blob). When the operator is already viewing the
+ * latest cycle, the picker advances to the new latest and the chart
+ * re-paints — that's the customer-facing "chart updates each cycle"
+ * behaviour. When the operator has manually pinned an earlier cycle (e.g.
+ * examining cycle 3 while cycle 47 streams in), the picker stays put so
+ * the examination isn't interrupted.
+ *
+ * The hook intentionally suppresses `read_raw` until at least one cycle
+ * is known to be on disk for this slice. Otherwise the server returns
+ * "no raw_data file found" between `tis.start_test` and the first
+ * `add_raw_data` write, and the chart flashes an error overlay during
+ * what's really just "test just started, no data yet" — confusing for
+ * the operator. With the suppression the chart sits empty (or in a
+ * loading state) until the first raw_data_added broadcast arrives.
  */
 
-import { useContext, useEffect, useState } from 'react';
+import { useCallback, useContext, useEffect, useRef, useState } from 'react';
 import { EventEmitterContext } from '../../core/EventEmitterContext';
 import { MessageType } from '../../hub/CommandMessage';
 
@@ -50,7 +65,7 @@ export interface UseRawCycleDataResult {
 
 export function useRawCycleData(opts: UseRawCycleDataOptions): UseRawCycleDataResult {
     const { projectId, methodId, runId, blobName, enabled } = opts;
-    const { invoke } = useContext(EventEmitterContext);
+    const { invoke, subscribe, unsubscribe } = useContext(EventEmitterContext);
 
     const [cycles, setCycles]               = useState<number[]>([]);
     const [selectedCycle, setSelectedCycle] = useState<number | null>(null);
@@ -59,14 +74,49 @@ export function useRawCycleData(opts: UseRawCycleDataOptions): UseRawCycleDataRe
     const [loading, setLoading]             = useState(false);
     const [error, setError]                 = useState<string | null>(null);
 
+    // Track whether the user has explicitly pinned a cycle. When false,
+    // the live-follow path is free to advance the picker to the newest
+    // cycle as it arrives. Flipping to true on a manual pick freezes
+    // the picker so examining cycle 3 while cycle 47 streams in doesn't
+    // get yanked back to 47.
+    //
+    // Lives in a ref so updating it doesn't re-trigger any effect — it's
+    // a behavioural latch, not state the renderer cares about.
+    const userPinnedRef = useRef<boolean>(false);
+
+    /** Discover the per-cycle indices currently on disk for this slice.
+     *  Returns the sorted-ascending list; never throws (a listing error
+     *  is logged-as-empty rather than surfaced — the rendering layer
+     *  has its own empty state). */
+    const listCycles = useCallback(async (): Promise<number[]> => {
+        if (!projectId || !methodId || !runId) return [];
+        try {
+            const resp: any = await invoke(
+                'tis.list_raw' as any, MessageType.Request as any,
+                { project_id: projectId, method_id: methodId, run_id: runId } as any,
+            );
+            if (!resp?.success) return [];
+            const list: any[] = resp.data?.cycles ?? [];
+            return list
+                .filter(c => c?.name === blobName && typeof c?.cycle_index === 'number')
+                .map(c => c.cycle_index as number)
+                .sort((a, b) => a - b);
+        } catch {
+            return [];
+        }
+    }, [projectId, methodId, runId, blobName, invoke]);
+
     // Reset cycle state when the run identity (or blob) changes — the
     // new slice has its own cycle list and its own "latest" target.
+    // Clearing userPinnedRef too so the next slice is free to follow
+    // the latest cycle automatically.
     useEffect(() => {
         setCycles([]);
         setSelectedCycle(null);
         setRaw(null);
         setEnvelope(null);
         setError(null);
+        userPinnedRef.current = false;
     }, [projectId, methodId, runId, blobName]);
 
     // Cycle-list discovery. Runs ahead of the data fetch so the cycle
@@ -75,47 +125,86 @@ export function useRawCycleData(opts: UseRawCycleDataOptions): UseRawCycleDataRe
         if (!enabled || !projectId || !methodId || !runId) return;
         let cancelled = false;
         (async () => {
-            try {
-                const resp: any = await invoke(
-                    'tis.list_raw' as any, MessageType.Request as any,
-                    { project_id: projectId, method_id: methodId, run_id: runId } as any,
-                );
-                if (cancelled || !resp?.success) return;
-                const list: any[] = resp.data?.cycles ?? [];
-                const indices = list
-                    .filter(c => c?.name === blobName && typeof c?.cycle_index === 'number')
-                    .map(c => c.cycle_index as number)
-                    .sort((a, b) => a - b);
-                setCycles(indices);
-                if (indices.length > 0) {
-                    setSelectedCycle(prev => prev ?? indices[indices.length - 1]);
-                }
-            } catch {
-                // Listing failure is non-fatal — the data fetch below
-                // still tries "latest" and the picker just stays empty.
+            const indices = await listCycles();
+            if (cancelled) return;
+            setCycles(indices);
+            if (indices.length > 0) {
+                setSelectedCycle(prev => prev ?? indices[indices.length - 1]);
             }
         })();
         return () => { cancelled = true; };
-    }, [enabled, projectId, methodId, runId, blobName, invoke]);
+    }, [enabled, projectId, methodId, runId, blobName, listCycles]);
+
+    // Live updates: each new raw_data file landing on disk triggers a
+    // re-listing. The handler closes over `selectedCycle` via the
+    // functional setter and the live `cycles` snapshot, so we use refs
+    // to avoid re-subscribing every time those state values change.
+    const cyclesRef = useRef<number[]>(cycles);
+    cyclesRef.current = cycles;
+    const selectedRef = useRef<number | null>(selectedCycle);
+    selectedRef.current = selectedCycle;
+
+    useEffect(() => {
+        if (!enabled || !projectId || !methodId || !runId) return;
+        const onRawAdded = async (payload: any) => {
+            // Filter to the slice this hook instance is bound to.
+            // The server can also fire raw_data_added for the same
+            // run+method+project but a different blob name (rare, but
+            // legal); the blob-name check keeps us from refreshing
+            // for an unrelated dataset.
+            if (payload?.project_id !== projectId) return;
+            if (payload?.method_id  !== methodId)  return;
+            if (payload?.run_id     !== runId)     return;
+            if (payload?.name       !== blobName)  return;
+
+            const fresh = await listCycles();
+            if (fresh.length === 0) return;
+            setCycles(fresh);
+            // Auto-follow "latest" iff the operator hasn't manually
+            // moved away from it. The "was viewing the previous
+            // latest" check uses the snapshot taken via the ref so the
+            // closure stays stable.
+            const prevLatest = cyclesRef.current.length > 0
+                ? cyclesRef.current[cyclesRef.current.length - 1]
+                : null;
+            const newLatest  = fresh[fresh.length - 1];
+            const onLatest   = !userPinnedRef.current
+                && (selectedRef.current === null || selectedRef.current === prevLatest);
+            if (onLatest && newLatest !== selectedRef.current) {
+                setSelectedCycle(newLatest);
+            }
+        };
+        const id = subscribe('tis.raw_data_added', onRawAdded);
+        return () => { unsubscribe(id); };
+    }, [enabled, projectId, methodId, runId, blobName, listCycles, subscribe, unsubscribe]);
 
     // Lazy blob fetch — runs whenever identifiers / selectedCycle change.
+    // Suppressed entirely when no cycle is selected (e.g. test just
+    // started, no raw_data on disk yet): no point asking the server
+    // for a file that's known to not exist, and surfacing the resulting
+    // error would flash an unfriendly overlay over an otherwise valid
+    // "waiting for data" state.
     useEffect(() => {
         if (!enabled || !projectId || !methodId || !runId) {
             setRaw(null); setEnvelope(null); setLoading(false); setError(null);
             return;
         }
+        if (selectedCycle == null) {
+            setRaw(null); setEnvelope(null); setLoading(false); setError(null);
+            return;
+        }
         let cancelled = false;
         setLoading(true);
         setError(null);
         (async () => {
             try {
-                const args: Record<string, any> = {
-                    project_id: projectId, method_id: methodId,
-                    run_id: runId, name: blobName,
-                };
-                if (selectedCycle != null) args.cycle_index = selectedCycle;
                 const resp: any = await invoke(
-                    'tis.read_raw' as any, MessageType.Request as any, args as any,
+                    'tis.read_raw' as any, MessageType.Request as any,
+                    {
+                        project_id: projectId, method_id: methodId,
+                        run_id: runId, name: blobName,
+                        cycle_index: selectedCycle,
+                    } as any,
                 );
                 if (cancelled) return;
                 if (resp?.success) {
@@ -134,7 +223,19 @@ export function useRawCycleData(opts: UseRawCycleDataOptions): UseRawCycleDataRe
         return () => { cancelled = true; };
     }, [enabled, projectId, methodId, runId, blobName, selectedCycle, invoke]);
 
-    return { cycles, selectedCycle, setSelectedCycle, raw, envelope, loading, error };
+    // Public setter wraps setSelectedCycle and flips userPinnedRef so
+    // an operator's manual pick freezes the picker for the rest of the
+    // run. Re-mounting (new run) clears userPinnedRef in the
+    // identifier-change effect above.
+    const pickCycle = useCallback((n: number | null) => {
+        userPinnedRef.current = n != null;
+        setSelectedCycle(n);
+    }, []);
+
+    return {
+        cycles, selectedCycle, setSelectedCycle: pickCycle,
+        raw, envelope, loading, error,
+    };
 }
 
 /**