@adcops/autocore-react 3.3.112 → 3.3.115

package/src/components/ams-editor/SubLocationsEditor.tsx

@@ -0,0 +1,151 @@
+/**
+ * SubLocationsEditor — edits the keyed-fields (multi-axis) `sub_locations`
+ * shape of an asset type: a fixed set of keys (e.g. x/y/z axes) plus
+ * per-key nameplate and calibration fields.
+ *
+ * The positional (surface-lanes) shape — `count` + `per_location_state` —
+ * is not editable here; it's left to the form's JSON tab. Assets without
+ * any sub_locations can add a keyed schema with one click.
+ */
+
+import { Button } from 'primereact/button';
+import { InputText } from 'primereact/inputtext';
+import { FormSection } from '../forms/FormSection';
+import { FormRow } from '../forms/FormRow';
+import { AssetFieldArray } from './AssetFieldArray';
+import { isKeyedSubLocations, type AssetTypeDef, type KeyedSubLocations, type TestField } from './types';
+
+export interface SubLocationsEditorProps {
+    def: AssetTypeDef;
+    onChange: (next: AssetTypeDef) => void;
+}
+
+const EMPTY_KEYED: KeyedSubLocations = { keys: [], fields: [], calibration_fields: [] };
+
+export const SubLocationsEditor: React.FC<SubLocationsEditorProps> = ({ def, onChange }) => {
+    const sl = def.sub_locations;
+
+    // No sub_locations yet — offer to add a keyed schema.
+    if (sl == null) {
+        return (
+            <FormSection
+                title="Sub-locations"
+                description="Optional. For multi-axis assets (e.g. a triaxial transducer), declare a fixed set of keys with per-key fields and calibration."
+            >
+                <Button
+                    label="Add multi-axis sub-locations"
+                    icon="pi pi-plus"
+                    size="small"
+                    onClick={() => onChange({ ...def, sub_locations: { ...EMPTY_KEYED } })}
+                />
+            </FormSection>
+        );
+    }
+
+    // Present but positional (surface-lanes) — not editable in the form.
+    if (!isKeyedSubLocations(sl)) {
+        return (
+            <FormSection title="Sub-locations">
+                <p style={{ color: 'var(--text-color-secondary, #64748b)' }}>
+                    This type uses the positional (surface-lanes) sub-locations shape,
+                    which isn't editable in the form. Use the <strong>JSON</strong> tab
+                    to edit it.
+                </p>
+            </FormSection>
+        );
+    }
+
+    const keyed = sl as KeyedSubLocations;
+    const setKeyed = (next: KeyedSubLocations) => onChange({ ...def, sub_locations: next });
+
+    const setKey = (idx: number, value: string) => {
+        const keys = [...keyed.keys];
+        keys[idx] = value;
+        setKeyed({ ...keyed, keys });
+    };
+    const addKey = () => setKeyed({ ...keyed, keys: [...keyed.keys, ''] });
+    const removeKey = (idx: number) =>
+        setKeyed({ ...keyed, keys: keyed.keys.filter((_, i) => i !== idx) });
+    const moveKey = (idx: number, dir: -1 | 1) => {
+        const j = idx + dir;
+        if (j < 0 || j >= keyed.keys.length) return;
+        const keys = [...keyed.keys];
+        [keys[idx], keys[j]] = [keys[j], keys[idx]];
+        setKeyed({ ...keyed, keys });
+    };
+
+    return (
+        <>
+            <FormSection
+                title="Sub-locations (multi-axis)"
+                description="A fixed, ordered set of keys. Each asset carries per-key values; calibration records carry a per-key sub-object."
+                actions={
+                    <Button
+                        label="Remove sub-locations"
+                        icon="pi pi-trash"
+                        className="p-button-text p-button-danger"
+                        size="small"
+                        onClick={() => {
+                            if (window.confirm('Remove the sub-locations schema from this type?')) {
+                                const next = { ...def };
+                                delete next.sub_locations;
+                                onChange(next);
+                            }
+                        }}
+                    />
+                }
+            >
+                <FormRow label="Group label" hint="Pretty label for the set (e.g. Axes).">
+                    <InputText
+                        value={keyed.label ?? ''}
+                        onChange={(e) => setKeyed({ ...keyed, label: e.target.value || undefined })}
+                    />
+                </FormRow>
+                <FormRow label="Key label" hint="Pretty label for one key (e.g. Axis).">
+                    <InputText
+                        value={keyed.key_label ?? ''}
+                        onChange={(e) => setKeyed({ ...keyed, key_label: e.target.value || undefined })}
+                    />
+                </FormRow>
+                <FormRow label="Keys" hint="Ordered. Each becomes a per-key column on assets & calibrations.">
+                    <div style={{ display: 'flex', flexDirection: 'column', gap: '0.35rem' }}>
+                        {keyed.keys.map((k, i) => (
+                            <div key={i} style={{ display: 'flex', gap: '0.25rem', alignItems: 'center' }}>
+                                <InputText
+                                    value={k}
+                                    placeholder="e.g. x"
+                                    onChange={(e) => setKey(i, e.target.value)}
+                                    style={{ flex: 1 }}
+                                />
+                                <Button icon="pi pi-arrow-up" className="p-button-text p-button-sm"
+                                    disabled={i === 0} onClick={() => moveKey(i, -1)} aria-label="Move up" />
+                                <Button icon="pi pi-arrow-down" className="p-button-text p-button-sm"
+                                    disabled={i === keyed.keys.length - 1} onClick={() => moveKey(i, 1)} aria-label="Move down" />
+                                <Button icon="pi pi-trash" className="p-button-text p-button-danger p-button-sm"
+                                    onClick={() => removeKey(i)} aria-label="Remove key" />
+                            </div>
+                        ))}
+                        <div>
+                            <Button label="Add key" icon="pi pi-plus" size="small" className="p-button-secondary" onClick={addKey} />
+                        </div>
+                    </div>
+                </FormRow>
+            </FormSection>
+
+            <AssetFieldArray
+                title="Per-key fields"
+                description="Nameplate fields recorded once per key on each asset."
+                fields={(keyed.fields ?? []) as TestField[]}
+                onChange={(next) => setKeyed({ ...keyed, fields: next })}
+            />
+            <AssetFieldArray
+                title="Per-key calibration fields"
+                description="Calibration values captured per key. When present, each calibration record must carry a per-key sub-object."
+                fields={(keyed.calibration_fields ?? []) as TestField[]}
+                onChange={(next) => setKeyed({ ...keyed, calibration_fields: next })}
+            />
+        </>
+    );
+};
+
+export default SubLocationsEditor;

package/src/components/ams-editor/index.ts

@@ -0,0 +1,16 @@
+/*
+ * AMS asset-TYPE editor. Operator-facing HMI screen for authoring the
+ * custom asset types that AssetRegistryTable / AssetEditDialog then create
+ * instances of. Mount inside a Settings screen (e.g. a PrimeReact
+ * AccordionTab), like the TIS TisConfigEditor.
+ *
+ * Deep-imported by consumer apps:
+ *   import { AssetTypeEditor } from '@adcops/autocore-react/components/ams-editor/AssetTypeEditor';
+ */
+
+export { AssetTypeEditor } from './AssetTypeEditor';
+export type { AssetTypeEditorProps } from './AssetTypeEditor';
+export { AssetTypeFormEditor } from './AssetTypeFormEditor';
+export { AssetFieldArray } from './AssetFieldArray';
+export { SubLocationsEditor } from './SubLocationsEditor';
+export type { AssetTypeDef, KeyedSubLocations, TestField } from './types';

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

@@ -0,0 +1,40 @@
+/**
+ * Client-side mirror of the autocore-ams `AssetTypeConfig` (see
+ * autocore-ams/src/config.rs). Kept loose so unknown server-side
+ * extensions don't trip the editor at parse time. Reuses the shared
+ * `TestField` shape from the TIS editor — the server reuses the same
+ * Rust `TestField` for both test methods and asset/calibration fields.
+ */
+
+import type { TestField } from '../tis-editor/types';
+
+export type { TestField };
+
+/** One custom asset type. `sub_locations` is deliberately untyped: two
+ *  shapes exist (keyed-fields multi-axis, discriminated by a `keys` array;
+ *  and positional surface-lanes). The form edits the keyed shape; the
+ *  positional shape is left to the JSON tab. */
+export interface AssetTypeDef {
+    extends?: string;
+    id_prefix?: string;
+    label?: string;
+    description?: string;
+    fields?: TestField[];
+    calibration_fields?: TestField[];
+    sub_locations?: unknown;
+}
+
+/** The keyed-fields (multi-axis) `sub_locations` shape. */
+export interface KeyedSubLocations {
+    label?: string;
+    key_label?: string;
+    keys: string[];
+    fields?: TestField[];
+    calibration_fields?: TestField[];
+}
+
+/** True when a `sub_locations` value is the keyed-fields (multi-axis)
+ *  shape the form can edit — discriminated by a `keys` array. */
+export function isKeyedSubLocations(v: unknown): v is KeyedSubLocations {
+    return !!v && typeof v === 'object' && Array.isArray((v as any).keys);
+}

package/src/components/tis/ResultHistoryTable.tsx

@@ -1,8 +1,10 @@
-import React, { useState, useEffect, useContext } from 'react';
+import React, { useState, useEffect, useContext, useRef } from 'react';
 import { DataTable } from 'primereact/datatable';
 import { Column } from 'primereact/column';
 import { Button } from 'primereact/button';
 import { Badge } from 'primereact/badge';
+import { Menu } from 'primereact/menu';
+import { confirmDialog } from 'primereact/confirmdialog';
 import { EventEmitterContext } from '../../core/EventEmitterContext';
 import { MessageType } from '../../hub/CommandMessage';
 import { useTis } from './TisProvider';
@@ -75,6 +77,11 @@ export const ResultHistoryTable: React.FC<ResultHistoryTableProps> = (props) =>
     const [downloading, setDownloading] = useState<InFlight | null>(null);
     const [projectBusy, setProjectBusy] = useState<ProjectDownloadKind | null>(null);
     const [excludingRunId, setExcludingRunId] = useState<string | null>(null);
+    // Per-row lifecycle menu (complete / abandon / reopen). One Menu instance is
+    // reused; `menuRow` is the row it was opened for.
+    const rowMenuRef = useRef<Menu>(null);
+    const [menuRow, setMenuRow] = useState<any>(null);
+    const [lifecycleBusy, setLifecycleBusy] = useState<string | null>(null);
     const { invoke } = useContext(EventEmitterContext);
 
     const loadTests = async () => {
@@ -176,6 +183,112 @@ export const ResultHistoryTable: React.FC<ResultHistoryTableProps> = (props) =>
     // kept on disk (not deleted) but dropped from avg/min/max/stddev/count
     // results for their sample group. The server recomputes + rebroadcasts
     // the sample summary on success.
+    /**
+     * Run-lifecycle action on one row: complete, abandon, or reopen.
+     *
+     * All three are RECORD operations — they change what the stored run says
+     * about itself, never what the machine is doing. Reopening makes a run the
+     * active one so the control program's next cycle appends to it; it does not
+     * command motion, and the machine still decides when to run. That
+     * distinction is why this is safe to expose in a browser: a click here can
+     * retarget where data lands, but cannot start a machine.
+     *
+     * `tis.finish_test` / `reset_test` / `resume_test` all take an explicit
+     * `run_id`, so the row's own run is addressed rather than "whatever is
+     * newest".
+     */
+    const handleLifecycle = async (
+        rowData: any,
+        action: 'complete' | 'abandon' | 'reopen',
+    ) => {
+        const runId = rowData?.run_id;
+        const rowMethodId = rowData?.method_id ?? methodId;
+        if (!runId || !rowMethodId || !projectId) return;
+        const topic =
+            action === 'complete' ? 'tis.finish_test'
+            : action === 'abandon' ? 'tis.reset_test'
+            : 'tis.resume_test';
+        setLifecycleBusy(runId);
+        try {
+            const resp: any = await invoke(topic as any, MessageType.Request, {
+                project_id: projectId, method_id: rowMethodId, run_id: runId,
+            } as any);
+            if (!resp?.success) {
+                // The most common rejection is reopening while another test is
+                // already open for this project+method — the server refuses so
+                // two runs can't both be "active".
+                alert(`Could not ${action} ${runId}` +
+                      (resp?.error_message ? `:\n\n${resp.error_message}` : ''));
+                return;
+            }
+            await loadTests();
+        } catch (err) {
+            console.error(`Failed to ${action} test`, err);
+            alert(`${action} failed: ${err instanceof Error ? err.message : String(err)}`);
+        } finally {
+            setLifecycleBusy(null);
+        }
+    };
+
+    /**
+     * Menu items for a row, gated on its lifecycle state:
+     *  - open (in_progress / paused) → Complete, Abandon
+     *  - completed but not finalized → Reopen (add more cycles under the same
+     *    Test ID — the multi-specimen case where a set turned out to be bigger)
+     *  - finalized (abandoned)       → nothing; `finalized` exists precisely to
+     *    stop a deliberately-abandoned run being resurrected.
+     */
+    const rowMenuItems = (rowData: any) => {
+        const status = rowData?.status;
+        const finalized = rowData?.finalized === true;
+        const isOpen = status === 'in_progress' || status === 'paused';
+        const items: any[] = [];
+
+        if (isOpen) {
+            items.push({
+                label: 'Complete Test',
+                icon: 'pi pi-check-circle',
+                command: () => handleLifecycle(rowData, 'complete'),
+            });
+            items.push({
+                label: 'Abandon Test',
+                icon: 'pi pi-ban',
+                command: () => confirmDialog({
+                    header: 'Abandon Test',
+                    message:
+                        `Mark ${rowData?.sample_id || rowData?.run_id} as abandoned? ` +
+                        `Recorded data is kept, but the test can no longer be reopened.`,
+                    icon: 'pi pi-exclamation-triangle',
+                    acceptClassName: 'p-button-danger',
+                    acceptLabel: 'Abandon',
+                    accept: () => handleLifecycle(rowData, 'abandon'),
+                }),
+            });
+        } else if (status === 'completed' && !finalized) {
+            items.push({
+                label: 'Reopen Test',
+                icon: 'pi pi-replay',
+                command: () => confirmDialog({
+                    header: 'Reopen Test',
+                    message:
+                        `Reopen ${rowData?.sample_id || rowData?.run_id} so new cycles are added to ` +
+                        `it? Cycle numbering continues from where it stopped. This changes where ` +
+                        `data is recorded — it does not start the machine.`,
+                    icon: 'pi pi-replay',
+                    acceptLabel: 'Reopen',
+                    accept: () => handleLifecycle(rowData, 'reopen'),
+                }),
+            });
+        } else {
+            items.push({
+                label: finalized ? 'Abandoned — cannot reopen' : 'No actions available',
+                icon: 'pi pi-info-circle',
+                disabled: true,
+            });
+        }
+        return items;
+    };
+
     const handleToggleExclude = async (rowData: any) => {
         const runId = rowData?.run_id;
         const rowMethodId = rowData?.method_id ?? methodId;
@@ -440,7 +553,34 @@ export const ResultHistoryTable: React.FC<ResultHistoryTableProps> = (props) =>
                         );
                     }}
                 />
+                {/* Thin per-row lifecycle menu. Kept narrow and iconic so it
+                    doesn't compete with the download actions. */}
+                <Column
+                    header=""
+                    style={{ width: '3rem' }}
+                    body={(rowData) => (
+                        <Button
+                            icon={
+                                lifecycleBusy === rowData.run_id
+                                    ? 'pi pi-spin pi-spinner'
+                                    : 'pi pi-ellipsis-v'
+                            }
+                            text
+                            rounded
+                            size="small"
+                            disabled={lifecycleBusy !== null}
+                            aria-label="Test actions"
+                            tooltip="Complete / abandon / reopen this test"
+                            tooltipOptions={{ position: 'left' }}
+                            onClick={(e) => {
+                                setMenuRow(rowData);
+                                rowMenuRef.current?.toggle(e);
+                            }}
+                        />
+                    )}
+                />
             </DataTable>
+            <Menu model={menuRow ? rowMenuItems(menuRow) : []} popup ref={rowMenuRef} />
         </div>
     );
 };

package/src/components/tis/ScienceTable.tsx

@@ -16,6 +16,7 @@
 import React from 'react';
 import { DataTable } from 'primereact/datatable';
 import { Column } from 'primereact/column';
+import { InputText } from 'primereact/inputtext';
 import type { ColumnBodyOptions } from 'primereact/column';
 import './ScienceTable.css';
 
@@ -32,6 +33,14 @@ export interface ScienceColumn {
     body?: (row: any) => React.ReactNode;
     /** Optional per-column style (e.g. minWidth). */
     style?: React.CSSProperties;
+    /**
+     * Operator-editable cell. Requires the table's `onCellEdit`. Intended for
+     * ANNOTATION columns only (a specimen or lot identifier noted against an
+     * automatically-captured row) — never for measured values, which the server
+     * refuses to rewrite anyway (`tis.update_cycle` only accepts cycle_fields
+     * declared `editable: true`).
+     */
+    editable?: boolean;
 }
 
 export interface ScienceTableProps {
@@ -49,6 +58,13 @@ export interface ScienceTableProps {
     scrollHeight?: string;
     /** Virtual-scroll row height in px. Default 38. */
     virtualItemSize?: number;
+    /**
+     * Commit handler for cells in columns marked `editable`. Called with the
+     * edited row, the column field and the new value. Without it, `editable`
+     * columns stay read-only — there is no local-only edit mode, because a value
+     * that looks saved but isn't is worse than one that can't be typed.
+     */
+    onCellEdit?: (row: any, field: string, value: any) => void | Promise<void>;
 }
 
 const HeaderCell: React.FC<{ column: ScienceColumn }> = ({ column }) => (
@@ -68,8 +84,12 @@ export const ScienceTable: React.FC<ScienceTableProps> = ({
     scrollable = false,
     scrollHeight,
     virtualItemSize = 38,
+    onCellEdit,
 }) => {
     const virtual = scrollable && !!scrollHeight;
+    // Cell edit mode is switched on only when a column asks for it AND a commit
+    // handler exists, so a plain report table keeps DataTable's read-only path.
+    const anyEditable = !!onCellEdit && columns.some((c) => c.editable);
     return (
         <div className="ac-science-table-wrap">
             {title != null && <div className="ac-science-table-title">{title}</div>}
@@ -81,6 +101,7 @@ export const ScienceTable: React.FC<ScienceTableProps> = ({
                     scrollHeight={scrollHeight}
                     virtualScrollerOptions={virtual ? { itemSize: virtualItemSize } : undefined}
                     emptyMessage={emptyMessage}
+                    editMode={anyEditable ? 'cell' : undefined}
                 >
                     {showIndex ? (
                         <Column
@@ -93,18 +114,56 @@ export const ScienceTable: React.FC<ScienceTableProps> = ({
                             body={(_data: any, options: ColumnBodyOptions) => options.rowIndex + 1}
                         />
                     ) : null}
-                    {columns.map((c) => (
-                        <Column
-                            key={c.field}
-                            field={c.field}
-                            header={<HeaderCell column={c} />}
-                            align={c.align ?? 'center'}
-                            alignHeader="center"
-                            style={c.style}
-                            bodyClassName="ac-sci-cell"
-                            body={c.body ? (row: any) => c.body!(row) : undefined}
-                        />
-                    ))}
+                    {columns.map((c) => {
+                        const cellEditable = !!onCellEdit && !!c.editable;
+                        return (
+                            <Column
+                                key={c.field}
+                                field={c.field}
+                                header={<HeaderCell column={c} />}
+                                align={c.align ?? 'center'}
+                                alignHeader="center"
+                                style={c.style}
+                                bodyClassName={
+                                    cellEditable ? 'ac-sci-cell ac-sci-cell-editable' : 'ac-sci-cell'
+                                }
+                                body={c.body ? (row: any) => c.body!(row) : undefined}
+                                editor={
+                                    cellEditable
+                                        ? (options: any) => (
+                                            <InputText
+                                                value={options.value ?? ''}
+                                                autoFocus
+                                                style={{ width: '100%' }}
+                                                onChange={(e) => options.editorCallback?.(e.target.value)}
+                                                onKeyDown={(e) => e.stopPropagation()}
+                                            />
+                                        )
+                                        : undefined
+                                }
+                                onCellEditComplete={
+                                    cellEditable
+                                        ? (e: any) => {
+                                            // Numeric annotation columns come back
+                                            // as a string from the text editor;
+                                            // coerce so the stored type matches the
+                                            // schema instead of silently turning a
+                                            // number column into strings.
+                                            const prev = e.rowData?.[c.field];
+                                            let next: any = e.newValue;
+                                            if (typeof prev === 'number' && next !== '' && next != null) {
+                                                const n = Number(next);
+                                                if (!Number.isNaN(n)) next = n;
+                                            }
+                                            if (next !== prev) {
+                                                void onCellEdit!(e.rowData, c.field, next);
+                                            }
+                                        }
+                                        : undefined
+                                }
+                            />
+                        );
+                    })}
                 </DataTable>
             </div>
         </div>

package/src/components/tis/TestDataView.tsx

@@ -72,6 +72,12 @@ export interface TestFieldDef {
      *  (label === stored value) or an explicit { label, value } pair.
      *  Mirrors the Rust TestField::options (untagged FieldOption). */
     options?: Array<string | number | boolean | { label: string; value: any }>;
+    /** Operator-editable after recording — annotation columns only (a specimen
+     *  or lot id noted against a captured row). Meaningful on `cycle_fields`;
+     *  the server refuses `tis.update_cycle` for any field without it, so
+     *  measured columns can never be typed over. Mirrors Rust
+     *  `TestField::editable`. */
+    editable?: boolean;
 }
 
 export interface ChartAxis  { field?: string; column?: string; label?: string; }
@@ -155,10 +161,16 @@ export interface TestConfiguration {
     defaults?: { [field: string]: any };
 }
 export interface TestMethod {
-    project_fields:  TestFieldDef[];
-    config_fields:   TestFieldDef[];
-    cycle_fields:    TestFieldDef[];
-    results_fields:  TestFieldDef[];
+    /* All four field lists are OPTIONAL by design. Server-side each is
+     * `#[serde(default)]`, so a method that declares only `config_fields` is
+     * perfectly valid and the other keys simply aren't in the JSON. Typing
+     * them as required let `schema.cycle_fields.map(...)` compile and then
+     * blank the operator's page at runtime (gen4_ac, 2026-08-11). Keep them
+     * optional so the compiler demands a `?? []` at every use. */
+    project_fields?: TestFieldDef[];
+    config_fields?:  TestFieldDef[];
+    cycle_fields?:   TestFieldDef[];
+    results_fields?: TestFieldDef[];
     raw_data?:       RawDataShape | null;
     views?:          { [name: string]: ChartView };
     /** Optional pretty label for the Test Method picker. */
@@ -208,6 +220,46 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
     const [rawOpen, setRawOpen] = useState(false);
     const [configOpen, setConfigOpen] = useState(false);
 
+    /**
+     * Commit an operator edit to an annotation cell (`tis.update_cycle`).
+     *
+     * The server is the gate: it accepts a field only if the method declares it
+     * `editable: true`, so a measured column is refused even if a caller asks.
+     * We update local state only after the round trip succeeds — showing an edit
+     * that didn't persist is worse than showing the old value.
+     */
+    const saveCycleField = useCallback(
+        async (row: any, field: string, value: any) => {
+            const cycleIndex = row?.cycle_index;
+            if (!projectId || !methodId || !runId || !cycleIndex) return;
+            try {
+                const resp: any = await invoke(
+                    'tis.update_cycle' as any,
+                    MessageType.Request,
+                    {
+                        project_id: projectId,
+                        method_id: methodId,
+                        run_id: runId,
+                        cycle_index: cycleIndex,
+                        fields: { [field]: value },
+                    } as any,
+                );
+                if (resp?.success === false) {
+                    console.error('tis.update_cycle rejected:', resp?.error_message);
+                    return;
+                }
+                setCycles((prev) =>
+                    prev.map((c) =>
+                        c?.cycle_index === cycleIndex ? { ...c, [field]: value } : c,
+                    ),
+                );
+            } catch (e) {
+                console.error('tis.update_cycle failed:', e);
+            }
+        },
+        [invoke, projectId, methodId, runId],
+    );
+
     // Direct handle on the chart.js instance so the toolbar's reset-
     // zoom button can call chart.resetZoom() — the zoom plugin's only
     // imperative API. Customers like the wheel/pinch/drag zoom but
@@ -742,10 +794,16 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
                 doesn't render 1000 row elements at once. */}
             {(() => {
                 const useVirtual = cycles.length > CYCLE_VIRTUAL_THRESHOLD;
-                const cycleColumns: ScienceColumn[] = schema.cycle_fields.map(f => ({
+                // `?? []` is load-bearing: cycle_fields is `#[serde(default)]`
+                // server-side, so a method that declares only config_fields is
+                // valid and arrives with the key absent. Without the guard the
+                // `.map` throws inside render and React unmounts the whole
+                // app — the operator sees a blank page, not a missing table.
+                const cycleColumns: ScienceColumn[] = (schema.cycle_fields ?? []).map(f => ({
                     field: f.name,
                     label: f.name,
                     units: f.units,
+                    editable: f.editable,
                     body: (row) => formatCell(row[f.name], f.type, f.scale),
                 }));
                 return (
@@ -756,6 +814,7 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
                         scrollable={useVirtual}
                         scrollHeight={useVirtual ? cycleTableHeight : undefined}
                         emptyMessage="No cycles yet."
+                        onCellEdit={saveCycleField}
                     />
                 );
             })()}
@@ -767,7 +826,7 @@ export const TestDataView: React.FC<TestDataViewProps> = (props) => {
             {(() => {
                 const values = { ...results, ...sampleSummary };
                 const hasValues = Object.keys(values).length > 0;
-                const resultColumns: ScienceColumn[] = schema.results_fields.map(f => ({
+                const resultColumns: ScienceColumn[] = (schema.results_fields ?? []).map(f => ({
                     field: f.name,
                     label: f.name,
                     units: f.units,

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

@@ -7,7 +7,7 @@
  * Action bar: New / Duplicate / Delete / Apply / Save / Revert.
  *
  * "Apply" pushes the local Monaco buffer to the server-side stage
- * (`tis.put_method`). "Save" persists the entire stage to project.json
+ * (`tis.put_method`). "Save" persists the entire stage to test_methods.json
  * (`tis.save_config`). "Revert" drops the stage (`tis.discard_config_changes`).
  *
  * Save is disabled (with a tooltip) when active tests are open against

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

@@ -79,9 +79,10 @@ export const SaveDiffDialog: React.FC<SaveDiffDialogProps> = ({
             {diff && (
                 <div>
                     <p>
-                        About to overwrite <code>project.json</code>. A backup
-                        of the previous file will be written to{' '}
-                        <code>project.json.bak</code>.
+                        About to save the test methods to{' '}
+                        <code>test_methods.json</code>. A backup of the
+                        previous file will be written to{' '}
+                        <code>test_methods.json.bak</code>.
                     </p>
                     {diff.added.length === 0 && diff.removed.length === 0 && diff.modified.length === 0 && (
                         <p><em>No changes detected.</em></p>