@adcops/autocore-react 3.3.82 → 3.3.84

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

@@ -0,0 +1,258 @@
+/*
+ * Copyright (C) 2026 Automated Design Corp. All Rights Reserved.
+ *
+ * useRawCycleData — shared hook that fetches `tis.list_raw` + `tis.read_raw`
+ * for one (project, method, run, blob_name) slice and tracks the
+ * operator's per-cycle selection. Used by:
+ *
+ *   - <TestRawDataView> — the focused trace-only viewer.
+ *   - <TestDataView>    — the unified chart panel, which lazily fetches
+ *                          raw data only when a raw_trace view is selected
+ *                          (set `enabled` to false to short-circuit while
+ *                          a cycle_scatter view is active).
+ *
+ * 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 { useCallback, useContext, useEffect, useRef, useState } from 'react';
+import { EventEmitterContext } from '../../core/EventEmitterContext';
+import { MessageType } from '../../hub/CommandMessage';
+
+export interface UseRawCycleDataOptions {
+    projectId?: string;
+    methodId?:  string;
+    runId?:     string;
+    /** Blob name (e.g. "trace"); usually schema.raw_data.blob_name. */
+    blobName:   string;
+    /** When false, the hook does no fetching and returns empty state.
+     *  Wire to "is the current chart view a raw_trace?" so scatter
+     *  selections don't trigger a blob round-trip. */
+    enabled:    boolean;
+}
+
+export interface UseRawCycleDataResult {
+    /** Per-cycle indices discovered on disk for this run/blob, sorted
+     *  ascending. Empty when no raw_data has been written yet. */
+    cycles:           number[];
+    selectedCycle:    number | null;
+    setSelectedCycle: (n: number | null) => void;
+    /** Columnar payload unwrapped from the per-cycle envelope, or the
+     *  blob itself for legacy flat shapes. `null` until the fetch lands. */
+    raw:              Record<string, number[]> | null;
+    /** Full envelope as returned by `tis.read_raw`. Carries
+     *  `cycle_index`, `cycle_fields`, and `context` alongside `data`. */
+    envelope:         any | null;
+    loading:          boolean;
+    error:            string | null;
+}
+
+export function useRawCycleData(opts: UseRawCycleDataOptions): UseRawCycleDataResult {
+    const { projectId, methodId, runId, blobName, enabled } = opts;
+    const { invoke, subscribe, unsubscribe } = useContext(EventEmitterContext);
+
+    const [cycles, setCycles]               = useState<number[]>([]);
+    const [selectedCycle, setSelectedCycle] = useState<number | null>(null);
+    const [raw, setRaw]                     = useState<Record<string, number[]> | null>(null);
+    const [envelope, setEnvelope]           = useState<any | null>(null);
+    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
+    // picker can render immediately. Filtered to the requested blob name.
+    useEffect(() => {
+        if (!enabled || !projectId || !methodId || !runId) return;
+        let cancelled = false;
+        (async () => {
+            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, 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 resp: any = await invoke(
+                    '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) {
+                    const payload = resp.data ?? {};
+                    setEnvelope(payload);
+                    setRaw(unwrapEnvelope(payload));
+                } else {
+                    setError(resp?.error_message ?? 'Failed to read raw data');
+                }
+            } catch (e: any) {
+                if (!cancelled) setError(String(e?.message ?? e));
+            } finally {
+                if (!cancelled) setLoading(false);
+            }
+        })();
+        return () => { cancelled = true; };
+    }, [enabled, projectId, methodId, runId, blobName, selectedCycle, invoke]);
+
+    // 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,
+    };
+}
+
+/**
+ * `tis.read_raw` returns one of:
+ *   - per-cycle envelope: `{ cycle_index, cycle_fields, context, data: { col: number[] } }`
+ *   - legacy flat blob:   `{ col: number[] }`
+ *
+ * Chart and CSV code only care about the columnar payload — peel off
+ * the envelope when present, otherwise pass the blob through. Returned
+ * shape is always `Record<string, number[]>` so consumers can index
+ * uniformly.
+ */
+export function unwrapEnvelope(blob: any): Record<string, number[]> {
+    if (!blob || typeof blob !== 'object') return {};
+    if ('data' in blob && blob.data && typeof blob.data === 'object'
+        && Object.values(blob.data).some(v => Array.isArray(v))) {
+        return blob.data;
+    }
+    return blob;
+}