@seedtactics/insight-client 17.0.1-beta.1 → 17.0.1-beta.11

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

@@ -31,6 +31,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 import { useMemo, useState } from "react";
 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 { InProcMaterial } from "./Material.js";
 import { MoveMaterialArrowNode } from "./MoveMaterialArrows.js";
@@ -69,14 +70,48 @@ function basketAction(mat, basketId) {
     }
     return undefined;
 }
-function confirmableWork(material, basketId) {
+function stationWork(material, basket) {
     const classifiedActions = LazySeq.of(material)
-        .collect((mat) => basketAction(mat, basketId))
+        .collect((mat) => basketAction(mat, basket.basketId))
         .toRArray();
     if (classifiedActions.some((action) => action.type === "invalid")) {
         return { type: "inconsistent" };
     }
     const validActions = classifiedActions.filter((action) => action.type === "valid");
+    const descriptor = basket.loadStationWork;
+    if (descriptor !== undefined) {
+        if (!descriptor ||
+            !isNonBlank(descriptor.workId) ||
+            typeof descriptor.readyToConfirm !== "boolean")
+            return { type: "inconsistent" };
+        const awaiting = descriptor.awaitingMaterialSlots ?? [];
+        if (!Array.isArray(awaiting) ||
+            !awaiting.every(isPositiveInteger) ||
+            new Set(awaiting).size !== awaiting.length ||
+            (descriptor.readyToConfirm && awaiting.length > 0) ||
+            validActions.some((action) => action.workId !== descriptor.workId))
+            return { type: "inconsistent" };
+        const empty = descriptor.type === api.BasketLoadStationWorkType.ConfirmEmptyBasket;
+        if (empty) {
+            if (validActions.length > 0 ||
+                awaiting.length > 0 ||
+                material.some((mat) => mat.location.type === api.LocType.InBasket && mat.location.basketId === basket.basketId))
+                return { type: "inconsistent" };
+        }
+        else if (descriptor.type !== api.BasketLoadStationWorkType.Material ||
+            (descriptor.readyToConfirm && validActions.length === 0)) {
+            return { type: "inconsistent" };
+        }
+        return {
+            type: "active",
+            work: {
+                workId: descriptor.workId,
+                ready: descriptor.readyToConfirm,
+                confirmEmpty: empty,
+                awaitingSlots: awaiting,
+            },
+        };
+    }
     if (validActions.length === 0)
         return { type: "none" };
     const tagged = validActions.filter((action) => isNonBlank(action.workId));
@@ -85,8 +120,8 @@ function confirmableWork(material, basketId) {
         return { type: "inconsistent" };
     }
     return {
-        type: "confirmable",
-        work: { workId: tagged[0].workId },
+        type: "active",
+        work: { workId: tagged[0].workId, ready: true, confirmEmpty: false, awaitingSlots: [] },
     };
 }
 function loadingInstruction(mat) {
@@ -105,21 +140,29 @@ function SlotMaterial({ material, fsize, }) {
 }
 export function BasketLoadStationWorkflow({ stationNumber, basket, material, fsize, submitCommand, }) {
     const [submission, setSubmission] = useState();
-    const workState = useMemo(() => confirmableWork(material, basket.basketId), [basket.basketId, material]);
-    const work = workState.type === "confirmable" ? workState.work : undefined;
-    const submissionState = submission !== undefined && submission.workId === work?.workId ? submission.state : "idle";
+    const workState = useMemo(() => stationWork(material, basket), [basket, material]);
+    const blockedReason = basket.loadStationWork?.confirmationBlockedReason?.trim();
+    const work = workState.type === "active" ? workState.work : undefined;
+    const submissionState = submission !== undefined &&
+        submission.workId === work?.workId &&
+        // A conflict rejects the submitted status snapshot, not the preserved occurrence.
+        // Compare the captured snapshot even when refresh precedes the response.
+        (submission.state !== "conflict" ||
+            (submission.basket === basket && submission.material === material))
+        ? submission.state
+        : "idle";
     const materialBySlot = useMemo(() => LazySeq.of(material)
         .filter((mat) => mat.location.type === api.LocType.InBasket &&
         mat.location.basketId === basket.basketId &&
         mat.location.basketSlot !== undefined)
         .groupBy((mat) => mat.location.basketSlot ?? 0)
-        .toHashMap((entry) => entry), [basket.basketId, material]);
+        .toHashMap((entry) => entry), [basket, material]);
     const loadsBySlot = useMemo(() => LazySeq.of(material)
         .filter((mat) => mat.action.type === api.ActionType.LoadingToBasket &&
         mat.action.loadToBasketId === basket.basketId &&
         mat.action.loadToBasketSlot !== undefined)
         .groupBy((mat) => mat.action.loadToBasketSlot ?? 0)
-        .toHashMap((entry) => entry), [basket.basketId, material]);
+        .toHashMap((entry) => entry), [basket, material]);
     const slots = useMemo(() => LazySeq.of(basket.emptySlots ?? [])
         .concat(basket.unknownSlots ?? [])
         .concat(materialBySlot.keysToLazySeq())
@@ -127,19 +170,21 @@ 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 || submitCommand === undefined)
+        if (work === undefined || !work.ready || submitCommand === undefined)
             return;
         const submittedWorkId = work.workId;
-        setSubmission({ workId: submittedWorkId, state: "submitting" });
+        const pending = { workId: submittedWorkId, basket, material, state: "submitting" };
+        setSubmission(pending);
         try {
             const state = await submitCommand(stationNumber, { workId: submittedWorkId });
-            setSubmission((current) => current?.workId === submittedWorkId ? { workId: submittedWorkId, state } : current);
+            setSubmission((current) => (current === pending ? { ...pending, state } : current));
         }
         catch {
-            setSubmission((current) => current?.workId === submittedWorkId ? { workId: submittedWorkId, state: "error" } : current);
+            setSubmission((current) => (current === pending ? { ...pending, state: "error" } : current));
         }
     }
-    const submissionDisabled = submissionState === "submitting" ||
+    const submissionDisabled = !work?.ready ||
+        submissionState === "submitting" ||
         submissionState === "accepted" ||
         submissionState === "conflict";
     return (_jsxs(Stack, { spacing: 2, sx: { mt: 2 }, children: [_jsx(Typography, { variant: "h6", children: "Basket slots" }), _jsx(Box, { sx: {
@@ -154,6 +199,11 @@ export function BasketLoadStationWorkflow({ stationNumber, basket, material, fsi
                             type: MoveMaterialNodeKindType.BasketSlotZone,
                             basketId: basket.basketId,
                             slot,
-                        }, 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 ", slot] }), 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 && 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] }));
+                        }, 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.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] }));
 }

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

@@ -26,7 +26,7 @@ export interface BasketArrivalReceipt {
     readonly status: "recorded" | "corrected" | "retracted";
 }
 export declare function loadStationArrivalInstruction(instructions: ReadonlyArray<Readonly<api.IBasketMoveInstruction>>, stationNumber: number): Readonly<api.IBasketMoveInstruction> | undefined;
-export declare function BasketMovementArrival({ stationNumber, basketName, instruction, submitCommand, submitCorrection, receipt, onAccepted, onCorrected, }: {
+interface BasketMovementArrivalProps {
     readonly stationNumber: number;
     readonly basketName: string;
     readonly instruction: Readonly<api.IBasketMoveInstruction>;
@@ -35,4 +35,6 @@ export declare function BasketMovementArrival({ stationNumber, basketName, instr
     readonly receipt?: BasketArrivalReceipt;
     readonly onAccepted?: (receipt: BasketArrivalReceipt) => void;
     readonly onCorrected?: (command: BasketLocationCorrectionCommand) => void;
-}): import("react").JSX.Element;
+}
+export declare function BasketMovementArrival(props: BasketMovementArrivalProps): import("react").JSX.Element;
+export {};

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

@@ -39,35 +39,30 @@ export function loadStationArrivalInstruction(instructions, stationNumber) {
         (instruction.prerequisiteInstructionId === undefined ||
             !activeIds.has(instruction.prerequisiteInstructionId)));
 }
-export function BasketMovementArrival({ stationNumber, basketName, instruction, submitCommand, submitCorrection, receipt, onAccepted, onCorrected, }) {
+function basketMovementArrivalKey({ stationNumber, instruction, receipt, }) {
+    return [
+        stationNumber,
+        instruction.instructionId,
+        receipt?.status ?? "pending",
+        receipt?.receipt.observationId ?? "",
+    ].join(":");
+}
+export function BasketMovementArrival(props) {
+    return _jsx(BasketMovementArrivalContent, { ...props }, basketMovementArrivalKey(props));
+}
+function BasketMovementArrivalContent({ stationNumber, basketName, instruction, submitCommand, submitCorrection, receipt, onAccepted, onCorrected, }) {
+    const mounted = useRef(true);
     const [chooseDifferent, setChooseDifferent] = useState(false);
     const [differentBasket, setDifferentBasket] = useState("");
     const [submission, setSubmission] = useState();
     const [changingRecordedBasket, setChangingRecordedBasket] = useState(false);
     const [correctionSubmission, setCorrectionSubmission] = useState();
-    const currentInstructionId = useRef(instruction.instructionId);
-    const currentStationNumber = useRef(stationNumber);
-    const currentCorrectionTargetId = useRef(undefined);
-    currentInstructionId.current = instruction.instructionId;
-    currentStationNumber.current = stationNumber;
     useEffect(() => {
-        setChooseDifferent(false);
-        setDifferentBasket("");
-        setSubmission((current) => current?.state === "error" && current.command.instructionId === instruction.instructionId
-            ? current
-            : undefined);
-        setChangingRecordedBasket(false);
-        setCorrectionSubmission(undefined);
-    }, [instruction.instructionId, stationNumber]);
-    useEffect(() => {
-        setChangingRecordedBasket(false);
-        setDifferentBasket("");
-        setCorrectionSubmission((current) => current?.state === "error" &&
-            receipt?.status !== "retracted" &&
-            current.command.targetObservationId === receipt?.receipt.observationId
-            ? current
-            : undefined);
-    }, [receipt?.receipt.observationId, receipt?.status]);
+        mounted.current = true;
+        return () => {
+            mounted.current = false;
+        };
+    }, []);
     const expectedBasketId = instruction.basketId;
     if (expectedBasketId === undefined) {
         return (_jsx(Alert, { severity: "warning", children: "This tracked basket must be handled through the recovery workflow." }));
@@ -78,8 +73,7 @@ export function BasketMovementArrival({ stationNumber, basketName, instruction,
         setSubmission({ state: "submitting", command });
         try {
             const result = await submitCommand(stationNumber, command);
-            if (currentStationNumber.current !== stationNumber ||
-                currentInstructionId.current !== command.instructionId)
+            if (!mounted.current)
                 return;
             if (result === "conflict") {
                 setSubmission({ state: result, command });
@@ -96,8 +90,7 @@ export function BasketMovementArrival({ stationNumber, basketName, instruction,
             }
         }
         catch (error) {
-            if (currentStationNumber.current !== stationNumber ||
-                currentInstructionId.current !== command.instructionId)
+            if (!mounted.current)
                 return;
             setSubmission({
                 state: "error",
@@ -112,16 +105,14 @@ export function BasketMovementArrival({ stationNumber, basketName, instruction,
         setCorrectionSubmission({ state: "submitting", command });
         try {
             const result = await submitCorrection(stationNumber, command);
-            if (currentStationNumber.current !== stationNumber ||
-                currentCorrectionTargetId.current !== command.targetObservationId)
+            if (!mounted.current)
                 return;
             setCorrectionSubmission({ state: result, command });
             if (result === "accepted")
                 onCorrected?.(command);
         }
         catch {
-            if (currentStationNumber.current !== stationNumber ||
-                currentCorrectionTargetId.current !== command.targetObservationId)
+            if (!mounted.current)
                 return;
             setCorrectionSubmission({ state: "error", command });
         }
@@ -145,7 +136,6 @@ export function BasketMovementArrival({ stationNumber, basketName, instruction,
         ? undefined
         : (receipt?.receipt.observationId ??
             (submission?.state === "accepted" ? submission.receipt.observationId : undefined));
-    currentCorrectionTargetId.current = activeObservationId;
     function createCorrection(replacementBasketId) {
         return {
             correctionId: crypto.randomUUID(),
@@ -171,5 +161,5 @@ export function BasketMovementArrival({ stationNumber, basketName, instruction,
                                     ? `Bring ${basketName.toLocaleLowerCase()} ${expectedBasketId} to this station`
                                     : `${basketName} ${receipt.command.observedBasketId} at this station` }), receipt === undefined ? (_jsx(Typography, { children: "Record arrival after the basket is physically in place." })) : null] }), receipt === undefined ? (_jsxs(Stack, { direction: { xs: "column", sm: "row" }, spacing: 1, children: [_jsx(Button, { disabled: disabled, onClick: () => void record(createCommand(expectedBasketId)), size: "large", variant: "contained", children: submission?.state === "submitting"
                                 ? "Recording arrival…"
-                                : `${basketName} ${expectedBasketId} arrived` }), _jsxs(Button, { disabled: disabled, onClick: () => setChooseDifferent((visible) => !visible), size: "large", variant: "outlined", children: ["Different ", basketName.toLocaleLowerCase()] })] })) : null, receipt === undefined && chooseDifferent && !disabled ? (_jsxs(Stack, { direction: { xs: "column", sm: "row" }, spacing: 1, children: [_jsx(TextField, { label: `${basketName} number`, onChange: (event) => setDifferentBasket(event.target.value), type: "number", value: differentBasket, slotProps: { htmlInput: { inputMode: "numeric", min: 1 } } }), _jsxs(Button, { disabled: !validDifferentBasket, onClick: () => void record(createCommand(parsedDifferentBasket)), variant: "contained", children: ["Record ", basketName.toLocaleLowerCase(), " arrival"] })] })) : null, submitCommand === undefined ? (_jsx(Alert, { severity: "warning", children: "Basket arrival completion is not configured." })) : activeCommand !== undefined || receipt?.status === "retracted" ? (_jsxs(Stack, { spacing: 1, children: [_jsx(Alert, { severity: "success", children: receiptMessage }), submitCorrection === undefined || activeCommand === undefined ? null : (_jsxs(Stack, { direction: { xs: "column", sm: "row" }, spacing: 1, children: [_jsx(Button, { disabled: correctionSubmission !== undefined, onClick: () => setChangingRecordedBasket((visible) => !visible), variant: "outlined", children: "Change" }), _jsx(Button, { color: "error", disabled: correctionSubmission !== undefined, onClick: () => void correct(createCorrection(null)), variant: "text", children: "Undo" })] })), changingRecordedBasket && correctionSubmission === undefined ? (_jsxs(Stack, { direction: { xs: "column", sm: "row" }, spacing: 1, children: [_jsx(TextField, { label: `Correct ${basketName.toLocaleLowerCase()} number`, onChange: (event) => setDifferentBasket(event.target.value), type: "number", value: differentBasket, slotProps: { htmlInput: { inputMode: "numeric", min: 1 } } }), _jsx(Button, { disabled: !validDifferentBasket, onClick: () => void correct(createCorrection(parsedDifferentBasket)), variant: "contained", children: "Save correction" })] })) : null, correctionSubmission?.state === "accepted" ? (_jsx(Alert, { severity: "success", children: "Correction recorded." })) : correctionSubmission?.state === "conflict" ? (_jsx(Alert, { severity: "warning", children: "Basket evidence changed. Review the refreshed status." })) : correctionSubmission?.state === "error" ? (_jsx(Alert, { action: _jsx(Button, { color: "inherit", onClick: () => void correct(correctionSubmission.command), children: "Retry correction" }), severity: "error", children: "Unable to correct the recorded arrival." })) : null] })) : submission?.state === "conflict" ? (_jsx(Alert, { severity: "warning", children: "Basket movement changed. Review the refreshed instruction." })) : submission?.state === "error" ? (_jsx(Alert, { action: _jsx(Button, { onClick: () => void record(submission.command), color: "inherit", children: "Retry arrival" }), severity: "error", children: submission.message })) : null] }) }));
+                                : `${basketName} ${expectedBasketId} arrived` }), _jsxs(Button, { disabled: disabled, onClick: () => setChooseDifferent((visible) => !visible), size: "large", variant: "outlined", children: ["Different ", basketName.toLocaleLowerCase()] })] })) : null, receipt === undefined && chooseDifferent && !disabled ? (_jsxs(Stack, { direction: { xs: "column", sm: "row" }, spacing: 1, children: [_jsx(TextField, { label: `${basketName} number`, onChange: (event) => setDifferentBasket(event.target.value), type: "number", value: differentBasket, slotProps: { htmlInput: { inputMode: "numeric", min: 1 } } }), _jsxs(Button, { disabled: !validDifferentBasket, onClick: () => void record(createCommand(parsedDifferentBasket)), variant: "contained", children: ["Record ", basketName.toLocaleLowerCase(), " arrival"] })] })) : null, submitCommand === undefined ? (_jsx(Alert, { severity: "warning", children: "Basket arrival completion is not configured." })) : activeCommand !== undefined || receipt?.status === "retracted" ? (_jsxs(Stack, { spacing: 1, children: [_jsx(Alert, { severity: "success", children: receiptMessage }), submitCorrection === undefined || activeCommand === undefined ? null : (_jsxs(Stack, { direction: { xs: "column", sm: "row" }, spacing: 1, children: [_jsx(Button, { disabled: correctionSubmission !== undefined, onClick: () => setChangingRecordedBasket((visible) => !visible), variant: "outlined", children: "Change" }), _jsx(Button, { color: "error", disabled: correctionSubmission !== undefined, onClick: () => void correct(createCorrection(null)), variant: "text", children: "Undo" })] })), changingRecordedBasket && correctionSubmission === undefined ? (_jsxs(Stack, { direction: { xs: "column", sm: "row" }, spacing: 1, children: [_jsx(TextField, { label: `Correct ${basketName.toLocaleLowerCase()} number`, onChange: (event) => setDifferentBasket(event.target.value), type: "number", value: differentBasket, slotProps: { htmlInput: { inputMode: "numeric", min: 1 } } }), _jsx(Button, { disabled: !validDifferentBasket, onClick: () => void correct(createCorrection(parsedDifferentBasket)), variant: "contained", children: "Save correction" })] })) : null, correctionSubmission?.state === "accepted" ? (_jsx(Alert, { severity: "success", children: "Correction recorded." })) : correctionSubmission?.state === "conflict" ? (_jsx(Alert, { severity: "warning", children: "Basket status changed. Review the refreshed status." })) : correctionSubmission?.state === "error" ? (_jsx(Alert, { action: _jsx(Button, { color: "inherit", onClick: () => void correct(correctionSubmission.command), children: "Retry correction" }), severity: "error", children: "Unable to correct the recorded arrival." })) : null] })) : submission?.state === "conflict" ? (_jsx(Alert, { severity: "warning", children: "Basket movement changed. Review the refreshed instruction." })) : submission?.state === "error" ? (_jsx(Alert, { action: _jsx(Button, { onClick: () => void record(submission.command), color: "inherit", children: "Retry arrival" }), severity: "error", children: submission.message })) : null] }) }));
 }

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

@@ -172,7 +172,9 @@ export const BulkAddCastingWithoutSerialDialog = memo(function BulkAddCastingWit
                                     enteredQty === null ||
                                     isNaN(enteredQty) ||
                                     (fmsInfo.requireOperatorNamePromptWhenAddingMaterial &&
-                                        (enteredOperator === null || enteredOperator === "")), onClick: addAndPrint, children: [adding ? _jsx(CircularProgress, { size: 10 }) : undefined, "Add ", enteredQty !== null && !isNaN(enteredQty) ? enteredQty.toString() + " " : "", "to", " ", queue] })) : (_jsxs(Button, { color: "primary", disabled: selectedCasting === null ||
+                                        (enteredOperator === null || enteredOperator === "")), onClick: addAndPrint, children: [adding ? _jsx(CircularProgress, { size: 10 }) : undefined, "Add ", enteredQty !== null && !isNaN(enteredQty)
+                                        ? enteredQty.toString() + " "
+                                        : "", "to", " ", queue] })) : (_jsxs(Button, { color: "primary", disabled: selectedCasting === null ||
                                     enteredQty === null ||
                                     isNaN(enteredQty) ||
                                     (fmsInfo.requireOperatorNamePromptWhenAddingMaterial &&
@@ -191,22 +193,31 @@ export const MultiMaterialDialog = memo(function MultiMaterialDialog(props) {
         if (props.material === null)
             return;
         let isSubscribed = true;
-        setLoading(true);
-        loadRawMaterialEvents(props.material)
-            .then((loadedEvents) => {
-            if (isSubscribed) {
-                setEvents(loadedEvents);
-                let operator;
-                for (const e of loadedEvents) {
-                    if (e.type === api.LogType.AddToQueue && e.details?.["operator"] !== undefined) {
-                        operator = e.details["operator"];
+        const fetchData = async () => {
+            if (props.material === null)
+                return;
+            setLoading(true);
+            try {
+                const loadedEvents = await loadRawMaterialEvents(props.material);
+                if (isSubscribed) {
+                    setEvents(loadedEvents);
+                    let operator;
+                    for (const e of loadedEvents) {
+                        if (e.type === api.LogType.AddToQueue && e.details?.["operator"] !== undefined) {
+                            operator = e.details["operator"];
+                        }
                     }
+                    setLastOperator(operator);
                 }
-                setLastOperator(operator);
             }
-        })
-            .catch(console.error)
-            .finally(() => setLoading(false));
+            catch (e) {
+                console.error(e);
+            }
+            finally {
+                setLoading(false);
+            }
+        };
+        fetchData().catch(console.error);
         return () => {
             isSubscribed = false;
         };

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

@@ -56,5 +56,7 @@ export function CancelLoadButton({ onClose, ignoreOperator = false, }) {
                         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" })] })] })] }));
+                    }, 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, index) => (_jsx("li", { children: candidate.materialID < 0
+                                        ? `${candidate.partName} raw material`
+                                        : candidate.serial || `Material ID ${candidate.materialID}` }, candidate.materialID >= 0 ? candidate.materialID : `raw-${index}`))) }), _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/InvalidateCycle.d.ts

@@ -1,6 +1,5 @@
-import { IInProcessMaterial, ILogEntry } from "../../network/api.js";
+import { 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;
@@ -19,18 +18,3 @@ export declare function InvalidateCycleDialogButton(props: InvalidateCycleProps
     readonly ignoreOperator?: boolean;
     readonly loadStation?: boolean;
 }): import("react").JSX.Element | null;
-interface SwapMaterial {
-    readonly selectedMatToSwap: Readonly<IInProcessMaterial> | null;
-    readonly updating: boolean;
-}
-export type SwapMaterialState = SwapMaterial | null;
-export interface SwapMaterialProps {
-    readonly st: SwapMaterialState;
-    readonly setState: (s: SwapMaterialState) => void;
-}
-export declare function SwapMaterialDialogContent(props: SwapMaterialProps): ReactNode;
-export declare function SwapMaterialButtons(props: SwapMaterialProps & {
-    readonly onClose: () => void;
-    readonly ignoreOperator?: boolean;
-}): import("react").JSX.Element | null;
-export {};

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

@@ -47,14 +47,12 @@ import { last30Jobs } from "../../cell-status/scheduled-jobs.js";
 import { PartIdenticon } from "./Material.js";
 import { isLogEntryInvalidated } from "../LogEntry.js";
 import { ApiException } from "../../network/api.js";
-import { canInvalidateMaterial, isActiveLoadStationOperation, } from "../../data/material-operation-policy.js";
+import { canInvalidateMaterial } from "../../data/material-operation-policy.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();
@@ -150,7 +148,7 @@ export function InvalidateCycleDialogContent(props) {
             behavior: "smooth",
             block: "end",
         });
-    }, [boxRef, show]);
+    }, [boxRef]);
     if (!show)
         return _jsx("div", {});
     const hasSelection = props.st.process !== null ||
@@ -245,91 +243,3 @@ export function InvalidateCycleDialogButton(props) {
                                 : "Invalidate Process " + props.st.process.toString()
                             : "Invalidate Cycle" })) : undefined] }));
 }
-function isNullOrEmpty(s) {
-    return s === undefined || s === null || s == "";
-}
-function matCanSwap(curMat, job) {
-    return (newMat) => {
-        if (isNullOrEmpty(newMat.serial))
-            return false;
-        if (newMat.location.type === LocType.OnPallet)
-            return false;
-        if (newMat.process !== curMat.process - 1)
-            return false;
-        if (isNullOrEmpty(newMat.jobUnique)) {
-            // if part name is wrong, check casting
-            if (isNullOrEmpty(newMat.partName))
-                return false;
-            if (newMat.partName !== curMat.partName) {
-                if (!job)
-                    return false;
-                if (!LazySeq.of(job.procsAndPaths)
-                    .flatMap((p) => p.paths)
-                    .some((p) => p.casting === newMat.partName)) {
-                    return false;
-                }
-            }
-        }
-        else {
-            // check path
-            if (newMat.jobUnique !== curMat.jobUnique)
-                return false;
-            if (newMat.path !== curMat.path)
-                return false;
-        }
-        return true;
-    };
-}
-export function SwapMaterialDialogContent(props) {
-    const status = useAtomValue(currentStatus);
-    const curMat = useAtomValue(inProcessMaterialInDialog);
-    if (curMat === null || props.st === null)
-        return _jsx("div", {});
-    const curMatJob = status.jobs[curMat.jobUnique];
-    const availMats = status.material.filter(matCanSwap(curMat, curMatJob));
-    if (availMats.length === 0) {
-        return (_jsx("p", { style: { margin: "2em" }, children: "No material with the same job is available for swapping. You must edit the pallet using the cell controller software to remove the material from the pallet. Insight will automatically refresh once the cell controller software is updated." }));
-    }
-    else {
-        return (_jsxs("div", { style: { margin: "2em" }, children: [_jsx("p", { children: "Swap serial on pallet with material from the same job." }), _jsx("p", { children: "If material on the pallet is from a different job, you cannot use this screen. Instead, the material must first be removed from the pallet using the cell controller software. Insight will automatically refresh when this occurs." }), _jsx(TextField, { value: props.st?.selectedMatToSwap?.serial ?? "", select: true, onChange: (e) => props.st &&
-                        props.setState({
-                            ...props.st,
-                            selectedMatToSwap: availMats.find((m) => m.serial === e.target.value) ?? null,
-                        }), style: { width: "20em" }, variant: "outlined", label: "Select serial to swap with " + (curMat.serial ?? ""), children: availMats.map((m) => (_jsx(MenuItem, { value: m.serial, children: m.serial }, m.materialID))) })] }));
-    }
-}
-export function SwapMaterialButtons(props) {
-    const fmsInfo = useAtomValue(fmsInformation);
-    const curMat = useAtomValue(inProcessMaterialInDialog);
-    const closeMatDialog = useSetAtom(materialDialogOpen);
-    let operator = useAtomValue(currentOperator);
-    if (!fmsInfo.allowSwapSerialAtLoadStation)
-        return null;
-    if (props.ignoreOperator)
-        operator = null;
-    if (!curMat ||
-        curMat.location.type !== LocType.OnPallet ||
-        isActiveLoadStationOperation(curMat)) {
-        return null;
-    }
-    function swapMats() {
-        if (curMat &&
-            props.st &&
-            props.st.selectedMatToSwap &&
-            curMat.location.type === LocType.OnPallet) {
-            props.setState({ selectedMatToSwap: props.st.selectedMatToSwap, updating: true });
-            JobsBackend.swapMaterialOnPallet(curMat.materialID, operator, {
-                pallet: curMat.location.palletNum ?? 0,
-                materialIDToSetOnPallet: props.st.selectedMatToSwap.materialID,
-            })
-                .catch(console.log)
-                .finally(() => {
-                closeMatDialog(null);
-                props.onClose();
-            });
-        }
-    }
-    return (_jsxs(_Fragment, { children: [props.st === null ? (_jsx(Button, { color: "primary", onClick: () => props.setState({ selectedMatToSwap: null, updating: false }), children: "Swap Serial" })) : undefined, props.st !== null ? (_jsx(Button, { color: "primary", onClick: swapMats, disabled: props.st.selectedMatToSwap === null || props.st.updating, children: props.st.selectedMatToSwap === null
-                    ? "Swap Serial"
-                    : "Swap with " + (props.st.selectedMatToSwap.serial ?? "") })) : undefined] }));
-}

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

@@ -33,7 +33,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 import { useMemo, memo, useState, useCallback, useEffect } from "react";
 import { Box, useMediaQuery, Button, Typography } from "@mui/material";
-import { LazySeq, mkCompareByProperties, OrderedMap } from "@seedtactics/immutable-collections";
+import { LazySeq, OrderedMap } from "@seedtactics/immutable-collections";
 import { FolderOpen as FolderOpenIcon } from "@mui/icons-material";
 import { MaterialDialog, InProcMaterial, SortableInProcMaterial, DragOverlayInProcMaterial, MatSummary, } from "./Material.js";
 import { SortableRegion } from "./Whiteboard.js";
@@ -54,7 +54,7 @@ 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";
+import { InvalidateCycleDialogButton, InvalidateCycleDialogContent, } from "./InvalidateCycle.js";
 import { last30MaterialSummary } from "../../cell-status/material-summary.js";
 import { addHours } from "date-fns";
 import { PromptForQueue } from "./QueuesAddMaterial.js";
@@ -103,12 +103,13 @@ function selectLoadStationAndQueueProps(loadNum, queues, curSt, hideNonLoading)
             }
         }
         for (const basket of Object.values(curSt.baskets ?? {})) {
-            if (basket.position.locationNum !== loadNum)
+            const position = basket.position;
+            if (position === undefined || position.locationNum !== loadNum)
                 continue;
-            if (basket.position.location === api.BasketLocationEnum.LoadUnload) {
+            if (position.location === api.BasketLocationEnum.LoadUnload) {
                 activeBasket = basket;
             }
-            else if (basket.position.location === api.BasketLocationEnum.LoadStationStaging) {
+            else if (position.location === api.BasketLocationEnum.LoadStationStaging) {
                 basketsToShow.add(basket.basketId);
             }
         }
@@ -282,8 +283,24 @@ function selectLoadStationAndQueueProps(loadNum, queues, curSt, hideNonLoading)
             }
         }
     }
-    queueMat.forEach((queue) => queue.mats.sort(mkCompareByProperties((mat) => mat.location.queuePosition ?? 0)));
-    basketMat.forEach((basket) => basket.mats.sort(mkCompareByProperties((mat) => mat.location.basketSlot ?? 0)));
+    const sortedQueueMat = new Map([...queueMat].map(([queueName, queue]) => [
+        queueName,
+        {
+            ...queue,
+            mats: LazySeq.of(queue.mats)
+                .sortBy((mat) => mat.location.queuePosition ?? 0)
+                .toRArray(),
+        },
+    ]));
+    const sortedBasketMat = new Map([...basketMat].map(([basketId, basket]) => [
+        basketId,
+        {
+            ...basket,
+            mats: LazySeq.of(basket.mats)
+                .sortBy((mat) => mat.location.basketSlot ?? 0)
+                .toRArray(),
+        },
+    ]));
     const matCount = freeLoading.length + palFaces.valuesToAscLazySeq().sumBy((x) => x.length);
     const activeBasketSlotCount = activeBasket
         ? LazySeq.of(activeBasket.emptySlots ?? [])
@@ -306,8 +323,8 @@ function selectLoadStationAndQueueProps(loadNum, queues, curSt, hideNonLoading)
         allMaterial: curSt.material,
         face: palFaces,
         freeLoadingMaterial: freeLoading,
-        queues: queueMat,
-        baskets: basketMat,
+        queues: sortedQueueMat,
+        baskets: sortedBasketMat,
         elapsedLoadingTime,
         fsize: layoutCount <= 2 ? "x-large" : layoutCount <= 6 ? "large" : "normal",
     };
@@ -320,7 +337,7 @@ function MultiInstructionButton({ loadData }) {
         if (pal) {
             return LazySeq.of(loadData.face.values())
                 .append(loadData.freeLoadingMaterial)
-                .concat(LazySeq.of(loadData.queues).collect(([_, v]) => v.mats))
+                .concat(LazySeq.of(loadData.queues).collect(([, v]) => v.mats))
                 .flatMap((x) => x)
                 .collect((mat) => {
                 if (mat.action.type === api.ActionType.Loading &&
@@ -608,18 +625,16 @@ function AssignWorkorderButton() {
     return (_jsx(Button, { color: "primary", onClick: () => setWorkorderDialogOpen(true), children: "Assign Workorder" }));
 }
 const LoadMatDialog = memo(function LoadMatDialog(props) {
-    const [swapSt, setSwapSt] = useState(null);
     const [invalidateSt, setInvalidateSt] = useState(null);
     // add material state
     const [showAddMaterial, setShowAddMaterial] = useState(false);
     const [selectedQueue, setSelectedQueue] = useState(null);
     const onClose = useCallback(function onClose() {
-        setSwapSt(null);
         setInvalidateSt(null);
         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(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, {})] }) }));
+    }, [setInvalidateSt]);
+    return (_jsx(MaterialDialog, { onClose: onClose, allowNote: true, highlightProcsGreaterOrEqualTo: invalidateSt?.process ?? undefined, extraDialogElements: _jsxs(_Fragment, { children: [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(InvalidateCycleDialogButton, { st: invalidateSt, setState: setInvalidateSt, onClose: onClose, loadStation: true }), _jsx(AssignWorkorderButton, {})] }) }));
 });
 function useGridLayout({ numMatCols, maxNumFaces, horizontal, showMatInCompleted, }) {
     let rows = "";
@@ -670,8 +685,11 @@ export function LoadStation(props) {
         if (recentArrivalReceipt !== undefined &&
             (recentArrivalReceipt.stationNumber !== props.loadNum ||
                 (arrivalInstruction !== undefined &&
-                    arrivalInstruction.instructionId !== recentArrivalReceipt.instruction.instructionId)))
+                    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 &&
@@ -679,7 +697,7 @@ export function LoadStation(props) {
         ? recentArrivalReceipt
         : undefined;
     const queueCols = LazySeq.of(data.queues)
-        .sortBy(([q, _]) => q)
+        .sortBy(([q]) => q)
         .map(([q, mats]) => ({
         kind: "queue",
         label: q,
@@ -689,8 +707,8 @@ export function LoadStation(props) {
     const matCols = [...queueCols];
     if (data.baskets.size > 0) {
         const baskets = LazySeq.of(data.baskets)
-            .filter(([b, _]) => b !== data.activeBasket?.basketId)
-            .sortBy(([b, _]) => b)
+            .filter(([b]) => b !== data.activeBasket?.basketId)
+            .sortBy(([b]) => b)
             .map(([b, mats]) => ({
             basketId: b,
             label: `${basketName} ${b}`,