@seedtactics/insight-client 17.0.1-beta.13 → 17.0.1-beta.15

package/dist/cell-status/loading.d.ts

@@ -1,4 +1,5 @@
 import { ICurrentStatus, IHistoricData, ILogEntry, IRecentHistoricData, IServerEvent } from "../network/api.js";
+import * as currentSt from "./current-status.js";
 import { Atom } from "jotai";
 export interface ServerEventAndTime {
     readonly evt: Readonly<IServerEvent>;
@@ -24,6 +25,12 @@ export declare const onLoadLast30Log: import("jotai").WritableAtom<null, [log: r
 export declare const onLoadCurrentSt: import("jotai").WritableAtom<null, [curSt: Readonly<ICurrentStatus>], void> & {
     init: null;
 };
+export interface QueuedMatMove extends currentSt.QueueReordering {
+    readonly operator: string | null;
+}
+export declare const moveQueuedMatInCurrentStatus: import("jotai").WritableAtom<null, [QueuedMatMove], Promise<void>> & {
+    init: null;
+};
 export declare const onLoadSpecificMonthJobs: import("jotai").WritableAtom<null, [historicData: Readonly<IHistoricData>], void> & {
     init: null;
 };

package/dist/cell-status/loading.js

@@ -30,6 +30,8 @@ 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 { QueuePosition, } from "../network/api.js";
+import { JobsBackend } from "../network/backend.js";
 import { LazySeq } from "@seedtactics/immutable-collections";
 import * as simProd from "./sim-production.js";
 import * as simUse from "./sim-station-use.js";
@@ -112,6 +114,29 @@ export const onLoadCurrentSt = atom(null, (_, set, curSt) => {
     set(customSt.replaceCustomState, curSt.customState ?? null);
     set(names.setNamesFromCurrentStatus, curSt);
 });
+// Show queue drops immediately. Recovery must not replace intervening live updates or drags.
+export const moveQueuedMatInCurrentStatus = atom(null, async (get, set, { operator, ...move }) => {
+    const before = get(currentSt.currentStatus);
+    set(currentSt.reorderQueuedMatInCurrentStatus, move);
+    const optimistic = get(currentSt.currentStatus);
+    try {
+        await JobsBackend.setMaterialInQueue(move.matId, operator, new QueuePosition({ queue: move.queue, position: move.newIdx }));
+    }
+    catch (error) {
+        const beforeReload = get(currentSt.currentStatus);
+        try {
+            const refreshed = await JobsBackend.currentStatus();
+            if (get(currentSt.currentStatus) === beforeReload)
+                set(onLoadCurrentSt, refreshed);
+        }
+        catch {
+            // If the server is unreachable, undo only this move's untouched optimistic snapshot.
+            if (get(currentSt.currentStatus) === optimistic)
+                set(onLoadCurrentSt, before);
+        }
+        throw error;
+    }
+});
 export const onLoadSpecificMonthJobs = atom(null, (_, set, historicData) => {
     set(simUse.setSpecificMonthSimStatUse, historicData);
     set(simProd.setSpecificMonthJobProduction, historicData);

package/dist/components/App.d.ts

@@ -1,8 +1,6 @@
 import { ReactNode, ComponentType } from "react";
 import { ChooseModeItem } from "./ChooseMode.js";
 import * as serverSettings from "../network/server-settings.js";
-import type { SubmitBasketLoadStationCommand } from "./station-monitor/BasketLoadStationWork.js";
-import type { SubmitBasketLocationCorrection, SubmitBasketMovementCompletion } from "./station-monitor/BasketMovementArrival.js";
 export declare function NavTabs({ children }: {
     children?: ReactNode;
 }): import("react").JSX.Element;
@@ -12,9 +10,6 @@ export interface AppProps {
         readonly page: ReactNode;
     };
     readonly chooseModes?: (i: serverSettings.FMSInfoAndUser) => ReadonlyArray<ChooseModeItem> | null;
-    readonly submitBasketLoadStationCommand?: SubmitBasketLoadStationCommand;
-    readonly submitBasketMovementCompletion?: SubmitBasketMovementCompletion;
-    readonly submitBasketLocationCorrection?: SubmitBasketLocationCorrection;
 }
 declare const App: import("react").MemoExoticComponent<(props: AppProps) => import("react").JSX.Element>;
 export default App;

package/dist/components/App.js

@@ -310,7 +310,7 @@ const App = memo(function App(props) {
     else {
         switch (route.route) {
             case routes.RouteLocation.Station_LoadMonitor:
-                page = (_jsx(LoadStation, { loadNum: route.loadNum, queues: route.queues, completed: route.completed, submitBasketLoadStationCommand: props.submitBasketLoadStationCommand, submitBasketMovementCompletion: props.submitBasketMovementCompletion, submitBasketLocationCorrection: props.submitBasketLocationCorrection }, route.loadNum));
+                page = (_jsx(LoadStation, { loadNum: route.loadNum, queues: route.queues, completed: route.completed }, route.loadNum));
                 nav1 = StationToolbar;
                 nav2 = StationToolbarOverviewButton;
                 showOperator = true;

package/dist/components/operations/AllMaterial.js

@@ -33,8 +33,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 import { forwardRef, memo, PureComponent, useState, useCallback, useMemo, } from "react";
 import { selectAllMaterialIntoBins, MaterialBinType, moveMaterialBin, currentMaterialBinOrder, moveMaterialInBin, findMaterialInQuarantineQueues, findQueueInQuarantineQueues, } from "../../data/all-material-bins.js";
-import * as matDetails from "../../cell-status/material-details.js";
 import * as currentSt from "../../cell-status/current-status.js";
+import { moveQueuedMatInCurrentStatus } from "../../cell-status/loading.js";
 import { Box } from "@mui/material";
 import { Typography } from "@mui/material";
 import { LazySeq } from "@seedtactics/immutable-collections";
@@ -48,6 +48,7 @@ import { useSetTitle } from "../routes.js";
 import { useAtom, useAtomValue, useSetAtom } from "jotai";
 import { fmsInformation } from "../../network/server-settings.js";
 import { basketDisplayName, loadStationDisplayName } from "../../cell-status/station-cycles.js";
+import { canSetMaterialInQueue } from "../../data/material-operation-policy.js";
 const ColumnWithTitle = forwardRef(function MaterialBin(props, ref) {
     return (_jsxs(Box, { sx: {
             margin: props.isDragOverlay ? undefined : "0.75em",
@@ -187,8 +188,7 @@ export function AllMaterial(props) {
     useSetTitle("All Material");
     const st = useAtomValue(currentSt.currentStatus);
     const [matBinOrder, setMatBinOrder] = useAtom(currentMaterialBinOrder);
-    const [addExistingMatToQueue] = matDetails.useAddExistingMaterialToQueue();
-    const reorderQueuedMat = useSetAtom(currentSt.reorderQueuedMatInCurrentStatus);
+    const moveQueuedMat = useSetAtom(moveQueuedMatInCurrentStatus);
     const [activeDrag, setActiveDrag] = useState(null);
     const allBins = useMemo(() => {
         const bins = selectAllMaterialIntoBins(st, matBinOrder);
@@ -232,6 +232,8 @@ export function AllMaterial(props) {
                 : findMaterialInQuarantineQueues(over.id, allBins);
             if (!overCol)
                 return;
+            if (!canSetMaterialInQueue(activeDrag.mat, overCol.bin.queueName))
+                return;
             if (overCol.bin.binId !== activeDrag.curOverBinId) {
                 setActiveDrag({
                     ...activeDrag,
@@ -258,18 +260,13 @@ export function AllMaterial(props) {
                 const overCol = typeof over.id === "string"
                     ? findQueueInQuarantineQueues(over.id, allBins)
                     : findMaterialInQuarantineQueues(over.id, allBins);
-                if (overCol) {
-                    void addExistingMatToQueue({
-                        materialId: activeDrag.mat.materialID,
-                        queue: overCol.bin.queueName,
-                        queuePosition: overCol.idx,
-                        operator: null,
-                    }).catch(console.error);
-                    reorderQueuedMat({
+                if (overCol && canSetMaterialInQueue(activeDrag.mat, overCol.bin.queueName)) {
+                    moveQueuedMat({
                         queue: overCol.bin.queueName,
                         matId: activeDrag.mat.materialID,
                         newIdx: overCol.idx,
-                    });
+                        operator: null,
+                    }).catch(console.error);
                 }
             }
             setActiveDrag(null);

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

@@ -1,15 +1,9 @@
 import * as api from "../../network/api.js";
 import { MatCardFontSize } from "./Material.js";
-export interface BasketLoadStationCommand {
-    readonly workId: string;
-}
-export type SubmitBasketLoadStationCommand = (stationNumber: number, command: BasketLoadStationCommand) => Promise<"accepted" | "conflict">;
 interface BasketLoadStationWorkflowProps {
-    readonly stationNumber: number;
     readonly basket: Readonly<api.IBasketStatus>;
     readonly material: ReadonlyArray<Readonly<api.IInProcessMaterial>>;
     readonly fsize: MatCardFontSize;
-    readonly submitCommand: SubmitBasketLoadStationCommand | undefined;
 }
-export declare function BasketLoadStationWorkflow({ stationNumber, basket, material, fsize, submitCommand, }: BasketLoadStationWorkflowProps): import("react").JSX.Element;
+export declare function BasketLoadStationWorkflow({ basket, material, fsize, }: BasketLoadStationWorkflowProps): import("react").JSX.Element;
 export {};

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

@@ -33,6 +33,7 @@ import { Alert, Box, Button, Stack, Typography } from "@mui/material";
 import { LazySeq } from "@seedtactics/immutable-collections";
 import { basketSlotLabel } from "../../cell-status/station-cycles.js";
 import * as api from "../../network/api.js";
+import { JobsBackend } from "../../network/backend.js";
 import { InProcMaterial } from "./Material.js";
 import { MoveMaterialArrowNode } from "./MoveMaterialArrows.js";
 import { MoveMaterialNodeKindType } from "../../data/move-arrows.js";
@@ -138,10 +139,11 @@ function loadingInstruction(mat) {
 function SlotMaterial({ material, fsize, }) {
     return material.map((mat) => (_jsx(MoveMaterialArrowNode, { kind: { type: MoveMaterialNodeKindType.Material, material: mat }, children: _jsx(InProcMaterial, { mat: mat, fsize: fsize }) }, mat.materialID)));
 }
-export function BasketLoadStationWorkflow({ stationNumber, basket, material, fsize, submitCommand, }) {
+export function BasketLoadStationWorkflow({ basket, material, fsize, }) {
     const [submission, setSubmission] = useState();
     const workState = useMemo(() => stationWork(material, basket), [basket, material]);
     const blockedReason = basket.loadStationWork?.confirmationBlockedReason?.trim();
+    const instructionWarning = basket.loadStationWork?.instructionWarning?.trim();
     const work = workState.type === "active" ? workState.work : undefined;
     const submissionState = submission !== undefined &&
         submission.workId === work?.workId &&
@@ -170,17 +172,19 @@ export function BasketLoadStationWorkflow({ stationNumber, basket, material, fsi
         .distinctBy((slot) => slot)
         .toSortedArray((slot) => slot), [basket.emptySlots, basket.unknownSlots, materialBySlot, loadsBySlot]);
     async function submit() {
-        if (work === undefined || !work.ready || submitCommand === undefined)
+        if (work === undefined || !work.ready)
             return;
         const submittedWorkId = work.workId;
         const pending = { workId: submittedWorkId, basket, material, state: "submitting" };
         setSubmission(pending);
         try {
-            const state = await submitCommand(stationNumber, { workId: submittedWorkId });
+            await JobsBackend.completeBasketLoadStation(new api.BasketLoadStationCompletion({ workId: submittedWorkId }));
+            const state = "accepted";
             setSubmission((current) => (current === pending ? { ...pending, state } : current));
         }
-        catch {
-            setSubmission((current) => (current === pending ? { ...pending, state: "error" } : current));
+        catch (error) {
+            const state = api.ApiException.isApiException(error) && error.status === 409 ? "conflict" : "error";
+            setSubmission((current) => (current === pending ? { ...pending, state } : current));
         }
     }
     const submissionDisabled = !work?.ready ||
@@ -202,8 +206,8 @@ export function BasketLoadStationWorkflow({ stationNumber, basket, material, fsi
                         }, children: _jsxs(Box, { component: "section", "data-testid": `basket-load-station-slot-${slot}`, sx: { border: "1px solid", borderColor: "text.primary", p: 2 }, children: [_jsxs(Typography, { variant: "h6", children: ["Slot ", basketSlotLabel(slot)] }), loads.length > 0 &&
                                     slotMaterial.some((mat) => mat.action.type === api.ActionType.UnloadToInProcess ||
                                         mat.action.type === api.ActionType.UnloadToCompletedMaterial) && (_jsx(Typography, { children: "Unload the current material before preparing the replacement." })), slotMaterial.length > 0 ? (_jsx(SlotMaterial, { material: slotMaterial, fsize: fsize })) : (_jsx(Typography, { color: isUnknown ? "warning.main" : "text.secondary", children: isUnknown ? "Unknown" : "Empty" })), loads.map((mat, index) => (_jsxs(Box, { sx: { mt: 1 }, children: [_jsx(Typography, { children: loadingInstruction(mat) }), _jsxs(Typography, { variant: "body2", color: "text.secondary", children: [mat.partName, " \u00B7 Process ", mat.action.processAfterLoad ?? mat.process] })] }, `${mat.jobUnique}-${mat.process}-${index}`)))] }) }, slot));
-                }) }), work?.confirmEmpty && _jsxs(Typography, { children: ["Confirm basket ", basket.basketId, " is empty."] }), work && !work.ready && (_jsx(Alert, { severity: "info", children: blockedReason ||
+                }) }), work?.confirmEmpty && _jsxs(Typography, { children: ["Confirm basket ", basket.basketId, " is empty."] }), instructionWarning && _jsx(Alert, { severity: "warning", children: instructionWarning }), work && !work.ready && (_jsx(Alert, { severity: "info", children: blockedReason ||
                     (work.awaitingSlots.length > 0
                         ? `Waiting for material for slots ${work.awaitingSlots.map(basketSlotLabel).join(", ")}.`
-                        : "Basket work is not ready for confirmation.") })), work && submitCommand ? (_jsx(Box, { sx: { display: "flex", justifyContent: "flex-end" }, children: _jsx(Button, { variant: "contained", disabled: submissionDisabled, onClick: () => void submit(), children: "Confirm" }) })) : work ? (_jsx(Alert, { severity: "warning", children: "Basket work confirmation is not configured." })) : workState.type === "inconsistent" ? (_jsx(Alert, { severity: "warning", children: "Basket work is inconsistent. Wait for refreshed material actions before confirming." })) : null, submissionState === "accepted" ? (_jsx(Alert, { severity: "success", children: "Confirmation accepted. Waiting for refreshed work." })) : submissionState === "conflict" ? (_jsx(Alert, { severity: "warning", children: "Basket work changed before confirmation. Review the refreshed slots and try again." })) : submissionState === "error" ? (_jsx(Alert, { severity: "error", children: "Unable to confirm basket work. No work was assumed complete." })) : null] }));
+                        : "Basket work is not ready for confirmation.") })), work ? (_jsx(Box, { sx: { display: "flex", justifyContent: "flex-end" }, children: _jsx(Button, { variant: "contained", disabled: submissionDisabled, onClick: () => void submit(), children: "Confirm" }) })) : workState.type === "inconsistent" ? (_jsx(Alert, { severity: "warning", children: "Basket work is inconsistent. Wait for refreshed material actions before confirming." })) : null, submissionState === "accepted" ? (_jsx(Alert, { severity: "success", children: "Confirmation accepted. Waiting for refreshed work." })) : submissionState === "conflict" ? (_jsx(Alert, { severity: "warning", children: "Basket work changed before confirmation. Review the refreshed slots and try again." })) : submissionState === "error" ? (_jsx(Alert, { severity: "error", children: "Unable to confirm basket work. No work was assumed complete." })) : null] }));
 }

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

@@ -82,12 +82,15 @@ function InvalidateSelect(props) {
         job: currentSt.jobs[j.jobUnique] ?? history.get(j.jobUnique) ?? null,
     }));
     const hasProc = lastMat !== null && lastMat.process >= 1;
-    const hasChangeMat = castings.length > 0 || jobs.length > 0;
+    const canChangeAssignment = lastMat === null || lastMat.process <= 1;
+    const hasChangeMat = canChangeAssignment && (castings.length > 0 || jobs.length > 0);
     const selectedCasting = props.st?.changeRawMat !== null &&
         props.st?.changeRawMat !== undefined &&
+        canChangeAssignment &&
         castings.includes(props.st.changeRawMat);
     const selectedJob = props.st?.changeJobUnique !== null &&
         props.st?.changeJobUnique !== undefined &&
+        canChangeAssignment &&
         jobs.some((job) => job.jobUnique === props.st?.changeJobUnique);
     function change(e) {
         props.setState({
@@ -102,7 +105,7 @@ function InvalidateSelect(props) {
             ? "rawMat" + props.st.changeRawMat
             : selectedJob
                 ? "job" + props.st.changeJobUnique
-                : props.st?.process && hasProc
+                : props.st?.process && hasProc && props.st.process === lastMat.process
                     ? "proc" + props.st.process.toString()
                     : "", select: true, onChange: (e) => change(e.target.value), variant: "outlined", label: props.st?.changeRawMat
             ? "Change Raw Material"
@@ -119,11 +122,6 @@ function InvalidateSelect(props) {
             hasProc
                 ? [
                     _jsxs(MenuItem, { value: "proc" + lastMat.process.toString(), children: ["Invalidate Process ", lastMat.process] }, lastMat.process),
-                    ...(lastMat.process > 1
-                        ? [
-                            _jsx(MenuItem, { value: "proc1", children: "Invalidate All Processes" }, "all"),
-                        ]
-                        : []),
                 ]
                 : [],
             hasProc && hasChangeMat
@@ -131,8 +129,9 @@ function InvalidateSelect(props) {
                 : [],
             hasChangeMat
                 ? [
-                    ...castings.map((c) => (_jsxs(MenuItem, { value: "rawMat" + c, children: ["Invalidate Everything and Change to ", c] }, "rawMat" + c))),
-                    ...jobs.map(({ jobUnique, job }) => (_jsxs(MenuItem, { value: "job" + jobUnique, children: [job ? (_jsx(ListItemIcon, { children: _jsx(PartIdenticon, { part: job.partName }) })) : undefined, _jsx(ListItemText, { primary: "Invalidate Everything and Change to Job " + jobUnique, secondary: job?.partName })] }, "job" + jobUnique))),
+                    ...castings.map((c) => (_jsxs(MenuItem, { value: "rawMat" + c, children: [hasProc ? "Invalidate Process 1 and Change to " : "Change to ", c] }, "rawMat" + c))),
+                    ...jobs.map(({ jobUnique, job }) => (_jsxs(MenuItem, { value: "job" + jobUnique, children: [job ? (_jsx(ListItemIcon, { children: _jsx(PartIdenticon, { part: job.partName }) })) : undefined, _jsx(ListItemText, { primary: (hasProc ? "Invalidate Process 1 and Change to Job " : "Change to Job ") +
+                                    jobUnique, secondary: job?.partName })] }, "job" + jobUnique))),
                 ]
                 : [],
         ] }));
@@ -183,13 +182,15 @@ export function InvalidateCycleDialogButton(props) {
         return null;
     if (!canInvalidateMaterial(inProcMat))
         return null;
-    const allowChange = possibleNew !== null &&
+    const allowChange = (lastMat === null || lastMat.process <= 1) &&
+        possibleNew !== null &&
         (!LazySeq.ofObject(possibleNew.possibleCastingsByQueue ?? {}).isEmpty() ||
             !LazySeq.ofObject(possibleNew.possibleJobsByQueue ?? {}).isEmpty());
     if (!allowChange && (lastMat === null || lastMat.process < 1))
         return null;
     if (props.ignoreOperator)
         operator = null;
+    const changingAssignment = props.st !== null && (props.st.changeRawMat !== null || props.st.changeJobUnique !== null);
     function showInvalidate() {
         props.setState({
             process: null,
@@ -230,17 +231,20 @@ export function InvalidateCycleDialogButton(props) {
         }
     }
     return (_jsxs(_Fragment, { children: [props.st === null ? (_jsx(Button, { color: "primary", onClick: showInvalidate, children: "Invalidate Cycle" })) : undefined, props.st !== null ? (_jsx(Button, { color: "primary", onClick: invalidateCycle, disabled: props.st.updating ||
+                    (changingAssignment && !allowChange) ||
+                    (!changingAssignment &&
+                        props.st.process !== null &&
+                        props.st.process !== lastMat?.process) ||
                     (props.st.process === null &&
                         props.st.changeRawMat === null &&
                         props.st.changeJobUnique === null), children: props.st.changeJobUnique !== null
-                    ? "Invalidate Everything and Change to Job " + props.st.changeJobUnique
+                    ? (lastMat?.process === 1
+                        ? "Invalidate Process 1 and Change to Job "
+                        : "Change to Job ") + props.st.changeJobUnique
                     : props.st.changeRawMat !== null
-                        ? "Invalidate Everything and Change to " + props.st.changeRawMat
+                        ? (lastMat?.process === 1 ? "Invalidate Process 1 and Change to " : "Change to ") +
+                            props.st.changeRawMat
                         : props.st.process !== null
-                            ? props.st.process === 1
-                                ? lastMat && lastMat.process > 1
-                                    ? "Invalidate All Processes"
-                                    : "Invalidate Process 1"
-                                : "Invalidate Process " + props.st.process.toString()
+                            ? "Invalidate Process " + props.st.process.toString()
                             : "Invalidate Cycle" })) : undefined] }));
 }

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

@@ -1,14 +1,9 @@
 import { ReactNode } from "react";
-import { SubmitBasketLoadStationCommand } from "./BasketLoadStationWork.js";
-import { SubmitBasketLocationCorrection, SubmitBasketMovementCompletion } from "./BasketMovementArrival.js";
 interface LoadStationProps {
     readonly loadNum: number;
     readonly queues: ReadonlyArray<string>;
     readonly completed: boolean;
     readonly whiteBackground?: boolean;
-    readonly submitBasketLoadStationCommand?: SubmitBasketLoadStationCommand;
-    readonly submitBasketMovementCompletion?: SubmitBasketMovementCompletion;
-    readonly submitBasketLocationCorrection?: SubmitBasketLocationCorrection;
 }
 export declare function LoadStation(props: LoadStationProps): import("react").JSX.Element;
 declare function LoadStationCheckWidth(props: LoadStationProps): ReactNode;

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

@@ -31,7 +31,7 @@ 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 { useMemo, memo, useState, useCallback, useEffect } from "react";
+import { useMemo, memo, useState, useCallback } from "react";
 import { Box, useMediaQuery, Button, Typography } from "@mui/material";
 import { LazySeq, OrderedMap } from "@seedtactics/immutable-collections";
 import { FolderOpen as FolderOpenIcon } from "@mui/icons-material";
@@ -63,8 +63,7 @@ import { PrintLabelButton } from "./PrintedLabel.js";
 import { hideNonLoadingMaterialOnLoadStation } from "../../data/queue-material.js";
 import { basketDisplayName, loadStationDisplayName } from "../../cell-status/station-cycles.js";
 import { canAddOrMoveMaterialToQueue } from "../../data/material-operation-policy.js";
-import { BasketLoadStationWorkflow, } from "./BasketLoadStationWork.js";
-import { BasketMovementArrival, loadStationArrivalInstruction, } from "./BasketMovementArrival.js";
+import { BasketLoadStationWorkflow } from "./BasketLoadStationWork.js";
 function encodeLoadStationRegionIdPart(value) {
     return encodeURIComponent(value.toString());
 }
@@ -393,7 +392,7 @@ function ElapsedLoadTime({ elapsedLoadTime }) {
         return null;
     }
 }
-function PalletFace({ data, faceNum, loadNum, submitBasketLoadStationCommand, }) {
+function PalletFace({ data, faceNum }) {
     const face = data.face.get(faceNum);
     const fmsInfo = useAtomValue(fmsInformation);
     const basketName = basketDisplayName(fmsInfo.basketName);
@@ -408,7 +407,7 @@ function PalletFace({ data, faceNum, loadNum, submitBasketLoadStationCommand, })
                             }, children: _jsx(ElapsedLoadTime, { elapsedLoadTime: data.elapsedLoadingTime }) })] })) : null, _jsx(Box, { sx: { ml: "4em", mr: "4em" }, children: _jsx(MoveMaterialArrowNode, { kind: {
                             type: MoveMaterialNodeKindType.BasketZone,
                             basketId: data.activeBasket.basketId,
-                        }, children: _jsx(BasketLoadStationWorkflow, { stationNumber: loadNum, basket: data.activeBasket, material: data.allMaterial, fsize: data.fsize, submitCommand: submitBasketLoadStationCommand }) }) })] }));
+                        }, children: _jsx(BasketLoadStationWorkflow, { basket: data.activeBasket, material: data.allMaterial, fsize: data.fsize }) }) })] }));
     }
     if (!data.pallet)
         return null;
@@ -680,23 +679,6 @@ export function LoadStation(props) {
     const currentSt = useAtomValue(currentStatus);
     const hideNonLoading = useAtomValue(hideNonLoadingMaterialOnLoadStation);
     const data = useMemo(() => selectLoadStationAndQueueProps(props.loadNum, props.queues, currentSt, hideNonLoading), [currentSt, props.loadNum, props.queues, hideNonLoading]);
-    const arrivalInstruction = loadStationArrivalInstruction(currentSt.basketMoveInstructions ?? [], props.loadNum);
-    const [recentArrivalReceipt, setRecentArrivalReceipt] = useState();
-    useEffect(() => {
-        if (recentArrivalReceipt !== undefined &&
-            (recentArrivalReceipt.stationNumber !== props.loadNum ||
-                (arrivalInstruction !== undefined &&
-                    arrivalInstruction.instructionId !== recentArrivalReceipt.instruction.instructionId))) {
-            // This state is an ephemeral receipt; discard it permanently when a new instruction supersedes it.
-            // oxlint-disable-next-line react/set-state-in-effect -- intentional invalidation of stale UI state.
-            setRecentArrivalReceipt(undefined);
-        }
-    }, [arrivalInstruction, props.loadNum, recentArrivalReceipt]);
-    const displayedArrivalInstruction = arrivalInstruction ?? recentArrivalReceipt?.instruction;
-    const displayedArrivalReceipt = recentArrivalReceipt?.stationNumber === props.loadNum &&
-        displayedArrivalInstruction?.instructionId === recentArrivalReceipt?.instruction.instructionId
-        ? recentArrivalReceipt
-        : undefined;
     const queueCols = LazySeq.of(data.queues)
         .sortBy(([q]) => q)
         .map(([q, mats]) => ({
@@ -743,53 +725,31 @@ export function LoadStation(props) {
         horizontal: fillViewPort,
         showMatInCompleted: props.completed,
     });
-    return (_jsxs(_Fragment, { children: [displayedArrivalInstruction === undefined ? null : (_jsx(BasketMovementArrival, { basketName: basketName, instruction: displayedArrivalInstruction, stationNumber: props.loadNum, submitCommand: props.submitBasketMovementCompletion, submitCorrection: props.submitBasketLocationCorrection, receipt: displayedArrivalReceipt, onAccepted: setRecentArrivalReceipt, onCorrected: (command) => setRecentArrivalReceipt((current) => {
-                    if (current === undefined ||
-                        current.stationNumber !== props.loadNum ||
-                        current.receipt.observationId !== command.targetObservationId)
-                        return current;
-                    return command.replacementBasketId === null ||
-                        command.replacementObservationId === null
-                        ? { ...current, status: "retracted" }
-                        : {
-                            ...current,
-                            receipt: {
-                                ...current.receipt,
-                                observationId: command.replacementObservationId,
-                                observedBasketId: command.replacementBasketId,
-                            },
-                            command: {
-                                ...current.command,
-                                commandId: command.replacementObservationId,
-                                observedBasketId: command.replacementBasketId,
-                            },
-                            status: "corrected",
-                        };
-                }) })), _jsx(MoveMaterialArrowContainer, { hideArrows: !fillViewPort, whiteBackground: props.whiteBackground, children: _jsxs(Box, { component: "main", sx: {
-                        width: "100%",
-                        display: "grid",
-                        gridTemplate: grid,
-                        minHeight: {
-                            xs: "calc(100vh - 64px - 32px)",
-                            sm: "calc(100vh - 64px - 40px)",
-                            md: "calc(100vh - 64px)",
-                        },
-                        padding: fillViewPort ? undefined : "8px",
-                    }, children: [matCols.map((col, idx) => (_jsx(Box, { "data-testid": materialColumnTestId(col), sx: {
-                                gridArea: `mat${idx}`,
-                                padding: "8px",
-                                borderRight: fillViewPort ? "1px solid black" : undefined,
-                                borderBottom: !fillViewPort ? "1px solid black" : undefined,
-                            }, children: _jsx(MaterialColumn, { data: data, region: col }) }, idx))), data.face.keysToAscLazySeq().map((faceNum, idx) => (_jsx(Box, { sx: {
-                                marginLeft: "15px",
-                                gridArea: `palface${idx}`,
-                                padding: "8px",
-                                borderTop: data.pallet && idx !== 0 ? "1px solid black" : undefined,
-                            }, children: _jsx(PalletFace, { data: data, faceNum: faceNum, loadNum: props.loadNum, submitBasketLoadStationCommand: props.submitBasketLoadStationCommand }) }, faceNum))), _jsx(Box, { "data-testid": "load-station-completed", sx: {
-                                borderLeft: fillViewPort ? "1px solid black" : undefined,
-                                borderTop: !fillViewPort ? "1px solid black" : undefined,
-                                gridArea: "completed",
-                            }, children: _jsx(CompletedCol, { fillViewPort: fillViewPort, showMaterial: props.completed }) }), _jsx(MultiInstructionButton, { loadData: data }), _jsx(SelectWorkorderDialog, {}), _jsx(SelectInspTypeDialog, {}), _jsx(LoadMatDialog, { pallet: data.pallet?.palletNum ?? null, queues: props.queues })] }) })] }));
+    return (_jsx(_Fragment, { children: _jsx(MoveMaterialArrowContainer, { hideArrows: !fillViewPort, whiteBackground: props.whiteBackground, children: _jsxs(Box, { component: "main", sx: {
+                    width: "100%",
+                    display: "grid",
+                    gridTemplate: grid,
+                    minHeight: {
+                        xs: "calc(100vh - 64px - 32px)",
+                        sm: "calc(100vh - 64px - 40px)",
+                        md: "calc(100vh - 64px)",
+                    },
+                    padding: fillViewPort ? undefined : "8px",
+                }, children: [matCols.map((col, idx) => (_jsx(Box, { "data-testid": materialColumnTestId(col), sx: {
+                            gridArea: `mat${idx}`,
+                            padding: "8px",
+                            borderRight: fillViewPort ? "1px solid black" : undefined,
+                            borderBottom: !fillViewPort ? "1px solid black" : undefined,
+                        }, children: _jsx(MaterialColumn, { data: data, region: col }) }, idx))), data.face.keysToAscLazySeq().map((faceNum, idx) => (_jsx(Box, { sx: {
+                            marginLeft: "15px",
+                            gridArea: `palface${idx}`,
+                            padding: "8px",
+                            borderTop: data.pallet && idx !== 0 ? "1px solid black" : undefined,
+                        }, children: _jsx(PalletFace, { data: data, faceNum: faceNum }) }, faceNum))), _jsx(Box, { "data-testid": "load-station-completed", sx: {
+                            borderLeft: fillViewPort ? "1px solid black" : undefined,
+                            borderTop: !fillViewPort ? "1px solid black" : undefined,
+                            gridArea: "completed",
+                        }, children: _jsx(CompletedCol, { fillViewPort: fillViewPort, showMaterial: props.completed }) }), _jsx(MultiInstructionButton, { loadData: data }), _jsx(SelectWorkorderDialog, {}), _jsx(SelectInspTypeDialog, {}), _jsx(LoadMatDialog, { pallet: data.pallet?.palletNum ?? null, queues: props.queues })] }) }) }));
 }
 function LoadStationCheckWidth(props) {
     const fmsInfo = useAtomValue(fmsInformation);

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

@@ -49,7 +49,7 @@ import { useAtom, useAtomValue, useSetAtom } from "jotai";
 import { last30Rebookings } from "../../cell-status/rebookings.js";
 import { fmsInformation } from "../../network/server-settings.js";
 import { basketDisplayName, basketSlotLabel } from "../../cell-status/station-cycles.js";
-import { materialOperationState } from "../../data/material-operation-policy.js";
+import { canAddOrMoveMaterialToQueue, canReorderQueuedMaterial, materialOperationState, } from "../../data/material-operation-policy.js";
 export class PartIdenticon extends PureComponent {
     render() {
         const iconSize = this.props.size || 50;
@@ -402,10 +402,12 @@ export const InProcMaterial = memo(function InProcMaterial(props) {
     return (_jsx(MatCard, { mat: inproc_mat_to_summary(props.mat), inProcMat: props.mat, displayActionForSinglePallet: props.displayActionForSinglePallet, fsize: props.fsize, hideAvatar: props.hideAvatar, displayJob: props.displayJob, showDragHandle: props.showHandle, hideEmptySerial: props.hideEmptySerial, showRawMaterial: props.showRawMaterial, showJobComment: props.showJobComment, shake: props.shake }));
 });
 export const SortableInProcMaterial = memo(function SortableInProcMaterial(props) {
+    const canDrag = canReorderQueuedMaterial(props.mat) || canAddOrMoveMaterialToQueue(props.mat);
     const d = { mat: props.mat };
     const { active, isDragging, attributes, listeners, setNodeRef, setActivatorNodeRef, transform, transition, } = useSortable({
         id: props.mat.materialID,
         data: d,
+        disabled: { draggable: !canDrag },
     });
     const handleProps = {
         ...listeners,
@@ -421,7 +423,7 @@ export const SortableInProcMaterial = memo(function SortableInProcMaterial(props
             : undefined,
         transition: active !== null ? transition : undefined,
     };
-    return (_jsx(MatCard, { ref: setNodeRef, dragRootProps: { style }, showDragHandle: true, dragHandleProps: handleProps, setDragHandleRef: setActivatorNodeRef, isActiveDrag: isDragging, mat: inproc_mat_to_summary(props.mat), inProcMat: props.mat, displayActionForSinglePallet: props.displayActionForSinglePallet, hideAvatar: props.hideAvatar, displayJob: props.displayJob, hideEmptySerial: props.hideEmptySerial, fsize: props.fsize, shake: active ? undefined : props.shake, showRawMaterial: props.showRawMaterial }));
+    return (_jsx(MatCard, { ref: setNodeRef, dragRootProps: { style }, showDragHandle: canDrag, dragHandleProps: handleProps, setDragHandleRef: setActivatorNodeRef, isActiveDrag: isDragging, mat: inproc_mat_to_summary(props.mat), inProcMat: props.mat, displayActionForSinglePallet: props.displayActionForSinglePallet, hideAvatar: props.hideAvatar, displayJob: props.displayJob, hideEmptySerial: props.hideEmptySerial, fsize: props.fsize, shake: active ? undefined : props.shake, showRawMaterial: props.showRawMaterial }));
 });
 export function DragOverlayInProcMaterial(props) {
     return (_jsx(MatCard, { mat: inproc_mat_to_summary(props.mat), inProcMat: props.mat, displayActionForSinglePallet: props.displayActionForSinglePallet, showDragHandle: true, hideAvatar: props.hideAvatar, displayJob: props.displayJob, fsize: props.fsize, hideEmptySerial: props.hideEmptySerial, isDragOverlay: true }));

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

@@ -40,15 +40,16 @@ import { currentOperator } from "../../data/operators.js";
 import { ApiException, LocType, QueueRole, } from "../../network/api.js";
 import { fmsInformation } from "../../network/server-settings.js";
 import { useAtomValue, useSetAtom } from "jotai";
-import { canDirectlyQuarantine, canRemoveFromQueue, canSignalQuarantine, isActiveLoadStationOperation, } from "../../data/material-operation-policy.js";
+import { canDirectlyQuarantine, canRemoveFromQueue, canSignalQuarantine, quarantineRoute, } 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];
+    const route = quarantineRoute(material);
+    const path = job.procsAndPaths[route.process - 1]?.paths[route.path - 1];
     if (!path)
         return false;
-    return material.process === job.procsAndPaths.length || Boolean(path.outputQueue);
+    return route.process === job.procsAndPaths.length || Boolean(path.outputQueue);
 }
 function useQuarantineMaterial() {
     const fmsInfo = useAtomValue(fmsInformation);
@@ -56,8 +57,6 @@ function useQuarantineMaterial() {
     const curSt = useAtomValue(currentStatus);
     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;
@@ -80,7 +79,8 @@ function useQuarantineMaterial() {
         .filter(([qname]) => !activeQueues.has(qname))
         .toRSet(([qname]) => qname);
     // If in a quarantine queue, allow removal from system
-    if (inProcMat.location.type === LocType.InQueue &&
+    if (canRemoveFromQueue(inProcMat) &&
+        inProcMat.location.type === LocType.InQueue &&
         inProcMat.location.currentQueue &&
         quarantineQueues.has(inProcMat.location.currentQueue)) {
         return {
@@ -91,25 +91,16 @@ function useQuarantineMaterial() {
         };
     }
     let type = null;
-    switch (inProcMat.location.type) {
-        case LocType.OnPallet:
-        case LocType.InBasket:
-            if (!canSignalQuarantine(inProcMat) || !hasSupportedQuarantineExit(inProcMat, curSt)) {
-                return null;
-            }
-            type = "SignalForScrap";
-            break;
-        case LocType.InQueue:
-            if (!canDirectlyQuarantine(inProcMat))
-                return null;
-            if (inProcMat.location.currentQueue === undefined ||
-                quarantineQueues.has(inProcMat.location.currentQueue)) {
-                return null;
-            }
-            type = "Scrap";
-            break;
-        case LocType.Free:
+    if (canSignalQuarantine(inProcMat)) {
+        if (!hasSupportedQuarantineExit(inProcMat, curSt))
+            return null;
+        type = "SignalForScrap";
+    }
+    else if (canDirectlyQuarantine(inProcMat)) {
+        if (inProcMat.location.currentQueue === undefined ||
+            quarantineQueues.has(inProcMat.location.currentQueue))
             return null;
+        type = "Scrap";
     }
     if (type) {
         return {
@@ -214,7 +205,7 @@ export function QuarantineMatButton({ onClose, ignoreOperator, }) {
             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";
+            btnTxt = displayedSnapshot.destination ? "Signal for quarantine" : "Scrap";
             break;
     }
     async function quarantine() {
@@ -266,5 +257,5 @@ export function QuarantineMatButton({ onClose, ignoreOperator, }) {
                 ? 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" })] })] })] }));
+    return (_jsxs(_Fragment, { children: [q ? (_jsx(Tooltip, { title: title, describeChild: displayedSnapshot.operation === "DeferredQuarantine", 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" })] })] })] }));
 }