@adcops/autocore-react 3.3.72 → 3.3.75

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;

package/src/themes/adc-dark/_extensions.scss

@@ -320,3 +320,12 @@
         }
     }
 }
+
+/* Padding for OverlayPanels and Dialogs */
+.p-overlaypanel .p-overlaypanel-content {
+    padding: 4mm !important; 
+}
+
+.p-dialog .p-dialog-content {
+    padding: 4mm !important;
+}