@adcops/autocore-react 3.3.124 → 3.5.5

package/src/components/ams/AmsProvider.tsx

@@ -105,6 +105,20 @@ export interface AmsContextValue {
     listCalibrations: (assetId: string) => Promise<string[]>;
     readCalibration: (assetId: string, calId: string) => Promise<any | null>;
     readUsage: (assetId: string) => Promise<any | null>;
+    /**
+     * Declare which asset is INSTALLED at a role (`ams.assign_role`).
+     *
+     * Pass `null` for `assetId` to record that nothing is fitted. One RPC,
+     * not two `updateAsset` calls: the server vacates the role and installs
+     * the new asset atomically, so the role is never momentarily empty or
+     * double-claimed — `resolve_method_refs` takes the FIRST active asset at
+     * a location, so a double-claimed role resolves to an arbitrary one.
+     *
+     * Resolves to `null` on success, or the server's message on refusal
+     * (wrong asset type for the role, asset not active, unknown id) so the
+     * caller can show the operator WHY the swap was refused.
+     */
+    assignRole: (location: string, assetId: string | null) => Promise<string | null>;
     selection: AmsSelection;
     setSelection: (patch: Partial<AmsSelection>) => void;
 }
@@ -125,6 +139,7 @@ const AmsContext = createContext<AmsContextValue>({
     listCalibrations: async () => [],
     readCalibration: async () => null,
     readUsage: async () => null,
+    assignRole: async () => 'AmsProvider is not mounted',
     selection: { assetType: null, assetId: null },
     setSelection: () => {},
 });
@@ -257,6 +272,25 @@ export const AmsProvider: React.FC<AmsProviderProps> = ({ children }) => {
         } catch { return null; }
     }, [invoke]);
 
+    const assignRole = useCallback(async (location: string, assetId: string | null): Promise<string | null> => {
+        try {
+            const resp: any = await invoke('ams.assign_role' as any, MessageType.Request, {
+                location, asset_id: assetId,
+            } as any);
+            if (resp?.success) {
+                // The server broadcasts ams.asset_changed for every asset it
+                // touched, which already triggers a refresh — but the refresh
+                // is awaited here too so a caller that re-renders off `assets`
+                // sees the new occupant by the time this resolves.
+                await refreshAssets();
+                return null;
+            }
+            return resp?.error_message || 'ams.assign_role failed';
+        } catch (e: any) {
+            return String(e?.message ?? e);
+        }
+    }, [invoke, refreshAssets]);
+
     const value = useMemo<AmsContextValue>(() => ({
         schemas,
         schemasLoaded,
@@ -269,9 +303,10 @@ export const AmsProvider: React.FC<AmsProviderProps> = ({ children }) => {
         listCalibrations,
         readCalibration,
         readUsage,
+        assignRole,
         selection,
         setSelection,
-    }), [schemas, schemasLoaded, roles, rolesLoaded, alerts, assets, refreshAssets, readAsset, listCalibrations, readCalibration, readUsage, selection, setSelection]);
+    }), [schemas, schemasLoaded, roles, rolesLoaded, alerts, assets, refreshAssets, readAsset, listCalibrations, readCalibration, readUsage, assignRole, selection, setSelection]);
 
     return <AmsContext.Provider value={value}>{children}</AmsContext.Provider>;
 };

package/src/components/ams/AssetDetailView.tsx

@@ -16,6 +16,7 @@ import { MessageType } from '../../hub/CommandMessage';
 import { useAms } from './AmsProvider';
 import { CalibrationEntryDialog } from './CalibrationEntryDialog';
 import { AssetEditDialog } from './AssetEditDialog';
+import { AssetNameplateGrid } from './AssetNameplateGrid';
 
 export const AssetDetailView: React.FC = () => {
     const { selection, schemas, roles, readAsset, listCalibrations, readCalibration, readUsage,
@@ -189,26 +190,7 @@ export const AssetDetailView: React.FC = () => {
             {schemaFields.length > 0 && (
                 <div>
                     <h4 style={{ margin: '0 0 0.5rem 0' }}>Nameplate</h4>
-                    <div style={{ display: 'grid', gridTemplateColumns: 'auto 1fr',
-                                  gap: '0.25rem 1rem', alignItems: 'baseline',
-                                  fontSize: '0.9rem' }}>
-                        {schemaFields.map((f: any) => {
-                            const v = custom[f.name];
-                            const present = v !== undefined && v !== null && v !== '';
-                            const label = f.label ?? f.name;
-                            const display = present
-                                ? (f.units ? `${v} ${f.units}` : String(v))
-                                : '(not set)';
-                            return (
-                                <React.Fragment key={f.name}>
-                                    <strong title={f.description ?? undefined}>{label}</strong>
-                                    <span style={{ color: present ? undefined : '#f59e0b' }}>
-                                        {display}
-                                    </span>
-                                </React.Fragment>
-                            );
-                        })}
-                    </div>
+                    <AssetNameplateGrid schemaFields={schemaFields} custom={custom} />
                 </div>
             )}
 

package/src/components/ams/AssetNameplateGrid.tsx

@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2026 Automated Design Corp. All Rights Reserved.
+ *
+ * <AssetNameplateGrid> — the nameplate field/value grid for one asset.
+ *
+ * Extracted so <AssetDetailView> (the full record) and
+ * <InstalledAssetPicker> (what is fitted right now) render a nameplate the
+ * same way. A field the schema declares but the record has not filled in is
+ * drawn as an amber "(not set)" rather than blank space: that is exactly the
+ * state the placeholder resolver refuses to start a module on, so it is worth
+ * drawing the eye to.
+ */
+
+import React from 'react';
+
+export interface AssetNameplateGridProps {
+    /** The asset_type schema's `fields` array. */
+    schemaFields: any[];
+    /** The asset record's `custom` object (nameplate values). */
+    custom: Record<string, any>;
+    /** Only render these field names, in this order. Omit for all of them. */
+    only?: string[];
+    /** Font size for the grid; the detail view runs slightly larger. */
+    fontSize?: string;
+}
+
+export const AssetNameplateGrid: React.FC<AssetNameplateGridProps> = ({
+    schemaFields,
+    custom,
+    only,
+    fontSize = '0.9rem',
+}) => {
+    const fields = only
+        ? only
+              .map(name => schemaFields.find((f: any) => f.name === name))
+              .filter(Boolean)
+        : schemaFields;
+
+    if (fields.length === 0) return null;
+
+    return (
+        <div style={{ display: 'grid', gridTemplateColumns: 'auto 1fr',
+                      gap: '0.25rem 1rem', alignItems: 'baseline', fontSize }}>
+            {fields.map((f: any) => {
+                const v = custom[f.name];
+                const present = v !== undefined && v !== null && v !== '';
+                const label = f.label ?? f.name;
+                const display = present
+                    ? (f.units ? `${v} ${f.units}` : String(v))
+                    : '(not set)';
+                return (
+                    <React.Fragment key={f.name}>
+                        <strong title={f.description ?? undefined}>{label}</strong>
+                        <span style={{ color: present ? undefined : '#f59e0b' }}>
+                            {display}
+                        </span>
+                    </React.Fragment>
+                );
+            })}
+        </div>
+    );
+};

package/src/components/ams/InstalledAssetPicker.tsx

@@ -0,0 +1,209 @@
+/*
+ * Copyright (C) 2026 Automated Design Corp. All Rights Reserved.
+ *
+ * <InstalledAssetPicker> — "which asset is fitted in this role right now?"
+ *
+ * The operator-facing answer to a swap. A machine with a 2 kN and a 20 kN load
+ * cell in the drawer has ONE of them bolted to the press; this picker is where
+ * they say which, and everything downstream — the test record's asset
+ * snapshot, module placeholders, the control program's AssetWatch — follows
+ * from that one statement.
+ *
+ * It writes through `ams.assign_role`, never two `ams.update_asset` calls: the
+ * server vacates the role and installs the replacement atomically, because
+ * `resolve_method_refs` takes the FIRST active asset it finds at a location and
+ * a momentarily double-claimed role would therefore resolve to an arbitrary one.
+ *
+ * Deliberately NOT a nameplate editor. The nameplate belongs to the asset
+ * record (Assets tab / <AssetDetailView>) — one source of truth. This picker
+ * only chooses which record is in force, and shows what that record says so the
+ * operator can confirm they grabbed the right hardware before pressing on.
+ */
+
+import React, { useCallback, useMemo, useState } from 'react';
+import { Dropdown } from 'primereact/dropdown';
+import { Button } from 'primereact/button';
+import { Dialog } from 'primereact/dialog';
+import { Message } from 'primereact/message';
+import { AssetNameplateGrid } from './AssetNameplateGrid';
+import { useInstalledAsset } from './useInstalledAsset';
+
+export interface InstalledAssetPickerProps {
+    /** Asset type the role takes, e.g. `"load_cell"`. */
+    assetType: string;
+    /** The role's `location` string, e.g. `"press_load_cell"`. */
+    location: string;
+    /**
+     * Heading for the picker. Defaults to the role's label from
+     * `ams.list_roles`, then to the raw location.
+     */
+    label?: string;
+    /** One line under the dropdown explaining what this role drives. */
+    description?: string;
+    /**
+     * Nameplate field names folded into each option's text, so the operator can
+     * tell two assets apart without opening them (e.g.
+     * `["capacity", "capacity_units"]` → "2000 N"). Serial is always shown.
+     */
+    summaryFields?: string[];
+    /** Render the fitted asset's full nameplate below the dropdown. */
+    showNameplate?: boolean;
+    /** Render the fitted asset's calibration state below the nameplate. */
+    showCalibration?: boolean;
+    /**
+     * Block the swap. Use for "a test is running" — changing the fitted asset
+     * mid-run would re-scale a channel under the data being recorded.
+     */
+    disabled?: boolean;
+    /** Why it is blocked. Shown in place of the help text. */
+    disabledReason?: string;
+    /** Fired after a successful assignment with the new asset id (or null). */
+    onAssigned?: (assetId: string | null) => void;
+}
+
+/** Option value standing for "nothing is fitted". */
+const NONE = '__none__';
+
+export const InstalledAssetPicker: React.FC<InstalledAssetPickerProps> = ({
+    assetType,
+    location,
+    label,
+    description,
+    summaryFields = [],
+    showNameplate = true,
+    showCalibration = true,
+    disabled = false,
+    disabledReason,
+    onAssigned,
+}) => {
+    const {
+        candidates, records, installed, installedRecord,
+        calibration, calibrationOverdue, role, schemaFields, assign,
+    } = useInstalledAsset(assetType, location);
+
+    const [error, setError] = useState<string | null>(null);
+    const [busy, setBusy] = useState(false);
+    /** Non-null while the confirm dialog is open; carries the pending choice. */
+    const [pending, setPending] = useState<{ assetId: string | null } | null>(null);
+
+    const roleLabel = label ?? role?.label ?? location;
+    const roleHelp  = description ?? role?.description ?? null;
+
+    /** "SN 4471-A — 2000 N" — enough to tell two assets apart in a list. */
+    const optionText = useCallback((assetId: string): string => {
+        const entry = candidates.find(c => c.asset_id === assetId);
+        const custom = (records[assetId]?.custom ?? {}) as Record<string, any>;
+        const bits: string[] = [entry?.serial ? `SN ${entry.serial}` : assetId];
+        const summary = summaryFields
+            .map(name => custom[name])
+            .filter(v => v !== undefined && v !== null && v !== '')
+            .join(' ');
+        if (summary) bits.push(summary);
+        return bits.join(' — ');
+    }, [candidates, records, summaryFields]);
+
+    const options = useMemo(() => [
+        ...candidates.map(c => ({ label: optionText(c.asset_id), value: c.asset_id })),
+        { label: '— nothing fitted —', value: NONE },
+    ], [candidates, optionText]);
+
+    const commit = async (assetId: string | null) => {
+        setBusy(true);
+        setError(null);
+        const err = await assign(assetId);
+        setBusy(false);
+        setPending(null);
+        if (err) { setError(err); return; }
+        onAssigned?.(assetId);
+    };
+
+    const calExpiry = calibration?.expires_at ? new Date(calibration.expires_at) : null;
+
+    return (
+        <div style={{ display: 'flex', flexDirection: 'column', gap: '0.5rem' }}>
+            <div className="p-inputgroup">
+                <span className="p-inputgroup-addon" style={{ flexGrow: 1 }}>
+                    {roleLabel}
+                </span>
+                <Dropdown
+                    value={installed?.asset_id ?? NONE}
+                    options={options}
+                    disabled={disabled || busy}
+                    onChange={(e) => {
+                        const next = e.value === NONE ? null : (e.value as string);
+                        if (next === (installed?.asset_id ?? null)) return;
+                        setPending({ assetId: next });
+                    }}
+                    placeholder="Select the fitted asset"
+                    style={{ minWidth: '18rem' }}
+                />
+            </div>
+
+            {/* Help text, or the reason the operator can't change it. On screen
+                rather than in a hover tooltip — this runs on a touchscreen,
+                where a tooltip is unreachable. */}
+            {disabled && disabledReason
+                ? <small style={{ color: '#f59e0b' }}>{disabledReason}</small>
+                : roleHelp && <small style={{ color: '#9ca3af' }}>{roleHelp}</small>}
+
+            {candidates.length === 0 && (
+                <Message severity="warn"
+                    text={`No active ${assetType.replace(/_/g, ' ')} is registered. Add one on the Assets screen first.`} />
+            )}
+
+            {!installed && candidates.length > 0 && (
+                <Message severity="warn"
+                    text="Nothing is recorded as fitted in this role. Tests that need it will refuse to start." />
+            )}
+
+            {error && <Message severity="error" text={error} />}
+
+            {installed && showNameplate && (
+                <AssetNameplateGrid
+                    schemaFields={schemaFields}
+                    custom={(installedRecord?.custom ?? {}) as Record<string, any>}
+                />
+            )}
+
+            {installed && showCalibration && (
+                <small style={{ color: calibrationOverdue ? '#f59e0b' : '#9ca3af' }}>
+                    {!installed.current_calibration_id
+                        ? 'No calibration on record for this asset.'
+                        : calibrationOverdue
+                            ? `Calibration ${installed.current_calibration_id} expired ${calExpiry!.toLocaleDateString()}.`
+                            : `Calibration ${installed.current_calibration_id}${
+                                calExpiry ? `, in date until ${calExpiry.toLocaleDateString()}` : ''}.`}
+                </small>
+            )}
+
+            {/* Confirm, because this restates what hardware is bolted to the
+                machine: downstream it re-scales a measurement channel and is
+                frozen into every test record started afterwards. */}
+            <Dialog
+                visible={pending !== null}
+                header={`Change the ${roleLabel}?`}
+                modal
+                onHide={() => setPending(null)}
+                footer={
+                    <>
+                        <Button label="Cancel" outlined onClick={() => setPending(null)} />
+                        <Button label="Confirm" loading={busy}
+                            onClick={() => { void commit(pending?.assetId ?? null); }} />
+                    </>
+                }
+            >
+                <p style={{ margin: 0 }}>
+                    {pending?.assetId
+                        ? <>Record <strong>{optionText(pending.assetId)}</strong> as the asset fitted
+                            in <strong>{roleLabel}</strong>.</>
+                        : <>Record that <strong>nothing</strong> is fitted in <strong>{roleLabel}</strong>.</>}
+                </p>
+                <p style={{ marginBottom: 0, color: '#9ca3af' }}>
+                    Confirm only if this matches the hardware actually installed. The
+                    machine reconfigures the channel from this asset's nameplate, and
+                    every test started from now on records it.
+                </p>
+            </Dialog>
+        </div>
+    );
+};

package/src/components/ams/index.ts

@@ -14,3 +14,10 @@ export { AssetEditDialog } from './AssetEditDialog';
 export { SubLocationPicker } from './SubLocationPicker';
 export { PlaceholderHealthPanel } from './PlaceholderHealthPanel';
 export { MissingAssetsBanner } from './MissingAssetsBanner';
+// "What is fitted right now" — the operator's swap surface, and the
+// nameplate grid it shares with <AssetDetailView>.
+export { InstalledAssetPicker } from './InstalledAssetPicker';
+export type { InstalledAssetPickerProps } from './InstalledAssetPicker';
+export { AssetNameplateGrid } from './AssetNameplateGrid';
+export { useInstalledAsset } from './useInstalledAsset';
+export type { InstalledAssetState } from './useInstalledAsset';

package/src/components/ams/useInstalledAsset.ts

@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2026 Automated Design Corp. All Rights Reserved.
+ *
+ * useInstalledAsset — "what is fitted in this role, and what does its record
+ * say?" for one (assetType, location) pair.
+ *
+ * The registry cache in <AmsProvider> carries only identity (id, serial,
+ * status, location); anything that has to show or act on a NAMEPLATE needs the
+ * full record. This hook is the one place that fetch happens, so
+ * <InstalledAssetPicker> and a product's own panel (e.g. a load-channel
+ * verification table comparing the nameplate against what the hardware
+ * actually holds) read the same data instead of each querying for it.
+ */
+
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useAms, type AmsAssetEntry, type AmsRole } from './AmsProvider';
+
+export interface InstalledAssetState {
+    /** Every ACTIVE asset of this type — the assets that could be fitted. */
+    candidates: AmsAssetEntry[];
+    /** Full records for `candidates`, keyed by asset_id. */
+    records: Record<string, any>;
+    /** The registry entry fitted in this role, or null when nothing is. */
+    installed: AmsAssetEntry | null;
+    /** The fitted asset's full record; nameplate values live under `.custom`. */
+    installedRecord: any | null;
+    /** The fitted asset's current calibration record, or null. */
+    calibration: any | null;
+    /** True once the calibration on record has passed its `expires_at`. */
+    calibrationOverdue: boolean;
+    /** This role's metadata from `ams.list_roles`, when the project declares it. */
+    role: AmsRole | null;
+    /** The asset_type schema's nameplate `fields` array (empty if unknown). */
+    schemaFields: any[];
+    /**
+     * Declare what is fitted (`null` = nothing). Resolves to `null` on success
+     * or the server's refusal message.
+     */
+    assign: (assetId: string | null) => Promise<string | null>;
+}
+
+export function useInstalledAsset(assetType: string, location: string): InstalledAssetState {
+    const { assets, schemas, roles, readAsset, readCalibration, assignRole } = useAms();
+
+    const [records, setRecords] = useState<Record<string, any>>({});
+    const [calibration, setCalibration] = useState<any | null>(null);
+
+    const candidates = useMemo(
+        () => assets.filter(a => a.asset_type === assetType && a.status === 'active'),
+        [assets, assetType],
+    );
+    const installed = useMemo(
+        () => candidates.find(a => a.location === location) ?? null,
+        [candidates, location],
+    );
+    const role = useMemo(
+        () => (roles[assetType] ?? []).find(r => r.location === location) ?? null,
+        [roles, assetType, location],
+    );
+
+    // Fetch the full record for every candidate. Keyed on the id list, so a
+    // registry refresh that left the candidate set alone does no I/O.
+    const candidateKey = candidates.map(c => c.asset_id).join(',');
+    useEffect(() => {
+        let cancelled = false;
+        (async () => {
+            const next: Record<string, any> = {};
+            for (const c of candidates) {
+                const rec = await readAsset(c.asset_id);
+                if (cancelled) return;
+                if (rec) next[c.asset_id] = rec;
+            }
+            if (!cancelled) setRecords(next);
+        })();
+        return () => { cancelled = true; };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [candidateKey, readAsset]);
+
+    // The fitted asset's current calibration, for the "is it in date?" line.
+    useEffect(() => {
+        let cancelled = false;
+        (async () => {
+            if (!installed?.current_calibration_id) { setCalibration(null); return; }
+            const cal = await readCalibration(installed.asset_id, installed.current_calibration_id);
+            if (!cancelled) setCalibration(cal);
+        })();
+        return () => { cancelled = true; };
+    }, [installed?.asset_id, installed?.current_calibration_id, readCalibration]);
+
+    const assign = useCallback(
+        (assetId: string | null) => assignRole(location, assetId),
+        [assignRole, location],
+    );
+
+    const expiry = calibration?.expires_at ? new Date(calibration.expires_at) : null;
+
+    return {
+        candidates,
+        records,
+        installed,
+        installedRecord: installed ? (records[installed.asset_id] ?? null) : null,
+        calibration,
+        calibrationOverdue: !!expiry && expiry.getTime() < Date.now(),
+        role,
+        schemaFields: Array.isArray(schemas[assetType]?.fields) ? schemas[assetType].fields : [],
+        assign,
+    };
+}

package/src/components/index.ts

@@ -63,6 +63,10 @@ export { SampleSummaryPanel }  from './tis/SampleSummaryPanel';
 export type { SampleSummaryPanelProps } from './tis/SampleSummaryPanel';
 
 export { TestDataView, DEFAULT_X_DECIMALS } from './tis/TestDataView';
+export { UnitSystemSelector }  from './UnitSystemSelector';
+export type { UnitSystemSelectorProps } from './UnitSystemSelector';
+export { UnitsEditor }         from './UnitsEditor';
+export type { UnitsEditorProps } from './UnitsEditor';
 export type { TestDataViewProps, ChartAxis, ChartSeries, ChartView, RawDataShape } from './tis/TestDataView';
 
 export { TestRawDataView }     from './tis/TestRawDataView';

package/src/components/tis/ResultHistoryTable.tsx

@@ -77,10 +77,20 @@ 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.
+    // Per-row lifecycle menu (close / complete / abandon / reopen). One Menu
+    // instance is reused.
+    //
+    // The row is carried in an OPEN REQUEST rather than plain state, and the
+    // popup is shown from an effect once React has committed the new model.
+    // Opening it inline in onClick (the original shape) raced the state update:
+    // the popup rendered with the *previous* row's model — or an empty one on the
+    // first click — so an action either did nothing or silently hit the wrong
+    // run. Each click makes a fresh request object so re-opening the same row
+    // still fires the effect.
     const rowMenuRef = useRef<Menu>(null);
-    const [menuRow, setMenuRow] = useState<any>(null);
+    const [menuRequest, setMenuRequest] =
+        useState<{ row: any; anchor: HTMLElement; seq: number } | null>(null);
+    const menuSeqRef = useRef(0);
     const [lifecycleBusy, setLifecycleBusy] = useState<string | null>(null);
     const { invoke } = useContext(EventEmitterContext);
 
@@ -118,6 +128,15 @@ export const ResultHistoryTable: React.FC<ResultHistoryTableProps> = (props) =>
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [projectId, methodId, tis.state.activeRunId, tis.state.active]);
 
+    // Show the popup only after React has committed the model for `menuRequest`
+    // (see the note on `menuRequest`). `anchor` is the captured DOM node — the
+    // original event's currentTarget is null by now.
+    useEffect(() => {
+        if (!menuRequest) return;
+        rowMenuRef.current?.show({ currentTarget: menuRequest.anchor } as any);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [menuRequest]);
+
     const formatDate = (dateStr: string) => {
         if (!dateStr) return '';
         return new Date(dateStr).toLocaleString();
@@ -233,6 +252,10 @@ export const ResultHistoryTable: React.FC<ResultHistoryTableProps> = (props) =>
     /**
      * Menu items for a row, gated on its lifecycle state:
      *  - open (in_progress / paused) → Complete, Abandon
+     *  - interrupted (auto-closed)   → Close (acknowledge it as done), Reopen,
+     *    Abandon. Abandon is offered here but NOT for a run a person completed:
+     *    nobody vouched for an interrupted run, so clearing a junk one out of
+     *    the history is a judgement the operator is entitled to make.
      *  - 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
@@ -242,6 +265,11 @@ export const ResultHistoryTable: React.FC<ResultHistoryTableProps> = (props) =>
         const status = rowData?.status;
         const finalized = rowData?.finalized === true;
         const isOpen = status === 'in_progress' || status === 'paused';
+        // Closed by the TIS startup sweep, not by a person. It is already out of
+        // "In Progress", but nobody has confirmed the run is done with — so it
+        // still reads as Interrupted until someone closes it.
+        const isInterrupted =
+            status === 'completed' && rowData?.auto_closed === true && !finalized;
         const items: any[] = [];
 
         if (isOpen) {
@@ -264,6 +292,50 @@ export const ResultHistoryTable: React.FC<ResultHistoryTableProps> = (props) =>
                     accept: () => handleLifecycle(rowData, 'abandon'),
                 }),
             });
+        } else if (isInterrupted) {
+            items.push({
+                label: 'Close Test',
+                icon: 'pi pi-check-circle',
+                command: () => confirmDialog({
+                    header: 'Close Interrupted Test',
+                    message:
+                        `Close ${rowData?.sample_id || rowData?.run_id}? It was closed automatically ` +
+                        `when the software restarted mid-test. Closing it marks it Completed and ` +
+                        `keeps the recorded end time. Recorded data is not changed, and the test ` +
+                        `can still be reopened later.`,
+                    icon: 'pi pi-check-circle',
+                    acceptLabel: 'Close Test',
+                    accept: () => handleLifecycle(rowData, 'complete'),
+                }),
+            });
+            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'),
+                }),
+            });
+            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',
@@ -580,14 +652,25 @@ export const ResultHistoryTable: React.FC<ResultHistoryTableProps> = (props) =>
                             tooltip="Complete / abandon / reopen this test"
                             tooltipOptions={{ position: 'left' }}
                             onClick={(e) => {
-                                setMenuRow(rowData);
-                                rowMenuRef.current?.toggle(e);
+                                // Capture the DOM anchor now: React clears
+                                // currentTarget once the handler returns, and the
+                                // effect needs it to position the popup.
+                                menuSeqRef.current += 1;
+                                setMenuRequest({
+                                    row: rowData,
+                                    anchor: e.currentTarget as HTMLElement,
+                                    seq: menuSeqRef.current,
+                                });
                             }}
                         />
                     )}
                 />
             </DataTable>
-            <Menu model={menuRow ? rowMenuItems(menuRow) : []} popup ref={rowMenuRef} />
+            <Menu
+                model={menuRequest ? rowMenuItems(menuRequest.row) : []}
+                popup
+                ref={rowMenuRef}
+            />
         </div>
     );
 };