@seedtactics/insight-client 16.8.4-beta.8 → 17.0.0-beta.0

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

@@ -35,22 +35,31 @@ import { useState } from "react";
 import { Button, Dialog, DialogActions, DialogContent, DialogTitle, TextField, Tooltip, } from "@mui/material";
 import { LazySeq } from "@seedtactics/immutable-collections";
 import { currentStatus } from "../../cell-status/current-status.js";
-import { inProcessMaterialInDialog, materialDialogOpen, useRemoveFromQueue, useSignalForQuarantine, } from "../../cell-status/material-details.js";
+import { inProcessMaterialInDialog, materialDialogOpen, useQuarantineQueuedMaterial, useRemoveFromQueue, useSignalForQuarantine, } from "../../cell-status/material-details.js";
 import { currentOperator } from "../../data/operators.js";
-import { ActionType, LocType, PalletLocationEnum, QueueRole } from "../../network/api.js";
+import { ApiException, LocType, QueueRole, } from "../../network/api.js";
 import { fmsInformation } from "../../network/server-settings.js";
 import { useAtomValue, useSetAtom } from "jotai";
-function useQuarantineMaterial(ignoreOperator) {
+import { canDirectlyQuarantine, canRemoveFromQueue, canSignalQuarantine, isActiveLoadStationOperation, } from "../../data/material-operation-policy.js";
+function hasSupportedQuarantineExit(material, status) {
+    const job = status.jobs[material.jobUnique];
+    if (!job)
+        return false;
+    const path = job.procsAndPaths[material.process - 1]?.paths[material.path - 1];
+    if (!path)
+        return false;
+    return material.process === job.procsAndPaths.length || Boolean(path.outputQueue);
+}
+function useQuarantineMaterial() {
     const fmsInfo = useAtomValue(fmsInformation);
-    const [removeFromQueue, removingFromQueue] = useRemoveFromQueue();
-    const [signalQuarantine, signalingQuarantine] = useSignalForQuarantine();
     const inProcMat = useAtomValue(inProcessMaterialInDialog);
     const curSt = useAtomValue(currentStatus);
-    let operator = useAtomValue(currentOperator);
-    if (ignoreOperator)
-        operator = null;
     if (inProcMat === null || inProcMat.materialID < 0)
         return null;
+    if (isActiveLoadStationOperation(inProcMat))
+        return null;
+    if (inProcMat.quarantineAfterUnload)
+        return null;
     const quarantineQueue = fmsInfo.quarantineQueue?.length ? fmsInfo.quarantineQueue : null;
     const activeQueues = LazySeq.ofObject(curSt.jobs)
         .flatMap(([_, job]) => job.procsAndPaths)
@@ -70,131 +79,192 @@ function useQuarantineMaterial(ignoreOperator) {
     const quarantineQueues = LazySeq.ofObject(curSt.queues)
         .filter(([qname, _]) => !activeQueues.has(qname))
         .toRSet(([qname, _]) => qname);
-    const palLoc = LazySeq.ofObject(curSt.pallets).toOrderedMap(([_, pal]) => [
-        pal.palletNum,
-        pal.currentPalletLocation,
-    ]);
     // If in a quarantine queue, allow removal from system
     if (inProcMat.location.type === LocType.InQueue &&
         inProcMat.location.currentQueue &&
         quarantineQueues.has(inProcMat.location.currentQueue)) {
         return {
             type: "Remove",
-            quarantine: () => removeFromQueue(inProcMat.materialID, operator),
-            removing: removingFromQueue,
+            material: inProcMat,
             quarantineQueueDestination: null,
+            canRemoveFromQueues: false,
         };
     }
     let type = null;
     switch (inProcMat.location.type) {
         case LocType.OnPallet:
-            if (fmsInfo.allowQuarantineToCancelLoad) {
-                // either cancel load or signal based on material action and pallet location
-                const palAtLoad = inProcMat.location.palletNum &&
-                    palLoc.get(inProcMat.location.palletNum)?.loc === PalletLocationEnum.LoadUnload;
-                if (inProcMat.action.type === ActionType.Loading || palAtLoad) {
-                    type = "CancelLoad";
-                }
-                else {
-                    type = "SignalForScrap";
-                }
-            }
-            else {
-                // must signal since it is currently on a pallet, but only if the material is not loading
-                if (inProcMat.action.type === ActionType.Loading) {
-                    return null;
-                }
-                // Check that the job outputs to a queue, only then can signaling for quarantine work
-                const job = curSt.jobs[inProcMat.jobUnique];
-                if (!job)
-                    return null;
-                const path = job.procsAndPaths?.[inProcMat.process - 1]?.paths?.[inProcMat.path - 1];
-                if (inProcMat.process != job.procsAndPaths.length && (!path || !path.outputQueue)) {
-                    return null;
-                }
-                type = "SignalForScrap";
+        case LocType.InBasket:
+            if (!canSignalQuarantine(inProcMat) || !hasSupportedQuarantineExit(inProcMat, curSt)) {
+                return null;
             }
+            type = "SignalForScrap";
             break;
         case LocType.InQueue:
-            if ((inProcMat.action.type === ActionType.Loading ||
-                inProcMat.action.type === ActionType.LoadingToBasket) &&
-                !fmsInfo.allowQuarantineToCancelLoad) {
+            if (!canDirectlyQuarantine(inProcMat))
                 return null;
-            }
-            else if (inProcMat.action.type === ActionType.Loading ||
-                inProcMat.action.type === ActionType.LoadingToBasket) {
-                type = "CancelLoad";
-            }
-            else {
-                type = "Scrap";
-            }
-            break;
-        case LocType.InBasket:
-            if (inProcMat.action.type === ActionType.Loading && !fmsInfo.allowQuarantineToCancelLoad) {
+            if (inProcMat.location.currentQueue === undefined ||
+                quarantineQueues.has(inProcMat.location.currentQueue)) {
                 return null;
             }
-            else if (inProcMat.action.type === ActionType.Loading) {
-                type = "CancelLoad";
-            }
-            else {
-                type = "Scrap";
-            }
-            break;
-        case LocType.Free:
             type = "Scrap";
             break;
+        case LocType.Free:
+            return null;
     }
     if (type) {
         return {
             type,
-            quarantine: (reason) => signalQuarantine(inProcMat.materialID, operator, reason),
-            removing: signalingQuarantine,
+            material: inProcMat,
             quarantineQueueDestination: quarantineQueue,
+            canRemoveFromQueues: inProcMat.location.type === LocType.InQueue &&
+                inProcMat.location.currentQueue !== undefined &&
+                !quarantineQueues.has(inProcMat.location.currentQueue) &&
+                canRemoveFromQueue(inProcMat),
         };
     }
     else {
         return null;
     }
 }
+function RemoveFromQueuesButton({ material, removeFromQueues, removing, }) {
+    const [open, setOpen] = useState(false);
+    const [error, setError] = useState(null);
+    const setMatToShow = useSetAtom(materialDialogOpen);
+    async function remove() {
+        setError(null);
+        try {
+            await removeFromQueues();
+            setOpen(false);
+            setMatToShow({
+                type: "MatSummary",
+                summary: {
+                    materialID: material.materialID,
+                    partName: material.partName,
+                    serial: material.serial,
+                },
+            });
+        }
+        catch (e) {
+            setError(ApiException.isApiException(e) ? e.response : e instanceof Error ? e.message : String(e));
+        }
+    }
+    function openRemoval() {
+        setError(null);
+        setOpen(true);
+    }
+    return (_jsxs(_Fragment, { children: [_jsx(Tooltip, { title: "Remove from the current queue so it can be rescanned", children: _jsx(Button, { color: "primary", disabled: removing, onClick: openRemoval, children: "Remove from Queue" }) }), _jsxs(Dialog, { open: open, onClose: () => setOpen(false), children: [_jsx(DialogTitle, { children: "Remove Material from Queue" }), _jsxs(DialogContent, { children: [_jsx("p", { children: "Remove this material from its current queue. Its production history will remain available. You can scan it again to correct its history or assignment and then add it back to a queue." }), error ? _jsx("p", { role: "alert", children: error }) : null] }), _jsxs(DialogActions, { children: [_jsx(Button, { color: "primary", disabled: removing, onClick: remove, children: "Remove from Queue" }), _jsx(Button, { color: "secondary", disabled: removing, onClick: () => setOpen(false), children: "Cancel" })] })] })] }));
+}
 export function QuarantineMatButton({ onClose, ignoreOperator, }) {
     const [open, setOpen] = useState(false);
     const [reason, setReason] = useState("");
-    const q = useQuarantineMaterial(!!ignoreOperator);
+    const [error, setError] = useState(null);
+    const [updating, setUpdating] = useState(false);
+    const [snapshot, setSnapshot] = useState(null);
+    const q = useQuarantineMaterial();
+    const [removeFromQueue, removingFromQueue] = useRemoveFromQueue();
+    const [signalQuarantine, signalingQuarantine] = useSignalForQuarantine();
+    const [quarantineQueued, quarantiningQueued] = useQuarantineQueuedMaterial();
+    const currentOperatorValue = useAtomValue(currentOperator);
+    const operator = ignoreOperator ? null : currentOperatorValue;
     const setMatToShow = useSetAtom(materialDialogOpen);
-    if (q === null)
+    const currentSnapshot = q === null
+        ? null
+        : {
+            material: q.material,
+            materialId: q.material.materialID,
+            operation: q.type === "SignalForScrap"
+                ? "DeferredQuarantine"
+                : q.type === "Scrap"
+                    ? "DirectQuarantine"
+                    : "RemoveFromSystem",
+            destination: q.quarantineQueueDestination,
+            operator,
+        };
+    const displayedSnapshot = snapshot ?? currentSnapshot;
+    function openQuarantine() {
+        if (currentSnapshot === null)
+            return;
+        setError(null);
+        setReason("");
+        setSnapshot(currentSnapshot);
+        setOpen(true);
+    }
+    function closeQuarantine() {
+        if (updating)
+            return;
+        setOpen(false);
+        setSnapshot(null);
+    }
+    if (displayedSnapshot === null)
         return null;
     let title;
     let btnTxt;
-    switch (q.type) {
-        case "Remove":
+    switch (displayedSnapshot.operation) {
+        case "RemoveFromSystem":
             title = "Remove from system";
             btnTxt = "Remove";
             break;
-        case "Scrap":
-            title = q.quarantineQueueDestination
-                ? `Move to ${q.quarantineQueueDestination}`
-                : "Remove from queue";
-            btnTxt = q.quarantineQueueDestination ? "Quarantine" : "Remove";
+        case "DirectQuarantine":
+            title = displayedSnapshot.destination
+                ? `Move to ${displayedSnapshot.destination}`
+                : "Remove from queue and treat as scrap";
+            btnTxt = displayedSnapshot.destination ? "Quarantine" : "Scrap";
             break;
-        case "SignalForScrap":
-            title = q.quarantineQueueDestination
-                ? `After unload, move to ${q.quarantineQueueDestination}`
-                : "After unload, remove the part as scrap";
-            btnTxt = q.quarantineQueueDestination ? "Quarantine" : "Scrap";
-            break;
-        case "CancelLoad":
-            title = q.quarantineQueueDestination
-                ? `Cancel load and move to ${q.quarantineQueueDestination}`
-                : "Cancel load";
-            btnTxt = "Cancel Load";
+        case "DeferredQuarantine":
+            title = displayedSnapshot.destination
+                ? `The current automated operation will continue. When the material leaves automation control, move it to ${displayedSnapshot.destination}`
+                : "The current automated operation will continue. When the material leaves automation control, remove it from normal production flow as scrap";
+            btnTxt = displayedSnapshot.destination ? "Quarantine" : "Scrap";
             break;
     }
-    function quarantine() {
-        q?.quarantine(reason);
-        setMatToShow(null);
-        setOpen(false);
-        setReason("");
-        onClose?.();
+    async function quarantine() {
+        if (snapshot === null)
+            return;
+        setUpdating(true);
+        setError(null);
+        try {
+            switch (snapshot.operation) {
+                case "DeferredQuarantine":
+                    await signalQuarantine(snapshot.materialId, snapshot.operator, reason);
+                    break;
+                case "DirectQuarantine":
+                    await quarantineQueued(snapshot.materialId, snapshot.operator, reason);
+                    break;
+                case "RemoveFromSystem":
+                    await removeFromQueue(snapshot.materialId, snapshot.operator);
+                    break;
+            }
+            setOpen(false);
+            setSnapshot(null);
+            setReason("");
+            if (snapshot.operation === "RemoveFromSystem") {
+                setMatToShow({
+                    type: "MatSummary",
+                    summary: {
+                        materialID: snapshot.materialId,
+                        partName: snapshot.material.partName,
+                        serial: snapshot.material.serial,
+                    },
+                });
+            }
+            else {
+                setMatToShow(null);
+                onClose?.();
+            }
+        }
+        catch (e) {
+            setError(ApiException.isApiException(e) ? e.response : e instanceof Error ? e.message : String(e));
+        }
+        finally {
+            setUpdating(false);
+        }
     }
-    return (_jsxs(_Fragment, { children: [_jsx(Tooltip, { title: title, children: _jsx(Button, { color: "primary", disabled: q.removing, onClick: () => setOpen(true), children: btnTxt }) }), _jsxs(Dialog, { open: open, onClose: () => setOpen(false), children: [_jsx(DialogTitle, { children: "Quarantine Material" }), _jsxs(DialogContent, { children: [_jsx("p", { children: title }), _jsx(TextField, { label: "Reason", value: reason, onChange: (e) => setReason(e.target.value), fullWidth: true, autoFocus: true, multiline: true })] }), _jsxs(DialogActions, { children: [_jsx(Button, { color: "primary", onClick: quarantine, children: btnTxt }), _jsx(Button, { color: "secondary", onClick: () => setOpen(false), children: "Cancel" })] })] })] }));
+    const removing = updating ||
+        (displayedSnapshot.operation === "DeferredQuarantine"
+            ? signalingQuarantine
+            : displayedSnapshot.operation === "DirectQuarantine"
+                ? quarantiningQueued
+                : removingFromQueue);
+    const removeFromQueues = q?.canRemoveFromQueues === true ? () => removeFromQueue(q.material.materialID, operator) : null;
+    return (_jsxs(_Fragment, { children: [q ? (_jsx(Tooltip, { title: title, children: _jsx(Button, { color: "primary", disabled: removing, onClick: openQuarantine, children: btnTxt }) })) : null, removeFromQueues && q ? (_jsx(RemoveFromQueuesButton, { material: q.material, removeFromQueues: removeFromQueues, removing: removingFromQueue })) : null, _jsxs(Dialog, { open: open && snapshot !== null, onClose: closeQuarantine, children: [_jsx(DialogTitle, { children: "Quarantine Material" }), _jsxs(DialogContent, { children: [_jsx("p", { children: title }), _jsx(TextField, { label: "Reason", value: reason, onChange: (e) => setReason(e.target.value), fullWidth: true, autoFocus: true, multiline: true }), error ? _jsx("p", { role: "alert", children: error }) : null] }), _jsxs(DialogActions, { children: [_jsx(Button, { color: "primary", disabled: removing, onClick: quarantine, children: btnTxt }), _jsx(Button, { color: "secondary", disabled: removing, onClick: closeQuarantine, children: "Cancel" })] })] })] }));
 }

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

@@ -69,6 +69,7 @@ import { materialDialogOpen } from "../../cell-status/material-details.js";
 import { PrintLabelButton } from "./PrintedLabel.js";
 import { AddToQueueButton, AddToQueueMaterialDialogCt, } from "./QueuesAddMaterial.js";
 import { QuarantineMatButton } from "./QuarantineButton.js";
+import { CancelLoadButton } from "./CancelLoadButton.js";
 import { AddByBarcodeDialog, scanBarcodeToAddToQueueDialog } from "../BarcodeScanning.js";
 import { InvalidateCycleDialogButton, InvalidateCycleDialogContent, } from "./InvalidateCycle.js";
 const JobTableRow = styled(TableRow, { shouldForwardProp: (prop) => prop.toString()[0] !== "$" })(({ $noBorderBottom, $highlightedRow, $noncompletedRow }) => ({
@@ -287,7 +288,7 @@ const QueuedMaterialDialog = memo(function QueuedMaterialDialog({ queueNames, })
         setInvalidateSt(null);
     }, []);
     queueNames = usePossibleQueuesForAdd(queueNames);
-    return (_jsx(MaterialDialog, { allowNote: true, onClose: onClose, highlightProcsGreaterOrEqualTo: invalidateSt?.process ?? undefined, extraDialogElements: _jsxs(_Fragment, { children: [_jsx(InvalidateCycleDialogContent, { st: invalidateSt, setState: setInvalidateSt }), _jsx(AddToQueueMaterialDialogCt, { queueNames: queueNames, st: addMatSt, setState: setAddMatSt })] }), buttons: _jsxs(_Fragment, { children: [_jsx(PrintLabelButton, {}), _jsx(QuarantineMatButton, { onClose: onClose }), _jsx(InvalidateCycleDialogButton, { onClose: onClose, st: invalidateSt, setState: setInvalidateSt }), _jsx(AddToQueueButton, { st: addMatSt, queueNames: queueNames, onClose: onClose })] }) }));
+    return (_jsx(MaterialDialog, { allowNote: true, onClose: onClose, highlightProcsGreaterOrEqualTo: invalidateSt?.process ?? undefined, extraDialogElements: _jsxs(_Fragment, { children: [_jsx(InvalidateCycleDialogContent, { st: invalidateSt, setState: setInvalidateSt }), _jsx(AddToQueueMaterialDialogCt, { queueNames: queueNames, st: addMatSt, setState: setAddMatSt })] }), buttons: _jsxs(_Fragment, { children: [_jsx(PrintLabelButton, {}), _jsx(QuarantineMatButton, { onClose: onClose }), _jsx(CancelLoadButton, { onClose: onClose }), _jsx(InvalidateCycleDialogButton, { onClose: onClose, st: invalidateSt, setState: setInvalidateSt }), _jsx(AddToQueueButton, { st: addMatSt, queueNames: queueNames, onClose: onClose })] }) }));
 });
 export const Queues = (props) => {
     const operator = useAtomValue(currentOperator);

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

@@ -42,21 +42,18 @@ import { currentOperator } from "../../data/operators.js";
 import { fmsInformation } from "../../network/server-settings.js";
 import { useAddNewCastingToQueue } from "../../cell-status/material-details.js";
 import { useAtomValue, useSetAtom } from "jotai";
+import { canAddOrMoveMaterialToQueue } from "../../data/material-operation-policy.js";
 function useAllowAddToQueue(queueNames) {
     const existingMat = useAtomValue(matDetails.materialInDialogInfo);
     const inProcMat = useAtomValue(matDetails.inProcessMaterialInDialog);
     const possibleNewMats = useAtomValue(matDetails.barcodePotentialNewMaterial);
-    const curInQueueOnScreen = inProcMat !== null &&
-        inProcMat.location.type === api.LocType.InQueue &&
-        inProcMat.location.currentQueue &&
-        queueNames.includes(inProcMat.location.currentQueue);
-    if (curInQueueOnScreen)
+    if (!canAddOrMoveMaterialToQueue(inProcMat))
         return false;
-    if (inProcMat?.location.type === api.LocType.OnPallet)
-        return false;
-    if (inProcMat?.action.type === api.ActionType.Loading ||
-        inProcMat?.action.type === api.ActionType.LoadingToBasket)
+    if (inProcMat?.location.type === api.LocType.InQueue &&
+        inProcMat.location.currentQueue !== undefined &&
+        queueNames.includes(inProcMat.location.currentQueue)) {
         return false;
+    }
     if (existingMat === null && !possibleNewMats) {
         return false;
     }
@@ -183,6 +180,7 @@ export function AddToQueueButton({ st: { enteredOperator, newMaterialTy, toQueue
     const [addExistingMat, addingExistingMat] = matDetails.useAddExistingMaterialToQueue();
     const [addNewMat, addingNewMat] = matDetails.useAddNewMaterialToQueue();
     const [addNewCasting, addingNewCasting] = useAddNewCastingToQueue();
+    const [addError, setAddError] = useState(null);
     const allowAdd = useAllowAddToQueue(queueNames);
     if (!allowAdd) {
         return null;
@@ -213,52 +211,62 @@ export function AddToQueueButton({ st: { enteredOperator, newMaterialTy, toQueue
         withSerialMsg = " With Serial " + newSerial;
     }
     const curQueue = inProcMat?.location.currentQueue ?? null;
-    return (_jsx(_Fragment, { children: _jsx(Tooltip, { title: toQueue === null
-                ? "Select a queue to add the material to"
-                : fmsInfo.requireOperatorNamePromptWhenAddingMaterial &&
-                    (enteredOperator === null || enteredOperator === "")
-                    ? "Please enter an operator name"
-                    : "", children: _jsx("span", { children: _jsx(Button, { color: "primary", disabled: toQueue === null ||
-                        addingExistingMat ||
-                        addingNewMat ||
-                        addingNewCasting ||
-                        (existingMat === null && newMaterialTy === null) ||
-                        (fmsInfo.requireOperatorNamePromptWhenAddingMaterial &&
-                            (enteredOperator === null || enteredOperator === "")), onClick: () => {
-                        if (existingMat) {
-                            addExistingMat({
-                                materialId: existingMat.materialID,
-                                queue: toQueue ?? "",
-                                queuePosition: -1,
-                                operator: enteredOperator ?? operator,
-                            });
-                        }
-                        else if (newMaterialTy &&
-                            newMaterialTy.kind === "JobAndProc" &&
-                            newMaterialTy.jobUnique) {
-                            addNewMat({
-                                jobUnique: newMaterialTy.jobUnique,
-                                lastCompletedProcess: newMaterialTy.last_proc,
-                                serial: newSerial ?? undefined,
-                                workorder: newWorkorder ?? newMaterialTy?.workorder,
-                                queue: toQueue ?? "",
-                                queuePosition: -1,
-                                operator: enteredOperator ?? operator,
-                            });
-                        }
-                        else if (newMaterialTy &&
-                            newMaterialTy.kind === "RawMat" &&
-                            newMaterialTy.rawMatName) {
-                            addNewCasting({
-                                casting: newMaterialTy.rawMatName,
-                                quantity: 1,
-                                queue: toQueue ?? "",
-                                serials: newSerial ? [newSerial] : undefined,
-                                workorder: newWorkorder,
-                                operator: enteredOperator ?? operator,
-                            });
-                        }
-                        setMatToShow(null);
-                        onClose();
-                    }, children: toQueue === null ? ("Add to Queue") : (_jsxs("span", { children: [curQueue !== null ? `Move From ${curQueue} To` : "Add To", " ", toQueue, withSerialMsg, addProcMsg] })) }) }) }) }));
+    return (_jsxs(_Fragment, { children: [_jsx(Tooltip, { title: toQueue === null
+                    ? "Select a queue to add the material to"
+                    : fmsInfo.requireOperatorNamePromptWhenAddingMaterial &&
+                        (enteredOperator === null || enteredOperator === "")
+                        ? "Please enter an operator name"
+                        : "", children: _jsx("span", { children: _jsx(Button, { color: "primary", disabled: toQueue === null ||
+                            addingExistingMat ||
+                            addingNewMat ||
+                            addingNewCasting ||
+                            (existingMat === null && newMaterialTy === null) ||
+                            (fmsInfo.requireOperatorNamePromptWhenAddingMaterial &&
+                                (enteredOperator === null || enteredOperator === "")), onClick: async () => {
+                            setAddError(null);
+                            try {
+                                if (existingMat) {
+                                    await addExistingMat({
+                                        materialId: existingMat.materialID,
+                                        queue: toQueue ?? "",
+                                        queuePosition: -1,
+                                        operator: enteredOperator ?? operator,
+                                    });
+                                }
+                                else if (newMaterialTy &&
+                                    newMaterialTy.kind === "JobAndProc" &&
+                                    newMaterialTy.jobUnique) {
+                                    await addNewMat({
+                                        jobUnique: newMaterialTy.jobUnique,
+                                        lastCompletedProcess: newMaterialTy.last_proc,
+                                        serial: newSerial ?? undefined,
+                                        workorder: newWorkorder ?? newMaterialTy?.workorder,
+                                        queue: toQueue ?? "",
+                                        queuePosition: -1,
+                                        operator: enteredOperator ?? operator,
+                                    });
+                                }
+                                else if (newMaterialTy &&
+                                    newMaterialTy.kind === "RawMat" &&
+                                    newMaterialTy.rawMatName) {
+                                    await addNewCasting({
+                                        casting: newMaterialTy.rawMatName,
+                                        quantity: 1,
+                                        queue: toQueue ?? "",
+                                        serials: newSerial ? [newSerial] : undefined,
+                                        workorder: newWorkorder,
+                                        operator: enteredOperator ?? operator,
+                                    });
+                                }
+                                setMatToShow(null);
+                                onClose();
+                            }
+                            catch (e) {
+                                setAddError(api.ApiException.isApiException(e)
+                                    ? e.response
+                                    : e instanceof Error
+                                        ? e.message
+                                        : String(e));
+                            }
+                        }, children: toQueue === null ? ("Add to Queue") : (_jsxs("span", { children: [curQueue !== null ? `Move From ${curQueue} To` : "Add To", " ", toQueue, withSerialMsg, addProcMsg] })) }) }) }), addError ? _jsx("p", { role: "alert", children: addError }) : null] }));
 }

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

@@ -43,6 +43,7 @@ import { last30Jobs } from "../../cell-status/scheduled-jobs.js";
 import { addDays } from "date-fns";
 import { durationToSeconds } from "../../util/parseISODuration.js";
 import { InvalidateCycleDialogButton, InvalidateCycleDialogContent, SwapMaterialButtons, SwapMaterialDialogContent, } from "./InvalidateCycle.js";
+import { CancelLoadButton } from "./CancelLoadButton.js";
 import { QuarantineMatButton } from "./QuarantineButton.js";
 import { SelectInspTypeDialog, SignalInspectionButton } from "./SelectInspType.js";
 import { useSetTitle } from "../routes.js";
@@ -825,7 +826,7 @@ const SystemOverviewMaterialDialog = memo(function SystemOverviewMaterialDialog(
         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, { ignoreOperator: ignoreOperator }), _jsx(SignalInspectionButton, {}), _jsx(SwapMaterialButtons, { st: swapSt, setState: setSwapSt, onClose: onClose, ignoreOperator: ignoreOperator }), _jsx(InvalidateCycleDialogButton, { st: invalidateSt, setState: setInvalidateSt, onClose: onClose, ignoreOperator: ignoreOperator })] }) }));
+    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, { ignoreOperator: ignoreOperator }), _jsx(CancelLoadButton, { onClose: onClose, ignoreOperator: ignoreOperator }), _jsx(SignalInspectionButton, {}), _jsx(SwapMaterialButtons, { st: swapSt, setState: setSwapSt, onClose: onClose, ignoreOperator: ignoreOperator }), _jsx(InvalidateCycleDialogButton, { st: invalidateSt, setState: setInvalidateSt, onClose: onClose, ignoreOperator: ignoreOperator })] }) }));
 });
 export function SystemOverviewPage({ ignoreOperator, whiteBackground, }) {
     useSetTitle("System Overview");

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

@@ -58,12 +58,12 @@ export const SortableRegion = memo(function SortableRegion(props) {
             const overMatId = over ? numericId(over.id) : null;
             if (over && active.id !== over.id && activeMatId !== null && overMatId !== null) {
                 const overIdx = props.matIds.indexOf(overMatId);
-                addExistingMatToQueue({
+                void addExistingMatToQueue({
                     materialId: activeMatId,
                     queue: props.queueName,
                     queuePosition: overIdx,
                     operator: operator,
-                });
+                }).catch(console.error);
                 reorderQueuedMat({
                     queue: props.queueName,
                     matId: activeMatId,

package/dist/data/material-operation-policy.d.ts

@@ -0,0 +1,21 @@
+import { IInProcessMaterial } from "../network/api.js";
+export type MaterialOperationState = {
+    readonly kind: "ActiveLoadStationOperation";
+    readonly cancellationId: string | null;
+} | {
+    readonly kind: "AutomationControlled";
+} | {
+    readonly kind: "HumanControlledQueue";
+} | {
+    readonly kind: "AddToQueueProposal";
+};
+type MaterialForPolicy = Readonly<IInProcessMaterial> | null;
+export declare function materialOperationState(material: Readonly<IInProcessMaterial>): MaterialOperationState;
+export declare function isActiveLoadStationOperation(material: Readonly<IInProcessMaterial>): boolean;
+export declare function canCancelLoad(material: MaterialForPolicy): boolean;
+export declare function canSignalQuarantine(material: MaterialForPolicy): boolean;
+export declare function canDirectlyQuarantine(material: MaterialForPolicy): boolean;
+export declare function canRemoveFromQueue(material: MaterialForPolicy): boolean;
+export declare function canInvalidateMaterial(material: MaterialForPolicy): boolean;
+export declare function canAddOrMoveMaterialToQueue(material: MaterialForPolicy): boolean;
+export {};

package/dist/data/material-operation-policy.js

@@ -0,0 +1,89 @@
+/* Copyright (c) 2026, John Lenz
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the name of John Lenz, Black Maple Software, SeedTactics,
+      nor the names of other contributors may be used to endorse or promote
+      products derived from this software without specific prior written
+      permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+ */
+import { ActionType, LocType } from "../network/api.js";
+function nonBlankCancellationId(material) {
+    const cancellationId = material.action.loadCancellationId;
+    return cancellationId !== undefined && cancellationId.trim() !== "" ? cancellationId : null;
+}
+function hasLoadStationAction(material) {
+    switch (material.action.type) {
+        case ActionType.Loading:
+        case ActionType.UnloadToInProcess:
+        case ActionType.UnloadToCompletedMaterial:
+        case ActionType.LoadingToBasket:
+            return true;
+        default:
+            return false;
+    }
+}
+export function materialOperationState(material) {
+    const cancellationId = nonBlankCancellationId(material);
+    if (cancellationId !== null || hasLoadStationAction(material)) {
+        return { kind: "ActiveLoadStationOperation", cancellationId };
+    }
+    if (material.location.type === LocType.InQueue && material.action.type === ActionType.Waiting) {
+        return { kind: "HumanControlledQueue" };
+    }
+    if (material.location.type === LocType.OnPallet ||
+        material.location.type === LocType.InBasket ||
+        material.action.type === ActionType.Machining) {
+        return { kind: "AutomationControlled" };
+    }
+    return { kind: "AddToQueueProposal" };
+}
+export function isActiveLoadStationOperation(material) {
+    return materialOperationState(material).kind === "ActiveLoadStationOperation";
+}
+export function canCancelLoad(material) {
+    if (material === null)
+        return false;
+    const state = materialOperationState(material);
+    return state.kind === "ActiveLoadStationOperation" && state.cancellationId !== null;
+}
+export function canSignalQuarantine(material) {
+    return material !== null && materialOperationState(material).kind === "AutomationControlled";
+}
+export function canDirectlyQuarantine(material) {
+    return material !== null && materialOperationState(material).kind === "HumanControlledQueue";
+}
+export function canRemoveFromQueue(material) {
+    return canDirectlyQuarantine(material);
+}
+export function canInvalidateMaterial(material) {
+    return material === null || materialOperationState(material).kind === "AddToQueueProposal";
+}
+export function canAddOrMoveMaterialToQueue(material) {
+    if (material === null)
+        return true;
+    const state = materialOperationState(material);
+    return state.kind === "AddToQueueProposal" || state.kind === "HumanControlledQueue";
+}

package/dist/extension.d.ts

@@ -0,0 +1,11 @@
+import type { AppProps } from "./components/App.js";
+/**
+ * Starts one complete FMS Insight application with optional statically composed custom pages.
+ */
+export declare function bootstrapInsight(appProps?: AppProps, rootElement?: HTMLElement): Promise<void>;
+export { customState } from "./cell-status/custom-state.js";
+export type { AppProps };
+export { defaultChooseModes } from "./components/ChooseMode.js";
+export type { ChooseModeItem } from "./components/ChooseMode.js";
+export { RouteLocation } from "./components/routes.js";
+export { authenticatedFetch } from "./network/backend.js";