@parhelia/core 0.1.12907 → 0.1.12909

package/dist/editor/client/operations.js

@@ -5,17 +5,34 @@ import { DeleteItemsWarning } from "../DeleteItemsWarning";
 import React, { useCallback, useMemo, useRef, useState, } from "react";
 import { handleErrorResult } from "./helpers";
 import { useDebouncedCallback } from "use-debounce";
-import { createOrUpdateSuggestedEdit } from "../services/suggestedEditsService";
-import { decode } from "html-entities";
+import { createOrUpdateSuggestedEdit, deleteSuggestedEdit, } from "../services/suggestedEditsService";
+import { hasSuggestionContentChange, shouldRemoveNoOpSuggestion, } from "../reviews/suggestionContentChange";
 import { GUID_REGEX_EXACT, getItemDescriptor } from "../utils";
-import { copyItemsNeedsTerminalCompletion, waitForEditOperationTerminal, } from "./waitForEditOperationTerminal";
+import { cleanId } from "../utils/id-helper";
+import { copyItemsNeedsTerminalCompletion, normalizeOpId, waitForEditOperationTerminal, } from "./waitForEditOperationTerminal";
+import { isWorkflowMetadataField } from "../workflowFields";
 import { ExternalChangesWarningContent, TreeOperationConfirmContent, UndoDifferentItemContent, } from "./OperationDialogContent";
+import { isSuggestedEditRemoved, markSuggestedEditRemoved, upsertSuggestedEdit, } from "../reviews/suggestedEditState";
 /** When true, the delete dialog shows "permanently delete (bypass recycle bin)". */
 const ENABLE_HARD_DELETE_IN_DELETE_DIALOG = false;
 // Track pending suggested edit save requests to prevent race conditions
 const pendingSuggestedEditSaves = new Map();
 // Track pending suggested edits to prevent creating duplicates before server response
 const pendingSuggestedEdits = new Map();
+const SUGGESTED_EDIT_SAVE_DEBOUNCE_MS = 500;
+function createDelayedSuggestedEditSave(suggestedEdit) {
+    return new Promise((resolve, reject) => {
+        globalThis.setTimeout(() => {
+            if (isSuggestedEditRemoved(suggestedEdit.id)) {
+                // The suggestion was reverted to a no-op while this save was pending.
+                // It never reached the server, so there is nothing to persist or delete.
+                resolve({ type: "ignored" });
+                return;
+            }
+            createOrUpdateSuggestedEdit(suggestedEdit).then(resolve, reject);
+        }, SUGGESTED_EDIT_SAVE_DEBOUNCE_MS);
+    });
+}
 /**
  * Determines if an operation modifies the content tree structure.
  * Tree-modifying operations require confirmation before undo/redo.
@@ -31,6 +48,14 @@ function isTreeModifyingOperation(operation) {
     ];
     return treeModifyingTypes.includes(operation.type);
 }
+function getRemovedComponentIds(operation) {
+    if (operation.type !== "remove-component")
+        return [];
+    return (operation.componentIds ?? []).filter((id) => !!id);
+}
+function uniqueIds(ids) {
+    return Array.from(new Set(ids));
+}
 // Helper function to clean up pending operations for a deleted suggested edit
 export function cleanupPendingSuggestedEditOperations(suggestedEdit, user) {
     const userKey = user?.name || "unknown";
@@ -66,6 +91,7 @@ export function getOperationsContext(state, ui) {
     // hasn't been rendered yet. Cleared on each render (when stateRef.current is up-to-date).
     const recentlyUndoneIds = useRef(new Set());
     const recentlyRedoneIds = useRef(new Set());
+    const removingComponentIdsByOperationId = useRef(new Map());
     // Cache for field items (template field definitions) - these are static and don't change during editing
     // This prevents refetching on every keystroke since itemsRepository always refetches version 0
     const fieldItemsCache = useRef(new Map());
@@ -79,35 +105,82 @@ export function getOperationsContext(state, ui) {
     recentlyRedoneIds.current.clear();
     // Extract values to avoid state object reference issues
     const itemsRepository = stateRef.current.itemsRepository;
-    // Debounced version of createOrUpdateSuggestedEdit to prevent excessive API calls
-    const debouncedCreateOrUpdateSuggestedEdit = useDebouncedCallback(createOrUpdateSuggestedEdit, 500);
+    const clearInsertingIndicatorForOperation = useCallback((operationId) => {
+        const key = normalizeOpId(operationId);
+        stateRef.current.setInserting((current) => current?.operationId && normalizeOpId(current.operationId) === key
+            ? undefined
+            : current);
+    }, []);
+    const showRemovingIndicatorsForOperation = useCallback((operationId, componentIds) => {
+        if (componentIds.length === 0)
+            return;
+        const key = normalizeOpId(operationId);
+        removingComponentIdsByOperationId.current.set(key, componentIds);
+        stateRef.current.setRemovingComponentIds((current) => uniqueIds([...current, ...componentIds]));
+    }, []);
+    const clearRemovingIndicatorsForOperation = useCallback((operationId) => {
+        const key = normalizeOpId(operationId);
+        const ids = removingComponentIdsByOperationId.current.get(key);
+        if (!ids)
+            return;
+        removingComponentIdsByOperationId.current.delete(key);
+        stateRef.current.setRemovingComponentIds((current) => {
+            if (current.length === 0)
+                return current;
+            const activeRemovingIds = new Set();
+            removingComponentIdsByOperationId.current.forEach((operationIds) => {
+                operationIds.forEach((id) => activeRemovingIds.add(id));
+            });
+            return current.filter((id) => activeRemovingIds.has(id));
+        });
+    }, []);
     const executeOp = useCallback(async (op, options = {
         refresh: "immediate",
     }) => {
         console.log("Executing op", op);
+        const removedComponentIds = getRemovedComponentIds(op);
+        let keepRemovingIndicatorsUntilSocketCompletion = false;
+        if (removedComponentIds.length > 0) {
+            showRemovingIndicatorsForOperation(op.id, removedComponentIds);
+        }
         setExecutingEditOperations((ops) => (ops ? [...ops, op] : [op]));
-        const result = await executeEditOperation(op, stateRef.current.sessionId);
-        // console.log("Result", result);
-        if (!handleResult(result, options)) {
-            const failedOp = {
-                ...op,
-                executionStatus: "failed",
-            };
-            setExecutingEditOperations((ops) => ops ? ops.filter((x) => x.id !== op.id) : []);
-            return failedOp;
-        }
-        //await stateRef.current.refreshHistory(op.mainItem);
-        //stateRef.current.addToEditHistory(result.data as EditOperation);
-        const returnedOp = result.data;
-        setEditOperationExecuted(returnedOp);
-        // Only remove from executing operations if it's not a long-running operation
-        // still in progress. Long-running ops will be removed when WebSocket sends
-        // operation:completed or operation:failed
-        if (returnedOp.executionStatus !== "executing") {
-            setExecutingEditOperations((ops) => ops ? ops.filter((x) => x.id !== op.id) : []);
-        }
-        return returnedOp;
-    }, []);
+        try {
+            const result = await executeEditOperation(op, stateRef.current.sessionId);
+            // console.log("Result", result);
+            if (!handleResult(result, options)) {
+                const failedOp = {
+                    ...op,
+                    executionStatus: "failed",
+                };
+                setExecutingEditOperations((ops) => ops ? ops.filter((x) => x.id !== op.id) : []);
+                return failedOp;
+            }
+            //await stateRef.current.refreshHistory(op.mainItem);
+            //stateRef.current.addToEditHistory(result.data as EditOperation);
+            const returnedOp = result.data;
+            setEditOperationExecuted(returnedOp);
+            keepRemovingIndicatorsUntilSocketCompletion =
+                returnedOp.executionStatus === "executing";
+            // Only remove from executing operations if it's not a long-running operation
+            // still in progress. Long-running ops will be removed when WebSocket sends
+            // operation:completed or operation:failed
+            if (returnedOp.executionStatus !== "executing") {
+                setExecutingEditOperations((ops) => ops ? ops.filter((x) => x.id !== op.id) : []);
+            }
+            else {
+                // Swap in the server's "executing" version so consumers (e.g. the
+                // operations indicator) can tell long-running ops apart from ops that
+                // are merely awaiting their HTTP response
+                setExecutingEditOperations((ops) => (ops ?? []).map((x) => (x.id === op.id ? returnedOp : x)));
+            }
+            return returnedOp;
+        }
+        finally {
+            if (!keepRemovingIndicatorsUntilSocketCompletion) {
+                clearRemovingIndicatorsForOperation(op.id);
+            }
+        }
+    }, [clearRemovingIndicatorsForOperation, showRemovingIndicatorsForOperation]);
     const duplicateComponents = useCallback(({ componentIds }) => {
         const op = {
             type: "duplicate-components",
@@ -119,7 +192,7 @@ export function getOperationsContext(state, ui) {
         };
         executeOp(op);
     }, [executeOp]);
-    const addComponent = useCallback(async (componentTypeId, placeholderKey, index, pageItem) => {
+    const addComponent = useCallback(async (componentTypeId, placeholderKey, index, pageItem, options) => {
         const normalizedTypeId = (componentTypeId || "").trim();
         if (!normalizedTypeId ||
             normalizedTypeId.includes("[...]") ||
@@ -149,9 +222,28 @@ export function getOperationsContext(state, ui) {
             title: "Add component",
             addToSharedLayout,
         };
-        const result = await executeOp(op);
-        return result;
-    }, [executeOp]);
+        let keepIndicatorUntilSocketCompletion = false;
+        const showIndicator = options?.showIndicator !== false;
+        if (showIndicator) {
+            stateRef.current.setInserting({
+                placeholderKey,
+                index,
+                operationId: op.id,
+                color: options?.color,
+            });
+        }
+        try {
+            const result = await executeOp(op);
+            keepIndicatorUntilSocketCompletion =
+                result.executionStatus === "executing";
+            return result;
+        }
+        finally {
+            if (showIndicator && !keepIndicatorUntilSocketCompletion) {
+                clearInsertingIndicatorForOperation(op.id);
+            }
+        }
+    }, [clearInsertingIndicatorForOperation, executeOp]);
     const updateRenderingParameters = useCallback(async (componentId, parameters) => {
         const pageItem = stateRef.current.page?.item?.descriptor;
         if (!pageItem) {
@@ -206,8 +298,9 @@ export function getOperationsContext(state, ui) {
                     executedOp.type === "link-component" ||
                     executedOp.type === "duplicate-components")) {
                 if (executedOp.focus) {
-                    stateRef.current.setSelection([executedOp.focus]);
-                    stateRef.current.setFocusFieldComponentId(executedOp.focus);
+                    const focusId = cleanId(executedOp.focus) ?? executedOp.focus;
+                    stateRef.current.setSelection([focusId]);
+                    stateRef.current.setFocusFieldComponentId(focusId);
                     // Clear insert mode immediately after selecting the newly added component
                     if (executedOp.type === "add-component") {
                         stateRef.current.setInsertMode(false);
@@ -269,6 +362,9 @@ export function getOperationsContext(state, ui) {
         else
             stateRef.current.requestRefresh("immediate");
     }, []);
+    const refreshWorkboxAfterWorkflowChange = useDebouncedCallback(() => {
+        stateRef.current.refreshWorkbox?.();
+    }, 300, { trailing: true });
     const executeWorkflowCommandAndRefresh = useCallback(async (item, commandId) => {
         const result = await executeWorkflowCommand(item, commandId, "");
         if (result.type === "success") {
@@ -279,9 +375,12 @@ export function getOperationsContext(state, ui) {
                 };
                 ui.showErrorToast(errorMessage);
             }
+            if (result.data.succeeded) {
+                refreshWorkboxAfterWorkflowChange();
+            }
             stateRef.current.requestRefresh("immediate");
         }
-    }, [ui]);
+    }, [refreshWorkboxAfterWorkflowChange, ui]);
     const renameItem = useCallback(async (item, newName) => {
         await executeOp({
             type: "rename-item",
@@ -318,78 +417,145 @@ export function getOperationsContext(state, ui) {
         }
     }, [itemsRepository, executeOp]);
     const lastEditField = useRef(undefined);
-    const editField = useCallback(async ({ field, value, rawValue, forceMode, refresh = "immediate", }) => {
+    const pendingFieldSaves = useRef(new Map());
+    const getFieldSaveKey = (field) => {
+        const database = field.item.database || "master";
+        return `${field.item.id}:${field.item.language}:${field.item.version}:${database}:${field.fieldId}`.toLowerCase();
+    };
+    const enqueueFieldSave = useCallback(async (field, save) => {
+        const key = getFieldSaveKey(field);
+        const previousSave = pendingFieldSaves.current.get(key);
+        const queuedSave = (previousSave ?? Promise.resolve())
+            .catch(() => undefined)
+            .then(save);
+        pendingFieldSaves.current.set(key, queuedSave);
+        try {
+            await queuedSave;
+        }
+        finally {
+            if (pendingFieldSaves.current.get(key) === queuedSave) {
+                pendingFieldSaves.current.delete(key);
+            }
+        }
+    }, []);
+    const resolveOriginatingFieldModificationStore = useCallback((originatingSlotId) => {
+        if (originatingSlotId) {
+            return stateRef.current.getFieldModificationStoreForSlot?.(originatingSlotId);
+        }
+        const activeSlotStore = stateRef.current.getActiveSlotContext?.()?.fieldModificationStore;
+        if (activeSlotStore)
+            return activeSlotStore;
+        const activeSlotId = stateRef.current.getActiveSlotId?.();
+        return activeSlotId
+            ? stateRef.current.getFieldModificationStoreForSlot?.(activeSlotId)
+            : undefined;
+    }, []);
+    const editField = useCallback(async ({ field, value, rawValue, forceMode, refresh = "immediate", originatingSlotId, }) => {
         const effectiveMode = forceMode ?? stateRef.current.mode;
-        if (effectiveMode === "suggestions" && stateRef.current.page) {
+        if (effectiveMode === "suggestions" &&
+            (stateRef.current.page || stateRef.current.currentItemDescriptor)) {
             // Create a unique key for this field to track pending saves
             const fieldKey = `${field.item.id}:${field.item.language}:${field.item.version}:${field.fieldId}`;
-            // If there's already a save in progress for this field, await it first
-            const existingPromise = pendingSuggestedEditSaves.get(fieldKey);
-            if (existingPromise) {
-                try {
-                    await existingPromise;
-                }
-                catch (error) {
-                    // Continue processing even if the previous save failed
-                    console.warn("Previous suggested edit save failed:", error);
-                }
-                // Clean up any stale entries that may not have been properly removed
-                if (pendingSuggestedEditSaves.get(fieldKey) === existingPromise) {
-                    pendingSuggestedEditSaves.delete(fieldKey);
-                }
-            }
             const op = await getOrMergeSuggestedEditOp(field, rawValue, value, {
                 page: stateRef.current.page,
+                currentItemDescriptor: stateRef.current.currentItemDescriptor,
                 user: stateRef.current.user,
                 itemsRepository: itemsRepository,
+                comments: stateRef.current.comments,
+                commentsLoaded: stateRef.current.commentsLoaded,
                 suggestedEdits: stateRef.current.suggestedEdits,
                 setSuggestedEdits: stateRef.current.setSuggestedEdits,
             });
             if (op) {
-                // Create and track the save promise
-                const savePromise = debouncedCreateOrUpdateSuggestedEdit(op)
+                // Keep local suggestion state in step with typing immediately, then
+                // serialize persistence behind any in-flight save for this field.
+                const existingPromise = pendingSuggestedEditSaves.get(fieldKey);
+                if (existingPromise) {
+                    try {
+                        await existingPromise;
+                    }
+                    catch (error) {
+                        // Continue processing even if the previous save failed
+                        console.warn("Previous suggested edit save failed:", error);
+                    }
+                    // Clean up any stale entries that may not have been properly removed
+                    if (pendingSuggestedEditSaves.get(fieldKey) === existingPromise) {
+                        pendingSuggestedEditSaves.delete(fieldKey);
+                    }
+                }
+                // Create and track the save promise. useDebouncedCallback can return
+                // undefined before the trailing call runs, so this path uses a real
+                // promise that resolves after the delayed save completes.
+                const saveSnapshot = { ...op };
+                const expectedNewValue = saveSnapshot.newValue;
+                const savePromise = createDelayedSuggestedEditSave(saveSnapshot)
                     .then((result) => {
                     // Update the suggested edits state with the result from the server
                     if (result.type === "success" && result.data) {
                         const updatedEdit = result.data;
-                        const filtered = stateRef.current.suggestedEdits.filter((edit) => edit.id !== updatedEdit.id);
-                        stateRef.current.setSuggestedEdits([...filtered, updatedEdit]);
+                        if (isSuggestedEditRemoved(updatedEdit.id)) {
+                            // Reverted to a no-op while this save was in flight; make sure
+                            // it stays gone on the server and do not re-add it locally.
+                            void deleteSuggestedEdit(updatedEdit).then((deleteResult) => {
+                                if (deleteResult.type !== "success") {
+                                    console.warn("Failed to delete reverted suggestion after save:", deleteResult.summary, deleteResult.details);
+                                }
+                            }, () => undefined);
+                            return result;
+                        }
+                        stateRef.current.setSuggestedEdits((current) => upsertSuggestedEdit(current, updatedEdit, {
+                            expectedNewValue,
+                            source: "save-ack",
+                        }));
                     }
                     else if (result.type === "error" ||
                         result.type === "unauthorized") {
-                        // Show error toast for failed suggested edit save
-                        ui.showErrorToast({
-                            summary: result.summary || "Failed to save suggestion",
-                            details: result.details,
-                        });
+                        // Show error toast for failed suggested edit save — unless the
+                        // suggestion was reverted while the request was in flight, in
+                        // which case there is nothing for the user to see or retry.
+                        if (!isSuggestedEditRemoved(saveSnapshot.id)) {
+                            ui.showErrorToast({
+                                summary: result.summary || "Failed to save suggestion",
+                                details: result.details,
+                            });
+                        }
                     }
                     return result;
                 })
                     .finally(() => {
                     // Remove from pending saves when complete
-                    pendingSuggestedEditSaves.delete(fieldKey);
-                    // Also remove from pending edits since it's now persisted
+                    if (pendingSuggestedEditSaves.get(fieldKey) === savePromise) {
+                        pendingSuggestedEditSaves.delete(fieldKey);
+                    }
+                    // Also remove from pending edits once this exact value is
+                    // persisted. If the user typed again, keep the newer draft.
                     const pendingFieldKey = `${field.item.id}:${field.item.language}:${field.item.version}:${field.fieldId}:${stateRef.current.user?.name || "unknown"}`;
-                    pendingSuggestedEdits.delete(pendingFieldKey);
+                    const pendingEdit = pendingSuggestedEdits.get(pendingFieldKey);
+                    if (pendingEdit?.id === saveSnapshot.id &&
+                        pendingEdit.newValue === saveSnapshot.newValue) {
+                        pendingSuggestedEdits.delete(pendingFieldKey);
+                    }
                 });
                 pendingSuggestedEditSaves.set(fieldKey, savePromise);
                 await savePromise;
             }
             return;
         }
+        const fieldModificationStore = resolveOriginatingFieldModificationStore(originatingSlotId);
         const saveSequence = await itemsRepository.updateFieldValue(field, stateRef.current.user ?? {
             name: "unknown",
             ai: false,
             agentId: undefined,
-        }, true, value, rawValue);
+        }, true, value, rawValue, fieldModificationStore);
         if (refresh === "immediate") {
-            return editFieldImmediate({
+            return enqueueFieldSave(field, () => editFieldImmediate({
                 field,
                 value,
                 rawValue,
                 refresh,
                 saveSequence,
-            });
+                fieldModificationStore,
+            }));
         }
         const isNewField = lastEditField.current?.fieldId !== field.fieldId ||
             lastEditField.current?.item?.id !== field.item?.id ||
@@ -406,9 +572,15 @@ export function getOperationsContext(state, ui) {
             rawValue,
             refresh,
             saveSequence,
+            fieldModificationStore,
         });
-    }, [itemsRepository, getOrMergeSuggestedEditOp]);
-    const editFieldImmediate = useCallback(async ({ field, value, rawValue, refresh = "immediate", saveSequence, }) => {
+    }, [
+        itemsRepository,
+        getOrMergeSuggestedEditOp,
+        resolveOriginatingFieldModificationStore,
+        enqueueFieldSave,
+    ]);
+    const editFieldImmediate = useCallback(async ({ field, value, rawValue, refresh = "immediate", saveSequence, fieldModificationStore, }) => {
         const val = rawValue !== undefined ? rawValue : value;
         if (val === undefined)
             return;
@@ -417,7 +589,7 @@ export function getOperationsContext(state, ui) {
         // Clear dirty state so the field doesn't get stuck in "saving" state
         if (!op) {
             console.warn("[editFieldImmediate] Could not create edit operation for field:", field.fieldId);
-            itemsRepository.clearDirtyState(field);
+            itemsRepository.clearDirtyState(field, fieldModificationStore);
             return;
         }
         try {
@@ -426,32 +598,37 @@ export function getOperationsContext(state, ui) {
             // If result is undefined/null, the operation likely failed
             if (!result) {
                 console.warn("[editFieldImmediate] Edit operation returned no result, clearing dirty state");
-                itemsRepository.clearDirtyState(field);
+                itemsRepository.clearDirtyState(field, fieldModificationStore);
                 return;
             }
             // Don't refresh here - the websocket handler will trigger a refresh when
             // it receives the item-changed notification from the server. This avoids
             // duplicate refresh calls for the same edit.
-            itemsRepository.onFieldSaved(field, val, saveSequence || 0);
+            if (result.executionStatus !== "failed" &&
+                isWorkflowMetadataField(op.fieldId, op.fieldName)) {
+                refreshWorkboxAfterWorkflowChange();
+            }
+            itemsRepository.onFieldSaved(field, val, saveSequence || 0, fieldModificationStore);
         }
         catch (error) {
             // Fix: Handle network errors and other exceptions
             // Clear the dirty state to prevent the field from getting stuck in "saving" state
             console.error("[editFieldImmediate] Error saving field:", error);
-            itemsRepository.clearDirtyState(field);
+            itemsRepository.clearDirtyState(field, fieldModificationStore);
         }
-    }, [itemsRepository, executeOp]);
-    const executeEditFieldDebounced = useDebouncedCallback(async ({ field, value, rawValue, refresh, saveSequence, }) => {
+    }, [itemsRepository, executeOp, refreshWorkboxAfterWorkflowChange]);
+    const executeEditFieldDebounced = useDebouncedCallback(async ({ field, value, rawValue, refresh, saveSequence, fieldModificationStore, }) => {
         // Fix: Use the saveSequence passed from editField instead of calling
         // updateFieldValue again. This prevents the race condition where the
         // field gets marked dirty twice with different sequences.
-        return editFieldImmediate({
+        return enqueueFieldSave(field, () => editFieldImmediate({
             field,
             value,
             rawValue,
             refresh,
             saveSequence,
-        });
+            fieldModificationStore,
+        }));
     }, stateRef.current.configuration.debounceFieldEditsInterval * 2, { trailing: true });
     // Note: We intentionally keep a single save debounce window here.
     async function getEditOP(field, rawValue, value) {
@@ -1094,7 +1271,7 @@ export function getOperationsContext(state, ui) {
         const result = await new Promise((resolve) => {
             const undoCheckboxId = `delete-enable-undo-${Date.now()}`;
             const hardDeleteCheckboxId = `delete-hard-delete-${Date.now()}`;
-            const deleteOptions = (_jsxs("div", { className: "mt-4 space-y-3", children: [ENABLE_HARD_DELETE_IN_DELETE_DIALOG ? (_jsx("div", { className: "rounded-md border border-red-200 bg-red-50/60 p-3", children: _jsxs("label", { className: "flex cursor-pointer items-start gap-2", children: [_jsx("input", { type: "checkbox", id: hardDeleteCheckboxId, "data-testid": "delete-hard-delete-checkbox", defaultChecked: options?.hardDelete ?? false, className: "mt-0.5 h-4 w-4 rounded border-gray-300" }), _jsxs("span", { className: "space-y-1", children: [_jsx("span", { className: "block text-sm font-medium text-red-900", children: "Permanently delete (bypass recycle bin)" }), _jsx("span", { className: "block text-xs text-red-800", children: "This skips the recycle bin. Items can only be restored if undo is enabled for this operation." })] })] }) })) : null, _jsxs("label", { className: "flex cursor-pointer items-center gap-2", children: [_jsx("input", { type: "checkbox", id: undoCheckboxId, "data-testid": "delete-enable-undo-checkbox", defaultChecked: options?.canUndo ?? true, className: "h-4 w-4 rounded border-gray-300" }), _jsx("span", { className: "text-sm", children: "Enable undo (serializes complete content)" })] })] }));
+            const deleteOptions = (_jsxs("div", { className: "mt-4 space-y-3", children: [ENABLE_HARD_DELETE_IN_DELETE_DIALOG ? (_jsx("div", { className: "border-feedback-red bg-feedback-red-light/60 rounded-md border p-3", children: _jsxs("label", { className: "flex cursor-pointer items-start gap-2", children: [_jsx("input", { type: "checkbox", id: hardDeleteCheckboxId, "data-testid": "delete-hard-delete-checkbox", defaultChecked: options?.hardDelete ?? false, className: "border-border-default mt-0.5 h-4 w-4 rounded" }), _jsxs("span", { className: "space-y-1", children: [_jsx("span", { className: "text-feedback-red block text-sm font-medium", children: "Permanently delete (bypass recycle bin)" }), _jsx("span", { className: "text-feedback-red block text-xs", children: "This skips the recycle bin. Items can only be restored if undo is enabled for this operation." })] })] }) })) : null, _jsxs("label", { className: "flex cursor-pointer items-center gap-2", children: [_jsx("input", { type: "checkbox", id: undoCheckboxId, "data-testid": "delete-enable-undo-checkbox", defaultChecked: options?.canUndo ?? true, className: "border-border-default h-4 w-4 rounded" }), _jsx("span", { className: "text-sm", children: "Enable undo (serializes complete content)" })] })] }));
             const getEnableUndo = () => {
                 const checkbox = document.getElementById(undoCheckboxId);
                 return checkbox?.checked ?? options?.canUndo ?? true;
@@ -1129,9 +1306,9 @@ export function getOperationsContext(state, ui) {
             else {
                 // No references - use simple confirmation
                 ui.confirmationDialogRef.current?.confirm({
-                    header: "Delete Items",
-                    message: (_jsxs("div", { children: [_jsxs("p", { children: ["Are you sure you want to delete", " ", _jsx("span", { className: "font-semibold", children: itemNames }), "?"] }), deleteOptions] })),
-                    acceptLabel: "Delete",
+                    header: "Delete Items?",
+                    message: (_jsxs("div", { children: [_jsxs("p", { children: ["Are you sure you want to delete", " ", _jsx("span", { className: "font-medium", children: itemNames }), "?"] }), deleteOptions] })),
+                    acceptLabel: "Yes, delete",
                     rejectLabel: "Cancel",
                     accept: () => resolve({
                         confirmed: true,
@@ -1283,19 +1460,14 @@ export function getOperationsContext(state, ui) {
                 const terminal = await waitForEditOperationTerminal(cloneResult.id, 120_000);
                 cloneResult = { ...cloneResult, ...terminal };
             }
-            catch (e) {
-                ui.showErrorToast({
-                    summary: "Clone failed",
-                    details: e?.message || "Operation timed out",
-                });
+            catch {
+                // No terminal message within the timeout; the central lifecycle
+                // toast keeps tracking the operation
                 return [];
             }
         }
         if (cloneResult?.errorMessage) {
-            ui.showErrorToast({
-                summary: "Clone failed",
-                details: cloneResult.errorMessage,
-            });
+            // operation:failed already produced the central error toast
             return [];
         }
         if (cloneResult?.createdItemIds) {
@@ -1306,7 +1478,7 @@ export function getOperationsContext(state, ui) {
             }));
         }
         return [];
-    }, [executeOp, ui]);
+    }, [executeOp]);
     const duplicateItem = useCallback(async (item, target, name) => {
         // Use generic edit endpoint for long-running operation support
         // Duplicate is a copy to the same parent, positioned after the original
@@ -1327,19 +1499,14 @@ export function getOperationsContext(state, ui) {
                 const terminal = await waitForEditOperationTerminal(copyResult.id, 120_000);
                 copyResult = { ...copyResult, ...terminal };
             }
-            catch (e) {
-                ui.showErrorToast({
-                    summary: "Duplicate failed",
-                    details: e?.message || "Operation timed out",
-                });
+            catch {
+                // No terminal message within the timeout; the central lifecycle
+                // toast keeps tracking the operation
                 return;
             }
         }
         if (copyResult.errorMessage) {
-            ui.showErrorToast({
-                summary: "Duplicate failed",
-                details: copyResult.errorMessage,
-            });
+            // operation:failed already produced the central error toast
             return;
         }
         itemsRepository.refreshItems([target]);
@@ -1352,7 +1519,7 @@ export function getOperationsContext(state, ui) {
             };
         }
         return undefined;
-    }, [executeOp, itemsRepository, ui]);
+    }, [executeOp, itemsRepository]);
     const publishItem = useCallback(async (operation) => {
         const result = (await executeOp(operation, {
             refresh: "immediate",
@@ -1425,11 +1592,34 @@ export function getOperationsContext(state, ui) {
     // This prevents fields from getting stuck in "saving" state when navigating away
     const cleanup = useCallback(() => {
         executeEditFieldDebounced.flush();
-    }, []);
+        refreshWorkboxAfterWorkflowChange.cancel();
+    }, [executeEditFieldDebounced, refreshWorkboxAfterWorkflowChange]);
     // Function to mark an operation as no longer executing
     // Called when WebSocket receives operation:completed or operation:failed
     const markOperationComplete = useCallback((operationId) => {
-        setExecutingEditOperations((ops) => ops ? ops.filter((x) => x.id !== operationId) : []);
+        const key = normalizeOpId(operationId);
+        clearInsertingIndicatorForOperation(operationId);
+        clearRemovingIndicatorsForOperation(operationId);
+        setExecutingEditOperations((ops) => ops ? ops.filter((x) => normalizeOpId(x.id) !== key) : []);
+    }, [clearInsertingIndicatorForOperation, clearRemovingIndicatorsForOperation]);
+    // Upsert a long-running operation reported by the WebSocket. Covers ops
+    // started in another tab of the same user, which never pass through
+    // executeOp in this tab.
+    const addExecutingOperation = useCallback((operation) => {
+        const key = normalizeOpId(operation.id);
+        setExecutingEditOperations((ops) => {
+            const list = ops ?? [];
+            const existing = list.find((x) => normalizeOpId(x.id) === key);
+            if (existing) {
+                return list.map((x) => normalizeOpId(x.id) === key ? { ...x, ...operation } : x);
+            }
+            return [...list, operation];
+        });
+    }, []);
+    // Live progress for an executing operation (from operation:progress messages)
+    const updateExecutingOperationProgress = useCallback((operationId, progress, statusMessage) => {
+        const key = normalizeOpId(operationId);
+        setExecutingEditOperations((ops) => (ops ?? []).map((x) => normalizeOpId(x.id) === key ? { ...x, progress, statusMessage } : x));
     }, []);
     return useMemo(() => ({
         ops,
@@ -1437,77 +1627,160 @@ export function getOperationsContext(state, ui) {
             editOperationExecuted,
             executingEditOperations,
             markOperationComplete,
+            addExecutingOperation,
+            updateExecutingOperationProgress,
         },
         cleanup,
     }), [
         executingEditOperations,
         editOperationExecuted,
         markOperationComplete,
+        addExecutingOperation,
+        updateExecutingOperationProgress,
         ops,
         cleanup,
     ]);
 }
+function removeSuggestedEditFromState(edit, state, keys) {
+    // Tombstone first so any in-flight debounced save neither re-creates the
+    // suggestion on the server nor re-adds it to local state via its save-ack.
+    // The tombstone is permanent for the session: a save scheduled while this
+    // removal is settling (e.g. an edit queued behind the in-flight save) would
+    // otherwise fire after an early release and resurrect the suggestion.
+    markSuggestedEditRemoved(edit.id);
+    // The saves map is keyed by the field's own item descriptor (which can have
+    // a different version/language than the page the suggestion is stored
+    // under), so the caller passes the exact keys it used.
+    const pendingSave = pendingSuggestedEditSaves.get(keys.saveKey);
+    pendingSuggestedEdits.delete(keys.pendingFieldKey);
+    cleanupPendingSuggestedEditOperations(edit, state.user);
+    state.setSuggestedEdits((current) => current.filter((candidate) => candidate.id !== edit.id));
+    // Delete on the server only after any in-flight save settles, otherwise the
+    // delete can race ahead of a pending create and the suggestion comes back.
+    void Promise.resolve(pendingSave)
+        .catch(() => undefined)
+        .then(() => deleteSuggestedEdit(edit))
+        .then((result) => {
+        if (result.type !== "success") {
+            console.warn("Failed to delete no-op suggestion:", result.summary, result.details);
+        }
+    })
+        .catch((error) => {
+        console.warn("Failed to delete no-op suggestion:", error);
+    });
+}
+function getSuggestionCommentCount(edit, state) {
+    return (state.comments || []).filter((comment) => comment.suggestedEditId === edit.id).length;
+}
 async function getOrMergeSuggestedEditOp(field, rawValue, value, state) {
     const item = await state.itemsRepository.getItem(field.item);
-    if (!item)
+    if (!item) {
         return;
+    }
     const fieldItem = item.fields.find((f) => f.id === field.fieldId);
     if (!fieldItem) {
         console.log("Could not locate field in item for suggested edit:", field.fieldId);
         return;
     }
     const newVal = rawValue !== undefined ? rawValue : value;
-    if (newVal === undefined)
+    if (newVal === undefined) {
         return;
-    if (!state.page) {
+    }
+    const pageDescriptor = state.page?.item.descriptor ?? state.currentItemDescriptor;
+    if (!pageDescriptor) {
         return;
     }
-    const page = state.page;
-    // Create a unique key for this field to check for pending edits
-    const fieldKey = `${field.item.id}:${field.item.language}:${field.item.version}:${field.fieldId}:${state.user?.name || "unknown"}`;
-    // First check if there's a pending suggested edit for this field
-    const pendingEdit = pendingSuggestedEdits.get(fieldKey);
+    // Keys for the per-field bookkeeping maps. The saves map must use the same
+    // key format as editField (the field's own item descriptor — NOT the
+    // suggestion's mainItem fields, which hold the page's language/version and
+    // diverge for datasource items).
+    const saveKey = `${field.item.id}:${field.item.language}:${field.item.version}:${field.fieldId}`;
+    const fieldKey = `${saveKey}:${state.user?.name || "unknown"}`;
+    const shouldRemoveAsNoOp = (edit, nextValue) => 
+    // Comments load asynchronously; deleting on the strength of a not-yet-
+    // loaded comments array would destroy another reviewer's thread (the
+    // server cascade-deletes a suggestion's comments along with it).
+    state.commentsLoaded === true &&
+        shouldRemoveNoOpSuggestion(edit.oldValue, nextValue, () => getSuggestionCommentCount(edit, state)) &&
+        // Only auto-remove when the typed value is also a no-op against the
+        // field's live value: if the field changed underneath the suggestion, the
+        // typed content still differs from the page and must stay recorded.
+        !hasSuggestionContentChange(fieldItem.rawValue, nextValue);
+    // First check if there's a pending suggested edit for this field. A draft
+    // whose suggestion was already reverted must not be revived — a new edit
+    // mints a fresh suggestion instead.
+    let pendingEdit = pendingSuggestedEdits.get(fieldKey);
+    if (pendingEdit && isSuggestedEditRemoved(pendingEdit.id)) {
+        pendingSuggestedEdits.delete(fieldKey);
+        pendingEdit = undefined;
+    }
     if (pendingEdit) {
-        // Update the pending edit instead of creating a new one
-        pendingEdit.newValue = newVal || "";
-        pendingEdit.updated = new Date().toISOString();
-        pendingEdit.updatedBy = state.user?.name || "unknown";
-        return pendingEdit;
+        const nextValue = newVal || "";
+        if (shouldRemoveAsNoOp(pendingEdit, nextValue)) {
+            removeSuggestedEditFromState(pendingEdit, state, {
+                pendingFieldKey: fieldKey,
+                saveKey,
+            });
+            return;
+        }
+        // Update the pending edit instead of creating a new one.
+        const updatedEdit = {
+            ...pendingEdit,
+            newValue: nextValue,
+            updated: new Date().toISOString(),
+            updatedBy: state.user?.name || "unknown",
+        };
+        pendingSuggestedEdits.set(fieldKey, updatedEdit);
+        state.setSuggestedEdits((current) => upsertSuggestedEdit(current, updatedEdit, { source: "local" }));
+        return updatedEdit;
     }
-    const matchingSuggestions = state.suggestedEdits.filter((edit) => edit.mainItemId === page.item.descriptor.id &&
-        edit.mainItemLanguage === page.item.descriptor.language &&
+    const matchingSuggestions = state.suggestedEdits.filter((edit) => edit.mainItemId === pageDescriptor.id &&
+        edit.mainItemLanguage === pageDescriptor.language &&
         edit.itemId === item.id &&
         edit.fieldId === field.fieldId);
     // Attempt to find an existing suggested edit by the same user for this field.
-    const existing = matchingSuggestions.find((edit) => edit.mainItemId === page.item.descriptor.id &&
-        edit.mainItemLanguage === page.item.descriptor.language &&
-        edit.mainItemVersion === page.item.descriptor.version &&
+    // Tombstoned ids are skipped: the state snapshot can still contain a
+    // suggestion that was just reverted, and reusing its id would tie the new
+    // edit to a save pipeline that permanently ignores it.
+    const existing = matchingSuggestions.find((edit) => edit.mainItemId === pageDescriptor.id &&
+        edit.mainItemLanguage === pageDescriptor.language &&
+        edit.mainItemVersion === pageDescriptor.version &&
         edit.itemId === item.id &&
         edit.fieldId === field.fieldId &&
         edit.author === (state.user?.name || "unknown") &&
-        edit.status === "pending");
+        edit.status === "pending" && // or any status that indicates it's open for further editing.
+        !isSuggestedEditRemoved(edit.id));
     if (existing) {
+        const nextValue = newVal || "";
+        if (shouldRemoveAsNoOp(existing, nextValue)) {
+            removeSuggestedEditFromState(existing, state, {
+                pendingFieldKey: fieldKey,
+                saveKey,
+            });
+            return;
+        }
         // Update the existing suggestion.
-        existing.newValue = newVal || "";
-        existing.updated = new Date().toISOString();
-        existing.updatedBy = state.user?.name || "unknown";
-        const nextSuggestedEdits = [...state.suggestedEdits];
-        state.suggestedEdits = nextSuggestedEdits;
-        // Optionally, you might update the comments or other fields.
-        state.setSuggestedEdits(nextSuggestedEdits);
-        return existing;
+        const updatedEdit = {
+            ...existing,
+            newValue: nextValue,
+            updated: new Date().toISOString(),
+            updatedBy: state.user?.name || "unknown",
+        };
+        state.setSuggestedEdits((current) => upsertSuggestedEdit(current, updatedEdit, { source: "local" }));
+        return updatedEdit;
     }
     else {
         // Create a new suggested edit if none exists.
         const newValue = newVal || "";
         const oldValue = fieldItem.rawValue || "";
-        if (decode(newValue) === decode(oldValue))
+        if (!hasSuggestionContentChange(oldValue, newValue)) {
             return;
+        }
         const newEdit = {
             id: uuid(),
-            mainItemId: state.page?.item.descriptor.id,
-            mainItemLanguage: state.page?.item.descriptor.language,
-            mainItemVersion: state.page?.item.descriptor.version,
+            mainItemId: pageDescriptor.id,
+            mainItemLanguage: pageDescriptor.language,
+            mainItemVersion: pageDescriptor.version,
             itemId: item.id,
             fieldId: field.fieldId,
             oldValue: fieldItem.rawValue || "",
@@ -1521,9 +1794,7 @@ async function getOrMergeSuggestedEditOp(field, rawValue, value, state) {
         };
         // Add to pending edits to prevent race conditions
         pendingSuggestedEdits.set(fieldKey, newEdit);
-        const nextSuggestedEdits = [...state.suggestedEdits, newEdit];
-        state.suggestedEdits = nextSuggestedEdits;
-        state.setSuggestedEdits(nextSuggestedEdits);
+        state.setSuggestedEdits((current) => upsertSuggestedEdit(current, newEdit, { source: "local" }));
         return newEdit;
     }
 }