@adcops/autocore-react 3.3.115 → 3.3.118

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

@@ -31,6 +31,15 @@ export interface TestField {
      *  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;
+    /** cycle_fields only: operator-correctable after recording. Measured
+     *  columns must stay unflagged. cycle_config_fields don't need it —
+     *  they're annotation and are always correctable. */
+    editable?: boolean;
+    /** cycle_config_fields only: clear the operator's entry once a row has
+     *  recorded it, so the next row can't inherit a stale annotation. Pair
+     *  it with `required` — on its own it turns stale data into silently
+     *  missing data. */
+    autoclear?: boolean;
 }
 
 export type AggFn = 'avg' | 'min' | 'max' | 'stddev' | 'count';
@@ -113,11 +122,30 @@ export interface TestConfiguration {
     defaults?: Record<string, unknown>;
 }
 
+/**
+ * Which boundary an operator annotates `cycle_config_fields` at.
+ *
+ *   'run'    one latch per Start — the same values stamp every cycle of the
+ *            run and clear when it closes. Default; correct for a machine
+ *            that records many cycles from one Start.
+ *   'cycle'  one latch per cycle — values clear after each recorded row and
+ *            the gate re-arms, so every row is annotated separately.
+ */
+export type CycleConfigScope = 'run' | 'cycle';
+
 export interface TestMethod {
     label?: string;
     description?: string;
     project_fields?: TestField[];
     config_fields?: TestField[];
+    /** Operator-entered per-row annotation, recorded as the first Cycle Data
+     *  columns after the row index. */
+    cycle_config_fields?: TestField[];
+    /** Boundary at which cycle_config_fields latch and autoclear. */
+    cycle_config_scope?: CycleConfigScope;
+    /** Open the Cycle Configuration dialog at the boundary rather than
+     *  relying on the operator having filled the Cycle tab. */
+    prompt_before_cycle?: boolean;
     cycle_fields?: TestField[];
     results_fields?: TestField[];
     raw_data?: RawDataShape | null;
@@ -128,4 +156,9 @@ export interface TestMethod {
     [key: string]: unknown; // tolerate unknown server-side fields
 }
 
-export type FieldArrayKey = 'project_fields' | 'config_fields' | 'cycle_fields' | 'results_fields';
+export type FieldArrayKey =
+    | 'project_fields'
+    | 'config_fields'
+    | 'cycle_config_fields'
+    | 'cycle_fields'
+    | 'results_fields';

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

@@ -10,7 +10,22 @@ import type {
     TestField, TestMethod, ChartAxis, ChartSeries,
 } from './types';
 
-const FIELD_ARRAY_KEYS = ['project_fields', 'config_fields', 'cycle_fields', 'results_fields'] as const;
+const FIELD_ARRAY_KEYS = [
+    'project_fields', 'config_fields', 'cycle_config_fields', 'cycle_fields', 'results_fields',
+] as const;
+
+/**
+ * Columns TIS writes onto every cycle row itself, in `add_cycle`. Never
+ * declared in a field array — the author can't add them and the control
+ * program doesn't supply them — but every recorded row carries them, so a
+ * chart view may plot against one. `x.field: "cycle_index"` is the
+ * canonical "value by cycle" chart.
+ *
+ * Mirrors `SERVER_ASSIGNED_CYCLE_COLUMNS` in autocore-tis `main.rs`. Keep
+ * the two in step: this list being short by one is what made a valid method
+ * unsaveable (gen4_ac, 2026-08-12).
+ */
+const SERVER_ASSIGNED_CYCLE_COLUMNS = ['cycle_index', 'timestamp', 'checksum'] as const;
 
 export interface ValidationError {
     /** Dotted path: "<arrayKey>.<index>.<sub>" or "views.<viewId>.x" etc. */
@@ -49,7 +64,7 @@ export function validateMethod(methodId: string, m: TestMethod): ValidationError
     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) {
+    for (const key of ['project_fields', 'config_fields', 'cycle_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` });
@@ -74,12 +89,29 @@ export function validateMethod(methodId: string, m: TestMethod): ValidationError
         }
     });
 
+    // A cycle_config_field and a cycle_field share one row namespace in
+    // cycles.jsonl — the same name in both means the operator's annotation
+    // and a measured value would fight over one column. Mirrors the
+    // server-side check in validate_method.
+    const cycleFieldNames = new Set<string>(
+        ((m.cycle_fields as TestField[] | undefined) ?? []).map(f => f.name).filter(Boolean),
+    );
+    ((m.cycle_config_fields as TestField[] | undefined) ?? []).forEach((f, i) => {
+        if (f.name && cycleFieldNames.has(f.name)) {
+            errs.push({
+                path: `cycle_config_fields.${i}.name`,
+                message: `${methodId}: "${f.name}" is declared as both a cycle_config_field and a cycle_field. They share one row namespace; rename one.`,
+            });
+        }
+    });
+
     // Build sets for axis-reference resolution.
     const knownFields = new Set<string>();
     for (const key of FIELD_ARRAY_KEYS) {
         const arr = (m[key] as TestField[] | undefined) ?? [];
         arr.forEach((f) => f.name && knownFields.add(f.name));
     }
+    for (const name of SERVER_ASSIGNED_CYCLE_COLUMNS) knownFields.add(name);
     const knownColumns = new Set<string>(
         Object.keys(((m.raw_data as any)?.columns ?? {}) as Record<string, unknown>)
     );