@seedtactics/insight-client 16.5.2 → 16.7.0

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

@@ -31,27 +31,35 @@ 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 { memo, useState } from "react";
+import { memo, useMemo, useState } from "react";
 import { closestCenter, DndContext, DragOverlay, KeyboardSensor, PointerSensor, useSensor, useSensors, } from "@dnd-kit/core";
 import { rectSortingStrategy, SortableContext, sortableKeyboardCoordinates, verticalListSortingStrategy, } from "@dnd-kit/sortable";
 import { useAddExistingMaterialToQueue } from "../../cell-status/material-details.js";
 import { reorderQueuedMatInCurrentStatus } from "../../cell-status/current-status.js";
 import { currentOperator } from "../../data/operators.js";
 import { useAtomValue, useSetAtom } from "jotai";
+function isSortableMatData(value) {
+    return typeof value === "object" && value !== null && "mat" in value;
+}
+function numericId(id) {
+    return typeof id === "number" ? id : null;
+}
 export const SortableRegion = memo(function SortableRegion(props) {
     const [activeMat, setActiveMat] = useState(undefined);
     const [addExistingMatToQueue] = useAddExistingMaterialToQueue();
     const reorderQueuedMat = useSetAtom(reorderQueuedMatInCurrentStatus);
     const operator = useAtomValue(currentOperator);
+    const sortableItemIds = useMemo(() => props.matIds.slice(), [props.matIds]);
     const sensors = useSensors(useSensor(PointerSensor), useSensor(KeyboardSensor, {
         coordinateGetter: sortableKeyboardCoordinates,
     }));
-    return (_jsx(DndContext, { sensors: sensors, collisionDetection: closestCenter, onDragStart: ({ active }) => setActiveMat(active.data.current.mat), onDragCancel: () => setActiveMat(undefined), onDragEnd: ({ active, over }) => {
-            if (over && active.id !== over.id) {
-                const activeMatId = active.id;
-                const overIdx = props.matIds.indexOf(over.id);
+    return (_jsx(DndContext, { sensors: sensors, collisionDetection: closestCenter, onDragStart: ({ active }) => setActiveMat(isSortableMatData(active.data.current) ? active.data.current.mat : undefined), onDragCancel: () => setActiveMat(undefined), onDragEnd: ({ active, over }) => {
+            const activeMatId = numericId(active.id);
+            const overMatId = over ? numericId(over.id) : null;
+            if (over && active.id !== over.id && activeMatId !== null && overMatId !== null) {
+                const overIdx = props.matIds.indexOf(overMatId);
                 addExistingMatToQueue({
-                    materialId: active.id,
+                    materialId: activeMatId,
                     queue: props.queueName,
                     queuePosition: overIdx,
                     operator: operator,
@@ -63,5 +71,5 @@ export const SortableRegion = memo(function SortableRegion(props) {
                 });
             }
             setActiveMat(undefined);
-        }, children: _jsxs(SortableContext, { items: props.matIds, strategy: props.direction === "vertical" ? verticalListSortingStrategy : rectSortingStrategy, children: [props.children, _jsx(DragOverlay, { children: activeMat !== undefined ? props.renderDragOverlay(activeMat) : undefined })] }) }));
+        }, children: _jsxs(SortableContext, { items: sortableItemIds, strategy: props.direction === "vertical" ? verticalListSortingStrategy : rectSortingStrategy, children: [props.children, _jsx(DragOverlay, { children: activeMat !== undefined ? props.renderDragOverlay(activeMat) : undefined })] }) }));
 });

package/dist/data/all-material-bins.d.ts

@@ -4,6 +4,7 @@ export type MaterialBinId = string;
 export declare const LoadStationBinId: MaterialBinId;
 export declare const PalletsBinId: MaterialBinId;
 export declare const ActiveQueuesBinId: MaterialBinId;
+export declare const BasketsBinId: MaterialBinId;
 export interface MaterialBinState {
     readonly curBinOrder: ReadonlyArray<MaterialBinId>;
 }
@@ -13,6 +14,7 @@ export declare enum MaterialBinType {
     LoadStations = "Bin_LoadStations",
     Pallets = "Bin_Pallets",
     ActiveQueues = "Bin_ActiveQueues",
+    Baskets = "Bin_Baskets",
     QuarantineQueues = "Bin_Quarantine"
 }
 export type MaterialBin = {
@@ -27,6 +29,11 @@ export type MaterialBin = {
     readonly type: MaterialBinType.ActiveQueues;
     readonly binId: MaterialBinId;
     readonly byQueue: ReadonlyMap<string, MaterialList>;
+} | {
+    readonly type: MaterialBinType.Baskets;
+    readonly binId: MaterialBinId;
+    readonly byBasket: ReadonlyMap<number, MaterialList>;
+    readonly basketLocations: ReadonlyMap<number, string>;
 } | {
     readonly type: MaterialBinType.QuarantineQueues;
     readonly binId: MaterialBinId;

package/dist/data/all-material-bins.js

@@ -36,6 +36,7 @@ import { atomWithStorage } from "jotai/utils";
 export const LoadStationBinId = "__FMS_INSIGHT_LOAD_STATION_BIN__";
 export const PalletsBinId = "__FMS_INSIGHT_PALLETS_BIN__";
 export const ActiveQueuesBinId = "__FMS_INSIGHT_ACTIVE_QUEUE_BIN__";
+export const BasketsBinId = "__FMS_INSIGHT_BASKETS_BIN__";
 export const currentMaterialBinOrder = atomWithStorage("material-bins", []);
 export function moveMaterialBin(curBinOrder, oldIdx, newIdx) {
     const newBinOrder = Array.from(curBinOrder);
@@ -57,12 +58,27 @@ export var MaterialBinType;
     MaterialBinType["LoadStations"] = "Bin_LoadStations";
     MaterialBinType["Pallets"] = "Bin_Pallets";
     MaterialBinType["ActiveQueues"] = "Bin_ActiveQueues";
+    MaterialBinType["Baskets"] = "Bin_Baskets";
     MaterialBinType["QuarantineQueues"] = "Bin_Quarantine";
 })(MaterialBinType || (MaterialBinType = {}));
+function basketLocation(st) {
+    let loc;
+    if (st.locationTitle && st.locationTitle.length > 0) {
+        loc = st.locationTitle;
+    }
+    else {
+        loc = st.location + " " + st.locationNum.toString();
+    }
+    if (st.slot) {
+        loc += `-${st.slot}`;
+    }
+    return loc;
+}
 export function selectAllMaterialIntoBins(curSt, curBinOrder) {
     const loadStations = new Map();
     const pallets = new Map();
     const queues = new Map();
+    const baskets = new Map();
     const palLoc = LazySeq.ofObject(curSt.pallets).toRMap(([, st]) => [
         st.palletNum,
         st.palletNum.toString() +
@@ -115,6 +131,11 @@ export function selectAllMaterialIntoBins(curSt, curBinOrder) {
                         break;
                 }
                 break;
+            case api.LocType.InBasket:
+                if (mat.location.basketId !== undefined) {
+                    addToMap(baskets, mat.location.basketId, mat);
+                }
+                break;
         }
     }
     const activeQueues = LazySeq.ofObject(curSt.jobs)
@@ -135,10 +156,17 @@ export function selectAllMaterialIntoBins(curSt, curBinOrder) {
     const quarantineQueues = LazySeq.ofObject(curSt.queues)
         .filter(([qname, _]) => !activeQueues.has(qname))
         .toRSet(([qname, _]) => qname);
-    const bins = curBinOrder.filter((b) => b === LoadStationBinId || b === PalletsBinId || b === ActiveQueuesBinId || quarantineQueues.has(b));
+    const bins = curBinOrder.filter((b) => b === LoadStationBinId ||
+        b === PalletsBinId ||
+        b === ActiveQueuesBinId ||
+        b === BasketsBinId ||
+        quarantineQueues.has(b));
     if (bins.indexOf(ActiveQueuesBinId) < 0) {
         bins.unshift(ActiveQueuesBinId);
     }
+    if (baskets.size > 0 && bins.indexOf(BasketsBinId) < 0) {
+        bins.unshift(BasketsBinId);
+    }
     if (bins.indexOf(PalletsBinId) < 0) {
         bins.unshift(PalletsBinId);
     }
@@ -168,6 +196,24 @@ export function selectAllMaterialIntoBins(curSt, curBinOrder) {
                 }, (ms1, ms2) => ms1.concat(ms2)),
             };
         }
+        else if (binId === BasketsBinId) {
+            return {
+                type: MaterialBinType.Baskets,
+                binId: BasketsBinId,
+                byBasket: new Map(baskets),
+                basketLocations: LazySeq.ofObject(curSt.baskets ?? {})
+                    .collect(([id, st]) => {
+                    const basketId = parseInt(id);
+                    if (basketId > 0) {
+                        return [parseInt(id), basketLocation(st)];
+                    }
+                    else {
+                        return null;
+                    }
+                })
+                    .toRMap((x) => x),
+            };
+        }
         else {
             const queueName = binId;
             const mat = queues.get(queueName) ?? [];

package/dist/data/cost-per-piece.js

@@ -32,9 +32,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 import { addMonths, getDaysInMonth, addDays } from "date-fns";
 import copy from "copy-to-clipboard";
+import { isLaborCycle, isMachineCycle, isPalletLoadCycle, } from "../cell-status/station-cycles.js";
 import { LazySeq } from "@seedtactics/immutable-collections";
 function isUnloadCycle(c) {
-    return c.isLabor && c.operation === "UNLOAD";
+    return isPalletLoadCycle(c) && c.operation === "UNLOAD";
 }
 function isMonthType(type) {
     return Object.prototype.hasOwnProperty.call(type, "month");
@@ -51,10 +52,10 @@ export function compute_monthly_cost_percentages(cycles, partsToIgnore, matsById
         if (isUnloadCycle(c)) {
             totalPalletCycles += 1;
         }
-        if (c.isLabor) {
+        if (isLaborCycle(c)) {
             totalLaborUseMinutes += c.activeMinutes;
         }
-        else {
+        else if (isMachineCycle(c)) {
             totalStatUseMinutes.set(c.stationGroup, c.activeMinutes + (totalStatUseMinutes.get(c.stationGroup) ?? 0));
             const s = stationCount.get(c.stationGroup);
             if (s) {
@@ -81,16 +82,18 @@ export function compute_monthly_cost_percentages(cycles, partsToIgnore, matsById
         part: partName,
         parts_completed: completed.get(partName) ?? 0,
         machine: LazySeq.of(forPart)
-            .filter((c) => !c.isLabor)
+            .filter((c) => isMachineCycle(c))
             .buildOrderedMap((c) => c.stationGroup, (old, c) => (old ?? 0) + c.activeMinutes)
             .mapValues((minutes, statGroup) => {
             const totalUse = totalStatUseMinutes.get(statGroup) ?? 1;
             return minutes / totalUse;
         }),
         labor: LazySeq.of(forPart)
-            .filter((c) => c.isLabor)
+            .filter((c) => isLaborCycle(c))
             .sumBy((c) => c.activeMinutes / totalLaborUseMinutes),
-        automation: forPart.reduce((acc, v) => (isUnloadCycle(v) ? acc + 1 : acc), 0) / totalPalletCycles,
+        automation: totalPalletCycles > 0
+            ? forPart.reduce((acc, v) => (isUnloadCycle(v) ? acc + 1 : acc), 0) / totalPalletCycles
+            : 0,
     }))
         .toRArray();
     const machineQuantities = LazySeq.of(stationCount).toOrderedMap(([statGroup, nums]) => [
@@ -147,7 +150,7 @@ export function buildCostPerPieceTable(costs) {
     return table;
 }
 export function copyCostPerPieceToClipboard(costs) {
-    copy(buildCostPerPieceTable(costs));
+    void copy(buildCostPerPieceTable(costs));
 }
 export function buildCostBreakdownTable(costs) {
     let table = "<table>\n<thead><tr>";
@@ -179,5 +182,5 @@ export function buildCostBreakdownTable(costs) {
     return table;
 }
 export function copyCostBreakdownToClipboard(costs) {
-    copy(buildCostBreakdownTable(costs));
+    void copy(buildCostBreakdownTable(costs));
 }

package/dist/data/current-cycles.d.ts

@@ -10,4 +10,4 @@ export type CurrentCycle = {
         readonly oper: string;
     }>;
 };
-export declare function currentCycles(currentSt: ICurrentStatus, estimated: EstimatedCycleTimes): ReadonlyArray<CurrentCycle>;
+export declare function currentCycles(currentSt: ICurrentStatus, estimated: EstimatedCycleTimes, loadStationNames?: Readonly<Record<string, string>>): ReadonlyArray<CurrentCycle>;

package/dist/data/current-cycles.js

@@ -33,10 +33,51 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 import { LazySeq } from "@seedtactics/immutable-collections";
 import { addSeconds } from "date-fns";
 import { isOutlierAbove, PartAndStationOperation, splitElapsedTimeAmongChunk, } from "../cell-status/estimated-cycle-times.js";
-import { stat_name_and_num } from "../cell-status/station-cycles.js";
-import { ActionType } from "../network/api.js";
+import { displayStationName } from "../cell-status/station-cycles.js";
+import { ActionType, BasketLocationEnum } from "../network/api.js";
 import { durationToMinutes, durationToSeconds } from "../util/parseISODuration.js";
-function machiningCurrentCycles(currentSt, estimated, palToLoc) {
+function basketsAtLoad(currentSt) {
+    return LazySeq.ofObject(currentSt.baskets ?? {})
+        .collect(([, basket]) => {
+        if (basket.location === BasketLocationEnum.LoadUnload ||
+            basket.location === BasketLocationEnum.LoadStationStaging) {
+            return [basket.basketId, { group: "L/U", num: basket.locationNum }];
+        }
+        return null;
+    })
+        .toRMap(([basketId, loc]) => [basketId, loc]);
+}
+function locationForLoadActivity(material, jobs, palToLoc, basketToLoad) {
+    if (material.action.type === ActionType.Loading) {
+        if (material.action.loadOntoPalletNum) {
+            return palToLoc.get(material.action.loadOntoPalletNum) ?? null;
+        }
+        if (material.action.loadFromBasketId) {
+            return basketToLoad.get(material.action.loadFromBasketId) ?? null;
+        }
+        // queue → basket: neither pallet nor source basket set.  Find a basket at a load station
+        // that is a basket-load station for this job/process.
+        const proc = material.action.processAfterLoad ?? material.process;
+        const procInfo = jobs[material.jobUnique]?.procsAndPaths?.[proc - 1];
+        const basketLoadStations = procInfo?.basketLoadStations ?? [];
+        for (const [, loc] of basketToLoad) {
+            if (basketLoadStations.length === 0 || basketLoadStations.includes(loc.num)) {
+                return loc;
+            }
+        }
+        return null;
+    }
+    else {
+        if (material.location.palletNum) {
+            return palToLoc.get(material.location.palletNum) ?? null;
+        }
+        if (material.location.basketId) {
+            return basketToLoad.get(material.location.basketId) ?? null;
+        }
+    }
+    return null;
+}
+function machiningCurrentCycles(currentSt, estimated, palToLoc, loadStationNames) {
     return LazySeq.of(currentSt.material)
         .collect((m) => {
         if (m.action.type !== ActionType.Machining)
@@ -55,7 +96,7 @@ function machiningCurrentCycles(currentSt, estimated, palToLoc) {
         const elapsedSec = durationToSeconds(mats[0].mat.action.elapsedMachiningTime ?? "PT0S");
         const remainingSec = durationToSeconds(mats[0].mat.action.expectedRemainingMachiningTime ?? "PT0S");
         return {
-            station: stat_name_and_num(statGroup, statNum),
+            station: displayStationName(statGroup, statNum, loadStationNames),
             start: addSeconds(currentSt.timeOfCurrentStatusUTC, -elapsedSec),
             expectedEnd: addSeconds(currentSt.timeOfCurrentStatusUTC, remainingSec),
             isOutlier: stats ? isOutlierAbove(stats, elapsedSec / 60 / mats.length) : false,
@@ -63,22 +104,19 @@ function machiningCurrentCycles(currentSt, estimated, palToLoc) {
         };
     });
 }
-function loadCurrentCycles(currentSt, estimated, palToLoc) {
+function loadCurrentCycles(currentSt, estimated, palToLoc, loadStationNames) {
+    const basketToLoad = basketsAtLoad(currentSt);
     return LazySeq.of(currentSt.material)
         .collect((m) => {
         if (m.action.type === ActionType.UnloadToCompletedMaterial ||
             m.action.type === ActionType.UnloadToInProcess) {
-            if (!m.location.palletNum)
-                return null;
-            const loc = palToLoc.get(m.location.palletNum);
+            const loc = locationForLoadActivity(m, currentSt.jobs, palToLoc, basketToLoad);
             if (!loc)
                 return null;
             return { mat: m, material: [m], proc: m.process, path: m.path, loc };
         }
         else if (m.action.type === ActionType.Loading) {
-            if (!m.action.loadOntoPalletNum)
-                return null;
-            const loc = palToLoc.get(m.action.loadOntoPalletNum);
+            const loc = locationForLoadActivity(m, currentSt.jobs, palToLoc, basketToLoad);
             if (!loc)
                 return null;
             return {
@@ -93,12 +131,19 @@ function loadCurrentCycles(currentSt, estimated, palToLoc) {
     })
         .map((m) => {
         const job = currentSt.jobs[m.mat.jobUnique];
+        const procInfo = job?.procsAndPaths?.[m.proc - 1];
         const pathData = job?.procsAndPaths?.[m.proc - 1]?.paths?.[m.path - 1];
         if (m.mat.action.type === ActionType.Loading) {
-            return { ...m, expectedLoadSecs: durationToSeconds(pathData?.expectedLoadTime ?? "PT0S") };
+            const expected = m.mat.action.loadOntoPalletNum !== null && m.mat.action.loadOntoPalletNum !== undefined
+                ? pathData?.expectedLoadTime
+                : (procInfo?.expectedBasketLoadTime ?? pathData?.expectedLoadTime);
+            return { ...m, expectedLoadSecs: durationToSeconds(expected ?? "PT0S") };
         }
         else {
-            return { ...m, expectedLoadSecs: durationToSeconds(pathData?.expectedUnloadTime ?? "PT0S") };
+            const expected = m.mat.location.palletNum !== null && m.mat.location.palletNum !== undefined
+                ? pathData?.expectedUnloadTime
+                : (procInfo?.expectedBasketUnloadTime ?? pathData?.expectedUnloadTime);
+            return { ...m, expectedLoadSecs: durationToSeconds(expected ?? "PT0S") };
         }
     })
         .groupBy(({ loc }) => loc.group, ({ loc }) => loc.num)
@@ -122,7 +167,7 @@ function loadCurrentCycles(currentSt, estimated, palToLoc) {
         }
         const elapsedSec = durationToSeconds(mats[0].mat.action.elapsedLoadUnloadTime ?? "PT0S");
         return {
-            station: stat_name_and_num(statGroup, statNum),
+            station: displayStationName(statGroup, statNum, loadStationNames),
             start: addSeconds(currentSt.timeOfCurrentStatusUTC, -elapsedSec),
             expectedEnd: addSeconds(currentSt.timeOfCurrentStatusUTC, -elapsedSec + expectedSecs),
             isOutlier: outlier,
@@ -136,9 +181,9 @@ function loadCurrentCycles(currentSt, estimated, palToLoc) {
         };
     });
 }
-export function currentCycles(currentSt, estimated) {
+export function currentCycles(currentSt, estimated, loadStationNames) {
     const palToLoc = LazySeq.ofObject(currentSt.pallets).buildHashMap(([, p]) => p.palletNum, (_old, [, pal]) => pal.currentPalletLocation);
-    return machiningCurrentCycles(currentSt, estimated, palToLoc)
-        .concat(loadCurrentCycles(currentSt, estimated, palToLoc))
+    return machiningCurrentCycles(currentSt, estimated, palToLoc, loadStationNames)
+        .concat(loadCurrentCycles(currentSt, estimated, palToLoc, loadStationNames))
         .toRArray();
 }

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

@@ -6,7 +6,8 @@ export declare enum MoveMaterialNodeKindType {
     CompletedCollapsedMaterialZone = 2,
     CompletedExpandedMaterialZone = 3,
     PalletFaceZone = 4,
-    QueueZone = 5
+    QueueZone = 5,
+    BasketZone = 6
 }
 export type MoveMaterialNodeKind = {
     readonly type: MoveMaterialNodeKindType.Material;
@@ -23,6 +24,9 @@ export type MoveMaterialNodeKind = {
 } | {
     readonly type: MoveMaterialNodeKindType.QueueZone;
     readonly queue: string;
+} | {
+    readonly type: MoveMaterialNodeKindType.BasketZone;
+    readonly basketId: number;
 };
 export type MoveMaterialIdentifier = string;
 export declare function uniqueIdForNodeKind(kind: MoveMaterialNodeKind): MoveMaterialIdentifier;

package/dist/data/move-arrows.js

@@ -40,6 +40,7 @@ export var MoveMaterialNodeKindType;
     MoveMaterialNodeKindType[MoveMaterialNodeKindType["CompletedExpandedMaterialZone"] = 3] = "CompletedExpandedMaterialZone";
     MoveMaterialNodeKindType[MoveMaterialNodeKindType["PalletFaceZone"] = 4] = "PalletFaceZone";
     MoveMaterialNodeKindType[MoveMaterialNodeKindType["QueueZone"] = 5] = "QueueZone";
+    MoveMaterialNodeKindType[MoveMaterialNodeKindType["BasketZone"] = 6] = "BasketZone";
 })(MoveMaterialNodeKindType || (MoveMaterialNodeKindType = {}));
 export function uniqueIdForNodeKind(kind) {
     switch (kind.type) {
@@ -55,6 +56,8 @@ export function uniqueIdForNodeKind(kind) {
             return "PalletFaceZone-" + kind.face.toString();
         case MoveMaterialNodeKindType.QueueZone:
             return "QueueZone-" + kind.queue;
+        case MoveMaterialNodeKindType.BasketZone:
+            return "BasketZone-" + kind.basketId.toString();
     }
 }
 export function memoPropsForNodeKind(kind) {
@@ -69,6 +72,8 @@ export function memoPropsForNodeKind(kind) {
             return [kind.type, kind.face];
         case MoveMaterialNodeKindType.QueueZone:
             return [kind.type, kind.queue];
+        case MoveMaterialNodeKindType.BasketZone:
+            return [kind.type, kind.basketId];
     }
 }
 function groupMatByKind(allNodes) {
@@ -76,6 +81,7 @@ function groupMatByKind(allNodes) {
     let completedMaterial;
     const faces = new Map();
     const queues = new Map();
+    const baskets = new Map();
     const material = new Array();
     for (const node of allNodes.values()) {
         switch (node.type) {
@@ -92,6 +98,9 @@ function groupMatByKind(allNodes) {
             case MoveMaterialNodeKindType.QueueZone:
                 queues.set(node.queue, node.elem);
                 break;
+            case MoveMaterialNodeKindType.BasketZone:
+                baskets.set(node.basketId, node.elem);
+                break;
             case MoveMaterialNodeKindType.Material:
                 if (node.material) {
                     material.push([node.elem, node.material]);
@@ -99,7 +108,7 @@ function groupMatByKind(allNodes) {
                 break;
         }
     }
-    return { freeMaterial, completedMaterial, faces, queues, material };
+    return { freeMaterial, completedMaterial, faces, queues, baskets, material };
 }
 export function computeArrows(container, allNodes) {
     if (!container) {
@@ -112,12 +121,25 @@ export function computeArrows(container, allNodes) {
     const arrows = [];
     const faceDestUsed = new Map();
     const queueDestUsed = new Map();
+    const basketDestUsed = new Map();
     let lastFreeUsed = 0;
-    for (const [rect, mat] of LazySeq.of(byKind.material).sortBy(([rect]) => rect.left, ([rect]) => rect.top)) {
+    for (const [rect, mat] of LazySeq.of(byKind.material).sortBy(([box]) => box.left, ([box]) => box.top)) {
         switch (mat.action.type) {
             case api.ActionType.UnloadToCompletedMaterial:
             case api.ActionType.UnloadToInProcess:
-                if (mat.action.type === api.ActionType.UnloadToCompletedMaterial &&
+                if (mat.action.unloadToBasketId) {
+                    const dest = byKind.baskets.get(mat.action.unloadToBasketId);
+                    const lastSlotUsed = basketDestUsed.get(mat.action.unloadToBasketId) ?? 0;
+                    basketDestUsed.set(mat.action.unloadToBasketId, lastSlotUsed + 1);
+                    arrows.push({
+                        fromX: rect.left,
+                        fromY: rect.top + rect.height / 2,
+                        toX: dest !== undefined ? dest.right - 5 : container.left + 2,
+                        toY: dest !== undefined ? dest.top + 20 * (lastSlotUsed + 1) : rect.top + rect.height / 2,
+                        curveDirection: 1,
+                    });
+                }
+                else if (mat.action.type === api.ActionType.UnloadToCompletedMaterial &&
                     (!mat.action.unloadIntoQueue || mat.action.unloadIntoQueue === "")) {
                     arrows.push({
                         fromX: rect.right,
@@ -150,7 +172,35 @@ export function computeArrows(container, allNodes) {
                 }
                 break;
             case api.ActionType.Loading:
-                if (mat.action.loadOntoFace) {
+                if (mat.action.loadFromBasketId && mat.action.loadOntoFace) {
+                    // loading from basket onto pallet face
+                    const face = byKind.faces.get(mat.action.loadOntoFace);
+                    if (face !== undefined) {
+                        const faceSpotsUsed = faceDestUsed.get(mat.action.loadOntoFace) ?? 0;
+                        faceDestUsed.set(mat.action.loadOntoFace, faceSpotsUsed + 1);
+                        arrows.push({
+                            fromX: rect.right,
+                            fromY: rect.top + rect.height / 2,
+                            toX: face.left + 20,
+                            toY: face.top + 50 + 20 * faceSpotsUsed,
+                            curveDirection: -1,
+                        });
+                    }
+                }
+                else if (mat.action.loadFromBasketId) {
+                    // basket-only load from a queue into the active basket
+                    const dest = byKind.baskets.get(mat.action.loadFromBasketId);
+                    const lastSlotUsed = basketDestUsed.get(mat.action.loadFromBasketId) ?? 0;
+                    basketDestUsed.set(mat.action.loadFromBasketId, lastSlotUsed + 1);
+                    arrows.push({
+                        fromX: rect.right,
+                        fromY: rect.top + rect.height / 2,
+                        toX: dest !== undefined ? dest.left + 20 : container.right - 10,
+                        toY: dest !== undefined ? dest.top + 50 + 20 * lastSlotUsed : rect.top + rect.height / 2,
+                        curveDirection: -1,
+                    });
+                }
+                else if (mat.action.loadOntoFace) {
                     if (mat.location.type === api.LocType.OnPallet) {
                         if (mat.location.palletNum === mat.action.loadOntoPalletNum &&
                             mat.location.face === mat.action.loadOntoFace) {

package/dist/data/part-summary.js

@@ -33,12 +33,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 import { LazySeq, OrderedMap, OrderedSet } from "@seedtactics/immutable-collections";
 import { last30MaterialSummary } from "../cell-status/material-summary";
 import { atom } from "jotai";
-import { last30StationCycles } from "../cell-status/station-cycles";
+import { isLaborCycle, last30StationCycles } from "../cell-status/station-cycles";
 import { chartRangeAtom } from "./chart-times";
 function isAbnormal(m) {
     if (m.closeout_completed === undefined) {
         // no closeout has been done, so fall back to checking inspections and quarantined
-        if (LazySeq.ofObject(m.completedInspections ?? {}).some(([, insp]) => insp.success === false)) {
+        if (LazySeq.ofObject(m.completedInspections ?? {}).some(([, insp]) => !insp.success)) {
             return true;
         }
         if (m.currently_quarantined) {
@@ -52,7 +52,7 @@ function isAbnormal(m) {
 }
 export const last30PartSummaryRange = chartRangeAtom("part-summary");
 export const last30PartSummary = atom((get) => {
-    const mats = get(last30MaterialSummary);
+    const materialSummary = get(last30MaterialSummary);
     const cycles = get(last30StationCycles);
     const range = get(last30PartSummaryRange);
     const stationTimes = cycles
@@ -60,7 +60,7 @@ export const last30PartSummary = atom((get) => {
         .filter((c) => (range.startDate === null || c.endTime >= range.startDate) &&
         (range.endDate === null || c.endTime <= range.endDate))
         .toLookupOrderedMap((c) => c.part, (c) => c.stationGroup, (c) => ({
-        isLoadUnload: c.isLabor,
+        isLoadUnload: isLaborCycle(c),
         elapsed: c.elapsedMinsPerMaterial * c.material.length,
         active: c.activeMinutes,
         medianElapsed: c.medianCycleMinutes,
@@ -70,26 +70,26 @@ export const last30PartSummary = atom((get) => {
         active: a.active + b.active,
         medianElapsed: a.medianElapsed + b.medianElapsed,
     }));
-    return mats.matsById
+    return materialSummary.matsById
         .valuesToLazySeq()
         .filter((m) => Boolean(m.numProcesses &&
         m.unloaded_processes?.[m.numProcesses] &&
         (range.startDate === null || m.unloaded_processes[m.numProcesses] >= range.startDate) &&
         (range.endDate === null || m.unloaded_processes[m.numProcesses] <= range.endDate)))
         .toOrderedLookup((m) => m.partName)
-        .mapValues((mats, partName) => ({
+        .mapValues((partMats, partName) => ({
         part: partName,
-        completedQty: mats.length,
-        abnormalQty: LazySeq.of(mats).sumBy((m) => (isAbnormal(m) ? 1 : 0)),
-        mats: mats,
+        completedQty: partMats.length,
+        abnormalQty: LazySeq.of(partMats).sumBy((m) => (isAbnormal(m) ? 1 : 0)),
+        mats: partMats,
         stationMins: OrderedMap.empty(),
-        workorders: LazySeq.of(mats)
+        workorders: LazySeq.of(partMats)
             .toOrderedSet((m) => m.workorderId ?? "")
             .delete(""),
     }))
-        .adjust(stationTimes, (summary, stationTimes, partName) => {
+        .adjust(stationTimes, (summary, partStationTimes, partName) => {
         if (summary) {
-            return { ...summary, stationMins: stationTimes };
+            return { ...summary, stationMins: partStationTimes };
         }
         else {
             return {
@@ -97,7 +97,7 @@ export const last30PartSummary = atom((get) => {
                 completedQty: 0,
                 abnormalQty: 0,
                 mats: [],
-                stationMins: stationTimes,
+                stationMins: partStationTimes,
                 workorders: OrderedSet.empty(),
             };
         }

package/dist/data/path-lookup.js

@@ -35,19 +35,21 @@ import { addDays } from "date-fns";
 import { convertLogToInspections, } from "../cell-status/inspections.js";
 import { HashMap, LazySeq } from "@seedtactics/immutable-collections";
 import { atom } from "jotai";
-import { loadable } from "jotai/utils";
+import { unwrap } from "jotai/utils";
 export const pathLookupRange = atom(null);
 const localLogEntries = atom(async (get, { signal }) => {
     const range = get(pathLookupRange);
     if (range == null)
         return HashMap.empty();
+    if (typeof LogBackend === "undefined")
+        return HashMap.empty();
     const events = await LogBackend.get(range.curStart, range.curEnd, signal);
     return LazySeq.of(events)
         .flatMap(convertLogToInspections)
         .filter((e) => e.key.part === range.part)
         .toLookupMap((e) => e.key, (e) => e.entry.cntr, (e) => e.entry);
 });
-const localLogLoadable = loadable(localLogEntries);
+const localLogEntriesUnwrapped = unwrap(localLogEntries, (prev) => prev ?? HashMap.empty());
 const otherLogEntries = atom(async (get) => {
     const range = get(pathLookupRange);
     if (range == null)
@@ -62,28 +64,9 @@ const otherLogEntries = atom(async (get) => {
         .filter((e) => e.key.part === range.part)
         .toLookupMap((e) => e.key, (e) => e.entry.cntr, (e) => e.entry);
 });
-const otherLogLoadable = loadable(otherLogEntries);
+const otherLogEntriesUnwrapped = unwrap(otherLogEntries, (prev) => prev ?? HashMap.empty());
 export const inspectionLogEntries = atom((get) => {
-    const localEvts = get(localLogLoadable);
-    const otherEvts = get(otherLogLoadable);
-    const localData = localEvts.state === "hasData" ? localEvts.data : null;
-    const otherData = otherEvts.state === "hasData" ? otherEvts.data : null;
-    if (localData) {
-        if (!otherData) {
-            return localData;
-        }
-        else {
-            return HashMap.union((inspsByCntr1, inspsByCntr2) => inspsByCntr1.union(inspsByCntr2), localData, otherData);
-        }
-    }
-    else {
-        if (otherData) {
-            return otherData;
-        }
-        else {
-            return HashMap.empty();
-        }
-    }
+    return HashMap.union((inspsByCntr1, inspsByCntr2) => inspsByCntr1.union(inspsByCntr2), get(localLogEntriesUnwrapped), get(otherLogEntriesUnwrapped));
 });
 export function extendRange(numDays) {
     return (range) => {

package/dist/data/queue-material.d.ts

@@ -44,4 +44,4 @@ export interface QueueData {
     readonly groupedRawMat?: ReadonlyArray<QueueRawMaterialGroup>;
 }
 export declare function selectQueueData(queuesToCheck: ReadonlyArray<string>, curSt: Readonly<api.ICurrentStatus>, rawMatQueues: ReadonlySet<string>, inProcQueues: ReadonlySet<string>): ReadonlyArray<QueueData>;
-export declare function loadRawMaterialEvents(material: ReadonlyArray<Readonly<api.IInProcessMaterial>>): Promise<ReadonlyArray<Readonly<api.ILogEntry>>>;
+export declare function loadRawMaterialEvents(materials: ReadonlyArray<Readonly<api.IInProcessMaterial>>): Promise<ReadonlyArray<Readonly<api.ILogEntry>>>;