@seedtactics/insight-client 16.8.4-beta.10 → 16.8.4-beta.11

package/dist/cell-status/material-details.d.ts

@@ -49,6 +49,7 @@ export declare const serialInMaterialDialog: Atom<Promise<string | null>>;
 export declare const serialInMaterialDialogUnwrapped: Atom<string | null>;
 export declare const serialInMaterialDialogState: Atom<AsyncAtomState<string | null>>;
 export declare const workorderInMaterialDialog: Atom<Promise<string | null>>;
+export declare const materialInDialogLocalEvents: Atom<readonly Readonly<ILogEntry>[]>;
 export declare const materialInDialogEvents: Atom<readonly Readonly<ILogEntry>[]>;
 export type LargestUsedProces = {
     readonly process: number;
@@ -96,9 +97,12 @@ export interface PrintLabelData {
     readonly proc: number;
 }
 export declare function usePrintLabel(): [(data: PrintLabelData) => void, boolean, boolean];
-export declare function useRemoveFromQueue(): [(matId: number, operator: string | null) => void, boolean];
+export declare function useRemoveFromQueue(): [
+    (matId: number, operator: string | null) => Promise<void>,
+    boolean
+];
 export declare function useSignalForQuarantine(): [
-    (matId: number, operator: string | null, reason: string) => void,
+    (matId: number, operator: string | null, reason: string) => Promise<void>,
     boolean
 ];
 export interface AddExistingMaterialToQueueData {
@@ -108,7 +112,7 @@ export interface AddExistingMaterialToQueueData {
     readonly operator: string | null;
 }
 export declare function useAddExistingMaterialToQueue(): [
-    (d: AddExistingMaterialToQueueData) => void,
+    (d: AddExistingMaterialToQueueData) => Promise<void>,
     boolean
 ];
 export interface AddNewMaterialToQueueData {
@@ -122,7 +126,10 @@ export interface AddNewMaterialToQueueData {
     readonly onNewMaterial?: (mat: Readonly<IInProcessMaterial>) => void;
     readonly onError?: (reason: unknown) => void;
 }
-export declare function useAddNewMaterialToQueue(): [(d: AddNewMaterialToQueueData) => void, boolean];
+export declare function useAddNewMaterialToQueue(): [
+    (d: AddNewMaterialToQueueData) => Promise<Readonly<IInProcessMaterial>>,
+    boolean
+];
 export interface AddNewCastingToQueueData {
     readonly casting: string;
     readonly quantity: number;
@@ -133,4 +140,7 @@ export interface AddNewCastingToQueueData {
     readonly onNewMaterial?: (mats: ReadonlyArray<Readonly<IInProcessMaterial>>) => void;
     readonly onError?: (reason: unknown) => void;
 }
-export declare function useAddNewCastingToQueue(): [(d: AddNewCastingToQueueData) => void, boolean];
+export declare function useAddNewCastingToQueue(): [
+    (d: AddNewCastingToQueueData) => Promise<ReadonlyArray<Readonly<IInProcessMaterial>>>,
+    boolean
+];

package/dist/cell-status/material-details.js

@@ -121,8 +121,9 @@ export const inProcessMaterialInDialog = atom(async (get) => {
     const toShow = get(matToShow);
     if (toShow === null)
         return null;
-    if (toShow.type === "InProcMat")
-        return toShow.inproc;
+    if (toShow.type === "InProcMat") {
+        return status.material.find((m) => m.materialID === toShow.inproc.materialID) ?? null;
+    }
     const matId = (await get(materialInDialogInfo))?.materialID ?? null;
     return matId !== null && matId >= 0
         ? (status.material.find((m) => m.materialID === matId) ?? null)
@@ -210,6 +211,9 @@ const otherMatEvents = atom(async (get, { signal }) => {
     return evts;
 });
 const otherMatEventsUnwrapped = unwrap(otherMatEvents, (prev) => prev ?? []);
+export const materialInDialogLocalEvents = atom((get) => {
+    return LazySeq.of(get(localMatEventsUnwrapped)).concat(get(extraLogEventsFromUpdates)).toRArray();
+});
 export const materialInDialogEvents = atom((get) => {
     const evtsFromUpdate = get(extraLogEventsFromUpdates);
     return LazySeq.of(get(localMatEventsUnwrapped))
@@ -373,66 +377,83 @@ export function usePrintLabel() {
 }
 export function useRemoveFromQueue() {
     const [updating, setUpdating] = useState(false);
-    const callback = useCallback((matId, operator) => {
+    const callback = useCallback(async (matId, operator) => {
         setUpdating(true);
-        JobsBackend.removeMaterialFromAllQueues(matId, operator ?? undefined)
-            .catch(console.log)
-            .finally(() => setUpdating(false));
+        try {
+            await JobsBackend.removeMaterialFromAllQueues(matId, operator ?? undefined);
+        }
+        finally {
+            setUpdating(false);
+        }
     }, []);
     return [callback, updating];
 }
 export function useSignalForQuarantine() {
     const [updating, setUpdating] = useState(false);
-    const callback = useCallback((matId, operator, reason) => {
+    const callback = useCallback(async (matId, operator, reason) => {
         setUpdating(true);
-        JobsBackend.signalMaterialForQuarantine(matId, operator, reason === "" ? undefined : reason)
-            .catch(console.log)
-            .finally(() => setUpdating(false));
+        try {
+            await JobsBackend.signalMaterialForQuarantine(matId, operator, reason === "" ? undefined : reason);
+        }
+        finally {
+            setUpdating(false);
+        }
     }, []);
     return [callback, updating];
 }
 export function useAddExistingMaterialToQueue() {
     const [updating, setUpdating] = useState(false);
-    const callback = useCallback((d) => {
+    const callback = useCallback(async (d) => {
         setUpdating(true);
-        JobsBackend.setMaterialInQueue(d.materialId, d.operator, new QueuePosition({
-            queue: d.queue,
-            position: d.queuePosition,
-        }))
-            .catch(console.log)
-            .finally(() => setUpdating(false));
+        try {
+            await JobsBackend.setMaterialInQueue(d.materialId, d.operator, new QueuePosition({
+                queue: d.queue,
+                position: d.queuePosition,
+            }));
+        }
+        finally {
+            setUpdating(false);
+        }
     }, []);
     return [callback, updating];
 }
 export function useAddNewMaterialToQueue() {
     const [updating, setUpdating] = useState(false);
-    const callback = useCallback((d) => {
+    const callback = useCallback(async (d) => {
         setUpdating(true);
-        JobsBackend.addUnprocessedMaterialToQueue(d.jobUnique, d.lastCompletedProcess, d.queue, d.queuePosition, d.operator, d.workorder, d.serial || "")
-            .then((m) => {
-            if (d.onNewMaterial && m) {
-                d.onNewMaterial(m);
-            }
-            else if (d.onError) {
-                d.onError("No material returned");
-            }
-        }, d.onError)
-            .catch(console.log)
-            .finally(() => setUpdating(false));
+        try {
+            const material = await JobsBackend.addUnprocessedMaterialToQueue(d.jobUnique, d.lastCompletedProcess, d.queue, d.queuePosition, d.operator, d.workorder, d.serial || "");
+            if (material === undefined)
+                throw new Error("No material returned");
+            d.onNewMaterial?.(material);
+            return material;
+        }
+        catch (e) {
+            d.onError?.(e);
+            throw e;
+        }
+        finally {
+            setUpdating(false);
+        }
     }, []);
     return [callback, updating];
 }
 export function useAddNewCastingToQueue() {
     const [updating, setUpdating] = useState(false);
-    const callback = useCallback((d) => {
+    const callback = useCallback(async (d) => {
         setUpdating(true);
-        JobsBackend.addUnallocatedCastingToQueue(d.casting, d.queue, d.quantity, d.operator, d.workorder, [...(d.serials || [])])
-            .then((ms) => {
-            if (d.onNewMaterial)
-                d.onNewMaterial(ms);
-        }, d.onError)
-            .catch(console.log)
-            .finally(() => setUpdating(false));
+        try {
+            const material = await JobsBackend.addUnallocatedCastingToQueue(d.casting, d.queue, d.quantity, d.operator, d.workorder, [...(d.serials || [])]);
+            d.onNewMaterial?.(material);
+            return material;
+        }
+        catch (e) {
+            d.onError?.(e);
+            throw e;
+        }
+        finally {
+            setUpdating(false);
+        }
     }, []);
     return [callback, updating];
 }

package/dist/components/operations/AllMaterial.js

@@ -43,6 +43,7 @@ import { InvalidateCycleDialogButton, InvalidateCycleDialogContent, SwapMaterial
 import { horizontalListSortingStrategy, SortableContext, useSortable, verticalListSortingStrategy, } from "@dnd-kit/sortable";
 import { closestCenter, DndContext, DragOverlay, getFirstCollision, MeasuringStrategy, pointerWithin, rectIntersection, } from "@dnd-kit/core";
 import { QuarantineMatButton } from "../station-monitor/QuarantineButton.js";
+import { CancelLoadButton } from "../station-monitor/CancelLoadButton.js";
 import { useSetTitle } from "../routes.js";
 import { useAtom, useAtomValue, useSetAtom } from "jotai";
 import { fmsInformation } from "../../network/server-settings.js";
@@ -152,7 +153,7 @@ const AllMatDialog = memo(function AllMatDialog() {
         setSwapSt(null);
         setInvalidateSt(null);
     }
-    return (_jsx(MaterialDialog, { onClose: onClose, allowNote: true, highlightProcsGreaterOrEqualTo: invalidateSt?.process ?? undefined, extraDialogElements: _jsxs(_Fragment, { children: [_jsx(SwapMaterialDialogContent, { st: swapSt, setState: setSwapSt }), invalidateSt !== null ? (_jsx(InvalidateCycleDialogContent, { st: invalidateSt, setState: setInvalidateSt })) : null] }), buttons: _jsxs(_Fragment, { children: [_jsx(QuarantineMatButton, { onClose: onClose, ignoreOperator: true }), _jsx(SwapMaterialButtons, { st: swapSt, setState: setSwapSt, onClose: onClose, ignoreOperator: true }), _jsx(InvalidateCycleDialogButton, { st: invalidateSt, setState: setInvalidateSt, onClose: onClose, ignoreOperator: true })] }) }));
+    return (_jsx(MaterialDialog, { onClose: onClose, allowNote: true, highlightProcsGreaterOrEqualTo: invalidateSt?.process ?? undefined, extraDialogElements: _jsxs(_Fragment, { children: [_jsx(SwapMaterialDialogContent, { st: swapSt, setState: setSwapSt }), invalidateSt !== null ? (_jsx(InvalidateCycleDialogContent, { st: invalidateSt, setState: setInvalidateSt })) : null] }), buttons: _jsxs(_Fragment, { children: [_jsx(QuarantineMatButton, { onClose: onClose, ignoreOperator: true }), _jsx(CancelLoadButton, { onClose: onClose, ignoreOperator: true }), _jsx(SwapMaterialButtons, { st: swapSt, setState: setSwapSt, onClose: onClose, ignoreOperator: true }), _jsx(InvalidateCycleDialogButton, { st: invalidateSt, setState: setInvalidateSt, onClose: onClose, ignoreOperator: true })] }) }));
 });
 function useCollisionDetection(allBins) {
     return useCallback((args) => {
@@ -260,12 +261,12 @@ export function AllMaterial(props) {
                     ? findQueueInQuarantineQueues(over.id, allBins)
                     : findMaterialInQuarantineQueues(over.id, allBins);
                 if (overCol) {
-                    addExistingMatToQueue({
+                    void addExistingMatToQueue({
                         materialId: activeDrag.mat.materialID,
                         queue: overCol.bin.queueName,
                         queuePosition: overCol.idx,
                         operator: null,
-                    });
+                    }).catch(console.error);
                     reorderQueuedMat({
                         queue: overCol.bin.queueName,
                         matId: activeDrag.mat.materialID,

package/dist/components/station-monitor/BulkRawMaterial.js

@@ -122,20 +122,20 @@ export const BulkAddCastingWithoutSerialDialog = memo(function BulkAddCastingWit
             enteredQty !== null &&
             !isNaN(enteredQty) &&
             enteredQty > 0) {
-            addNewCasting({
+            void addNewCasting({
                 casting: selectedCasting,
                 quantity: enteredQty,
                 queue: queue,
                 workorder: null,
                 operator: fmsInfo.requireOperatorNamePromptWhenAddingMaterial ? enteredOperator : operator,
-            });
+            }).catch(console.log);
         }
         close();
     }
     function addAndPrint() {
         if (queue !== null && selectedCasting !== null && enteredQty !== null && !isNaN(enteredQty)) {
             setAdding(true);
-            addNewCasting({
+            void addNewCasting({
                 casting: selectedCasting,
                 quantity: enteredQty,
                 queue: queue,
@@ -154,7 +154,7 @@ export const BulkAddCastingWithoutSerialDialog = memo(function BulkAddCastingWit
                 onError: () => {
                     close();
                 },
-            });
+            }).catch(() => { });
         }
     }
     return (_jsxs(_Fragment, { children: [_jsxs(Dialog, { open: queue !== null, onClose: () => close(), maxWidth: "md", children: [_jsx(DialogTitle, { children: "Add Raw Material" }), _jsx(DialogContent, { children: _jsxs(Stack, { direction: "column", spacing: 2, sx: {

package/dist/components/station-monitor/CancelLoadButton.d.ts

@@ -0,0 +1,4 @@
+export declare function CancelLoadButton({ onClose, ignoreOperator, }: {
+    readonly onClose?: () => void;
+    readonly ignoreOperator?: boolean;
+}): import("react").JSX.Element | null;

package/dist/components/station-monitor/CancelLoadButton.js

@@ -0,0 +1,59 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, Dialog, DialogActions, DialogContent, DialogTitle, TextField, Tooltip, } from "@mui/material";
+import { useAtomValue, useSetAtom } from "jotai";
+import { useState } from "react";
+import { LazySeq } from "@seedtactics/immutable-collections";
+import { currentStatus } from "../../cell-status/current-status.js";
+import { inProcessMaterialInDialog, materialDialogOpen, } from "../../cell-status/material-details.js";
+import { currentOperator } from "../../data/operators.js";
+import { JobsBackend } from "../../network/backend.js";
+import { ApiException, CancelLoadRequest } from "../../network/api.js";
+export function CancelLoadButton({ onClose, ignoreOperator = false, }) {
+    const material = useAtomValue(inProcessMaterialInDialog);
+    const status = useAtomValue(currentStatus);
+    const operator = useAtomValue(currentOperator);
+    const setMaterialDialogOpen = useSetAtom(materialDialogOpen);
+    const [open, setOpen] = useState(false);
+    const [reason, setReason] = useState("");
+    const [updating, setUpdating] = useState(false);
+    const [error, setError] = useState(null);
+    const [snapshot, setSnapshot] = useState(null);
+    const cancellationId = material?.action.loadCancellationId ?? null;
+    const currentSnapshot = material === null || cancellationId === null
+        ? null
+        : {
+            material,
+            cancellationId,
+            group: LazySeq.of(status.material)
+                .filter((candidate) => candidate.action.loadCancellationId === cancellationId)
+                .toRArray(),
+        };
+    if (currentSnapshot === null && snapshot === null)
+        return null;
+    async function cancelLoad() {
+        if (snapshot === null)
+            return;
+        setUpdating(true);
+        setError(null);
+        try {
+            await JobsBackend.cancelLoad(snapshot.material.materialID, ignoreOperator ? null : operator, new CancelLoadRequest({
+                expectedLoadCancellationId: snapshot.cancellationId,
+                reason: reason || undefined,
+            }));
+            setMaterialDialogOpen(null);
+            onClose?.();
+        }
+        catch (e) {
+            setError(ApiException.isApiException(e) ? e.response : e instanceof Error ? e.message : String(e));
+        }
+        finally {
+            setUpdating(false);
+        }
+    }
+    return (_jsxs(_Fragment, { children: [currentSnapshot ? (_jsx(Tooltip, { title: "Cancel the displayed load instruction", children: _jsx(Button, { color: "primary", disabled: updating, onClick: () => {
+                        setSnapshot(currentSnapshot);
+                        setReason("");
+                        setError(null);
+                        setOpen(true);
+                    }, children: "Cancel Load" }) })) : null, _jsxs(Dialog, { open: open && snapshot !== null, onClose: () => setOpen(false), children: [_jsx(DialogTitle, { children: "Cancel Load" }), _jsxs(DialogContent, { children: [_jsx("p", { children: "The displayed load instruction will be cancelled and recalculated for:" }), _jsx("ul", { children: snapshot?.group.map((candidate) => (_jsx("li", { children: candidate.serial || `Material ID ${candidate.materialID}` }, candidate.materialID))) }), _jsx(TextField, { label: "Reason (optional)", value: reason, onChange: (e) => setReason(e.target.value), fullWidth: true, multiline: true }), error ? _jsx("p", { role: "alert", children: error }) : null] }), _jsxs(DialogActions, { children: [_jsx(Button, { color: "primary", disabled: updating, onClick: cancelLoad, children: "Cancel Load" }), _jsx(Button, { color: "secondary", disabled: updating, onClick: () => setOpen(false), children: "Keep Load" })] })] })] }));
+}

package/dist/components/station-monitor/Closeout.js

@@ -44,6 +44,7 @@ import { materialDialogOpen, materialInDialogInfo, materialInDialogLargestUsedPr
 import { last30MaterialSummary, } from "../../cell-status/material-summary.js";
 import { instructionUrl } from "../../network/backend.js";
 import { QuarantineMatButton } from "./QuarantineButton.js";
+import { CancelLoadButton } from "./CancelLoadButton.js";
 import { useIsDemo, useSetTitle } from "../routes.js";
 import { atom, useAtom, useAtomValue, useSetAtom } from "jotai";
 function CompleteButton() {
@@ -108,7 +109,7 @@ function AssignWorkorderButton() {
     return (_jsx(Button, { color: "primary", onClick: () => setWorkorderDialogOpen(true), children: "Assign Workorder" }));
 }
 const CloseoutMaterialDialog = memo(function CloseoutDialog() {
-    return (_jsx(MaterialDialog, { allowNote: true, buttons: _jsxs(_Fragment, { children: [_jsx(InstrButton, {}), _jsx(QuarantineMatButton, {}), _jsx(AssignWorkorderButton, {}), _jsx(CompleteButton, {})] }) }));
+    return (_jsx(MaterialDialog, { allowNote: true, buttons: _jsxs(_Fragment, { children: [_jsx(InstrButton, {}), _jsx(QuarantineMatButton, {}), _jsx(CancelLoadButton, {}), _jsx(AssignWorkorderButton, {}), _jsx(CompleteButton, {})] }) }));
 });
 const currentNearestMinutes = atom(new Date());
 currentNearestMinutes.onMount = (set) => {

package/dist/components/station-monitor/Inspection.js

@@ -43,6 +43,7 @@ import { last30MaterialSummary } from "../../cell-status/material-summary.js";
 import { LazySeq } from "@seedtactics/immutable-collections";
 import { instructionUrl } from "../../network/backend.js";
 import { QuarantineMatButton } from "./QuarantineButton.js";
+import { CancelLoadButton } from "./CancelLoadButton.js";
 import { useIsDemo, useSetTitle } from "../routes.js";
 import { useAtomValue, useSetAtom } from "jotai";
 function InspButtons(props) {
@@ -67,7 +68,7 @@ function InspButtons(props) {
         setMatToShow(null);
     }
     const url = instructionUrl(material.partName, props.inspection_type, material.materialID, null, maxProc, operator);
-    return (_jsxs(_Fragment, { children: [material.partName !== "" ? (demo ? (_jsx(Button, { color: "primary", children: "Instructions" })) : (_jsx(Button, { href: url, target: "bms-instructions", color: "primary", children: "Instructions" }))) : undefined, _jsx(QuarantineMatButton, {}), _jsxs(Button, { color: "primary", disabled: completeInspUpdating, onClick: () => markInspComplete(true), children: ["Mark ", props.inspection_type, " Success"] }), _jsxs(Button, { color: "primary", disabled: completeInspUpdating, onClick: () => markInspComplete(false), children: ["Mark ", props.inspection_type, " Failed"] })] }));
+    return (_jsxs(_Fragment, { children: [material.partName !== "" ? (demo ? (_jsx(Button, { color: "primary", children: "Instructions" })) : (_jsx(Button, { href: url, target: "bms-instructions", color: "primary", children: "Instructions" }))) : undefined, _jsx(QuarantineMatButton, {}), _jsx(CancelLoadButton, {}), _jsxs(Button, { color: "primary", disabled: completeInspUpdating, onClick: () => markInspComplete(true), children: ["Mark ", props.inspection_type, " Success"] }), _jsxs(Button, { color: "primary", disabled: completeInspUpdating, onClick: () => markInspComplete(false), children: ["Mark ", props.inspection_type, " Failed"] })] }));
 }
 function DialogBodyInspButtons({ focusInspectionType }) {
     const material = useAtomValue(matDetails.materialInDialogInspections);

package/dist/components/station-monitor/InvalidateCycle.d.ts

@@ -1,15 +1,18 @@
-import { IInProcessMaterial } from "../../network/api.js";
+import { IInProcessMaterial, ILogEntry } from "../../network/api.js";
+import { HashMap } from "@seedtactics/immutable-collections";
 import { ReactNode } from "react";
 export type InvalidateCycleState = {
     readonly process: number | null;
     readonly changeRawMat: string | null;
     readonly changeJobUnique: string | null;
     readonly updating: boolean;
+    readonly error: string | null;
 };
 export type InvalidateCycleProps = {
     readonly st: InvalidateCycleState | null;
     readonly setState: (s: InvalidateCycleState | null) => void;
 };
+export declare function affectedMaterialForInvalidation(events: ReadonlyArray<Readonly<ILogEntry>>, materialId: number, process: number | null): HashMap<number, string | null>;
 export declare function InvalidateCycleDialogContent(props: InvalidateCycleProps): import("react").JSX.Element;
 export declare function InvalidateCycleDialogButton(props: InvalidateCycleProps & {
     readonly onClose: () => void;

package/dist/components/station-monitor/InvalidateCycle.js

@@ -34,17 +34,41 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 import { Box, Button, ListItemIcon, ListItemText, ListSubheader, Stack } from "@mui/material";
 import { MenuItem } from "@mui/material";
 import { TextField } from "@mui/material";
-import { ActionType, LocType } from "../../network/api.js";
+import { ActionType, LocType, LogType, } from "../../network/api.js";
 import { JobsBackend } from "../../network/backend.js";
-import { LazySeq } from "@seedtactics/immutable-collections";
+import { HashMap, LazySeq } from "@seedtactics/immutable-collections";
 import { currentStatus } from "../../cell-status/current-status.js";
-import { barcodePotentialNewMaterial, inProcessMaterialInDialog, materialDialogOpen, materialInDialogInfo, materialInDialogLargestUsedProcess, } from "../../cell-status/material-details.js";
+import { barcodePotentialNewMaterial, inProcessMaterialInDialog, materialDialogOpen, materialInDialogInfo, materialInDialogLargestUsedProcess, materialInDialogLocalEvents, } from "../../cell-status/material-details.js";
 import { currentOperator } from "../../data/operators.js";
 import { fmsInformation } from "../../network/server-settings.js";
 import { useAtomValue, useSetAtom } from "jotai";
 import { useEffect, useRef } from "react";
 import { last30Jobs } from "../../cell-status/scheduled-jobs.js";
 import { PartIdenticon } from "./Material.js";
+import { isLogEntryInvalidated } from "../LogEntry.js";
+import { ApiException } from "../../network/api.js";
+const invalidatableEventTypes = LazySeq.of([
+    LogType.AddToQueue,
+    LogType.RemoveFromQueue,
+    LogType.LoadUnloadCycle,
+    LogType.MachineCycle,
+    LogType.BasketLoadUnload,
+    LogType.BasketCycle,
+]).toRSet((eventType) => eventType);
+export function affectedMaterialForInvalidation(events, materialId, process) {
+    let affected = HashMap.empty();
+    for (const event of events) {
+        if (!invalidatableEventTypes.has(event.type) ||
+            isLogEntryInvalidated(event) ||
+            !event.material.some((material) => material.id === materialId && (process === null || material.proc >= process))) {
+            continue;
+        }
+        for (const material of event.material) {
+            affected = affected.set(material.id, material.serial ?? null);
+        }
+    }
+    return affected;
+}
 function InvalidateSelect(props) {
     const lastMat = useAtomValue(materialInDialogLargestUsedProcess);
     const possible = useAtomValue(barcodePotentialNewMaterial);
@@ -63,12 +87,13 @@ function InvalidateSelect(props) {
     function change(e) {
         props.setState({
             updating: false,
+            error: null,
             process: e.startsWith("proc") ? parseInt(e.substring(4)) : null,
             changeRawMat: e.startsWith("rawMat") ? e.substring(6) : null,
             changeJobUnique: e.startsWith("job") ? e.substring(3) : null,
         });
     }
-    return (_jsx(TextField, { value: props.st?.process
+    return (_jsx(TextField, { value: props.st?.process && hasProc
             ? "proc" + props.st.process.toString()
             : props.st?.changeRawMat
                 ? "rawMat" + props.st.changeRawMat
@@ -104,6 +129,8 @@ function InvalidateSelect(props) {
 }
 export function InvalidateCycleDialogContent(props) {
     const curMat = useAtomValue(materialInDialogInfo);
+    const events = useAtomValue(materialInDialogLocalEvents);
+    const status = useAtomValue(currentStatus);
     const show = props.st !== null && curMat !== null;
     const boxRef = useRef(null);
     useEffect(() => {
@@ -114,7 +141,17 @@ export function InvalidateCycleDialogContent(props) {
     }, [boxRef, show]);
     if (!show)
         return _jsx("div", {});
-    return (_jsx(Box, { ref: boxRef, sx: { display: "flex", flexDirection: "column", alignItems: "center", marginTop: "1em" }, children: _jsxs(Stack, { spacing: 2, children: [_jsx("p", { style: { maxWidth: "35em" }, children: "An invalidated cycle remains in the event log, but is not considered when determining the next process to be machined on a piece of material." }), _jsx(InvalidateSelect, { st: props.st, setState: props.setState })] }) }));
+    const process = props.st.process ?? (props.st.changeRawMat || props.st.changeJobUnique ? null : undefined);
+    const affected = process === undefined
+        ? HashMap.empty()
+        : affectedMaterialForInvalidation(events, curMat.materialID, process);
+    const affectedLabels = [...affected].map(([materialId, serial]) => ({
+        materialId,
+        serial,
+        queued: status.material.find((material) => material.materialID === materialId)?.location.type ===
+            LocType.InQueue,
+    }));
+    return (_jsx(Box, { ref: boxRef, sx: { display: "flex", flexDirection: "column", alignItems: "center", marginTop: "1em" }, children: _jsxs(Stack, { spacing: 2, children: [_jsx("p", { style: { maxWidth: "35em" }, children: "Invalidating removes whole recorded cycle events from active material reconstruction while retaining them in the event log." }), _jsx(InvalidateSelect, { st: props.st, setState: props.setState }), affectedLabels.length > 0 ? (_jsxs(_Fragment, { children: [_jsx("p", { children: "All material recorded on these events will be affected:" }), _jsx("ul", { children: affectedLabels.map((material) => (_jsxs("li", { children: [material.serial || `Material ID ${material.materialId}`, material.queued ? " (currently in a queue)" : ""] }, material.materialId))) })] })) : null, props.st.error ? _jsx("p", { role: "alert", children: props.st.error }) : null] }) }));
 }
 export function InvalidateCycleDialogButton(props) {
     const fmsInfo = useAtomValue(fmsInformation);
@@ -132,6 +169,8 @@ export function InvalidateCycleDialogButton(props) {
         return null;
     if (inProcMat && inProcMat.location.type === LocType.OnPallet)
         return null;
+    if (inProcMat && inProcMat.location.type === LocType.InQueue)
+        return null;
     const allowChange = possibleNew !== null &&
         (!LazySeq.ofObject(possibleNew.possibleCastingsByQueue ?? {}).isEmpty() ||
             !LazySeq.ofObject(possibleNew.possibleJobsByQueue ?? {}).isEmpty());
@@ -140,7 +179,13 @@ export function InvalidateCycleDialogButton(props) {
     if (props.ignoreOperator)
         operator = null;
     function showInvalidate() {
-        props.setState({ process: null, updating: false, changeRawMat: null, changeJobUnique: null });
+        props.setState({
+            process: null,
+            updating: false,
+            error: null,
+            changeRawMat: null,
+            changeJobUnique: null,
+        });
     }
     function invalidateCycle() {
         if (curMat && (props.st?.process || props.st?.changeRawMat || props.st?.changeJobUnique)) {
@@ -152,7 +197,7 @@ export function InvalidateCycleDialogButton(props) {
                         type: "MatDetails",
                         details: mat,
                     });
-                    props.onClose();
+                    props.setState(null);
                 }
                 else {
                     setMatToShow(null);
@@ -160,9 +205,15 @@ export function InvalidateCycleDialogButton(props) {
                 }
             })
                 .catch((e) => {
-                console.log(e);
-                setMatToShow(null);
-                props.onClose();
+                props.setState({
+                    ...props.st,
+                    updating: false,
+                    error: ApiException.isApiException(e)
+                        ? e.response
+                        : e instanceof Error
+                            ? e.message
+                            : String(e),
+                });
             });
         }
     }

package/dist/components/station-monitor/LoadStation.js

@@ -51,6 +51,7 @@ import { fmsInformation } from "../../network/server-settings.js";
 import { currentStatus, secondsSinceEpochAtom } from "../../cell-status/current-status.js";
 import { useIsDemo, useSetTitle } from "../routes.js";
 import { QuarantineMatButton } from "./QuarantineButton.js";
+import { CancelLoadButton } from "./CancelLoadButton.js";
 import { durationToSeconds } from "../../util/parseISODuration.js";
 import { formatSeconds } from "./SystemOverview.js";
 import { InvalidateCycleDialogButton, InvalidateCycleDialogContent, SwapMaterialButtons, SwapMaterialDialogContent, } from "./InvalidateCycle.js";
@@ -540,6 +541,7 @@ function AddMatButton({ queues, onClose, toQueue, showAddToQueue, setShowAddToQu
     const inProcMat = useAtomValue(matDetails.inProcessMaterialInDialog);
     const operator = useAtomValue(currentOperator);
     const [addExistingMat, addingExistingMat] = matDetails.useAddExistingMaterialToQueue();
+    const [addError, setAddError] = useState(null);
     if (!existingMat ||
         inProcMat?.location.type === api.LocType.OnPallet ||
         inProcMat?.action.type === api.ActionType.Loading ||
@@ -557,16 +559,26 @@ function AddMatButton({ queues, onClose, toQueue, showAddToQueue, setShowAddToQu
         return (_jsx(Button, { color: "primary", onClick: () => setShowAddToQueue(true), children: "Add To Queue" }));
     }
     else {
-        return (_jsxs(Button, { color: "primary", disabled: toQueue === null || addingExistingMat, onClick: () => {
-                addExistingMat({
-                    materialId: existingMat.materialID,
-                    queue: toQueue ?? "",
-                    queuePosition: -1,
-                    operator: operator,
-                });
-                setMatToShow(null);
-                onClose();
-            }, children: ["Add To ", toQueue ?? "Queue", " ", lastProcMat ? ` To Run Process ${lastProcMat.process + 1}` : ""] }));
+        return (_jsxs(_Fragment, { children: [_jsxs(Button, { color: "primary", disabled: toQueue === null || addingExistingMat, onClick: async () => {
+                        setAddError(null);
+                        try {
+                            await addExistingMat({
+                                materialId: existingMat.materialID,
+                                queue: toQueue ?? "",
+                                queuePosition: -1,
+                                operator: operator,
+                            });
+                            setMatToShow(null);
+                            onClose();
+                        }
+                        catch (e) {
+                            setAddError(api.ApiException.isApiException(e)
+                                ? e.response
+                                : e instanceof Error
+                                    ? e.message
+                                    : String(e));
+                        }
+                    }, children: ["Add To ", toQueue ?? "Queue", " ", lastProcMat ? ` To Run Process ${lastProcMat.process + 1}` : ""] }), addError ? _jsx(Typography, { role: "alert", children: addError }) : null] }));
     }
 }
 function AssignWorkorderButton() {
@@ -593,7 +605,7 @@ const LoadMatDialog = memo(function LoadMatDialog(props) {
         setShowAddMaterial(false);
         setSelectedQueue(null);
     }, [setSwapSt, setInvalidateSt]);
-    return (_jsx(MaterialDialog, { onClose: onClose, allowNote: true, highlightProcsGreaterOrEqualTo: invalidateSt?.process ?? undefined, extraDialogElements: _jsxs(_Fragment, { children: [_jsx(SwapMaterialDialogContent, { st: swapSt, setState: setSwapSt }), invalidateSt !== null ? (_jsx(InvalidateCycleDialogContent, { st: invalidateSt, setState: setInvalidateSt })) : null, showAddMaterial ? (_jsx(PromptForQueue, { selectedQueue: selectedQueue, setSelectedQueue: setSelectedQueue, queueNames: props.queues })) : undefined] }), buttons: _jsxs(_Fragment, { children: [_jsx(InstructionButton, { pallet: props.pallet }), _jsx(PrintLabelButton, {}), _jsx(QuarantineMatButton, {}), _jsx(SignalInspectionButton, {}), _jsx(AddMatButton, { toQueue: selectedQueue, queues: props.queues, onClose: onClose, showAddToQueue: showAddMaterial, setShowAddToQueue: setShowAddMaterial }), _jsx(SwapMaterialButtons, { st: swapSt, setState: setSwapSt, onClose: onClose }), _jsx(InvalidateCycleDialogButton, { st: invalidateSt, setState: setInvalidateSt, onClose: onClose, loadStation: true }), _jsx(AssignWorkorderButton, {})] }) }));
+    return (_jsx(MaterialDialog, { onClose: onClose, allowNote: true, highlightProcsGreaterOrEqualTo: invalidateSt?.process ?? undefined, extraDialogElements: _jsxs(_Fragment, { children: [_jsx(SwapMaterialDialogContent, { st: swapSt, setState: setSwapSt }), invalidateSt !== null ? (_jsx(InvalidateCycleDialogContent, { st: invalidateSt, setState: setInvalidateSt })) : null, showAddMaterial ? (_jsx(PromptForQueue, { selectedQueue: selectedQueue, setSelectedQueue: setSelectedQueue, queueNames: props.queues })) : undefined] }), buttons: _jsxs(_Fragment, { children: [_jsx(InstructionButton, { pallet: props.pallet }), _jsx(PrintLabelButton, {}), _jsx(QuarantineMatButton, {}), _jsx(CancelLoadButton, { onClose: onClose }), _jsx(SignalInspectionButton, {}), _jsx(AddMatButton, { toQueue: selectedQueue, queues: props.queues, onClose: onClose, showAddToQueue: showAddMaterial, setShowAddToQueue: setShowAddMaterial }), _jsx(SwapMaterialButtons, { st: swapSt, setState: setSwapSt, onClose: onClose }), _jsx(InvalidateCycleDialogButton, { st: invalidateSt, setState: setInvalidateSt, onClose: onClose, loadStation: true }), _jsx(AssignWorkorderButton, {})] }) }));
 });
 function useGridLayout({ numMatCols, maxNumFaces, horizontal, showMatInCompleted, }) {
     let rows = "";