@seedtactics/insight-client 17.0.1-beta.12 → 17.0.1-beta.14

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

@@ -5,6 +5,7 @@ export declare const currentStatus: Atom<ICurrentStatus>;
 export declare const secondsSinceEpochAtom: import("jotai").PrimitiveAtom<number> & {
     init: number;
 };
+export declare const minutesSinceEpochAtom: Atom<number>;
 export declare const setJobComment: import("jotai").WritableAtom<null, [uniq: string, newVal: string | null], void> & {
     init: null;
 };

package/dist/cell-status/current-status.js

@@ -51,6 +51,8 @@ secondsSinceEpochAtom.onMount = (setSelf) => {
     }, 1000);
     return () => clearInterval(interval);
 };
+// Minute precision keeps report time windows current without redrawing charts every second.
+export const minutesSinceEpochAtom = atom((get) => Math.floor(get(secondsSinceEpochAtom) / 60));
 export const setJobComment = atom(null, (_, set, uniq, newVal) => {
     const newComment = newVal === null ? "" : newVal;
     set(currentStatusRW, (st) => {

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

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

package/dist/cell-status/loading.js

@@ -30,6 +30,8 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
+import { QueuePosition, } from "../network/api.js";
+import { JobsBackend } from "../network/backend.js";
 import { LazySeq } from "@seedtactics/immutable-collections";
 import * as simProd from "./sim-production.js";
 import * as simUse from "./sim-station-use.js";
@@ -50,16 +52,20 @@ import * as simDayUsage from "./sim-day-usage.js";
 import * as rebookings from "./rebookings.js";
 import { atom } from "jotai";
 const lastEventCounterRW = atom(null);
+// Highest counter applied to historical projections. Buffered websocket events do not advance it.
+// This is a reconnect cursor, not proof that lower counters cannot arrive later on the socket.
 export const lastEventCounter = lastEventCounterRW;
-export const onServerEvent = atom(null, (_, set, evt) => {
+export const onLiveServerEvent = atom(null, (_, set, evt) => {
     if (evt.evt.newCurrentStatus) {
         set(customSt.replaceCustomState, evt.evt.newCurrentStatus.customState ?? null);
     }
+    set(currentSt.updateCurrentStatus, evt);
+});
+export const onHistoricalServerEvent = atom(null, (_, set, evt) => {
     set(simProd.updateLast30JobProduction, evt);
     set(simUse.updateLast30SimStatUse, evt);
     set(schJobs.updateLast30Jobs, evt);
     set(buffers.updateLast30Buffer, evt);
-    set(currentSt.updateCurrentStatus, evt);
     set(mats.updateLast30MatSummary, evt);
     set(insp.updateLast30Inspections, evt);
     set(names.updateNames, evt);
@@ -72,9 +78,13 @@ export const onServerEvent = atom(null, (_, set, evt) => {
     set(simDayUsage.updateLatestSimDayUsage, evt);
     if (evt.evt.logEntry) {
         const newCntr = evt.evt.logEntry.counter;
-        set(lastEventCounterRW, (old) => (old === null ? old : Math.max(old, newCntr)));
+        set(lastEventCounterRW, (old) => Math.max(old ?? newCntr, newCntr));
     }
 });
+export const onServerEvent = atom(null, (_, set, evt) => {
+    set(onLiveServerEvent, evt);
+    set(onHistoricalServerEvent, evt);
+});
 export const onLoadLast30Jobs = atom(null, (get, set, historicData) => {
     const filtered = schJobs.filterExistingJobs(get(schJobs.last30SchIds), historicData);
     set(simUse.setLast30SimStatUse, filtered);
@@ -104,6 +114,29 @@ export const onLoadCurrentSt = atom(null, (_, set, curSt) => {
     set(customSt.replaceCustomState, curSt.customState ?? null);
     set(names.setNamesFromCurrentStatus, curSt);
 });
+// Show queue drops immediately. Recovery must not replace intervening live updates or drags.
+export const moveQueuedMatInCurrentStatus = atom(null, async (get, set, { operator, ...move }) => {
+    const before = get(currentSt.currentStatus);
+    set(currentSt.reorderQueuedMatInCurrentStatus, move);
+    const optimistic = get(currentSt.currentStatus);
+    try {
+        await JobsBackend.setMaterialInQueue(move.matId, operator, new QueuePosition({ queue: move.queue, position: move.newIdx }));
+    }
+    catch (error) {
+        const beforeReload = get(currentSt.currentStatus);
+        try {
+            const refreshed = await JobsBackend.currentStatus();
+            if (get(currentSt.currentStatus) === beforeReload)
+                set(onLoadCurrentSt, refreshed);
+        }
+        catch {
+            // If the server is unreachable, undo only this move's untouched optimistic snapshot.
+            if (get(currentSt.currentStatus) === optimistic)
+                set(onLoadCurrentSt, before);
+        }
+        throw error;
+    }
+});
 export const onLoadSpecificMonthJobs = atom(null, (_, set, historicData) => {
     set(simUse.setSpecificMonthSimStatUse, historicData);
     set(simProd.setSpecificMonthJobProduction, historicData);

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

@@ -44,7 +44,7 @@ export declare const barcodePotentialNewMaterial: Atom<Promise<Readonly<IScanned
 export declare const materialInDialogInfo: Atom<Promise<MaterialToShowInfo | null>>;
 export declare const materialInDialogInfoUnwrapped: Atom<MaterialToShowInfo | null>;
 export declare const materialInDialogInfoState: Atom<AsyncAtomState<MaterialToShowInfo | null>>;
-export declare const inProcessMaterialInDialog: Atom<Promise<IInProcessMaterial | null>>;
+export declare const inProcessMaterialInDialog: Atom<IInProcessMaterial | Promise<IInProcessMaterial | null> | null>;
 export declare const serialInMaterialDialog: Atom<Promise<string | null>>;
 export declare const serialInMaterialDialogUnwrapped: Atom<string | null>;
 export declare const serialInMaterialDialogState: Atom<AsyncAtomState<string | null>>;
@@ -61,7 +61,7 @@ export interface MaterialToShowInspections {
     readonly completedInspections: ReadonlyArray<string>;
 }
 export declare const materialInDialogInspections: Atom<MaterialToShowInspections>;
-export declare const possibleWorkordersForMaterialInDialog: Atom<Promise<readonly IActiveWorkorder[]>>;
+export declare const possibleWorkordersForMaterialInDialog: Atom<Promise<readonly IActiveWorkorder[]> | readonly IActiveWorkorder[]>;
 export interface ForceInspectionData {
     readonly mat: MaterialToShowInfo;
     readonly inspType: string;

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

@@ -116,11 +116,26 @@ function asyncAtomState(source) {
     return unwrap(atom((get) => get(source).then((data) => ({ state: "hasData", data }), (error) => ({ state: "hasError", error }))), () => ({ state: "loading" }));
 }
 export const materialInDialogInfoState = asyncAtomState(materialInDialogInfo);
-export const inProcessMaterialInDialog = atom(async (get) => {
-    const status = get(currentStatus);
+// Some cells publish current status every second. Dialog atoms that combine current status with the
+// dialog material must not suspend on each status update, since that hides the dialog content behind
+// its loading fallback. They compute synchronously once the dialog material is known and suspend
+// only while it is still loading (e.g., a barcode or serial lookup).
+function withDialogMaterial(get, compute) {
+    const info = get(materialInDialogInfoState);
+    switch (info.state) {
+        case "hasData":
+            return compute(info.data);
+        case "hasError":
+            throw info.error;
+        case "loading":
+            return get(materialInDialogInfo).then(compute);
+    }
+}
+export const inProcessMaterialInDialog = atom((get) => {
     const toShow = get(matToShow);
     if (toShow === null)
         return null;
+    const status = get(currentStatus);
     if (toShow.type === "InProcMat") {
         return (status.material.find((m) => m.materialID === toShow.inproc.materialID &&
             (m.materialID >= 0 ||
@@ -130,10 +145,9 @@ export const inProcessMaterialInDialog = atom(async (get) => {
                     m.action.loadToBasketId === toShow.inproc.action.loadToBasketId &&
                     m.jobUnique === toShow.inproc.jobUnique))) ?? null);
     }
-    const matId = (await get(materialInDialogInfo))?.materialID ?? null;
-    return matId !== null && matId >= 0
-        ? (status.material.find((m) => m.materialID === matId) ?? null)
-        : null;
+    return withDialogMaterial(get, (mat) => mat !== null && mat.materialID >= 0
+        ? (status.material.find((m) => m.materialID === mat.materialID) ?? null)
+        : null);
 });
 export const serialInMaterialDialog = atom(async (get) => {
     const toShow = get(matToShow);
@@ -284,14 +298,13 @@ export const materialInDialogInspections = atom((get) => {
 //--------------------------------------------------------------------------------
 // Workorders
 //--------------------------------------------------------------------------------
-export const possibleWorkordersForMaterialInDialog = atom(async (get) => {
-    const mat = await get(materialInDialogInfo);
-    if (mat === null || mat.partName === "")
-        return [];
+export const possibleWorkordersForMaterialInDialog = atom((get) => {
     const works = get(currentStatus)?.workorders ?? [];
-    return LazySeq.of(works)
-        .filter((w) => w.part === mat.partName)
-        .toSortedArray((w) => w.dueDate.getTime(), (w) => -w.priority);
+    return withDialogMaterial(get, (mat) => mat === null || mat.partName === ""
+        ? []
+        : LazySeq.of(works)
+            .filter((w) => w.part === mat.partName)
+            .toSortedArray((w) => w.dueDate.getTime(), (w) => -w.priority));
 });
 export function useForceInspection() {
     const [updating, setUpdating] = useState(false);

package/dist/components/App.d.ts

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

package/dist/components/App.js

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

package/dist/components/analysis/BufferChart.js

@@ -74,6 +74,7 @@ const marginBottom = 50;
 const marginTop = 20;
 const marginRight = 20;
 function BufferChartSVG({ width, height, series, disabled, }) {
+    const [emptyDate] = useState(() => new Date());
     const [dateMin, dateMax] = useMemo(() => {
         let min = null;
         let max = null;
@@ -87,8 +88,8 @@ function BufferChartSVG({ width, height, series, disabled, }) {
                 }
             }
         }
-        return [min ?? new Date(), max ?? new Date()];
-    }, [series]);
+        return [min ?? emptyDate, max ?? emptyDate];
+    }, [series, emptyDate]);
     const xScale = useMemo(() => scaleTime()
         .range([0, width - marginLeft - marginRight])
         .domain([dateMin, dateMax]), [width, dateMin, dateMax]);

package/dist/components/operations/AllMaterial.js

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

package/dist/components/operations/RecentCycleChart.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, useCallback, useState, useRef, useEffect, } from "react";
+import { useMemo, useCallback, useRef } from "react";
 import { last30StationCycles } from "../../cell-status/station-cycles.js";
 import { last30EstimatedCycleTimes } from "../../cell-status/estimated-cycle-times.js";
 import { recentCycles } from "../../data/results.cycles.js";
@@ -43,7 +43,7 @@ import { localPoint } from "../../util/chart-helpers.js";
 import { Stack } from "@mui/material";
 import { Tooltip } from "../ChartTooltip.js";
 import { currentCycles } from "../../data/current-cycles.js";
-import { currentStatus } from "../../cell-status/current-status.js";
+import { currentStatus, minutesSinceEpochAtom } from "../../cell-status/current-status.js";
 import { last30Jobs } from "../../cell-status/scheduled-jobs.js";
 import { atom, useAtomValue, useSetAtom } from "jotai";
 import { fmsInformation } from "../../network/server-settings.js";
@@ -56,11 +56,12 @@ const occupiedNonOutlierColor = green[900];
 const occupiedOutlierColor = red[700];
 const simColor = grey[400];
 const downtimeColor = grey[100];
-function useSimCycles() {
+const chartTime = atom((get) => Math.floor(get(minutesSinceEpochAtom) / 5) * 5 * 60000);
+function useSimCycles(now) {
     const jobs = useAtomValue(last30Jobs);
     const statUse = useAtomValue(last30SimStationUse);
     return useMemo(() => {
-        const cutoff = addHours(new Date(), -12);
+        const cutoff = addHours(now, -12);
         return (LazySeq.of(statUse)
             .filter((s) => s.end >= cutoff)
             // make sure all planned downtimes come last so they are drawn over the top of any cycles
@@ -81,7 +82,7 @@ function useSimCycles() {
                 .toRArray(),
         }))
             .toRArray());
-    }, [jobs, statUse]);
+    }, [jobs, statUse, now]);
 }
 const tooltipData = atom(null);
 const stationFontSize = 14;
@@ -213,30 +214,24 @@ function NowLine({ now, xScale, yScale, }) {
 export function RecentCycleChart({ height, width }) {
     const last30Cycles = useAtomValue(last30StationCycles);
     const estimated = useAtomValue(last30EstimatedCycleTimes);
-    const sim = useSimCycles();
     const currentSt = useAtomValue(currentStatus);
+    const time = useAtomValue(chartTime);
+    // Keep history filtering independent of frequent status updates.
+    const historyNow = useMemo(() => new Date(time), [time]);
+    // Align the axis and now marker with cycles started after the chart's last clock tick.
+    const displayNow = useMemo(() => new Date(Math.max(time, currentSt.timeOfCurrentStatusUTC.getTime())), [time, currentSt.timeOfCurrentStatusUTC]);
+    const sim = useSimCycles(historyNow);
     const fmsInfo = useAtomValue(fmsInformation);
     const cycles = useMemo(() => {
-        const cutoff = addHours(new Date(), -12);
+        const cutoff = addHours(historyNow, -12);
         return recentCycles(last30Cycles.valuesToLazySeq().filter((e) => e.endTime >= cutoff));
-    }, [last30Cycles]);
+    }, [last30Cycles, historyNow]);
     const current = useMemo(() => {
         return currentCycles(currentSt, estimated, fmsInfo.loadStationNames);
     }, [currentSt, estimated, fmsInfo.loadStationNames]);
-    // ensure a re-render at least every 5 minutes, but reset the timer if the data changes
-    const now = new Date();
-    const [, forceRerender] = useState(0);
-    const refreshRef = useRef(null);
-    useEffect(() => {
-        if (refreshRef.current !== null)
-            clearTimeout(refreshRef.current);
-        refreshRef.current = setTimeout(() => {
-            forceRerender((x) => x + 1);
-        }, 5 * 60 * 1000);
-    });
-    const { xScale, yScale, actualPlannedScale, marginLeft } = useScales(cycles, current, now, width, height);
+    const { xScale, yScale, actualPlannedScale, marginLeft } = useScales(cycles, current, displayNow, width, height);
     const hideTooltipRef = useRef(null);
     if (height <= 0 || width <= 0)
         return null;
-    return (_jsxs("div", { style: { position: "relative", overflow: "hidden" }, children: [_jsx("svg", { height: height, width: width, children: _jsxs("g", { transform: `translate(${marginLeft}, ${marginTop})`, children: [_jsx("clipPath", { id: "recent-cycle-clip-body", children: _jsx("rect", { x: 0, y: 0, width: width - marginRight - marginLeft, height: height - marginBottom - marginTop }) }), _jsx(AxisAndGrid, { xScale: xScale, yScale: yScale }), _jsxs("g", { clipPath: "url(#recent-cycle-clip-body)", children: [_jsx(RecentSeries, { cycles: cycles, xScale: xScale, yScale: yScale, hideTooltipRef: hideTooltipRef, actualPlannedScale: actualPlannedScale }), _jsx(CurrentSeries, { now: now, cycles: current, xScale: xScale, yScale: yScale, hideTooltipRef: hideTooltipRef, actualPlannedScale: actualPlannedScale }), _jsx(SimSeries, { sim: sim, xScale: xScale, yScale: yScale, actualPlannedScale: actualPlannedScale, hideTooltipRef: hideTooltipRef })] }), _jsx(NowLine, { now: now, xScale: xScale, yScale: yScale })] }) }), _jsx(Tooltip, { chartHeight: height, chartWidth: width, atom: tooltipData, TooltipContent: RecentTooltip })] }));
+    return (_jsxs("div", { style: { position: "relative", overflow: "hidden" }, children: [_jsx("svg", { height: height, width: width, children: _jsxs("g", { transform: `translate(${marginLeft}, ${marginTop})`, children: [_jsx("clipPath", { id: "recent-cycle-clip-body", children: _jsx("rect", { x: 0, y: 0, width: width - marginRight - marginLeft, height: height - marginBottom - marginTop }) }), _jsx(AxisAndGrid, { xScale: xScale, yScale: yScale }), _jsxs("g", { clipPath: "url(#recent-cycle-clip-body)", children: [_jsx(RecentSeries, { cycles: cycles, xScale: xScale, yScale: yScale, hideTooltipRef: hideTooltipRef, actualPlannedScale: actualPlannedScale }), _jsx(CurrentSeries, { now: displayNow, cycles: current, xScale: xScale, yScale: yScale, hideTooltipRef: hideTooltipRef, actualPlannedScale: actualPlannedScale }), _jsx(SimSeries, { sim: sim, xScale: xScale, yScale: yScale, actualPlannedScale: actualPlannedScale, hideTooltipRef: hideTooltipRef })] }), _jsx(NowLine, { now: displayNow, xScale: xScale, yScale: yScale })] }) }), _jsx(Tooltip, { chartHeight: height, chartWidth: width, atom: tooltipData, TooltipContent: RecentTooltip })] }));
 }

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

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

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

@@ -33,6 +33,7 @@ import { Alert, Box, Button, Stack, Typography } from "@mui/material";
 import { LazySeq } from "@seedtactics/immutable-collections";
 import { basketSlotLabel } from "../../cell-status/station-cycles.js";
 import * as api from "../../network/api.js";
+import { JobsBackend } from "../../network/backend.js";
 import { InProcMaterial } from "./Material.js";
 import { MoveMaterialArrowNode } from "./MoveMaterialArrows.js";
 import { MoveMaterialNodeKindType } from "../../data/move-arrows.js";
@@ -138,7 +139,7 @@ function loadingInstruction(mat) {
 function SlotMaterial({ material, fsize, }) {
     return material.map((mat) => (_jsx(MoveMaterialArrowNode, { kind: { type: MoveMaterialNodeKindType.Material, material: mat }, children: _jsx(InProcMaterial, { mat: mat, fsize: fsize }) }, mat.materialID)));
 }
-export function BasketLoadStationWorkflow({ stationNumber, basket, material, fsize, submitCommand, }) {
+export function BasketLoadStationWorkflow({ basket, material, fsize, }) {
     const [submission, setSubmission] = useState();
     const workState = useMemo(() => stationWork(material, basket), [basket, material]);
     const blockedReason = basket.loadStationWork?.confirmationBlockedReason?.trim();
@@ -170,17 +171,19 @@ export function BasketLoadStationWorkflow({ stationNumber, basket, material, fsi
         .distinctBy((slot) => slot)
         .toSortedArray((slot) => slot), [basket.emptySlots, basket.unknownSlots, materialBySlot, loadsBySlot]);
     async function submit() {
-        if (work === undefined || !work.ready || submitCommand === undefined)
+        if (work === undefined || !work.ready)
             return;
         const submittedWorkId = work.workId;
         const pending = { workId: submittedWorkId, basket, material, state: "submitting" };
         setSubmission(pending);
         try {
-            const state = await submitCommand(stationNumber, { workId: submittedWorkId });
+            await JobsBackend.completeBasketLoadStation(new api.BasketLoadStationCompletion({ workId: submittedWorkId }));
+            const state = "accepted";
             setSubmission((current) => (current === pending ? { ...pending, state } : current));
         }
-        catch {
-            setSubmission((current) => (current === pending ? { ...pending, state: "error" } : current));
+        catch (error) {
+            const state = api.ApiException.isApiException(error) && error.status === 409 ? "conflict" : "error";
+            setSubmission((current) => (current === pending ? { ...pending, state } : current));
         }
     }
     const submissionDisabled = !work?.ready ||
@@ -205,5 +208,5 @@ export function BasketLoadStationWorkflow({ stationNumber, basket, material, fsi
                 }) }), 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] }));
+                        : "Basket work is not ready for confirmation.") })), work ? (_jsx(Box, { sx: { display: "flex", justifyContent: "flex-end" }, children: _jsx(Button, { variant: "contained", disabled: submissionDisabled, onClick: () => void submit(), children: "Confirm" }) })) : workState.type === "inconsistent" ? (_jsx(Alert, { severity: "warning", children: "Basket work is inconsistent. Wait for refreshed material actions before confirming." })) : null, submissionState === "accepted" ? (_jsx(Alert, { severity: "success", children: "Confirmation accepted. Waiting for refreshed work." })) : submissionState === "conflict" ? (_jsx(Alert, { severity: "warning", children: "Basket work changed before confirmation. Review the refreshed slots and try again." })) : submissionState === "error" ? (_jsx(Alert, { severity: "error", children: "Unable to confirm basket work. No work was assumed complete." })) : null] }));
 }

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

@@ -41,6 +41,8 @@ export function CancelLoadButton({ onClose, ignoreOperator = false, }) {
                 expectedLoadCancellationId: snapshot.cancellationId,
                 reason: reason || undefined,
             }));
+            setOpen(false);
+            setSnapshot(null);
             setMaterialDialogOpen(null);
             onClose?.();
         }

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

@@ -41,7 +41,7 @@ import { currentStatus } from "../../cell-status/current-status.js";
 import { barcodePotentialNewMaterial, inProcessMaterialInDialog, materialDialogOpen, materialInDialogInfo, materialInDialogLargestUsedProcess, materialInDialogLocalEvents, } from "../../cell-status/material-details.js";
 import { currentOperator } from "../../data/operators.js";
 import { fmsInformation } from "../../network/server-settings.js";
-import { useAtomValue, useSetAtom } from "jotai";
+import { useAtomValue, useAtomValueRawSync, useSetAtom } from "jotai";
 import { useEffect, useRef } from "react";
 import { last30Jobs } from "../../cell-status/scheduled-jobs.js";
 import { PartIdenticon } from "./Material.js";
@@ -82,12 +82,15 @@ function InvalidateSelect(props) {
         job: currentSt.jobs[j.jobUnique] ?? history.get(j.jobUnique) ?? null,
     }));
     const hasProc = lastMat !== null && lastMat.process >= 1;
-    const hasChangeMat = castings.length > 0 || jobs.length > 0;
+    const canChangeAssignment = lastMat === null || lastMat.process <= 1;
+    const hasChangeMat = canChangeAssignment && (castings.length > 0 || jobs.length > 0);
     const selectedCasting = props.st?.changeRawMat !== null &&
         props.st?.changeRawMat !== undefined &&
+        canChangeAssignment &&
         castings.includes(props.st.changeRawMat);
     const selectedJob = props.st?.changeJobUnique !== null &&
         props.st?.changeJobUnique !== undefined &&
+        canChangeAssignment &&
         jobs.some((job) => job.jobUnique === props.st?.changeJobUnique);
     function change(e) {
         props.setState({
@@ -102,7 +105,7 @@ function InvalidateSelect(props) {
             ? "rawMat" + props.st.changeRawMat
             : selectedJob
                 ? "job" + props.st.changeJobUnique
-                : props.st?.process && hasProc
+                : props.st?.process && hasProc && props.st.process === lastMat.process
                     ? "proc" + props.st.process.toString()
                     : "", select: true, onChange: (e) => change(e.target.value), variant: "outlined", label: props.st?.changeRawMat
             ? "Change Raw Material"
@@ -119,11 +122,6 @@ function InvalidateSelect(props) {
             hasProc
                 ? [
                     _jsxs(MenuItem, { value: "proc" + lastMat.process.toString(), children: ["Invalidate Process ", lastMat.process] }, lastMat.process),
-                    ...(lastMat.process > 1
-                        ? [
-                            _jsx(MenuItem, { value: "proc1", children: "Invalidate All Processes" }, "all"),
-                        ]
-                        : []),
                 ]
                 : [],
             hasProc && hasChangeMat
@@ -131,15 +129,17 @@ function InvalidateSelect(props) {
                 : [],
             hasChangeMat
                 ? [
-                    ...castings.map((c) => (_jsxs(MenuItem, { value: "rawMat" + c, children: ["Invalidate Everything and Change to ", c] }, "rawMat" + c))),
-                    ...jobs.map(({ jobUnique, job }) => (_jsxs(MenuItem, { value: "job" + jobUnique, children: [job ? (_jsx(ListItemIcon, { children: _jsx(PartIdenticon, { part: job.partName }) })) : undefined, _jsx(ListItemText, { primary: "Invalidate Everything and Change to Job " + jobUnique, secondary: job?.partName })] }, "job" + jobUnique))),
+                    ...castings.map((c) => (_jsxs(MenuItem, { value: "rawMat" + c, children: [hasProc ? "Invalidate Process 1 and Change to " : "Change to ", c] }, "rawMat" + c))),
+                    ...jobs.map(({ jobUnique, job }) => (_jsxs(MenuItem, { value: "job" + jobUnique, children: [job ? (_jsx(ListItemIcon, { children: _jsx(PartIdenticon, { part: job.partName }) })) : undefined, _jsx(ListItemText, { primary: (hasProc ? "Invalidate Process 1 and Change to Job " : "Change to Job ") +
+                                    jobUnique, secondary: job?.partName })] }, "job" + jobUnique))),
                 ]
                 : [],
         ] }));
 }
 export function InvalidateCycleDialogContent(props) {
     const curMat = useAtomValue(materialInDialogInfo);
-    const events = useAtomValue(materialInDialogLocalEvents);
+    // History can resolve while InvalidateSelect suspends, before this component subscribes.
+    const events = useAtomValueRawSync(materialInDialogLocalEvents);
     const status = useAtomValue(currentStatus);
     const show = props.st !== null && curMat !== null;
     const boxRef = useRef(null);
@@ -182,13 +182,15 @@ export function InvalidateCycleDialogButton(props) {
         return null;
     if (!canInvalidateMaterial(inProcMat))
         return null;
-    const allowChange = possibleNew !== null &&
+    const allowChange = (lastMat === null || lastMat.process <= 1) &&
+        possibleNew !== null &&
         (!LazySeq.ofObject(possibleNew.possibleCastingsByQueue ?? {}).isEmpty() ||
             !LazySeq.ofObject(possibleNew.possibleJobsByQueue ?? {}).isEmpty());
     if (!allowChange && (lastMat === null || lastMat.process < 1))
         return null;
     if (props.ignoreOperator)
         operator = null;
+    const changingAssignment = props.st !== null && (props.st.changeRawMat !== null || props.st.changeJobUnique !== null);
     function showInvalidate() {
         props.setState({
             process: null,
@@ -229,17 +231,20 @@ export function InvalidateCycleDialogButton(props) {
         }
     }
     return (_jsxs(_Fragment, { children: [props.st === null ? (_jsx(Button, { color: "primary", onClick: showInvalidate, children: "Invalidate Cycle" })) : undefined, props.st !== null ? (_jsx(Button, { color: "primary", onClick: invalidateCycle, disabled: props.st.updating ||
+                    (changingAssignment && !allowChange) ||
+                    (!changingAssignment &&
+                        props.st.process !== null &&
+                        props.st.process !== lastMat?.process) ||
                     (props.st.process === null &&
                         props.st.changeRawMat === null &&
                         props.st.changeJobUnique === null), children: props.st.changeJobUnique !== null
-                    ? "Invalidate Everything and Change to Job " + props.st.changeJobUnique
+                    ? (lastMat?.process === 1
+                        ? "Invalidate Process 1 and Change to Job "
+                        : "Change to Job ") + props.st.changeJobUnique
                     : props.st.changeRawMat !== null
-                        ? "Invalidate Everything and Change to " + props.st.changeRawMat
+                        ? (lastMat?.process === 1 ? "Invalidate Process 1 and Change to " : "Change to ") +
+                            props.st.changeRawMat
                         : props.st.process !== null
-                            ? props.st.process === 1
-                                ? lastMat && lastMat.process > 1
-                                    ? "Invalidate All Processes"
-                                    : "Invalidate Process 1"
-                                : "Invalidate Process " + props.st.process.toString()
+                            ? "Invalidate Process " + props.st.process.toString()
                             : "Invalidate Cycle" })) : undefined] }));
 }

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

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