@adcops/autocore-react 3.3.73 → 3.3.77

package/src/components/tis/TestDataView.tsx

@@ -109,7 +109,12 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
 
     // 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 while the dialog is closed.
+    // different run / cycle while the dialog is closed.
+    //
+    // Wire format (post per-cycle change) is an envelope:
+    //   { cycle_index, cycle_fields, context, data: { col: number[] } }
+    // The legacy flat `{ col: number[] }` shape is still tolerated for
+    // runs written before the change — see unwrapEnvelope() below.
     const [rawBlob, setRawBlob]           = useState<any | null>(null);
     const [rawError, setRawError]         = useState<string | null>(null);
     const [rawLoading, setRawLoading]     = useState(false);
@@ -117,6 +122,12 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
     const [filteredError, setFilteredError] = useState<string | null>(null);
     const [filteredLoading, setFilteredLoading] = useState(false);
 
+    // Per-test cycle listing for the raw dialog's cycle picker. Loaded
+    // once when the dialog opens. selectedCycle is null until the list
+    // arrives; we default it to the latest cycle.
+    const [availableCycles, setAvailableCycles] = useState<number[]>([]);
+    const [selectedCycle, setSelectedCycle]     = useState<number | null>(null);
+
     // Scatter-capable views only — raw_trace lives in <TestRawDataView>.
     const scatterViews = useMemo(() => {
         const out: { name: string; view: ChartView }[] = [];
@@ -295,14 +306,42 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
     // download in <ResultHistoryTable> pulls.
     // -----------------------------------------------------------------
     const blobName = schema?.raw_data?.blob_name ?? 'trace';
-    const fetchKeyRef = useRef<string>(''); // last (project, method, run, blob) we fetched
+    const fetchKeyRef = useRef<string>(''); // last (project, method, run, blob, cycle) we fetched
+
+    // Discover which cycles have raw_data on disk so we can present a
+    // picker. tis.list_raw returns the flat name list (back-compat) AND
+    // a per-cycle list; we want the cycles for the selected blob name.
+    const loadCycleList = useCallback(async (): Promise<number[]> => {
+        if (!projectId || !methodId || !runId) return [];
+        try {
+            const resp: any = await invoke(
+                'tis.list_raw' as any, MessageType.Request,
+                { project_id: projectId, method_id: methodId, run_id: runId } as any,
+            );
+            if (!resp?.success) return [];
+            const cycles: any[] = resp.data?.cycles ?? [];
+            const indices = cycles
+                .filter(c => c?.name === blobName && typeof c?.cycle_index === 'number')
+                .map(c => c.cycle_index as number)
+                .sort((a, b) => a - b);
+            return indices;
+        } catch {
+            return [];
+        }
+    }, [projectId, methodId, runId, blobName, invoke]);
 
-    const loadBlobs = useCallback(async () => {
+    const loadBlobs = useCallback(async (cycleIndex: number | null) => {
         if (!projectId || !methodId || !runId) return;
-        const key = `${projectId}|${methodId}|${runId}|${blobName}`;
-        if (fetchKeyRef.current === key) return; // already loaded for this run
+        const key = `${projectId}|${methodId}|${runId}|${blobName}|${cycleIndex ?? 'latest'}`;
+        if (fetchKeyRef.current === key) return; // already loaded for this slice
         fetchKeyRef.current = key;
 
+        const baseArgs: Record<string, any> = {
+            project_id: projectId, method_id: methodId,
+            run_id: runId, name: blobName,
+        };
+        if (cycleIndex != null) baseArgs.cycle_index = cycleIndex;
+
         // Raw — must succeed for the dialog to be useful, but a
         // missing file is logged and surfaced rather than aborted.
         setRawLoading(true);
@@ -310,8 +349,7 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
         setRawBlob(null);
         try {
             const resp: any = await invoke(
-                'tis.read_raw' as any, MessageType.Request,
-                { project_id: projectId, method_id: methodId, run_id: runId, name: blobName } as any,
+                'tis.read_raw' as any, MessageType.Request, baseArgs as any,
             );
             if (resp?.success) {
                 setRawBlob(resp.data ?? {});
@@ -327,6 +365,8 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
         // Filtered is optional. The 'no filtered data' case is the
         // common one (only the post-processing pipeline writes it),
         // and we render a friendly message rather than an error tone.
+        // Filtered files are not per-cycle (yet); cycle_index is
+        // ignored on the filtered side.
         setFilteredLoading(true);
         setFilteredError(null);
         setFilteredBlob(null);
@@ -347,18 +387,34 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
         }
     }, [projectId, methodId, runId, blobName, invoke]);
 
-    // When the run changes, drop the cache key so the next dialog
-    // open refetches. Don't auto-fetch — that's wasteful if the
-    // operator never opens the dialog.
+    // When the run / blob changes, reset cycle picker and cache key.
     useEffect(() => {
         fetchKeyRef.current = '';
+        setAvailableCycles([]);
+        setSelectedCycle(null);
     }, [projectId, methodId, runId, blobName]);
 
-    const openRawDialog = () => {
+    const openRawDialog = async () => {
         setRawOpen(true);
-        void loadBlobs();
+        // Resolve cycle list lazily — first open after a run change.
+        let cycles = availableCycles;
+        if (cycles.length === 0) {
+            cycles = await loadCycleList();
+            setAvailableCycles(cycles);
+        }
+        const latest = cycles.length > 0 ? cycles[cycles.length - 1] : null;
+        const initial = selectedCycle ?? latest;
+        if (selectedCycle !== initial) setSelectedCycle(initial);
+        await loadBlobs(initial);
     };
 
+    // Re-fetch when the operator picks a different cycle from the dialog.
+    useEffect(() => {
+        if (rawOpen && selectedCycle != null) {
+            void loadBlobs(selectedCycle);
+        }
+    }, [rawOpen, selectedCycle, loadBlobs]);
+
     // -----------------------------------------------------------------
     // Render
     // -----------------------------------------------------------------
@@ -436,10 +492,16 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
                     style={{ width: '90vw', height: '80vh' }}
                     maximizable
                 >
+                    <CyclePickerBar
+                        cycles={availableCycles}
+                        selected={selectedCycle}
+                        onChange={setSelectedCycle}
+                    />
+                    <RawEnvelopeHeader envelope={rawBlob} />
                     <TabView style={{ height: '100%' }}>
                         <TabPanel header="Raw Data">
                             <DataBlobTable
-                                blob={rawBlob}
+                                blob={unwrapEnvelope(rawBlob)}
                                 loading={rawLoading}
                                 error={rawError}
                                 rawData={schema.raw_data}
@@ -447,7 +509,7 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
                         </TabPanel>
                         <TabPanel header="Filtered Data">
                             <DataBlobTable
-                                blob={filteredBlob}
+                                blob={unwrapEnvelope(filteredBlob)}
                                 loading={filteredLoading}
                                 error={filteredError}
                                 rawData={schema.raw_data}
@@ -567,6 +629,90 @@ const ConfigList: React.FC<{ config: any }> = ({ config }) => {
     );
 };
 
+// -------------------------------------------------------------------------
+// unwrapEnvelope — `tis.read_raw` returns one of:
+//   - the per-cycle envelope `{ cycle_index, cycle_fields, context, data }`
+//   - the legacy flat columnar blob `{ col: number[] }` (pre per-cycle)
+// Downstream consumers (DataBlobTable, chart datasets, CSV) only care
+// about the columnar payload — peel off the envelope when present so
+// both shapes render identically.
+// -------------------------------------------------------------------------
+const unwrapEnvelope = (blob: any): any => {
+    if (!blob || typeof blob !== 'object') return blob;
+    if ('data' in blob && blob.data && typeof blob.data === 'object'
+        && Object.values(blob.data).some(v => Array.isArray(v))) {
+        return blob.data;
+    }
+    return blob;
+};
+
+// -------------------------------------------------------------------------
+// CyclePickerBar — dropdown of available cycle indices for the raw_data
+// dialog. Hidden when only one (or zero) cycles exist; rendered as a
+// labelled selector otherwise.
+// -------------------------------------------------------------------------
+const CyclePickerBar: React.FC<{
+    cycles: number[];
+    selected: number | null;
+    onChange: (idx: number) => void;
+}> = ({ cycles, selected, onChange }) => {
+    if (cycles.length <= 1) return null;
+    return (
+        <div style={{ display: 'flex', alignItems: 'center', gap: '0.5rem',
+                      padding: '0.25rem 0.5rem 0.5rem' }}>
+            <label htmlFor="raw-cycle-picker"
+                   style={{ color: 'var(--text-secondary-color)' }}>Cycle:</label>
+            <Dropdown
+                inputId="raw-cycle-picker"
+                value={selected}
+                options={cycles.map(c => ({ label: `Cycle ${c}`, value: c }))}
+                onChange={(e) => onChange(Number(e.value))}
+                style={{ minWidth: '8rem' }}
+            />
+            <span style={{ color: 'var(--text-secondary-color)' }}>
+                ({cycles.length} cycles recorded)
+            </span>
+        </div>
+    );
+};
+
+// -------------------------------------------------------------------------
+// RawEnvelopeHeader — small key/value strip showing the metadata embedded
+// in the on-disk envelope (cycle_index, schema-declared cycle_fields,
+// capture context). Renders nothing for legacy flat blobs.
+// -------------------------------------------------------------------------
+const RawEnvelopeHeader: React.FC<{ envelope: any }> = ({ envelope }) => {
+    if (!envelope || typeof envelope !== 'object') return null;
+    const cycleIndex = envelope.cycle_index;
+    const cycleFields = envelope.cycle_fields;
+    const context = envelope.context;
+    if (cycleIndex == null && !cycleFields && !context) return null;
+
+    const renderKV = (obj: any) => {
+        if (!obj || typeof obj !== 'object') return null;
+        const entries = Object.entries(obj).filter(([, v]) =>
+            v !== null && typeof v !== 'object');
+        if (entries.length === 0) return null;
+        return entries.map(([k, v]) => (
+            <span key={k} style={{ marginRight: '1rem' }}>
+                <span style={{ color: 'var(--text-secondary-color)' }}>{k}: </span>
+                <span>{String(v)}</span>
+            </span>
+        ));
+    };
+
+    return (
+        <div style={{ padding: '0.5rem', borderBottom: '1px solid var(--surface-border)',
+                      fontSize: '0.9rem' }}>
+            {cycleIndex != null && (
+                <div><strong>Cycle {cycleIndex}</strong></div>
+            )}
+            {cycleFields && <div style={{ marginTop: '0.25rem' }}>{renderKV(cycleFields)}</div>}
+            {context && <div style={{ marginTop: '0.25rem' }}>{renderKV(context)}</div>}
+        </div>
+    );
+};
+
 // -------------------------------------------------------------------------
 // DataBlobTable — tabular display of a columnar JSON blob
 // (`{ col_name: number[] }`). Used by the View Raw Data dialog for both

package/src/components/tis/TestRawDataView.tsx

@@ -56,10 +56,16 @@ export const TestRawDataView: React.FC<TestRawDataViewProps> = (props) => {
     const { invoke } = useContext(EventEmitterContext);
 
     const [raw, setRaw]         = useState<Record<string, number[]> | null>(null);
+    const [envelope, setEnvelope] = useState<any | null>(null);
     const [loading, setLoading] = useState(true);
     const [error, setError]     = useState<string | null>(null);
     const chartRef              = useRef<any>(null);
 
+    // Per-test cycle picker. Default to latest cycle on disk; the
+    // operator can flip backward through earlier cycles.
+    const [cycles, setCycles]               = useState<number[]>([]);
+    const [selectedCycle, setSelectedCycle] = useState<number | null>(null);
+
     // raw_trace-capable views only — cycle scatter lives in <TestDataView>.
     const traceViews = useMemo(() => {
         const out: { name: string; view: ChartView }[] = [];
@@ -75,10 +81,45 @@ export const TestRawDataView: React.FC<TestRawDataViewProps> = (props) => {
 
     const effectiveBlobName = blobName ?? schema?.raw_data?.blob_name ?? 'trace';
 
-    // Lazy fetch — only runs on mount / when identifiers change.
+    // Reset cycle state when the run identity changes; the new run has
+    // its own cycle list and "latest" target.
+    useEffect(() => {
+        setCycles([]);
+        setSelectedCycle(null);
+    }, [projectId, methodId, runId, effectiveBlobName]);
+
+    // Discover available cycles for this run/blob. Runs ahead of the
+    // data fetch so the cycle picker can render immediately.
+    useEffect(() => {
+        if (!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 === effectiveBlobName && 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.
+            }
+        })();
+        return () => { cancelled = true; };
+    }, [projectId, methodId, runId, effectiveBlobName, invoke]);
+
+    // Lazy fetch — runs on mount / when identifiers / selectedCycle change.
     useEffect(() => {
         if (!projectId || !methodId || !runId) {
-            setRaw(null); setLoading(false); setError(null);
+            setRaw(null); setEnvelope(null); setLoading(false); setError(null);
             return;
         }
         let cancelled = false;
@@ -86,13 +127,18 @@ export const TestRawDataView: React.FC<TestRawDataViewProps> = (props) => {
         setError(null);
         (async () => {
             try {
+                const args: Record<string, any> = {
+                    project_id: projectId, method_id: methodId,
+                    run_id: runId, name: effectiveBlobName,
+                };
+                if (selectedCycle != null) args.cycle_index = selectedCycle;
                 const resp: any = await invoke(
-                    'tis.read_raw' as any, MessageType.Request as any,
-                    { project_id: projectId, method_id: methodId,
-                      run_id: runId, name: effectiveBlobName } as any);
+                    'tis.read_raw' as any, MessageType.Request as any, args as any);
                 if (cancelled) return;
                 if (resp?.success) {
-                    setRaw(resp.data ?? {});
+                    const payload = resp.data ?? {};
+                    setEnvelope(payload);
+                    setRaw(unwrapEnvelope(payload));
                 } else {
                     setError(resp?.error_message ?? 'Failed to read raw data');
                 }
@@ -103,7 +149,7 @@ export const TestRawDataView: React.FC<TestRawDataViewProps> = (props) => {
             }
         })();
         return () => { cancelled = true; };
-    }, [projectId, methodId, runId, effectiveBlobName, invoke]);
+    }, [projectId, methodId, runId, effectiveBlobName, selectedCycle, invoke]);
 
     const chartData = useMemo(() => {
         if (!raw || !selectedView) return null;
@@ -174,7 +220,7 @@ export const TestRawDataView: React.FC<TestRawDataViewProps> = (props) => {
 
     return (
         <div className="vblock" style={{ display: 'flex', flexDirection: 'column', gap: '1rem', height: '100%' }}>
-            <div className="flex" style={{ gap: '1rem', alignItems: 'center' }}>
+            <div className="flex" style={{ gap: '1rem', alignItems: 'center', flexWrap: 'wrap' }}>
                 <Dropdown
                     value={selectedView}
                     options={traceViews.map(v => ({ label: v.view.title ?? v.name, value: v.name }))}
@@ -182,12 +228,30 @@ export const TestRawDataView: React.FC<TestRawDataViewProps> = (props) => {
                     placeholder="Select a view"
                 />
                 <h3 style={{ margin: 0 }}>{selectedViewDef?.title ?? ''}</h3>
+                {cycles.length > 1 && (
+                    <>
+                        <label htmlFor="rawview-cycle-picker"
+                               style={{ color: 'var(--text-secondary-color)' }}>Cycle:</label>
+                        <Dropdown
+                            inputId="rawview-cycle-picker"
+                            value={selectedCycle}
+                            options={cycles.map(c => ({ label: `Cycle ${c}`, value: c }))}
+                            onChange={(e) => setSelectedCycle(Number(e.value))}
+                            style={{ minWidth: '8rem' }}
+                        />
+                        <span style={{ color: 'var(--text-secondary-color)' }}>
+                            of {cycles.length}
+                        </span>
+                    </>
+                )}
                 <div style={{ flex: 1 }} />
                 <Button icon="pi pi-refresh" label="Reset Zoom"
                         outlined
                         onClick={() => chartRef.current?.resetZoom?.()} />
             </div>
 
+            <EnvelopeMetaStrip envelope={envelope} />
+
             <div style={{ flex: 1, minHeight: 0, height: chartHeight, position: 'relative' }}>
                 {loading && <Overlay>Loading raw data…</Overlay>}
                 {error   && <Overlay>{error}</Overlay>}
@@ -215,6 +279,52 @@ const EmptyState: React.FC<{ message: string }> = ({ message }) => (
     <div style={{ padding: '1rem', color: 'var(--text-secondary-color)' }}>{message}</div>
 );
 
+// tis.read_raw returns one of:
+//   - per-cycle envelope: { cycle_index, cycle_fields, context, data }
+//   - legacy flat blob:   { col: number[] }
+// Chart/CSV code only wants the columnar payload — strip the envelope
+// when present, otherwise pass the blob through.
+const 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;
+};
+
+// Strip of cycle_index + cycle_fields + context, rendered above the
+// chart so the operator can see *which* cycle they're looking at and
+// what schema-declared metric values were active for it. Renders
+// nothing for legacy flat blobs (no envelope to read).
+const EnvelopeMetaStrip: React.FC<{ envelope: any }> = ({ envelope }) => {
+    if (!envelope || typeof envelope !== 'object') return null;
+    const ci = envelope.cycle_index;
+    const cf = envelope.cycle_fields;
+    const ctx = envelope.context;
+    if (ci == null && !cf && !ctx) return null;
+    const kv = (obj: any) => {
+        if (!obj || typeof obj !== 'object') return null;
+        return Object.entries(obj)
+            .filter(([, v]) => v !== null && typeof v !== 'object')
+            .map(([k, v]) => (
+                <span key={k} style={{ marginRight: '1rem' }}>
+                    <span style={{ color: 'var(--text-secondary-color)' }}>{k}: </span>
+                    <span>{String(v)}</span>
+                </span>
+            ));
+    };
+    return (
+        <div style={{ padding: '0.5rem 0.25rem', fontSize: '0.9rem',
+                      borderTop: '1px solid var(--surface-border)',
+                      borderBottom: '1px solid var(--surface-border)' }}>
+            {ci != null && <div><strong>Cycle {ci}</strong></div>}
+            {cf && <div style={{ marginTop: '0.25rem' }}>{kv(cf)}</div>}
+            {ctx && <div style={{ marginTop: '0.25rem' }}>{kv(ctx)}</div>}
+        </div>
+    );
+};
+
 const CHART_COLORS = [
     '#4ea8de', '#f59e0b', '#22c55e', '#a855f7',
     '#ef4444', '#14b8a6', '#eab308', '#ec4899',

package/src/components/tis/TestSetupForm.tsx

@@ -1,4 +1,4 @@
-import React, { useState, useEffect, useContext, useMemo } from 'react';
+import React, { useState, useEffect, useContext, useMemo, useRef } from 'react';
 import { Button } from 'primereact/button';
 import { InputText } from 'primereact/inputtext';
 import { Dropdown } from 'primereact/dropdown';
@@ -38,6 +38,13 @@ export interface TestFieldDef {
     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. */
+    default?: any;
 }
 
 export interface TestMethod {
@@ -240,6 +247,40 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
     );
     const closeInfoDialog = () => setInfoDialog({ open: false, title: '', body: null });
 
+    // Apply schema-declared defaults when the operator picks a method.
+    // Source-bound fields write the default to GM (the control program
+    // is the consumer of record); non-source fields land directly in
+    // stagedConfig. We track the last method we seeded so subsequent
+    // re-renders don't clobber operator edits — only an actual method
+    // change re-applies the defaults.
+    const defaultsAppliedFor = useRef<string>('');
+    useEffect(() => {
+        if (!schema || !methodId) return;
+        if (defaultsAppliedFor.current === methodId) return;
+        defaultsAppliedFor.current = methodId;
+
+        setConfig((prev: any) => {
+            let next = prev;
+            for (const field of schema.config_fields) {
+                if (field.name === 'sample_id') continue;
+                if (field.default === undefined || field.default === null) continue;
+                if (next === prev) next = { ...prev };
+                next[field.name] = field.default;
+                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))
+                        .catch(e => console.error(
+                            `[TestSetupForm] Failed to seed default for ${field.name}:`, e));
+                }
+            }
+            return next;
+        });
+    }, [schema, methodId, write]);
+
     // Seed and live-update config_fields that declare a `source`.
     useEffect(() => {
         if (!schema) return;