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

package/dist/network/api.d.ts

@@ -31,6 +31,8 @@ export declare class JobsClient {
     protected processRecent(response: Response): Promise<RecentHistoricData>;
     latestSchedule(signal?: AbortSignal): Promise<MostRecentSchedule>;
     protected processLatestSchedule(response: Response): Promise<MostRecentSchedule>;
+    completeBasketLoadStation(completion: BasketLoadStationCompletion, signal?: AbortSignal): Promise<void>;
+    protected processCompleteBasketLoadStation(response: Response): Promise<void>;
     currentStatus(signal?: AbortSignal): Promise<CurrentStatus>;
     protected processCurrentStatus(response: Response): Promise<CurrentStatus>;
     unscheduledRebookings(signal?: AbortSignal): Promise<Rebooking[]>;
@@ -710,7 +712,6 @@ export declare class CurrentStatus implements ICurrentStatus {
     baskets?: {
         [key: string]: BasketStatus;
     } | undefined;
-    basketMoveInstructions?: BasketMoveInstruction[] | undefined;
     customState?: any | undefined;
     constructor(data?: ICurrentStatus);
     init(_data?: any): void;
@@ -735,7 +736,6 @@ export interface ICurrentStatus {
     baskets?: {
         [key: string]: BasketStatus;
     } | undefined;
-    basketMoveInstructions?: BasketMoveInstruction[] | undefined;
     customState?: any | undefined;
 }
 export declare class HistoricJob extends Job implements IHistoricJob {
@@ -893,6 +893,7 @@ export declare enum LocType {
 }
 export declare class InProcessMaterialAction implements IInProcessMaterialAction {
     type: ActionType;
+    automatedTransfer?: boolean;
     workId?: string | undefined;
     loadCancellationId?: string | undefined;
     loadOntoPalletNum?: number | undefined;
@@ -916,6 +917,7 @@ export declare class InProcessMaterialAction implements IInProcessMaterialAction
 }
 export interface IInProcessMaterialAction {
     type: ActionType;
+    automatedTransfer?: boolean;
     workId?: string | undefined;
     loadCancellationId?: string | undefined;
     loadOntoPalletNum?: number | undefined;
@@ -1116,38 +1118,6 @@ export declare enum BasketLocationEnum {
     Storage = "Storage",
     InTransit = "InTransit"
 }
-export declare class BasketMoveInstruction implements IBasketMoveInstruction {
-    instructionId: string;
-    basketId: number;
-    source?: BasketPosition | undefined;
-    destination: BasketPosition;
-    reason: BasketMoveReason;
-    displayText: string;
-    prerequisiteInstructionId?: string | undefined;
-    constructor(data?: IBasketMoveInstruction);
-    init(_data?: any): void;
-    static fromJS(data: any): BasketMoveInstruction;
-    toJSON(data?: any): any;
-}
-export interface IBasketMoveInstruction {
-    instructionId: string;
-    basketId: number;
-    source?: BasketPosition | undefined;
-    destination: BasketPosition;
-    reason: BasketMoveReason;
-    displayText: string;
-    prerequisiteInstructionId?: string | undefined;
-}
-export declare enum BasketMoveReason {
-    LoadMaterial = "LoadMaterial",
-    UnloadMaterial = "UnloadMaterial",
-    ProcessTransfer = "ProcessTransfer",
-    SupplyMaterialToCell = "SupplyMaterialToCell",
-    SupplyEmptyBasket = "SupplyEmptyBasket",
-    ReturnToStorage = "ReturnToStorage",
-    RemoveForCorrection = "RemoveForCorrection",
-    Other = "Other"
-}
 export declare class ProblemDetails implements IProblemDetails {
     type?: string | undefined;
     title?: string | undefined;
@@ -1330,6 +1300,16 @@ export interface IRebooking {
     notes?: string | undefined;
     workorder?: string | undefined;
 }
+export declare class BasketLoadStationCompletion implements IBasketLoadStationCompletion {
+    workId: string;
+    constructor(data?: IBasketLoadStationCompletion);
+    init(_data?: any): void;
+    static fromJS(data: any): BasketLoadStationCompletion;
+    toJSON(data?: any): any;
+}
+export interface IBasketLoadStationCompletion {
+    workId: string;
+}
 export declare class SimulationResults implements ISimulationResults {
     scheduleId: string;
     jobs: Job[];

package/dist/network/api.js

@@ -393,6 +393,40 @@ export class JobsClient {
         }
         return Promise.resolve(null);
     }
+    completeBasketLoadStation(completion, signal) {
+        let url_ = this.baseUrl + "/api/v1/jobs/basket-load-station/complete";
+        url_ = url_.replace(/[?&]$/, "");
+        const content_ = JSON.stringify(completion);
+        let options_ = {
+            body: content_,
+            method: "POST",
+            signal,
+            headers: {
+                "Content-Type": "application/json",
+            },
+        };
+        return this.http.fetch(url_, options_).then((_response) => {
+            return this.processCompleteBasketLoadStation(_response);
+        });
+    }
+    processCompleteBasketLoadStation(response) {
+        const status = response.status;
+        let _headers = {};
+        if (response.headers && response.headers.forEach) {
+            response.headers.forEach((v, k) => (_headers[k] = v));
+        }
+        if (status === 200) {
+            return response.text().then((_responseText) => {
+                return;
+            });
+        }
+        else if (status !== 200 && status !== 204) {
+            return response.text().then((_responseText) => {
+                return throwException("An unexpected server error occurred.", status, _responseText, _headers);
+            });
+        }
+        return Promise.resolve(null);
+    }
     currentStatus(signal) {
         let url_ = this.baseUrl + "/api/v1/jobs/status";
         url_ = url_.replace(/[?&]$/, "");
@@ -3625,11 +3659,6 @@ export class CurrentStatus {
                             : new BasketStatus();
                 }
             }
-            if (Array.isArray(_data["BasketMoveInstructions"])) {
-                this.basketMoveInstructions = [];
-                for (let item of _data["BasketMoveInstructions"])
-                    this.basketMoveInstructions.push(BasketMoveInstruction.fromJS(item));
-            }
             this.customState = _data["CustomState"];
         }
     }
@@ -3700,11 +3729,6 @@ export class CurrentStatus {
                         : undefined;
             }
         }
-        if (Array.isArray(this.basketMoveInstructions)) {
-            data["BasketMoveInstructions"] = [];
-            for (let item of this.basketMoveInstructions)
-                data["BasketMoveInstructions"].push(item ? item.toJSON() : undefined);
-        }
         data["CustomState"] = this.customState;
         return data;
     }
@@ -4050,6 +4074,7 @@ export class InProcessMaterialAction {
     init(_data) {
         if (_data) {
             this.type = _data["Type"];
+            this.automatedTransfer = _data["AutomatedTransfer"];
             this.workId = _data["WorkId"];
             this.loadCancellationId = _data["LoadCancellationId"];
             this.loadOntoPalletNum = _data["LoadOntoPalletNum"];
@@ -4077,6 +4102,7 @@ export class InProcessMaterialAction {
     toJSON(data) {
         data = typeof data === "object" ? data : {};
         data["Type"] = this.type;
+        data["AutomatedTransfer"] = this.automatedTransfer;
         data["WorkId"] = this.workId;
         data["LoadCancellationId"] = this.loadCancellationId;
         data["LoadOntoPalletNum"] = this.loadOntoPalletNum;
@@ -4497,60 +4523,6 @@ export var BasketLocationEnum;
     BasketLocationEnum["Storage"] = "Storage";
     BasketLocationEnum["InTransit"] = "InTransit";
 })(BasketLocationEnum || (BasketLocationEnum = {}));
-export class BasketMoveInstruction {
-    constructor(data) {
-        if (data) {
-            for (var property in data) {
-                if (data.hasOwnProperty(property))
-                    this[property] = data[property];
-            }
-        }
-        if (!data) {
-            this.destination = new BasketPosition();
-        }
-    }
-    init(_data) {
-        if (_data) {
-            this.instructionId = _data["InstructionId"];
-            this.basketId = _data["BasketId"];
-            this.source = _data["Source"] ? BasketPosition.fromJS(_data["Source"]) : undefined;
-            this.destination = _data["Destination"]
-                ? BasketPosition.fromJS(_data["Destination"])
-                : new BasketPosition();
-            this.reason = _data["Reason"];
-            this.displayText = _data["DisplayText"];
-            this.prerequisiteInstructionId = _data["PrerequisiteInstructionId"];
-        }
-    }
-    static fromJS(data) {
-        data = typeof data === "object" ? data : {};
-        let result = new BasketMoveInstruction();
-        result.init(data);
-        return result;
-    }
-    toJSON(data) {
-        data = typeof data === "object" ? data : {};
-        data["InstructionId"] = this.instructionId;
-        data["BasketId"] = this.basketId;
-        data["Source"] = this.source ? this.source.toJSON() : undefined;
-        data["Destination"] = this.destination ? this.destination.toJSON() : undefined;
-        data["Reason"] = this.reason;
-        data["DisplayText"] = this.displayText;
-        data["PrerequisiteInstructionId"] = this.prerequisiteInstructionId;
-        return data;
-    }
-}
-export var BasketMoveReason;
-(function (BasketMoveReason) {
-    BasketMoveReason["LoadMaterial"] = "LoadMaterial";
-    BasketMoveReason["UnloadMaterial"] = "UnloadMaterial";
-    BasketMoveReason["ProcessTransfer"] = "ProcessTransfer";
-    BasketMoveReason["SupplyMaterialToCell"] = "SupplyMaterialToCell";
-    BasketMoveReason["SupplyEmptyBasket"] = "SupplyEmptyBasket";
-    BasketMoveReason["ReturnToStorage"] = "ReturnToStorage";
-    BasketMoveReason["RemoveForCorrection"] = "RemoveForCorrection";
-    BasketMoveReason["Other"] = "Other";
-})(BasketMoveReason || (BasketMoveReason = {}));
 export class ProblemDetails {
     constructor(data) {
         if (data) {
@@ -5005,6 +4977,32 @@ export class Rebooking {
         return data;
     }
 }
+export class BasketLoadStationCompletion {
+    constructor(data) {
+        if (data) {
+            for (var property in data) {
+                if (data.hasOwnProperty(property))
+                    this[property] = data[property];
+            }
+        }
+    }
+    init(_data) {
+        if (_data) {
+            this.workId = _data["WorkId"];
+        }
+    }
+    static fromJS(data) {
+        data = typeof data === "object" ? data : {};
+        let result = new BasketLoadStationCompletion();
+        result.init(data);
+        return result;
+    }
+    toJSON(data) {
+        data = typeof data === "object" ? data : {};
+        data["WorkId"] = this.workId;
+        return data;
+    }
+}
 export class SimulationResults {
     constructor(data) {
         if (data) {

package/dist/network/backend-mock.js

@@ -229,6 +229,9 @@ export function registerMockBackend(offsetSeconds, mockD, mockEvts) {
         quarantineQueuedMaterial() {
             return Promise.resolve();
         },
+        completeBasketLoadStation() {
+            return Promise.resolve();
+        },
         cancelLoad() {
             return Promise.resolve();
         },

package/dist/network/backend.d.ts

@@ -12,6 +12,7 @@ export interface JobAPI {
     addUnallocatedCastingToQueue(castingName: string, queue: string, qty: number, operatrorName: string | null, workorder: string | null, serials: string[]): Promise<ReadonlyArray<Readonly<api.IInProcessMaterial>>>;
     signalMaterialForQuarantine(materialId: number, operName: string | null, reason: string | undefined): Promise<void>;
     quarantineQueuedMaterial(materialId: number, operName: string | null, reason: string | undefined): Promise<void>;
+    completeBasketLoadStation(request: Readonly<api.IBasketLoadStationCompletion>): Promise<void>;
     cancelLoad(materialId: number, operName: string | null, request: Readonly<api.ICancelLoadRequest>): Promise<void>;
     invalidatePalletCycle(materialId: number, operName: string | null | undefined, changeCastingTo: string | null | undefined, changeJobUniqueTo: string | null | undefined, process: number): Promise<Readonly<api.IMaterialDetails> | null | undefined>;
     unscheduledRebookings(signal?: AbortSignal): Promise<ReadonlyArray<Readonly<api.IRebooking>> | null>;

package/dist/network/websocket.d.ts

@@ -1,4 +1,5 @@
 import { Atom } from "jotai";
 export declare const websocketReconnecting: Atom<boolean>;
+export declare const currentStatusIsLive: Atom<boolean>;
 export declare const errorLoadingLast30: Atom<string | null>;
 export declare function WebsocketConnection(): null;

package/dist/network/websocket.js

@@ -33,36 +33,90 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 import { ServerEvent } from "./api.js";
 import { JobsBackend, LogBackend } from "./backend.js";
 import { fmsInformation } from "./server-settings.js";
-import { useCallback, useEffect, useRef } from "react";
-import { lastEventCounter, onLoadCurrentSt, onLoadLast30Jobs, onLoadLast30Log, onServerEvent, } from "../cell-status/loading.js";
+import { useEffect, useRef } from "react";
+import { lastEventCounter, onLoadCurrentSt, onLoadLast30Jobs, onLoadLast30Log, onLiveServerEvent, onHistoricalServerEvent, } from "../cell-status/loading.js";
 import { addDays } from "date-fns";
 import { last30SchIds } from "../cell-status/scheduled-jobs.js";
+import { HashSet, OrderedMap } from "@seedtactics/immutable-collections";
 import { atom, useAtomValue, useSetAtom } from "jotai";
 const websocketReconnectingAtom = atom(false);
 export const websocketReconnecting = websocketReconnectingAtom;
+// True while the websocket is open and this connection has loaded or received a current status, so
+// the retained current status reflects the server. Loading the historical jobs and log does not
+// affect it.
+const currentStatusIsLiveRW = atom(false);
+export const currentStatusIsLive = currentStatusIsLiveRW;
+const websocketSessionAtom = atom({ id: 0, statusFromSocket: false });
+// Only historical effects wait for HTTP catch-up. A fresh session discards its predecessor's
+// unapplied buffer and reloads from lastEventCounter, which has not advanced past that history.
+const bufferedLogAtom = atom(null);
+// HTTP can include entries whose socket messages arrive after the response. Suppress those exact
+// identities, never all counters below a maximum: live publication is not guaranteed to be ordered.
+const loadedLogCountersAtom = atom(HashSet.empty());
 const errorLoadingLast30RW = atom(null);
-export const errorLoadingLast30 = errorLoadingLast30RW;
-function loadInitial(set) {
-    const now = new Date();
-    const thirtyDaysAgo = addDays(now, -30);
-    const curStProm = JobsBackend.currentStatus().then((st) => set(onLoadCurrentSt, st));
-    const jobsProm = JobsBackend.recent(thirtyDaysAgo, []).then((j) => set(onLoadLast30Jobs, j));
-    const logProm = LogBackend.get(thirtyDaysAgo, now).then((log) => set(onLoadLast30Log, log));
-    Promise.all([curStProm, jobsProm, logProm])
-        .catch((e) => set(errorLoadingLast30RW, e.message ?? "Error"))
-        .finally(() => set(websocketReconnectingAtom, false));
+const errorLoadingLogRW = atom(null);
+export const errorLoadingLast30 = atom((get) => get(errorLoadingLast30RW) ?? get(errorLoadingLogRW));
+function isCurrentSession(get, session) {
+    return get(websocketSessionAtom).id === session;
+}
+function loadCurrentStatus(get, set, session) {
+    return JobsBackend.currentStatus().then((st) => {
+        const current = get(websocketSessionAtom);
+        if (current.id !== session || current.statusFromSocket)
+            return;
+        set(onLoadCurrentSt, st);
+        set(currentStatusIsLiveRW, true);
+    });
 }
-function loadMissed(lastCntr, schIds, set) {
+function loadHistory(get, set, session, from, retryDelay = 1000) {
     const now = new Date();
-    const curStProm = JobsBackend.currentStatus().then((st) => set(onLoadCurrentSt, st));
-    const jobsProm = JobsBackend.recent(addDays(now, -30), schIds ? Array.from(schIds) : []).then((j) => set(onLoadLast30Jobs, j));
-    const logProm = LogBackend.recent(lastCntr, undefined).then((log) => set(onLoadLast30Log, log));
-    Promise.all([curStProm, jobsProm, logProm])
-        .catch((e) => set(errorLoadingLast30RW, e.message ?? "Error"))
-        .finally(() => set(websocketReconnectingAtom, false));
+    const request = from === null ? LogBackend.get(addDays(now, -30), now) : LogBackend.recent(from, undefined);
+    return request.then((log) => {
+        if (!isCurrentSession(get, session))
+            return;
+        const buffered = get(bufferedLogAtom) ?? OrderedMap.empty();
+        const merged = log.reduce((entries, entry) => entries.set(entry.counter, entry), buffered);
+        set(onLoadLast30Log, merged.valuesToAscLazySeq().toRArray());
+        set(loadedLogCountersAtom, HashSet.from(merged.keys()));
+        set(bufferedLogAtom, null);
+        set(errorLoadingLogRW, null);
+    }, (e) => {
+        if (!isCurrentSession(get, session))
+            return;
+        set(errorLoadingLogRW, e.message ?? "Error loading log history");
+        // Keep buffering and retry from the same applied position without interrupting live status.
+        setTimeout(() => {
+            if (isCurrentSession(get, session)) {
+                void loadHistory(get, set, session, from, Math.min(retryDelay * 2, 30000));
+            }
+        }, retryDelay);
+    });
+}
+function loadConnection(get, set, session) {
+    const from = get(lastEventCounter);
+    const schIds = get(last30SchIds);
+    const curStProm = loadCurrentStatus(get, set, session);
+    const jobsProm = JobsBackend.recent(addDays(new Date(), -30), from !== null && schIds ? Array.from(schIds) : []).then((j) => {
+        if (isCurrentSession(get, session))
+            set(onLoadLast30Jobs, j);
+    });
+    const logProm = loadHistory(get, set, session, from);
+    finishLoading([curStProm, jobsProm, logProm], get, set, session);
+}
+function finishLoading(loads, get, set, session) {
+    Promise.all(loads)
+        .catch((e) => {
+        if (isCurrentSession(get, session))
+            set(errorLoadingLast30RW, e.message ?? "Error");
+    })
+        .finally(() => {
+        if (isCurrentSession(get, session))
+            set(websocketReconnectingAtom, false);
+    });
 }
 class ReconnectingWebsocket {
     constructor(url) {
+        this.session = null;
         this.userCalledClose = false;
         this.reconnectAttempts = 0;
         this.url = url;
@@ -71,6 +125,12 @@ class ReconnectingWebsocket {
     close() {
         this.userCalledClose = true;
         this.ws?.close();
+        this.endSession(false);
+    }
+    endSession(reconnecting) {
+        const session = this.session;
+        this.session = null;
+        this.handleClose?.(session, reconnecting);
     }
     connect() {
         if (this.userCalledClose)
@@ -83,7 +143,7 @@ class ReconnectingWebsocket {
         localWs.addEventListener("open", () => {
             clearTimeout(connectTimeout);
             this.reconnectAttempts = 0;
-            this.handleOpen?.();
+            this.session = this.handleOpen?.() ?? null;
         });
         localWs.addEventListener("close", () => {
             clearTimeout(connectTimeout);
@@ -91,7 +151,7 @@ class ReconnectingWebsocket {
             if (this.userCalledClose) {
                 return;
             }
-            this.handleReconnecting?.();
+            this.endSession(true);
             const delay = Math.min(1000 * Math.pow(1.5, this.reconnectAttempts), 30000);
             setTimeout(() => {
                 this.reconnectAttempts++;
@@ -99,7 +159,7 @@ class ReconnectingWebsocket {
             }, delay);
         });
         localWs.addEventListener("message", (evt) => {
-            this.handleMessage?.(evt);
+            this.handleMessage?.(evt, this.session);
         });
         // Browsers expose websocket failures as opaque events with no useful detail.
         // Reconnect handling is driven by close/open, so avoid polluting stderr by
@@ -107,25 +167,51 @@ class ReconnectingWebsocket {
     }
 }
 const onOpenAtom = atom(null, (get, set) => {
-    const lastSeenCntr = get(lastEventCounter);
-    const schIds = get(last30SchIds);
+    const session = get(websocketSessionAtom).id + 1;
+    set(websocketSessionAtom, { id: session, statusFromSocket: false });
     set(websocketReconnectingAtom, true);
+    set(currentStatusIsLiveRW, false);
     set(errorLoadingLast30RW, null);
-    if (lastSeenCntr !== null && lastSeenCntr !== undefined) {
-        loadMissed(lastSeenCntr, schIds, set);
-    }
-    else {
-        loadInitial(set);
-    }
+    set(errorLoadingLogRW, null);
+    set(bufferedLogAtom, OrderedMap.empty());
+    loadConnection(get, set, session);
+    return session;
 });
-const onMessageAtom = atom(null, (_, set, evt) => {
+// Every close, including disposal, ends the socket's own session; only an unexpected close
+// reconnects. A connection cannot end a newer connection's session.
+const onCloseAtom = atom(null, (get, set, session, reconnecting) => {
+    if (reconnecting)
+        set(websocketReconnectingAtom, true);
+    if (session === null || !isCurrentSession(get, session))
+        return;
+    set(websocketSessionAtom, { id: session + 1, statusFromSocket: false });
+    set(currentStatusIsLiveRW, false);
+    set(bufferedLogAtom, null);
+});
+const onMessageAtom = atom(null, (get, set, evt, session) => {
+    if (session === null || !isCurrentSession(get, session))
+        return;
     const serverEvt = ServerEvent.fromJS(JSON.parse(evt.data));
-    set(onServerEvent, { evt: serverEvt, now: new Date(), expire: true });
+    const eventAndTime = { evt: serverEvt, now: new Date(), expire: true };
+    set(onLiveServerEvent, eventAndTime);
+    const log = serverEvt.logEntry;
+    const buffered = get(bufferedLogAtom);
+    if (!log || !get(loadedLogCountersAtom).has(log.counter)) {
+        if (log && buffered !== null) {
+            set(bufferedLogAtom, buffered.set(log.counter, log));
+        }
+        else {
+            set(onHistoricalServerEvent, eventAndTime);
+        }
+    }
+    if (serverEvt.newCurrentStatus) {
+        set(websocketSessionAtom, { id: session, statusFromSocket: true });
+        set(currentStatusIsLiveRW, true);
+    }
 });
 export function WebsocketConnection() {
     const onOpen = useSetAtom(onOpenAtom);
-    const setReconnecting = useSetAtom(websocketReconnectingAtom);
-    const onReconnecting = useCallback(() => setReconnecting(true), [setReconnecting]);
+    const onClose = useSetAtom(onCloseAtom);
     const onMessage = useSetAtom(onMessageAtom);
     const fmsInfoLoadable = useAtomValue(fmsInformation);
     const websocketRef = useRef(null);
@@ -151,7 +237,7 @@ export function WebsocketConnection() {
         }
         const websocket = new ReconnectingWebsocket(uri);
         websocket.handleOpen = onOpen;
-        websocket.handleReconnecting = onReconnecting;
+        websocket.handleClose = onClose;
         websocket.handleMessage = onMessage;
         websocketRef.current = websocket;
         return () => {
@@ -160,6 +246,6 @@ export function WebsocketConnection() {
                 websocketRef.current = null;
             }
         };
-    }, [fmsInfoLoadable, onMessage, onOpen, onReconnecting]);
+    }, [fmsInfoLoadable, onMessage, onOpen, onClose]);
     return null;
 }

package/docs/material-quarantine.md

@@ -36,10 +36,11 @@ The [operations](client-operations#material) and [quality](client-quality#quaran
 webpages allow supervisors, quality engineers and others to manually move material between the
 various quarantined queues, view all the material, add notes, re-introduce material to "active"
 queues, or scrap material. In addition, the [server configuration](server-config) contains a setting
-_QuarantineQueue_ for the initial quarantine queue. If this setting is given, the
-[station monitor webpages](client-station-monitor) will contain a button _Quarantine Material_: if
-pressed the material is moved out of the "active" whiteboard regions/queues and into the quarantine
-queue specified in the server configuration file.
+_QuarantineQueue_ for the initial quarantine queue. Direct quarantine moves material that is waiting
+in a queue into this configured queue. A quarantine signal instead records a request for the backend
+to handle material when it leaves automation control; it does not immediately move material or
+cancel a load. The [operator procedures](operator-procedures#quarantine-material) explain this
+distinction. The available actions depend on the installation and the material's current state.
 
 FMS Insight allows arbitrary quarantined material queues, but we suggest you follow a scheme similar
 to the "TODO, In-Progress, Done" Kanban task management/project management technique.

package/docs/mazak.md

@@ -2,16 +2,14 @@
 title: Mazak Palletech Integration
 nav: FMS Insight Server > Mazak
 description: >-
-  FMS Insight works with all Palletech cell controller versions from Mazak: Version E, Web Version,
-  and Smooth PMC. FMS Insight can read all events from the cell controller and can also edit almost
-  all the data in the cell controller.
+  FMS Insight supports Mazak Palletech Web Version and Smooth/Neo PMC. FMS Insight can read all
+  events from the cell controller and can also edit almost all the data in the cell controller.
 ---
 
 # FMS Insight Mazak Palletech Integration
 
-FMS Insight works with all Palletech cell controller versions from Mazak: Version E, Web Version,
-and Smooth PMC. FMS Insight can read all events from the cell controller and can also edit almost
-all the data in the cell controller.
+FMS Insight supports Mazak Palletech Web Version and Smooth/Neo PMC. FMS Insight can read all events
+from the cell controller and can also edit almost all the data in the cell controller.
 
 ## Load station numbering
 
@@ -31,8 +29,7 @@ updating configuration.
 To facilitate the communication between FMS Insight and the Mazak cell controller, you must acquire
 a program called "Mazak Open Database Kit". This is a software program developed by Mazak which
 allows safe access to the data inside the cell controller. Please contact your Mazak representative
-and ask to obtain "Open Database Kit" that matches the specific cell controller (Version E, Web, or
-Smooth PMC).
+and ask to obtain "Open Database Kit" that matches the specific cell controller (Web or Smooth PMC).
 
 ## Enable Log CSV
 
@@ -49,10 +46,10 @@ specify the same folder in the FMS Insight server configuration file.
 
 ## Load Instructions
 
-On Version E and MazakWeb, one parameter must be changed. If you are using Mazak Smooth PMC, this
-step can be skipped! Open the Mazak Palletech software, go to the parameter edit screen, select `X`,
-and scroll to the setting `X-31`. Set the `X-31` setting from 0 to 1. This setting will cause CSV
-files describing the current load and unload operation at the load station to be output to the
+On MazakWeb, one parameter must be changed. If you are using Mazak Smooth PMC, this step can be
+skipped! Open the Mazak Palletech software, go to the parameter edit screen, select `X`, and scroll
+to the setting `X-31`. Set the `X-31` setting from 0 to 1. This setting will cause CSV files
+describing the current load and unload operation at the load station to be output to the
 `c:\Mazak\FMS\LDS` directory. FMS Insight monitors this directory and uses the CSV files to display
 the parts being loaded and unloaded from each pallet at the load station.
 

package/docs/operator-procedures.md

@@ -69,6 +69,12 @@ detailed inspection, or some other rework. Material can be quarantined on the qu
 the material dialog and clicking a button. This moves the material to the quarantine queue where it
 is visible on the supervisor's material page.
 
+A quarantine signal records a request for the backend to handle material when it leaves automation
+control. The signal does not immediately move material or cancel a load. Direct quarantine moves
+material that is waiting in a queue into the configured quarantine queue. The available actions
+depend on the installation and the material's current state. Follow the displayed instructions and
+the installation's procedure before moving physical material.
+
 Once the material is ready to be re-introduced into the cell, the operator should bring it back to
 the shop floor. Once the material has arrived, the operator can click a button on the queues webpage
 (or scan the barcode) to add the material into the queue. Once it is back in the queue, the cell
@@ -94,6 +100,14 @@ quarantine queue. That material can then be re-introduced back into the queue so
 FMS Insight matches the material on the shop floor. In addition, FMS Insight allows the ability to
 invalidate the inadvertent load events that were created.
 
+Only the latest still-valid process can be invalidated. For material with recorded processes 1, 2,
+and 3, first invalidate process 3, then review the refreshed history before invalidating process 2
+in a separate action. Continue backwards one process at a time as needed. To change a casting or job
+assignment, first invalidate any later processes in separate actions.
+
+Invalidation affects whole recorded cycle events and all material listed in the confirmation. The
+original events remain in the event log but no longer contribute to active material reconstruction.
+
 Insight does not reassign recorded pallet manufacturing history from one material identity to
 another. If machining was attributed to the wrong identity, record an explanatory operator note and
 use the installation's traceability exception procedure. Quarantine, invalidation, and readmission