@seedtactics/insight-client 17.0.0-beta.0 → 17.0.0-beta.2

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

@@ -2,6 +2,7 @@ import { Atom } from "jotai";
 import { ServerEventAndTime } from "./loading";
 import { ILogEntry, IRebooking, IRecentHistoricData } from "../network/api";
 import { OrderedMap } from "@seedtactics/immutable-collections";
+export declare function mapUnscheduledRebookings(bookings: ReadonlyArray<Readonly<IRebooking>> | null | undefined): OrderedMap<string, Readonly<IRebooking>>;
 export declare const last30Rebookings: Atom<OrderedMap<string, Readonly<IRebooking>>>;
 export declare const canceledRebookings: Atom<OrderedMap<string, Date>>;
 type ScheduledBooking = {

package/dist/cell-status/rebookings.js

@@ -46,8 +46,11 @@ const unschRebookings = unwrap(atom(async (_, { signal }) => {
         return OrderedMap.empty();
     }
     const bookings = await JobsBackend.unscheduledRebookings(signal);
-    return OrderedMap.build(bookings, (booking) => booking.bookingId);
+    return mapUnscheduledRebookings(bookings);
 }), (prev) => prev ?? OrderedMap.empty());
+export function mapUnscheduledRebookings(bookings) {
+    return OrderedMap.build(bookings ?? [], (booking) => booking.bookingId);
+}
 export const last30Rebookings = atom((get) => {
     const evts = get(rebookingEvts);
     const unsch = get(unschRebookings);

package/dist/components/App.d.ts

@@ -2,6 +2,7 @@ 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,6 +13,8 @@ export interface AppProps {
     };
     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 }));
+                page = (_jsx(LoadStation, { loadNum: route.loadNum, queues: route.queues, completed: route.completed, submitBasketLoadStationCommand: props.submitBasketLoadStationCommand, submitBasketMovementCompletion: props.submitBasketMovementCompletion, submitBasketLocationCorrection: props.submitBasketLocationCorrection }, route.loadNum));
                 nav1 = StationToolbar;
                 nav2 = StationToolbarOverviewButton;
                 showOperator = true;

package/dist/components/LogEntry.js

@@ -93,10 +93,22 @@ function logType(entry, fmsInfo) {
             else {
                 return "Depart";
             }
-        case api.LogType.BasketIdentityHint:
-            return `${basketName} Identity Hint`;
+        case api.LogType.BasketIdentityAssociation:
+            return `${basketName} Identity Association`;
+        case api.LogType.BasketIdentityAssociationCorrection:
+            return `${basketName} Identity Correction`;
         case api.LogType.BasketContentSnapshot:
             return `${basketName} Content Snapshot`;
+        case api.LogType.BasketLocationObservation:
+            return `${basketName} Location Observation`;
+        case api.LogType.BasketLocationObservationCorrection:
+            return `${basketName} Location Correction`;
+        case api.LogType.BasketRegionSurvey:
+            return `${basketName} Region Survey`;
+        case api.LogType.BasketMisload:
+            return `${basketName} Inspection Hold`;
+        case api.LogType.BasketMisloadResolution:
+            return `${basketName} Inspection Resolution`;
         case api.LogType.MachineCycle:
             if (entry.startofcycle) {
                 return "Start Cycle";
@@ -141,6 +153,12 @@ function logType(entry, fmsInfo) {
             return "Message";
     }
 }
+function evidencePosition(entry) {
+    const title = entry.details?.locationTitle ?? entry.details?.location ?? entry.loc;
+    const locationNumber = entry.locnum > 0 ? ` ${entry.locnum}` : "";
+    const zone = entry.details?.zone === undefined ? "" : ` zone ${entry.details.zone}`;
+    return `${title}${locationNumber}${zone}`;
+}
 export function isLogEntryInvalidated(e) {
     return e.details?.["PalletCycleInvalidated"] === "1";
 }
@@ -202,14 +220,57 @@ function display(props, fmsInfo) {
                 return (_jsxs("span", { children: [basketContainerName(entry, basketName), " departed from ", entry.loc, entry.locnum > 0 ? ` position ${entry.locnum}` : ""] }));
             }
         }
-        case api.LogType.BasketIdentityHint: {
+        case api.LogType.BasketIdentityAssociation: {
+            const basketName = basketDisplayName(fmsInfo.basketName);
+            const episodeCount = entry.details?.episodeCount;
+            const source = entry.details?.sourceName;
+            const note = entry.details?.note;
+            return (_jsxs("span", { children: [source === undefined ? "" : `${source} recorded `, episodeCount === undefined
+                        ? `content episodes associated with ${basketName} ${entry.pal}`
+                        : `${episodeCount} content episode${episodeCount === "1" ? "" : "s"} associated with ${basketName} ${entry.pal}`, entry.details?.location === undefined && entry.details?.locationTitle === undefined
+                        ? ""
+                        : ` at ${evidencePosition(entry)}`, note === undefined ? "" : `: ${note}`] }));
+        }
+        case api.LogType.BasketIdentityAssociationCorrection: {
             const basketName = basketDisplayName(fmsInfo.basketName);
-            return (_jsxs("span", { children: [basketContainerName(entry, basketName), " presently associated with ", basketName, " ", entry.pal] }));
+            return (_jsxs("span", { children: ["Identity association for ", basketName, " ", entry.pal, " corrected"] }));
         }
         case api.LogType.BasketContentSnapshot: {
             const basketName = basketDisplayName(fmsInfo.basketName);
             return (_jsxs("span", { children: [basketContainerName(entry, basketName), " contained ", displayMat(entry.material)] }));
         }
+        case api.LogType.BasketLocationObservation: {
+            const basketName = basketDisplayName(fmsInfo.basketName);
+            const operator = entry.details?.sourceName ?? entry.details?.operator ?? "Operator";
+            return (_jsxs("span", { children: [operator, " observed ", basketName, " ", entry.pal, " at ", evidencePosition(entry)] }));
+        }
+        case api.LogType.BasketLocationObservationCorrection: {
+            const basketName = basketDisplayName(fmsInfo.basketName);
+            const operator = entry.details?.sourceName ?? entry.details?.operator ?? "Operator";
+            const location = evidencePosition(entry);
+            const replacementBasketId = entry.details?.replacementBasketId;
+            return replacementBasketId === undefined ? (_jsxs("span", { children: [operator, " retracted the observation of ", basketName, " ", entry.pal, " at ", location] })) : (_jsxs("span", { children: [operator, " changed the observation of ", basketName, " ", entry.pal, " at ", location, " to", " ", basketName, " ", replacementBasketId, " at ", location] }));
+        }
+        case api.LogType.BasketRegionSurvey: {
+            const basketName = basketDisplayName(fmsInfo.basketName);
+            const source = entry.details?.sourceName;
+            const observed = entry.details?.observedBasketCount;
+            const unidentified = entry.details?.unidentifiedBasketCount;
+            return (_jsxs("span", { children: [source === undefined ? "Operator" : source, " recorded a ", entry.result.toLowerCase(), " ", basketName.toLowerCase(), " survey at ", evidencePosition(entry), observed === undefined ? "" : ` (${observed} identified`, unidentified === undefined ? "" : `, ${unidentified} unidentified`, observed === undefined && unidentified === undefined ? "" : ")"] }));
+        }
+        case api.LogType.BasketMisload: {
+            const basketName = basketDisplayName(fmsInfo.basketName);
+            const source = entry.details?.sourceName;
+            const reason = entry.details?.reason;
+            const subject = entry.pal > 0 ? `${basketName} ${entry.pal}` : `Unnumbered ${basketName.toLowerCase()}`;
+            return (_jsxs("span", { children: [source === undefined ? subject : `${source} reported ${subject}`, " requires inspection at", " ", evidencePosition(entry), reason === undefined ? "" : `: ${reason}`] }));
+        }
+        case api.LogType.BasketMisloadResolution: {
+            const basketName = basketDisplayName(fmsInfo.basketName);
+            const source = entry.details?.sourceName;
+            const subject = entry.pal > 0 ? `${basketName} ${entry.pal}` : `Unnumbered ${basketName.toLowerCase()}`;
+            return (_jsxs("span", { children: [source === undefined ? "Inspection hold" : `${source} resolved inspection hold`, " for", " ", subject, " at ", evidencePosition(entry), ": ", entry.result] }));
+        }
         case api.LogType.MachineCycle:
             return (_jsxs("span", { children: [displayMat(entry.material), " on", " ", _jsxs(ColoredSpan, { $type: "pallet", children: ["pallet ", entry.pal] }), " at", " ", _jsxs(ColoredSpan, { $type: "machine", children: [entry.loc, " ", entry.locnum.toString()] }), entry.program && entry.program !== "" ? (_jsxs("span", { children: [" with program ", entry.program] })) : undefined] }));
         case api.LogType.PartMark:

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

@@ -29,7 +29,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 import { useMemo, useState } from "react";
-import { Alert, Box, Button, Card, CardContent, Stack, Typography } from "@mui/material";
+import { Alert, Box, Button, Stack, Typography } from "@mui/material";
 import { LazySeq } from "@seedtactics/immutable-collections";
 import * as api from "../../network/api.js";
 import { InProcMaterial } from "./Material.js";
@@ -150,6 +150,10 @@ 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] }), 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));
+                    return (_jsx(MoveMaterialArrowNode, { kind: {
+                            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] }));
 }

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

@@ -0,0 +1,38 @@
+import * as api from "../../network/api.js";
+export interface BasketMovementCompletionCommand {
+    readonly commandId: string;
+    readonly instructionId: string;
+    readonly observedBasketId: number;
+}
+export interface BasketMovementCompletionReceipt {
+    readonly stationNumber: number;
+    readonly instructionId: string;
+    readonly observationId: string;
+    readonly observedBasketId: number;
+}
+export type SubmitBasketMovementCompletion = (stationNumber: number, command: BasketMovementCompletionCommand) => Promise<BasketMovementCompletionReceipt | "conflict">;
+export interface BasketLocationCorrectionCommand {
+    readonly correctionId: string;
+    readonly targetObservationId: string;
+    readonly replacementBasketId: number | null;
+    readonly replacementObservationId: string | null;
+}
+export type SubmitBasketLocationCorrection = (stationNumber: number, command: BasketLocationCorrectionCommand) => Promise<"accepted" | "conflict">;
+export interface BasketArrivalReceipt {
+    readonly stationNumber: number;
+    readonly instruction: Readonly<api.IBasketMoveInstruction>;
+    readonly command: BasketMovementCompletionCommand;
+    readonly receipt: BasketMovementCompletionReceipt;
+    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, }: {
+    readonly stationNumber: number;
+    readonly basketName: string;
+    readonly instruction: Readonly<api.IBasketMoveInstruction>;
+    readonly submitCommand: SubmitBasketMovementCompletion | undefined;
+    readonly submitCorrection: SubmitBasketLocationCorrection | undefined;
+    readonly receipt?: BasketArrivalReceipt;
+    readonly onAccepted?: (receipt: BasketArrivalReceipt) => void;
+    readonly onCorrected?: (command: BasketLocationCorrectionCommand) => void;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,175 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/* Copyright (c) 2026, John Lenz
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of John Lenz, Black Maple Software, SeedTactics,
+      nor the names of other contributors may be used to endorse or
+      promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+import { useEffect, useRef, useState } from "react";
+import { Alert, Box, Button, Paper, Stack, TextField, Typography } from "@mui/material";
+import * as api from "../../network/api.js";
+export function loadStationArrivalInstruction(instructions, stationNumber) {
+    const activeIds = new Set(instructions.map((instruction) => instruction.instructionId));
+    return instructions.find((instruction) => instruction.basketId !== undefined &&
+        instruction.destination.location === api.BasketLocationEnum.LoadUnload &&
+        instruction.destination.locationNum === stationNumber &&
+        (instruction.prerequisiteInstructionId === undefined ||
+            !activeIds.has(instruction.prerequisiteInstructionId)));
+}
+export function BasketMovementArrival({ stationNumber, basketName, instruction, submitCommand, submitCorrection, receipt, onAccepted, onCorrected, }) {
+    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]);
+    const expectedBasketId = instruction.basketId;
+    if (expectedBasketId === undefined) {
+        return (_jsx(Alert, { severity: "warning", children: "This tracked basket must be handled through the recovery workflow." }));
+    }
+    async function record(command) {
+        if (submitCommand === undefined)
+            return;
+        setSubmission({ state: "submitting", command });
+        try {
+            const result = await submitCommand(stationNumber, command);
+            if (currentStationNumber.current !== stationNumber ||
+                currentInstructionId.current !== command.instructionId)
+                return;
+            if (result === "conflict") {
+                setSubmission({ state: result, command });
+            }
+            else {
+                setSubmission({ state: "accepted", command, receipt: result });
+                onAccepted?.({
+                    stationNumber,
+                    instruction,
+                    command,
+                    receipt: result,
+                    status: "recorded",
+                });
+            }
+        }
+        catch (error) {
+            if (currentStationNumber.current !== stationNumber ||
+                currentInstructionId.current !== command.instructionId)
+                return;
+            setSubmission({
+                state: "error",
+                command,
+                message: error instanceof Error ? error.message : "Unable to record basket arrival",
+            });
+        }
+    }
+    async function correct(command) {
+        if (submitCorrection === undefined || activeCommand === undefined)
+            return;
+        setCorrectionSubmission({ state: "submitting", command });
+        try {
+            const result = await submitCorrection(stationNumber, command);
+            if (currentStationNumber.current !== stationNumber ||
+                currentCorrectionTargetId.current !== command.targetObservationId)
+                return;
+            setCorrectionSubmission({ state: result, command });
+            if (result === "accepted")
+                onCorrected?.(command);
+        }
+        catch {
+            if (currentStationNumber.current !== stationNumber ||
+                currentCorrectionTargetId.current !== command.targetObservationId)
+                return;
+            setCorrectionSubmission({ state: "error", command });
+        }
+    }
+    function createCommand(basketId) {
+        return {
+            commandId: crypto.randomUUID(),
+            instructionId: instruction.instructionId,
+            observedBasketId: basketId,
+        };
+    }
+    const parsedDifferentBasket = Number(differentBasket);
+    const activeCommand = receipt?.status === "retracted"
+        ? undefined
+        : (receipt?.command ??
+            (submission?.state === "accepted" &&
+                submission.command.instructionId === instruction.instructionId
+                ? submission.command
+                : undefined));
+    const activeObservationId = receipt?.status === "retracted"
+        ? undefined
+        : (receipt?.receipt.observationId ??
+            (submission?.state === "accepted" ? submission.receipt.observationId : undefined));
+    currentCorrectionTargetId.current = activeObservationId;
+    function createCorrection(replacementBasketId) {
+        return {
+            correctionId: crypto.randomUUID(),
+            targetObservationId: activeObservationId ?? "",
+            replacementBasketId,
+            replacementObservationId: replacementBasketId === null ? null : crypto.randomUUID(),
+        };
+    }
+    const validDifferentBasket = Number.isInteger(parsedDifferentBasket) &&
+        parsedDifferentBasket > 0 &&
+        parsedDifferentBasket !== (activeCommand?.observedBasketId ?? expectedBasketId);
+    const disabled = submitCommand === undefined ||
+        activeCommand !== undefined ||
+        (submission !== undefined && submission.state !== "error");
+    const receiptMessage = receipt?.status === "retracted"
+        ? "Arrival observation retracted."
+        : receipt?.status === "corrected"
+            ? `Arrival corrected to ${basketName.toLocaleLowerCase()} ${receipt.command.observedBasketId}.`
+            : "Arrival recorded. Waiting for updated status.";
+    return (_jsx(Paper, { component: "section", elevation: 2, sx: { margin: 1, padding: 2 }, children: _jsxs(Stack, { spacing: 2, children: [_jsxs(Box, { children: [_jsx(Typography, { variant: "overline", children: receipt === undefined ? "Basket arrival" : "Basket arrival receipt" }), _jsx(Typography, { variant: "h4", children: receipt?.status === "retracted"
+                                ? "Retracted basket arrival"
+                                : receipt === undefined
+                                    ? `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] }) }));
+}

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

@@ -1,11 +1,14 @@
 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 } from "react";
+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 { FolderOpen as FolderOpenIcon } from "@mui/icons-material";
@@ -64,6 +64,7 @@ import { hideNonLoadingMaterialOnLoadStation } from "../../data/queue-material.j
 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";
 function encodeLoadStationRegionIdPart(value) {
     return encodeURIComponent(value.toString());
 }
@@ -284,6 +285,21 @@ 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 matCount = freeLoading.length + palFaces.valuesToAscLazySeq().sumBy((x) => x.length);
+    const activeBasketSlotCount = activeBasket
+        ? LazySeq.of(activeBasket.emptySlots ?? [])
+            .concat(activeBasket.unknownSlots ?? [])
+            .concat(LazySeq.of(curSt.material).collect((mat) => mat.location.type === api.LocType.InBasket &&
+            mat.location.basketId === activeBasket.basketId
+            ? mat.location.basketSlot
+            : undefined))
+            .concat(LazySeq.of(curSt.material).collect((mat) => mat.action.type === api.ActionType.LoadingToBasket &&
+            mat.action.loadToBasketId === activeBasket.basketId
+            ? mat.action.loadToBasketSlot
+            : undefined))
+            .distinctBy((slot) => slot)
+            .toRArray().length
+        : 0;
+    const layoutCount = Math.max(matCount, activeBasketSlotCount);
     return {
         pallet: pal,
         activeBasket,
@@ -293,7 +309,7 @@ function selectLoadStationAndQueueProps(loadNum, queues, curSt, hideNonLoading)
         queues: queueMat,
         baskets: basketMat,
         elapsedLoadingTime,
-        fsize: matCount <= 2 ? "x-large" : matCount <= 6 ? "large" : "normal",
+        fsize: layoutCount <= 2 ? "x-large" : layoutCount <= 6 ? "large" : "normal",
     };
 }
 function MultiInstructionButton({ loadData }) {
@@ -648,6 +664,20 @@ 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)))
+            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]) => ({
@@ -694,31 +724,53 @@ export function LoadStation(props) {
         horizontal: fillViewPort,
         showMatInCompleted: props.completed,
     });
-    return (_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 (_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 })] }) })] }));
 }
 function LoadStationCheckWidth(props) {
     const fmsInfo = useAtomValue(fmsInformation);

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

@@ -377,6 +377,7 @@ const MatCard = forwardRef(function MatCard(props, ref) {
                     }, children: [_jsx(PartIdenticon, { part: props.mat.partName }), _jsxs(Box, { sx: {
                                 marginLeft: "8px",
                                 flexGrow: 1,
+                                minWidth: 0,
                             }, children: [_jsx(MatCardHeader, { fsize: props.fsize, children: props.mat.partName }), props.displayJob ? (_jsx(MatCardDetail, { fsize: props.fsize, children: props.mat.jobUnique && props.mat.jobUnique !== ""
                                         ? "Assigned to " + props.mat.jobUnique
                                         : "Unassigned material" })) : undefined, !props.hideEmptySerial || props.mat.serial ? (_jsxs(MatCardDetail, { fsize: props.fsize, children: ["Serial: ", props.mat.serial ? props.mat.serial : "none"] })) : undefined, props.mat.workorderId === undefined ||
@@ -391,6 +392,7 @@ const MatCard = forwardRef(function MatCard(props, ref) {
                                 justifyContent: "space-between",
                                 alignItems: "flex-end",
                                 alignSelf: "start",
+                                flexShrink: 0,
                             }, children: [props.mat.serial && props.mat.serial.length >= 1 && !props.hideAvatar ? (_jsx("div", { children: _jsx(Avatar, { style: { width: "30px", height: "30px" }, children: props.mat.serial.slice(-1) }) })) : undefined, props.hideWarningIcon ? undefined : (_jsx("div", { children: _jsx(Warning, { mat: props.mat }) }))] })] }) })] }));
 });
 export const MatSummary = memo(MatCard);

package/dist/data/move-arrows.d.ts

@@ -7,7 +7,8 @@ export declare enum MoveMaterialNodeKindType {
     CompletedExpandedMaterialZone = 3,
     PalletFaceZone = 4,
     QueueZone = 5,
-    BasketZone = 6
+    BasketZone = 6,
+    BasketSlotZone = 7
 }
 export type MoveMaterialNodeKind = {
     readonly type: MoveMaterialNodeKindType.Material;
@@ -28,6 +29,10 @@ export type MoveMaterialNodeKind = {
 } | {
     readonly type: MoveMaterialNodeKindType.BasketZone;
     readonly basketId: number;
+} | {
+    readonly type: MoveMaterialNodeKindType.BasketSlotZone;
+    readonly basketId: number;
+    readonly slot: number;
 };
 export type MoveMaterialIdentifier = string;
 export declare function uniqueIdForNodeKind(kind: MoveMaterialNodeKind): MoveMaterialIdentifier;