@adcops/autocore-react 3.3.106 → 3.3.111

package/src/components/tis/TestDataView.tsx

@@ -44,6 +44,8 @@ import { EventEmitterContext } from '../../core/EventEmitterContext';
 import { MessageType } from '../../hub/CommandMessage';
 import { useTis } from './TisProvider';
 import { useRawCycleData } from './useRawCycleData';
+import { ScienceTable } from './ScienceTable';
+import type { ScienceColumn } from './ScienceTable';
 
 ChartJS.register(
     CategoryScale, LinearScale, PointElement, LineElement,
@@ -199,6 +201,10 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
     const [meta, setMeta]       = useState<any>(null);
     const [cycles, setCycles]   = useState<any[]>([]);
     const [results, setResults] = useState<any>({});
+    // Server-derived cross-test aggregate results_fields (avg/min/max/stddev/
+    // count over the sample group). Overlaid on `results` for display — these
+    // fields are never in the per-test results blob.
+    const [sampleSummary, setSampleSummary] = useState<any>({});
     const [rawOpen, setRawOpen] = useState(false);
     const [configOpen, setConfigOpen] = useState(false);
 
@@ -351,6 +357,45 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [projectId, methodId, runId, throttleMs]);
 
+    // -----------------------------------------------------------------
+    // Cross-test aggregate summary (sample-group rollup)
+    //
+    // Keyed by sample_id, not run_id: every run of the same sample shares
+    // the rollup. Fetched once per sample and refreshed on the server's
+    // sample_summary_updated broadcast (fired when a sibling finishes or its
+    // exclusion is toggled). Empty unless the method declares aggregate
+    // results_fields.
+    // -----------------------------------------------------------------
+    const sampleId: string =
+        (typeof meta?.sample_id === 'string' && meta.sample_id)
+            ? meta.sample_id
+            : (typeof meta?.config?.sample_id === 'string' ? meta.config.sample_id : '');
+
+    useEffect(() => {
+        if (!projectId || !methodId || !sampleId) { setSampleSummary({}); return; }
+        let cancelled = false;
+        const fetchSummary = async () => {
+            try {
+                const resp: any = await invoke(
+                    'tis.sample_summary' as any, MessageType.Request as any,
+                    { project_id: projectId, method_id: methodId, sample_id: sampleId } as any);
+                if (!cancelled && resp?.success) setSampleSummary(resp.data?.summary ?? {});
+            } catch (e) {
+                console.error('[TestDataView] sample_summary fetch failed', e);
+            }
+        };
+        fetchSummary();
+        const onSummary = (payload: any) => {
+            if (payload?.project_id === projectId
+                && payload?.method_id === methodId
+                && payload?.sample_id === sampleId) {
+                setSampleSummary(payload.summary ?? {});
+            }
+        };
+        const id = subscribe('tis.sample_summary_updated', onSummary);
+        return () => { cancelled = true; unsubscribe(id); };
+    }, [projectId, methodId, sampleId, invoke, subscribe, unsubscribe]);
+
     // -----------------------------------------------------------------
     // Raw-trace data fetch (lazy)
     //
@@ -690,39 +735,53 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
                 </div>
             </div>
 
-            <div className="p-card" style={{ padding: '1rem' }}>
-                <h3 style={{ marginTop: 0 }}>Cycle Data ({cycles.length})</h3>
-                {/* 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' }}>
-                <h3 style={{ marginTop: 0 }}>Results</h3>
-                <ResultsGrid schema={schema.results_fields} values={results} />
-            </div>
+            {/* 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. */}
+            {(() => {
+                const useVirtual = cycles.length > CYCLE_VIRTUAL_THRESHOLD;
+                const cycleColumns: ScienceColumn[] = schema.cycle_fields.map(f => ({
+                    field: f.name,
+                    label: f.name,
+                    units: f.units,
+                    body: (row) => formatCell(row[f.name], f.type, f.scale),
+                }));
+                return (
+                    <ScienceTable
+                        title={`Cycle Data (${cycles.length})`}
+                        columns={cycleColumns}
+                        rows={cycles}
+                        scrollable={useVirtual}
+                        scrollHeight={useVirtual ? cycleTableHeight : undefined}
+                        emptyMessage="No cycles yet."
+                    />
+                );
+            })()}
+
+            {/* Overlay the server-derived cross-test rollup (avg/min/max/
+                stddev/count) onto this run's own results. Aggregate fields
+                are never in `results` — the summary is their only source.
+                Rendered as a single-row report table (Bluehill style). */}
+            {(() => {
+                const values = { ...results, ...sampleSummary };
+                const hasValues = Object.keys(values).length > 0;
+                const resultColumns: ScienceColumn[] = schema.results_fields.map(f => ({
+                    field: f.name,
+                    label: f.name,
+                    units: f.units,
+                    body: (row) => formatCell(row[f.name], f.type, f.scale),
+                }));
+                return (
+                    <ScienceTable
+                        title="Results"
+                        columns={resultColumns}
+                        rows={hasValues ? [values] : []}
+                        emptyMessage="No results yet."
+                    />
+                );
+            })()}
 
             {/*
              * View Raw Data dialog — tabular listing of the raw and
@@ -1088,24 +1147,6 @@ const formatNumeric = (v: any): string => {
     return String(v);
 };
 
-const ResultsGrid: React.FC<{ schema: TestFieldDef[]; values: any }> = ({ schema, values }) => {
-    if (!values || Object.keys(values).length === 0) {
-        return <div style={{ color: 'var(--text-secondary-color)' }}>No results yet.</div>;
-    }
-    return (
-        <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fill, minmax(220px, 1fr))', gap: '0.5rem 1rem' }}>
-            {schema.map(f => (
-                <div key={f.name}>
-                    <div style={{ fontSize: '0.8em', color: 'var(--text-secondary-color)' }}>
-                        {f.name}{f.units ? ` (${f.units})` : ''}
-                    </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

package/src/components/tis/TestSetupForm.tsx

@@ -242,8 +242,12 @@ const rangeIssue = (f: TestFieldDef, raw: any): string | null => {
     if (f.min == null && f.max == null) return null;
     const disp = Number(rawToDisplay(Number(raw), f.scale));
     if (!Number.isFinite(disp)) return null;
-    if (f.min != null && disp < f.min) return `must be ≥ ${f.min}`;
-    if (f.max != null && disp > f.max) return `must be ≤ ${f.max}`;
+    // 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;
+    if (lo != null && disp < lo) return `must be ≥ ${lo}`;
+    if (hi != null && disp > hi) return `must be ≤ ${hi}`;
     return null;
 };
 
@@ -462,6 +466,18 @@ export const TestSetupForm: React.FC<TestSetupFormProps> = ({
             for (const field of schema.config_fields) {
                 if (field.name === 'sample_id') continue;
                 if (field.default === undefined || field.default === null) continue;
+                // A source-bound field's default must only SEED when GM has no
+                // value yet — never clobber an existing one. The defaults effect
+                // re-runs after every completed run (clearStagedConfig resets the
+                // marker), so without this guard the operator's setting (e.g.
+                // cof_window_pct) is reset to the literal default on each load.
+                // When GM already holds a value, keep it; the source-seed effect
+                // below mirrors the live value into stagedConfig.
+                if (field.source) {
+                    const liveTag = findTagByFqdn(field.source);
+                    const liveVal = liveTag ? rawValues[liveTag.tagName] : undefined;
+                    if (liveVal !== undefined && liveVal !== null) continue;
+                }
                 // Resolve the default to a RAW value. Literals are authored in
                 // DISPLAY units (converted via `scale`); an `${fqdn}` token
                 // snapshots that tag's current (already-raw) value so a

package/src/components/tis-editor/editor/FieldArrayEditor.tsx

@@ -17,7 +17,14 @@ const DESCRIPTIONS: Record<FieldArrayKey, string> = {
     project_fields: 'System-level fields (operator, station). Filled by the HMI but not cycled.',
     config_fields:  'Operator-input config (speeds, loads). Snapshotted into test.json on start.',
     cycle_fields:   'Per-cycle capture. One row appended to cycles.jsonl per cycle.',
-    results_fields: 'Post-test summary (min/max/avg, pass/fail). Written once at finish.',
+    results_fields: 'Post-test summary (min/max/avg, pass/fail). Written once at finish. A field can also be a cross-test Aggregate (avg/min/max/stddev/count over tests sharing a sample_id).',
+};
+
+/** Short human label for a field's aggregate spec, e.g. "avg(cof)" / "count". */
+const aggregateLabel = (f: TestField): string => {
+    const a = f.aggregate;
+    if (!a) return '';
+    return a.fn === 'count' ? 'count' : `${a.fn}(${a.of ?? '?'})`;
 };
 
 export interface FieldArrayEditorProps {
@@ -116,6 +123,13 @@ export const FieldArrayEditor: React.FC<FieldArrayEditorProps> = ({ arrayKey, me
                         style={{ width: '4rem' }}
                     />
                     <Column field="label" header="Label" />
+                    {arrayKey === 'results_fields' && (
+                        <Column
+                            header="Aggregate"
+                            body={(r: TestField) => aggregateLabel(r)}
+                            style={{ width: '8rem' }}
+                        />
+                    )}
                     <Column header="" body={rowActions} style={{ width: '10rem' }} />
                 </DataTable>
             </FormSection>
@@ -123,6 +137,9 @@ export const FieldArrayEditor: React.FC<FieldArrayEditorProps> = ({ arrayKey, me
                 visible={dialogOpen}
                 initial={editingIdx !== null ? (fields[editingIdx] ?? null) : null}
                 siblingNames={fields.map(f => f.name)}
+                isResultsField={arrayKey === 'results_fields'}
+                cycleFieldNames={(method.cycle_fields ?? []).map(f => f.name).filter(Boolean)}
+                resultsFieldNames={(method.results_fields ?? []).map(f => f.name).filter(Boolean)}
                 onCancel={() => setDialogOpen(false)}
                 onSave={handleSaveField}
             />

package/src/components/tis-editor/editor/TestFieldDialog.tsx

@@ -7,7 +7,7 @@ import { Dropdown } from 'primereact/dropdown';
 import { Checkbox } from 'primereact/checkbox';
 import { InputNumber } from 'primereact/inputnumber';
 import { FormRow } from '../../forms/FormRow';
-import type { TestField } from '../types';
+import type { TestField, AggFn, AggFrom, AggregateSpec } from '../types';
 
 const FIELD_TYPES: { label: string; value: string }[] = [
     { label: 'string', value: 'string' },
@@ -20,6 +20,21 @@ const FIELD_TYPES: { label: string; value: string }[] = [
     { label: 'bool', value: 'bool' },
 ];
 
+// '' = no aggregation (the field is supplied by the analysis script).
+const AGG_FNS: { label: string; value: '' | AggFn }[] = [
+    { label: '— none (analysis-fed) —', value: '' },
+    { label: 'avg', value: 'avg' },
+    { label: 'min', value: 'min' },
+    { label: 'max', value: 'max' },
+    { label: 'stddev', value: 'stddev' },
+    { label: 'count (# included tests)', value: 'count' },
+];
+
+const AGG_FROMS: { label: string; value: AggFrom }[] = [
+    { label: 'cycle field (every cycle, every test)', value: 'cycle_fields' },
+    { label: 'result (one value per test)', value: 'results' },
+];
+
 export interface TestFieldDialogProps {
     visible: boolean;
     initial: TestField | null;
@@ -27,12 +42,19 @@ export interface TestFieldDialogProps {
     onSave: (field: TestField) => void;
     /** Names already in use within the same array — for uniqueness validation. */
     siblingNames: string[];
+    /** True when this field belongs to `results_fields` — only then is the
+     *  cross-test Aggregate section shown. */
+    isResultsField?: boolean;
+    /** Candidate target field names for an aggregate's `of`, by source. */
+    cycleFieldNames?: string[];
+    resultsFieldNames?: string[];
 }
 
 const blank: TestField = { name: '', type: 'f32' };
 
 export const TestFieldDialog: React.FC<TestFieldDialogProps> = ({
     visible, initial, onCancel, onSave, siblingNames,
+    isResultsField = false, cycleFieldNames = [], resultsFieldNames = [],
 }) => {
     const [draft, setDraft] = useState<TestField>(blank);
     // `default` is edited as free text so a numeric literal, a string, or an
@@ -73,9 +95,29 @@ export const TestFieldDialog: React.FC<TestFieldDialogProps> = ({
         if (typeof f.min === 'number' && typeof f.max === 'number' && f.min > f.max) {
             return `Min (${f.min}) cannot be greater than Max (${f.max}).`;
         }
+        if (f.aggregate && f.aggregate.fn !== 'count' && !f.aggregate.of?.trim()) {
+            return `Aggregate "${f.aggregate.fn}" needs a target field (the field to ${f.aggregate.fn} across tests).`;
+        }
         return null;
     };
 
+    // Build the aggregate spec from the chosen function. '' clears it; count
+    // drops of/from (it reduces over the set of included tests, not a field).
+    const setAggFn = (fn: '' | AggFn) => {
+        if (fn === '') { setDraft({ ...draft, aggregate: undefined }); return; }
+        if (fn === 'count') { setDraft({ ...draft, aggregate: { fn: 'count' } }); return; }
+        const next: AggregateSpec = { fn, of: draft.aggregate?.of, from: draft.aggregate?.from ?? 'cycle_fields' };
+        setDraft({ ...draft, aggregate: next });
+    };
+
+    const agg = draft.aggregate;
+    const aggFrom: AggFrom = agg?.from ?? 'cycle_fields';
+    // `of` candidates depend on the source; exclude this field's own name so
+    // a result can't aggregate itself.
+    const aggTargets = (aggFrom === 'results' ? resultsFieldNames : cycleFieldNames)
+        .filter(n => n && n !== draft.name)
+        .map(n => ({ label: n, value: n }));
+
     const handleSave = () => {
         const candidate: TestField = { ...draft };
         const dv = coerceDefault(defaultText);
@@ -173,6 +215,45 @@ export const TestFieldDialog: React.FC<TestFieldDialogProps> = ({
                     placeholder="e.g. 5  or  ${gm.safe_speed}"
                 />
             </FormRow>
+            {isResultsField && (
+                <>
+                    <div style={{ borderTop: '1px solid #e5e7eb', margin: '0.75rem 0 0.25rem' }} />
+                    <FormRow
+                        label="Aggregate"
+                        hint="Cross-test rollup. When set, this result is derived server-side over the non-excluded tests sharing the same sample_id — the analysis script does not supply it."
+                    >
+                        <Dropdown
+                            value={agg?.fn ?? ''}
+                            options={AGG_FNS}
+                            onChange={(e) => setAggFn(e.value)}
+                        />
+                    </FormRow>
+                    {agg && agg.fn !== 'count' && (
+                        <>
+                            <FormRow label="Aggregate from" hint="Which per-test source the target field is read from.">
+                                <Dropdown
+                                    value={aggFrom}
+                                    options={AGG_FROMS}
+                                    onChange={(e) =>
+                                        setDraft({ ...draft, aggregate: { ...agg, from: e.value } })
+                                    }
+                                />
+                            </FormRow>
+                            <FormRow label="Aggregate of" required hint="The field to reduce across tests.">
+                                <Dropdown
+                                    value={agg.of ?? null}
+                                    options={aggTargets}
+                                    onChange={(e) =>
+                                        setDraft({ ...draft, aggregate: { ...agg, of: e.value || undefined } })
+                                    }
+                                    editable
+                                    placeholder={aggTargets.length ? 'Select a field' : `No ${aggFrom} defined yet`}
+                                />
+                            </FormRow>
+                        </>
+                    )}
+                </>
+            )}
             <FormRow label="Description" hint="Hover tooltip in the form.">
                 <InputTextarea
                     rows={2}

package/src/components/tis-editor/types.ts

@@ -27,6 +27,23 @@ export interface TestField {
      *  numeric input rejects values outside `[min, max]`. */
     min?: number;
     max?: number;
+    /** results_fields only: a cross-test rollup derived server-side over the
+     *  non-excluded runs sharing this test's sample_id. When set, the field
+     *  is NOT supplied by the analysis script — the server computes it. */
+    aggregate?: AggregateSpec;
+}
+
+export type AggFn = 'avg' | 'min' | 'max' | 'stddev' | 'count';
+export type AggFrom = 'cycle_fields' | 'results';
+
+export interface AggregateSpec {
+    /** Reduction applied across the gathered values. */
+    fn: AggFn;
+    /** Field to aggregate — a cycle_field or results_field name (per `from`).
+     *  Ignored for `fn: "count"` (which counts included tests). */
+    of?: string;
+    /** Which per-test source `of` is read from. Defaults to "cycle_fields". */
+    from?: AggFrom;
 }
 
 export interface ChartAxis {

package/src/components/tis-editor/validation.ts

@@ -39,6 +39,41 @@ export function validateMethod(methodId: string, m: TestMethod): ValidationError
         });
     }
 
+    // Aggregate specs: only on results_fields; target must exist in the
+    // chosen source array and be numeric. `count` needs no target. Mirrors
+    // tis_servelet::validate_method.
+    const NUMERIC_TYPES = new Set(['i32', 'i64', 'u32', 'u64', 'f32', 'f64']);
+    const cycleTypes = new Map<string, string>(
+        ((m.cycle_fields as TestField[] | undefined) ?? []).map((f) => [f.name, String(f.type)])
+    );
+    const resultTypes = new Map<string, string>(
+        ((m.results_fields as TestField[] | undefined) ?? []).map((f) => [f.name, String(f.type)])
+    );
+    for (const key of ['project_fields', 'config_fields', 'cycle_fields'] as const) {
+        ((m[key] as TestField[] | undefined) ?? []).forEach((f, i) => {
+            if (f.aggregate) {
+                errs.push({ path: `${key}.${i}.aggregate`, message: `${methodId}.${key}.${f.name}: aggregate is only valid on results_fields` });
+            }
+        });
+    }
+    ((m.results_fields as TestField[] | undefined) ?? []).forEach((f, i) => {
+        const a = f.aggregate;
+        if (!a || a.fn === 'count') return;
+        const of = a.of?.trim();
+        if (!of) {
+            errs.push({ path: `results_fields.${i}.aggregate`, message: `${methodId}.results_fields.${f.name}: aggregate "${a.fn}" requires a target field (of)` });
+            return;
+        }
+        const lookup = (a.from ?? 'cycle_fields') === 'results' ? resultTypes : cycleTypes;
+        const srcLabel = (a.from ?? 'cycle_fields') === 'results' ? 'results_fields' : 'cycle_fields';
+        const ty = lookup.get(of);
+        if (ty === undefined) {
+            errs.push({ path: `results_fields.${i}.aggregate`, message: `${methodId}.results_fields.${f.name}: aggregate "of" references "${of}" which is not a ${srcLabel} of this method` });
+        } else if (!NUMERIC_TYPES.has(ty)) {
+            errs.push({ path: `results_fields.${i}.aggregate`, message: `${methodId}.results_fields.${f.name}: aggregate target "${of}" has non-numeric type "${ty}"` });
+        }
+    });
+
     // Build sets for axis-reference resolution.
     const knownFields = new Set<string>();
     for (const key of FIELD_ARRAY_KEYS) {

package/dist/assets/JogXNeg.d.ts

@@ -1,4 +0,0 @@
-import type { SVGProps } from "react";
-export declare const SvgJogXNeg: (props: SVGProps<SVGSVGElement>) => import("react/jsx-runtime").JSX.Element;
-export default SvgJogXNeg;
-//# sourceMappingURL=JogXNeg.d.ts.map

package/dist/assets/JogXNeg.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"JogXNeg.d.ts","sourceRoot":"","sources":["../../src/assets/JogXNeg.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEtC,eAAO,MAAM,UAAU,GAAI,OAAO,QAAQ,CAAC,aAAa,CAAC,4CAkBxD,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/assets/JogXNeg.js

@@ -1 +0,0 @@
-import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";export const SvgJogXNeg=o=>_jsxs("svg",{xmlns:"http://www.w3.org/2000/svg",width:"24",height:"24",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round",...o,children:[_jsx("path",{d:"M10 6 3 12 10 18Z",fill:"currentColor"}),_jsx("path",{d:"M14 6l8 12M22 6l-8 12"})]});export default SvgJogXNeg;

package/dist/assets/JogXPos.d.ts

@@ -1,4 +0,0 @@
-import type { SVGProps } from "react";
-export declare const SvgJogXPos: (props: SVGProps<SVGSVGElement>) => import("react/jsx-runtime").JSX.Element;
-export default SvgJogXPos;
-//# sourceMappingURL=JogXPos.d.ts.map

package/dist/assets/JogXPos.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"JogXPos.d.ts","sourceRoot":"","sources":["../../src/assets/JogXPos.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEtC,eAAO,MAAM,UAAU,GAAI,OAAO,QAAQ,CAAC,aAAa,CAAC,4CAkBxD,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/assets/JogXPos.js

@@ -1 +0,0 @@
-import{jsx as _jsx,jsxs as _jsxs}from"react/jsx-runtime";export const SvgJogXPos=o=>_jsxs("svg",{xmlns:"http://www.w3.org/2000/svg",width:"24",height:"24",viewBox:"0 0 24 24",fill:"none",stroke:"currentColor",strokeWidth:"2",strokeLinecap:"round",strokeLinejoin:"round",...o,children:[_jsx("path",{d:"M2 6l8 12M10 6l-8 12"}),_jsx("path",{d:"M14 6 21 12 14 18Z",fill:"currentColor"})]});export default SvgJogXPos;