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

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

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

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

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

package/dist/components/LogEntry.js

@@ -48,7 +48,7 @@ import { useAtomValue } from "jotai";
 import { fmsInformation } from "../network/server-settings.js";
 import { basketDisplayName, loadStationDisplayName } from "../cell-status/station-cycles.js";
 import { filterRemoveAddQueue } from "./log-entry-queue-filter.js";
-import { basketContainerName } from "./log-entry-container-name.js";
+import { basketContainerName, basketCycleDescription } from "./log-entry-container-name.js";
 const ColoredSpan = styled("span", { shouldForwardProp: (prop) => prop.toString()[0] !== "$" })(({ $type }) => {
     switch ($type) {
         case "machine":
@@ -191,14 +191,7 @@ function display(props, fmsInfo) {
         }
         case api.LogType.BasketCycle: {
             const basketName = basketDisplayName(fmsInfo.basketName);
-            if (entry.startofcycle) {
-                return (_jsxs("span", { children: [basketName, " ", entry.pal, " started cycle"] }));
-            }
-            else {
-                return (_jsxs("span", { children: [basketName, " ", entry.pal, " completed cycle", entry.containerIds && entry.containerIds.length > 0
-                            ? ` from ${entry.containerIds.length} UUID fragment${entry.containerIds.length === 1 ? "" : "s"}`
-                            : ""] }));
-            }
+            return _jsx("span", { children: basketCycleDescription(entry, basketName) });
         }
         case api.LogType.BasketInLocation: {
             const basketName = basketDisplayName(fmsInfo.basketName);

package/dist/components/log-entry-container-name.d.ts

@@ -1,4 +1,6 @@
 import * as api from "../network/api.js";
 type ContainerNameEntry = Readonly<Pick<api.ILogEntry, "pal" | "containerId">>;
+type BasketCycleEntry = ContainerNameEntry & Readonly<Pick<api.ILogEntry, "startofcycle" | "containerIds">>;
 export declare function basketContainerName(entry: ContainerNameEntry, basketName: string): string;
+export declare function basketCycleDescription(entry: BasketCycleEntry, basketName: string): string;
 export {};

package/dist/components/log-entry-container-name.js

@@ -5,3 +5,13 @@ export function basketContainerName(entry, basketName) {
         return `${basketName} ${entry.pal}`;
     return basketName;
 }
+export function basketCycleDescription(entry, basketName) {
+    const container = basketContainerName(entry, basketName);
+    if (entry.startofcycle)
+        return `${container} started cycle`;
+    const fragmentCount = entry.containerIds?.length ?? 0;
+    const fragments = fragmentCount > 0
+        ? ` from ${fragmentCount} UUID fragment${fragmentCount === 1 ? "" : "s"}`
+        : "";
+    return `${container} completed cycle${fragments}`;
+}

package/dist/components/operations/AllMaterial.js

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

package/dist/components/operations/Programs.js

@@ -249,7 +249,7 @@ export function ProgramSummaryTable() {
 function ProgramContentCode() {
     const ct = useAtomValue(programContent);
     const [highlighted, setHighlighted] = useState(null);
-    const worker = useMemo(() => new Worker(new URL("./ProgramHighlight.ts", import.meta.url), { type: "module" }), []);
+    const worker = useMemo(() => new Worker(new URL("./ProgramHighlight.js", import.meta.url), { type: "module" }), []);
     useEffect(() => {
         let set = (h) => setHighlighted(h);
         const handleMessage = (event) => set(event.data);

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

@@ -28,81 +28,86 @@ 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 { useEffect, useMemo, useState } from "react";
+import { useMemo, useState } from "react";
 import { Alert, Box, Button, Card, CardContent, Stack, Typography } from "@mui/material";
 import { LazySeq } from "@seedtactics/immutable-collections";
 import * as api from "../../network/api.js";
 import { InProcMaterial } from "./Material.js";
 import { MoveMaterialArrowNode } from "./MoveMaterialArrows.js";
 import { MoveMaterialNodeKindType } from "../../data/move-arrows.js";
-function isNonNegativeInteger(value) {
-    return Number.isInteger(value) && (value ?? -1) >= 0;
+function isPositiveInteger(value) {
+    return Number.isInteger(value) && (value ?? 0) > 0;
 }
 function isNonBlank(value) {
     return typeof value === "string" && value.trim() !== "";
 }
-function actionPhase(mat, basketId) {
+function basketAction(mat, basketId) {
     if (mat.location.type === api.LocType.InBasket &&
         mat.location.basketId === basketId &&
         (mat.action.type === api.ActionType.UnloadToInProcess ||
             mat.action.type === api.ActionType.UnloadToCompletedMaterial)) {
-        if (!isNonNegativeInteger(mat.location.basketSlot)) {
-            return "invalid";
+        if (!isPositiveInteger(mat.location.basketSlot)) {
+            return { type: "invalid" };
         }
-        return "unload";
+        return { type: "valid", workId: mat.action.workId };
     }
     if (mat.action.type === api.ActionType.LoadingToBasket) {
-        if (!isNonNegativeInteger(mat.action.loadToBasketId))
-            return "invalid";
+        if (!isPositiveInteger(mat.action.loadToBasketId))
+            return { type: "invalid" };
         if (mat.action.loadToBasketId !== basketId)
             return undefined;
-        if (!isNonNegativeInteger(mat.action.loadToBasketSlot) ||
-            (mat.location.type !== api.LocType.Free &&
+        const reloadsSameSlot = mat.location.type === api.LocType.InBasket &&
+            mat.location.basketId === basketId &&
+            mat.location.basketSlot === mat.action.loadToBasketSlot;
+        if (!isPositiveInteger(mat.action.loadToBasketSlot) ||
+            (!reloadsSameSlot &&
+                mat.location.type !== api.LocType.Free &&
                 (mat.location.type !== api.LocType.InQueue || !isNonBlank(mat.location.currentQueue)))) {
-            return "invalid";
+            return { type: "invalid" };
         }
-        return "load";
+        return { type: "valid", workId: mat.action.workId };
     }
     return undefined;
 }
 function confirmableWork(material, basketId) {
     const classifiedActions = LazySeq.of(material)
-        .collect((mat) => {
-        const phase = actionPhase(mat, basketId);
-        return phase === undefined ? undefined : { phase, workId: mat.action.workId };
-    })
+        .collect((mat) => basketAction(mat, basketId))
         .toRArray();
-    if (classifiedActions.some(({ phase }) => phase === "invalid")) {
+    if (classifiedActions.some((action) => action.type === "invalid")) {
         return { type: "inconsistent" };
     }
-    const phaseActions = classifiedActions.filter((action) => action.phase !== "invalid");
-    if (phaseActions.length === 0)
+    const validActions = classifiedActions.filter((action) => action.type === "valid");
+    if (validActions.length === 0)
         return { type: "none" };
-    const tagged = phaseActions.filter((action) => isNonBlank(action.workId));
+    const tagged = validActions.filter((action) => isNonBlank(action.workId));
     const workIds = LazySeq.of(tagged).toHashSet(({ workId }) => workId);
-    const phases = LazySeq.of(tagged).toHashSet(({ phase }) => phase);
-    if (tagged.length !== phaseActions.length || workIds.size !== 1 || phases.size !== 1) {
+    if (tagged.length !== validActions.length || workIds.size !== 1) {
         return { type: "inconsistent" };
     }
     return {
         type: "confirmable",
-        work: { workId: tagged[0].workId, phase: tagged[0].phase },
+        work: { workId: tagged[0].workId },
     };
 }
-function loadingSource(mat) {
+function loadingInstruction(mat) {
+    if (mat.location.type === api.LocType.InBasket &&
+        mat.location.basketId === mat.action.loadToBasketId &&
+        mat.location.basketSlot === mat.action.loadToBasketSlot) {
+        return "Unload, re-plate, and reload this slot";
+    }
     if (mat.location.type === api.LocType.InQueue && mat.location.currentQueue) {
-        return mat.location.currentQueue;
+        return `Load from ${mat.location.currentQueue}`;
     }
-    return "raw material";
+    return "Load from raw material";
 }
 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, }) {
-    const [submission, setSubmission] = useState("idle");
+    const [submission, setSubmission] = useState();
     const workState = useMemo(() => confirmableWork(material, basket.basketId), [basket.basketId, material]);
     const work = workState.type === "confirmable" ? workState.work : undefined;
-    useEffect(() => setSubmission("idle"), [work?.workId]);
+    const submissionState = submission !== undefined && submission.workId === work?.workId ? submission.state : "idle";
     const materialBySlot = useMemo(() => LazySeq.of(material)
         .filter((mat) => mat.location.type === api.LocType.InBasket &&
         mat.location.basketId === basket.basketId &&
@@ -124,16 +129,19 @@ export function BasketLoadStationWorkflow({ stationNumber, basket, material, fsi
     async function submit() {
         if (work === undefined || submitCommand === undefined)
             return;
-        setSubmission("submitting");
+        const submittedWorkId = work.workId;
+        setSubmission({ workId: submittedWorkId, state: "submitting" });
         try {
-            setSubmission(await submitCommand(stationNumber, { workId: work.workId }));
+            const state = await submitCommand(stationNumber, { workId: submittedWorkId });
+            setSubmission((current) => current?.workId === submittedWorkId ? { workId: submittedWorkId, state } : current);
         }
         catch {
-            setSubmission("error");
+            setSubmission((current) => current?.workId === submittedWorkId ? { workId: submittedWorkId, state: "error" } : current);
         }
     }
-    const submissionDisabled = submission === "submitting" || submission === "accepted" || submission === "conflict";
-    const buttonLabel = work?.phase === "unload" ? "Unload Complete" : "Load Complete";
+    const submissionDisabled = 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: {
                     display: "grid",
                     gridTemplateColumns: "repeat(auto-fit, minmax(15em, 1fr))",
@@ -142,6 +150,6 @@ export function BasketLoadStationWorkflow({ stationNumber, basket, material, fsi
                     const slotMaterial = materialBySlot.get(slot) ?? [];
                     const loads = loadsBySlot.get(slot) ?? [];
                     const isUnknown = basket.unknownSlots?.includes(slot) === true;
-                    return (_jsx(Card, { "data-testid": `basket-load-station-slot-${slot}`, variant: "outlined", children: _jsxs(CardContent, { children: [_jsxs(Typography, { variant: "h6", children: ["Slot ", slot + 1] }), 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: [_jsxs(Typography, { children: ["Load from ", loadingSource(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: buttonLabel }) })) : 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, submission === "accepted" ? (_jsx(Alert, { severity: "success", children: "Confirmation accepted. Waiting for refreshed work." })) : submission === "conflict" ? (_jsx(Alert, { severity: "warning", children: "Basket work changed before confirmation. Review the refreshed slots and try again." })) : submission === "error" ? (_jsx(Alert, { severity: "error", children: "Unable to confirm basket work. No work was assumed complete." })) : null] }));
+                    return (_jsx(Card, { "data-testid": `basket-load-station-slot-${slot}`, variant: "outlined", children: _jsxs(CardContent, { 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] }));
 }

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

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

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

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

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

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

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

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

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

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

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

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