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

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

@@ -89,11 +89,12 @@ function shakeAnimationIteration(event) {
 }
 const MatCardHeader = styled("div", { shouldForwardProp: (prop) => prop !== "fsize" })(({ fsize, theme }) => {
     if (!fsize)
-        return { fontSize: "1.25rem" };
+        return { fontSize: "1.25rem", fontWeight: "500" };
     switch (fsize) {
         case "normal":
             return {
                 fontSize: "1rem",
+                fontWeight: "500",
                 [theme.breakpoints.up("md")]: {
                     fontSize: "1.25rem",
                 },
@@ -104,6 +105,7 @@ const MatCardHeader = styled("div", { shouldForwardProp: (prop) => prop !== "fsi
         case "large":
             return {
                 fontSize: "1.5rem",
+                fontWeight: "500",
                 [theme.breakpoints.up("lg")]: {
                     fontSize: "1.75rem",
                 },
@@ -114,6 +116,7 @@ const MatCardHeader = styled("div", { shouldForwardProp: (prop) => prop !== "fsi
         case "x-large":
             return {
                 fontSize: "1.5rem",
+                fontWeight: "500",
                 [theme.breakpoints.up("md")]: {
                     fontSize: "1.75rem",
                 },
@@ -128,11 +131,12 @@ const MatCardHeader = styled("div", { shouldForwardProp: (prop) => prop !== "fsi
 });
 const MatCardDetail = styled("div", { shouldForwardProp: (prop) => prop !== "fsize" })(({ fsize, theme }) => {
     if (!fsize)
-        return { fontSize: "0.75rem" };
+        return { fontSize: "0.75rem", fontWeight: "500" };
     switch (fsize) {
         case "normal":
             return {
                 fontSize: "0.75rem",
+                fontWeight: "500",
                 [theme.breakpoints.up("md")]: {
                     fontSize: "1rem",
                 },
@@ -140,6 +144,7 @@ const MatCardDetail = styled("div", { shouldForwardProp: (prop) => prop !== "fsi
         case "large":
             return {
                 fontSize: "1rem",
+                fontWeight: "500",
                 [theme.breakpoints.up("lg")]: {
                     fontSize: "1.5rem",
                 },
@@ -150,6 +155,7 @@ const MatCardDetail = styled("div", { shouldForwardProp: (prop) => prop !== "fsi
         case "x-large":
             return {
                 fontSize: "1rem",
+                fontWeight: "500",
                 [theme.breakpoints.up("md")]: {
                     fontSize: "1.5rem",
                 },
@@ -228,6 +234,10 @@ export function MaterialAction({ mat, displayActionForSinglePallet, fsize, }) {
                     }
                 }
             }
+        case api.ActionType.LoadingToBasket:
+            return (_jsxs(MatCardDetail, { fsize: fsize, children: ["Load into ", basketName, " ", mat.action.loadToBasketId ?? "", mat.action.loadToBasketSlot !== undefined
+                        ? ` slot ${mat.action.loadToBasketSlot + 1}`
+                        : ""] }));
         case api.ActionType.UnloadToInProcess:
         case api.ActionType.UnloadToCompletedMaterial:
             if (mat.action.unloadToBasketId) {
@@ -238,6 +248,13 @@ export function MaterialAction({ mat, displayActionForSinglePallet, fsize, }) {
             else if (mat.action.unloadIntoQueue) {
                 return (_jsxs(MatCardDetail, { fsize: fsize, children: ["Unload into queue ", mat.action.unloadIntoQueue] }));
             }
+            else if (mat.action.type === api.ActionType.UnloadToCompletedMaterial &&
+                mat.location.type === api.LocType.InBasket) {
+                return (_jsxs(MatCardDetail, { fsize: fsize, children: ["Unload from ", basketName, " ", mat.location.basketId, " to completed material"] }));
+            }
+            else if (mat.location.type === api.LocType.InBasket) {
+                return (_jsxs(MatCardDetail, { fsize: fsize, children: ["Unload from ", basketName, " ", mat.location.basketId] }));
+            }
             else {
                 return _jsx(MatCardDetail, { fsize: fsize, children: "Unload from pallet" });
             }
@@ -282,7 +299,9 @@ function Warning({ mat }) {
 function JobRawMaterial({ fsize, mat, }) {
     const job = useAtomValue(currentStatus).jobs[mat.jobUnique];
     let path = mat.path;
-    if (mat.action.type === api.ActionType.Loading && mat.action.pathAfterLoad) {
+    if ((mat.action.type === api.ActionType.Loading ||
+        mat.action.type === api.ActionType.LoadingToBasket) &&
+        mat.action.pathAfterLoad) {
         path = mat.action.pathAfterLoad;
     }
     if (!job) {

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

@@ -116,5 +116,5 @@ export function useMoveMaterialArrowRef(kind) {
 }
 export function MoveMaterialArrowNode({ kind, children, }) {
     const ref = useMoveMaterialArrowRef(kind);
-    return _jsx("div", { ref: ref, children: children });
+    return (_jsx("div", { ref: ref, "data-move-material-identifier": uniqueIdForNodeKind(kind), children: children }));
 }

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

@@ -116,10 +116,13 @@ function useQuarantineMaterial(ignoreOperator) {
             }
             break;
         case LocType.InQueue:
-            if (inProcMat.action.type === ActionType.Loading && !fmsInfo.allowQuarantineToCancelLoad) {
+            if ((inProcMat.action.type === ActionType.Loading ||
+                inProcMat.action.type === ActionType.LoadingToBasket) &&
+                !fmsInfo.allowQuarantineToCancelLoad) {
                 return null;
             }
-            else if (inProcMat.action.type === ActionType.Loading) {
+            else if (inProcMat.action.type === ActionType.Loading ||
+                inProcMat.action.type === ActionType.LoadingToBasket) {
                 type = "CancelLoad";
             }
             else {

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

@@ -54,7 +54,8 @@ function useAllowAddToQueue(queueNames) {
         return false;
     if (inProcMat?.location.type === api.LocType.OnPallet)
         return false;
-    if (inProcMat?.action.type === api.ActionType.Loading)
+    if (inProcMat?.action.type === api.ActionType.Loading ||
+        inProcMat?.action.type === api.ActionType.LoadingToBasket)
         return false;
     if (existingMat === null && !possibleNewMats) {
         return false;

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

@@ -59,10 +59,13 @@ function useCellOverview() {
         .filter((m) => m.location.type === LocType.OnPallet || m.action.type === ActionType.Loading)
         .toRLookup((m) => m.location.palletNum ?? m.action.loadOntoPalletNum ?? 0);
     const matByBasket = LazySeq.of(currentSt.material)
-        .filter((m) => m.location.type === LocType.InBasket &&
+        .filter((m) => (m.location.type === LocType.InBasket &&
         m.location.basketId !== null &&
-        m.location.basketId !== undefined)
-        .toRLookup((m) => m.location.basketId ?? 0);
+        m.location.basketId !== undefined) ||
+        (m.action.type === ActionType.LoadingToBasket &&
+            m.action.loadToBasketId !== null &&
+            m.action.loadToBasketId !== undefined))
+        .toRLookup((m) => m.location.basketId ?? m.action.loadToBasketId ?? 0);
     let loads = LazySeq.ofObject(currentSt.pallets)
         .filter(([_, p]) => p.currentPalletLocation.loc === PalletLocationEnum.LoadUnload)
         .toOrderedMap(([_, p]) => [
@@ -582,6 +585,7 @@ function Machine({ maxNumFaces, machine }) {
 }
 function useElapsedLoadTime(material) {
     const mat = material?.find((m) => m.action.type === ActionType.Loading ||
+        m.action.type === ActionType.LoadingToBasket ||
         m.action.type === ActionType.UnloadToCompletedMaterial ||
         m.action.type === ActionType.UnloadToInProcess);
     const elapsedDurationFromCurSt = mat?.action?.elapsedLoadUnloadTime;

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

@@ -126,6 +126,16 @@ export function selectAllMaterialIntoBins(curSt, curBinOrder) {
                         addToMap(loadStations, lul, mat);
                         break;
                     }
+                    case api.ActionType.LoadingToBasket: {
+                        const basket = curSt.baskets?.[mat.action.loadToBasketId ?? 0];
+                        if (basket?.position.location === api.BasketLocationEnum.LoadUnload) {
+                            addToMap(loadStations, basket.position.locationNum, mat);
+                        }
+                        else {
+                            addToMap(queues, "Free Material", mat);
+                        }
+                        break;
+                    }
                     default:
                         addToMap(queues, "Free Material", mat);
                         break;

package/dist/data/current-cycles.js

@@ -47,24 +47,17 @@ function basketsAtLoad(currentSt) {
     })
         .toRMap(([basketId, loc]) => [basketId, loc]);
 }
-function locationForLoadActivity(material, jobs, palToLoc, basketToLoad) {
-    if (material.action.type === ActionType.Loading) {
+function locationForLoadActivity(material, palToLoc, basketToLoad) {
+    if (material.action.type === ActionType.LoadingToBasket) {
+        return basketToLoad.get(material.action.loadToBasketId ?? 0) ?? null;
+    }
+    else 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 {
@@ -110,13 +103,14 @@ function loadCurrentCycles(currentSt, estimated, palToLoc, loadStationNames) {
         .collect((m) => {
         if (m.action.type === ActionType.UnloadToCompletedMaterial ||
             m.action.type === ActionType.UnloadToInProcess) {
-            const loc = locationForLoadActivity(m, currentSt.jobs, palToLoc, basketToLoad);
+            const loc = locationForLoadActivity(m, 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) {
-            const loc = locationForLoadActivity(m, currentSt.jobs, palToLoc, basketToLoad);
+        else if (m.action.type === ActionType.Loading ||
+            m.action.type === ActionType.LoadingToBasket) {
+            const loc = locationForLoadActivity(m, palToLoc, basketToLoad);
             if (!loc)
                 return null;
             return {
@@ -133,8 +127,9 @@ function loadCurrentCycles(currentSt, estimated, palToLoc, loadStationNames) {
         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) {
-            const expected = m.mat.action.loadOntoPalletNum !== null && m.mat.action.loadOntoPalletNum !== undefined
+        if (m.mat.action.type === ActionType.Loading ||
+            m.mat.action.type === ActionType.LoadingToBasket) {
+            const expected = m.mat.action.type === ActionType.Loading
                 ? pathData?.expectedLoadTime
                 : (procInfo?.expectedBasketLoadTime ?? pathData?.expectedLoadTime);
             return { ...m, expectedLoadSecs: durationToSeconds(expected ?? "PT0S") };
@@ -152,7 +147,8 @@ function loadCurrentCycles(currentSt, estimated, palToLoc, loadStationNames) {
         let outlier = false;
         let expectedSecs = 0;
         for (const { cycle: m, elapsedForSingleMaterialMinutes } of matsWithTime) {
-            const stats = estimated.get(new PartAndStationOperation(m.mat.partName, statGroup, m.mat.action.type === ActionType.Loading
+            const stats = estimated.get(new PartAndStationOperation(m.mat.partName, statGroup, m.mat.action.type === ActionType.Loading ||
+                m.mat.action.type === ActionType.LoadingToBasket
                 ? "LOAD-" + m.proc.toString()
                 : "UNLOAD-" + m.proc.toString()));
             if (stats && isOutlierAbove(stats, elapsedForSingleMaterialMinutes)) {
@@ -172,10 +168,16 @@ function loadCurrentCycles(currentSt, estimated, palToLoc, loadStationNames) {
             expectedEnd: addSeconds(currentSt.timeOfCurrentStatusUTC, -elapsedSec + expectedSecs),
             isOutlier: outlier,
             parts: LazySeq.of(mats)
-                .distinctAndSortBy((m) => m.mat.partName, (m) => m.proc, (m) => (m.mat.action.type === ActionType.Loading ? "LOAD" : "UNLOAD"))
+                .distinctAndSortBy((m) => m.mat.partName, (m) => m.proc, (m) => m.mat.action.type === ActionType.Loading ||
+                m.mat.action.type === ActionType.LoadingToBasket
+                ? "LOAD"
+                : "UNLOAD")
                 .map((m) => ({
                 part: m.mat.partName + "-" + m.proc.toString(),
-                oper: m.mat.action.type === ActionType.Loading ? "LOAD" : "UNLOAD",
+                oper: m.mat.action.type === ActionType.Loading ||
+                    m.mat.action.type === ActionType.LoadingToBasket
+                    ? "LOAD"
+                    : "UNLOAD",
             }))
                 .toRArray(),
         };

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

@@ -12,6 +12,7 @@ export declare enum MoveMaterialNodeKindType {
 export type MoveMaterialNodeKind = {
     readonly type: MoveMaterialNodeKindType.Material;
     readonly material: Readonly<api.IInProcessMaterial> | null;
+    readonly identifier?: string;
 } | {
     readonly type: MoveMaterialNodeKindType.FreeMaterialZone;
 } | {

package/dist/data/move-arrows.js

@@ -45,7 +45,7 @@ export var MoveMaterialNodeKindType;
 export function uniqueIdForNodeKind(kind) {
     switch (kind.type) {
         case MoveMaterialNodeKindType.Material:
-            return "Material-" + (kind.material?.materialID ?? -1).toString();
+            return "Material-" + (kind.identifier ?? (kind.material?.materialID ?? -1).toString());
         case MoveMaterialNodeKindType.FreeMaterialZone:
             return "FreeMaterialZone";
         case MoveMaterialNodeKindType.CompletedCollapsedMaterialZone:
@@ -63,7 +63,7 @@ export function uniqueIdForNodeKind(kind) {
 export function memoPropsForNodeKind(kind) {
     switch (kind.type) {
         case MoveMaterialNodeKindType.Material:
-            return [kind.type, kind.material];
+            return [kind.type, kind.material, kind.identifier];
         case MoveMaterialNodeKindType.FreeMaterialZone:
         case MoveMaterialNodeKindType.CompletedCollapsedMaterialZone:
         case MoveMaterialNodeKindType.CompletedExpandedMaterialZone:
@@ -257,6 +257,22 @@ export function computeArrows(container, allNodes) {
                     }
                 }
                 break;
+            case api.ActionType.LoadingToBasket: {
+                const basketId = mat.action.loadToBasketId;
+                if (basketId === undefined)
+                    break;
+                const dest = byKind.baskets.get(basketId);
+                const lastSlotUsed = basketDestUsed.get(basketId) ?? 0;
+                basketDestUsed.set(basketId, 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,
+                });
+                break;
+            }
         }
     }
     return arrows.map((arr) => ({

package/dist/data/queue-material.js

@@ -107,12 +107,14 @@ function isMatAssignedRaw(unique, m) {
     return (m.jobUnique === unique &&
         m.location.type === api.LocType.InQueue &&
         m.action.type !== api.ActionType.Loading &&
+        m.action.type !== api.ActionType.LoadingToBasket &&
         m.process === 0);
 }
 function isMatUnassignedRaw(rawMatName, m) {
     return (m.partName === rawMatName &&
         m.location.type === api.LocType.InQueue &&
         m.action.type !== api.ActionType.Loading &&
+        m.action.type !== api.ActionType.LoadingToBasket &&
         m.process === 0 &&
         !m.jobUnique);
 }

package/dist/index.html

@@ -44,8 +44,8 @@
         }
       }
     </style>
-    <script type="module" crossorigin src="/assets/index-BDPKYaRT.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CbqW4-gR.css">
+    <script type="module" crossorigin src="/assets/index-Y5yNHUvc.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DXfAwuj-.css">
   </head>
   <body>
     <noscript> You need to enable JavaScript to run this app. </noscript>

package/dist/index.js

@@ -30,16 +30,15 @@ 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 { render } from "./renderer.js";
-import { registerNetworkBackend } from "./network/backend.js";
-import { fmsInformation, loadInfo } from "./network/server-settings.js";
+import { bootstrapInsight } from "./bootstrap.js";
 import { ApiException } from "./network/api.js";
-import { createStore } from "jotai";
 async function main() {
-    registerNetworkBackend();
-    const store = createStore();
-    store.set(fmsInformation, await loadInfo());
-    render(null, document.getElementById("root"), store);
+    const developmentProps = import.meta.env.DEV
+        ? {
+            submitBasketLoadStationCommand: async () => "accepted",
+        }
+        : {};
+    await bootstrapInsight(developmentProps);
 }
 main().catch((e) => {
     console.log(e);
@@ -51,10 +50,3 @@ main().catch((e) => {
     p.textContent = msg;
     (document.getElementById("loading") ?? document.body).appendChild(p);
 });
-if ("serviceWorker" in navigator) {
-    void navigator.serviceWorker.getRegistrations().then((registrations) => {
-        for (const reg of registrations) {
-            void reg.unregister();
-        }
-    });
-}

package/dist/network/api.d.ts

@@ -221,6 +221,8 @@ export declare class LogEntry implements ILogEntry {
     loc: string;
     locnum: number;
     pal: number;
+    containerId?: string | undefined;
+    containerIds?: string[] | undefined;
     program: string;
     result: string;
     elapsed: string;
@@ -243,6 +245,8 @@ export interface ILogEntry {
     loc: string;
     locnum: number;
     pal: number;
+    containerId?: string | undefined;
+    containerIds?: string[] | undefined;
     program: string;
     result: string;
     elapsed: string;
@@ -301,7 +305,9 @@ export declare enum LogType {
     CancelRebooking = "CancelRebooking",
     BasketLoadUnload = "BasketLoadUnload",
     BasketCycle = "BasketCycle",
-    BasketInLocation = "BasketInLocation"
+    BasketInLocation = "BasketInLocation",
+    BasketIdentityHint = "BasketIdentityHint",
+    BasketContentSnapshot = "BasketContentSnapshot"
 }
 export declare class ToolUse implements IToolUse {
     tool: string;
@@ -454,6 +460,9 @@ export interface IHoldPattern {
     holdUnholdPatternRepeats: boolean;
 }
 export declare class ProcessInfo implements IProcessInfo {
+    extraFields?: {
+        [key: string]: number;
+    } | undefined;
     basketLoadStations?: number[] | undefined;
     expectedBasketLoadTime?: string | undefined;
     basketUnloadStations?: number[] | undefined;
@@ -465,6 +474,9 @@ export declare class ProcessInfo implements IProcessInfo {
     toJSON(data?: any): any;
 }
 export interface IProcessInfo {
+    extraFields?: {
+        [key: string]: number;
+    } | undefined;
     basketLoadStations?: number[] | undefined;
     expectedBasketLoadTime?: string | undefined;
     basketUnloadStations?: number[] | undefined;
@@ -710,6 +722,7 @@ export declare class CurrentStatus implements ICurrentStatus {
         [key: string]: BasketStatus;
     } | undefined;
     basketMoveInstructions?: BasketMoveInstruction[] | undefined;
+    customState?: unknown | undefined;
     constructor(data?: ICurrentStatus);
     init(_data?: any): void;
     static fromJS(data: any): CurrentStatus;
@@ -734,6 +747,7 @@ export interface ICurrentStatus {
         [key: string]: BasketStatus;
     } | undefined;
     basketMoveInstructions?: BasketMoveInstruction[] | undefined;
+    customState?: unknown | undefined;
 }
 export declare class HistoricJob extends Job implements IHistoricJob {
     scheduleId?: string | undefined;
@@ -890,11 +904,14 @@ export declare enum LocType {
 }
 export declare class InProcessMaterialAction implements IInProcessMaterialAction {
     type: ActionType;
+    workId?: string | undefined;
     loadOntoPalletNum?: number | undefined;
     loadOntoFace?: number | undefined;
     processAfterLoad?: number | undefined;
     pathAfterLoad?: number | undefined;
     loadFromBasketId?: number | undefined;
+    loadToBasketId?: number | undefined;
+    loadToBasketSlot?: number | undefined;
     unloadIntoQueue?: string | undefined;
     unloadToBasketId?: number | undefined;
     unloadToBasketSlot?: number | undefined;
@@ -909,11 +926,14 @@ export declare class InProcessMaterialAction implements IInProcessMaterialAction
 }
 export interface IInProcessMaterialAction {
     type: ActionType;
+    workId?: string | undefined;
     loadOntoPalletNum?: number | undefined;
     loadOntoFace?: number | undefined;
     processAfterLoad?: number | undefined;
     pathAfterLoad?: number | undefined;
     loadFromBasketId?: number | undefined;
+    loadToBasketId?: number | undefined;
+    loadToBasketSlot?: number | undefined;
     unloadIntoQueue?: string | undefined;
     unloadToBasketId?: number | undefined;
     unloadToBasketSlot?: number | undefined;
@@ -927,7 +947,8 @@ export declare enum ActionType {
     Loading = "Loading",
     UnloadToInProcess = "UnloadToInProcess",
     UnloadToCompletedMaterial = "UnloadToCompletedMaterial",
-    Machining = "Machining"
+    Machining = "Machining",
+    LoadingToBasket = "LoadingToBasket"
 }
 export declare class QueueInfo implements IQueueInfo {
     maxSizeBeforeStopUnloading?: number | undefined;

package/dist/network/api.js

@@ -2386,6 +2386,12 @@ export class LogEntry {
             this.loc = _data["loc"];
             this.locnum = _data["locnum"];
             this.pal = _data["pal"];
+            this.containerId = _data["containerId"];
+            if (Array.isArray(_data["containerIds"])) {
+                this.containerIds = [];
+                for (let item of _data["containerIds"])
+                    this.containerIds.push(item);
+            }
             this.program = _data["program"];
             this.result = _data["result"];
             this.elapsed = _data["elapsed"];
@@ -2424,6 +2430,12 @@ export class LogEntry {
         data["loc"] = this.loc;
         data["locnum"] = this.locnum;
         data["pal"] = this.pal;
+        data["containerId"] = this.containerId;
+        if (Array.isArray(this.containerIds)) {
+            data["containerIds"] = [];
+            for (let item of this.containerIds)
+                data["containerIds"].push(item);
+        }
         data["program"] = this.program;
         data["result"] = this.result;
         data["elapsed"] = this.elapsed;
@@ -2510,6 +2522,8 @@ export var LogType;
     LogType["BasketLoadUnload"] = "BasketLoadUnload";
     LogType["BasketCycle"] = "BasketCycle";
     LogType["BasketInLocation"] = "BasketInLocation";
+    LogType["BasketIdentityHint"] = "BasketIdentityHint";
+    LogType["BasketContentSnapshot"] = "BasketContentSnapshot";
 })(LogType || (LogType = {}));
 export class ToolUse {
     constructor(data) {
@@ -2903,6 +2917,13 @@ export class ProcessInfo {
     }
     init(_data) {
         if (_data) {
+            if (_data["ExtraFields"]) {
+                this.extraFields = {};
+                for (let key in _data["ExtraFields"]) {
+                    if (_data["ExtraFields"].hasOwnProperty(key))
+                        this.extraFields[key] = _data["ExtraFields"][key];
+                }
+            }
             if (Array.isArray(_data["BasketLoadStations"])) {
                 this.basketLoadStations = [];
                 for (let item of _data["BasketLoadStations"])
@@ -2930,6 +2951,13 @@ export class ProcessInfo {
     }
     toJSON(data) {
         data = typeof data === "object" ? data : {};
+        if (this.extraFields) {
+            data["ExtraFields"] = {};
+            for (let key in this.extraFields) {
+                if (this.extraFields.hasOwnProperty(key))
+                    data["ExtraFields"][key] = this.extraFields[key];
+            }
+        }
         if (Array.isArray(this.basketLoadStations)) {
             data["BasketLoadStations"] = [];
             for (let item of this.basketLoadStations)
@@ -3533,6 +3561,7 @@ export class CurrentStatus {
                 for (let item of _data["BasketMoveInstructions"])
                     this.basketMoveInstructions.push(BasketMoveInstruction.fromJS(item));
             }
+            this.customState = _data["CustomState"];
         }
     }
     static fromJS(data) {
@@ -3607,6 +3636,7 @@ export class CurrentStatus {
             for (let item of this.basketMoveInstructions)
                 data["BasketMoveInstructions"].push(item ? item.toJSON() : undefined);
         }
+        data["CustomState"] = this.customState;
         return data;
     }
 }
@@ -3951,11 +3981,14 @@ export class InProcessMaterialAction {
     init(_data) {
         if (_data) {
             this.type = _data["Type"];
+            this.workId = _data["WorkId"];
             this.loadOntoPalletNum = _data["LoadOntoPalletNum"];
             this.loadOntoFace = _data["LoadOntoFace"];
             this.processAfterLoad = _data["ProcessAfterLoad"];
             this.pathAfterLoad = _data["PathAfterLoad"];
             this.loadFromBasketId = _data["LoadFromBasketId"];
+            this.loadToBasketId = _data["LoadToBasketId"];
+            this.loadToBasketSlot = _data["LoadToBasketSlot"];
             this.unloadIntoQueue = _data["UnloadIntoQueue"];
             this.unloadToBasketId = _data["UnloadToBasketId"];
             this.unloadToBasketSlot = _data["UnloadToBasketSlot"];
@@ -3974,11 +4007,14 @@ export class InProcessMaterialAction {
     toJSON(data) {
         data = typeof data === "object" ? data : {};
         data["Type"] = this.type;
+        data["WorkId"] = this.workId;
         data["LoadOntoPalletNum"] = this.loadOntoPalletNum;
         data["LoadOntoFace"] = this.loadOntoFace;
         data["ProcessAfterLoad"] = this.processAfterLoad;
         data["PathAfterLoad"] = this.pathAfterLoad;
         data["LoadFromBasketId"] = this.loadFromBasketId;
+        data["LoadToBasketId"] = this.loadToBasketId;
+        data["LoadToBasketSlot"] = this.loadToBasketSlot;
         data["UnloadIntoQueue"] = this.unloadIntoQueue;
         data["UnloadToBasketId"] = this.unloadToBasketId;
         data["UnloadToBasketSlot"] = this.unloadToBasketSlot;
@@ -3996,6 +4032,7 @@ export var ActionType;
     ActionType["UnloadToInProcess"] = "UnloadToInProcess";
     ActionType["UnloadToCompletedMaterial"] = "UnloadToCompletedMaterial";
     ActionType["Machining"] = "Machining";
+    ActionType["LoadingToBasket"] = "LoadingToBasket";
 })(ActionType || (ActionType = {}));
 export class QueueInfo {
     constructor(data) {

package/dist/network/backend.d.ts

@@ -54,4 +54,6 @@ export declare function registerNetworkBackend(): void;
 export declare function setOtherLogBackends(servers: ReadonlyArray<string>): void;
 export declare function registerBackend(log: LogAPI, job: JobAPI, fms: FmsAPI, machine: MachineAPI): void;
 export declare function setUserToken(u: User): void;
+/** Performs a request using the authenticated Insight user's bearer token, when present. */
+export declare function authenticatedFetch(url: RequestInfo, init?: RequestInit): Promise<Response>;
 export declare function instructionUrl(partName: string, type: string, matId: number, pallet: number | null, proc: number | null | undefined, operator: string | null): string;

package/dist/network/backend.js

@@ -37,6 +37,7 @@ export let LogBackend;
 export let MachineBackend;
 let otherLogServers = [];
 export let OtherLogBackends = [];
+let userAccessToken;
 export function registerNetworkBackend() {
     LogBackend = new api.LogClient();
     MachineBackend = new api.MachinesClient();
@@ -54,16 +55,20 @@ export function registerBackend(log, job, fms, machine) {
     MachineBackend = machine;
 }
 export function setUserToken(u) {
-    const token = u.access_token;
-    function fetch(url, init) {
-        const headers = new Headers(init?.headers);
-        headers.set("Authorization", "Bearer " + token);
-        return window.fetch(url, init ? { ...init, headers } : { headers });
+    userAccessToken = u.access_token;
+    const http = { fetch: authenticatedFetch };
+    FmsServerBackend = new api.FmsClient(undefined, http);
+    JobsBackend = new api.JobsClient(undefined, http);
+    LogBackend = new api.LogClient(undefined, http);
+    OtherLogBackends = otherLogServers.map((s) => new api.LogClient(s, http));
+}
+/** Performs a request using the authenticated Insight user's bearer token, when present. */
+export function authenticatedFetch(url, init) {
+    const headers = new Headers(init?.headers);
+    if (userAccessToken) {
+        headers.set("Authorization", "Bearer " + userAccessToken);
     }
-    FmsServerBackend = new api.FmsClient(undefined, { fetch });
-    JobsBackend = new api.JobsClient(undefined, { fetch });
-    LogBackend = new api.LogClient(undefined, { fetch });
-    OtherLogBackends = otherLogServers.map((s) => new api.LogClient(s, { fetch }));
+    return window.fetch(url, init ? { ...init, headers } : { headers });
 }
 export function instructionUrl(partName, type, matId, pallet, proc, operator) {
     return ("/api/v1/fms/find-instructions/" +