canopycms 0.11.1 → 0.12.1

package/dist/editor/Editor.js

@@ -16,7 +16,10 @@ import { EditorShell } from './shell/EditorShell.js';
 import { FORM_PANE_ID, PaneLayout } from './shell/PaneLayout.js';
 import { SidePanelHost } from './shell/SidePanelHost.js';
 import { CanopyCMSProvider } from './theme.js';
-import { BranchManager } from './BranchManager.js';
+import { BranchManager, getBranchPermissions } from './BranchManager.js';
+import { useBaseUpdate } from './hooks/useBaseUpdate.js';
+import { BaseUpdateNotice } from './components/BaseUpdateNotice.js';
+import { WAITING_NOTICE, WAITING_SUBMIT_REASON, getLatestChangesTooltip, } from './base-update-wait.js';
 import { BranchesDrawer } from './components/BranchesDrawer.js';
 import { CommentsPanel } from './CommentsPanel.js';
 import { GroupManager } from './GroupManager.js';
@@ -31,6 +34,13 @@ import { useEditorLayout, useDraftManager, useEntryManager, useGroupManager, use
 import { useBranchActions } from './hooks/useBranchActions.js';
 import { branchAddress, displayBranchName } from './branch-names.js';
 import { useBranchChangesData, useEntryChangeData } from './hooks/useBranchChangesData.js';
+import { useBranchConflictsData, useEntryConflictData } from './hooks/useConflictsData.js';
+import { useConflictChoices } from './hooks/useConflictChoices.js';
+import { openConfirm } from './utils/confirm-modal.js';
+import { canopyPathOf } from './undo-change.js';
+import { placeOf } from './conflict-choices.js';
+import { findBodyFieldName } from '../utils/body-field.js';
+import { entryConflictNotice } from './conflict-notice.js';
 import { LazyEntryChangesDrawer } from './components/LazyEntryChangesDrawer.js';
 import { CONTENT_PANEL_WIDTH_MAX, CONTENT_PANEL_WIDTH_MIN, editorLayoutStorageKey, } from './hooks/useEditorLayout.js';
 import { EntrySchemaUnavailableError } from './hooks/useEntryManager.js';
@@ -38,6 +48,7 @@ import { useEntryLinkResolution } from './hooks/useEntryLinkResolution.js';
 import { useReferenceResolution } from './hooks/useReferenceResolution.js';
 import { usePreviewMarks } from './hooks/usePreviewMarks.js';
 import { branchBarStatus, describeBranchLock } from './branch-lock.js';
+import { EDITOR_ACTIONS, NO_EDIT_ACCESS_REASON } from './copy.js';
 import { EditorHeader, EditorRail, EntryHeader } from './components/index.js';
 import { showSaveAllResult } from './components/SaveAllResult.js';
 import { RenameEntryModal } from './components/RenameEntryModal.js';
@@ -67,7 +78,21 @@ import { findFieldTarget, focusFieldTarget } from './field-target.js';
 import { PreviewFollowContext, usePreviewFollow } from './hooks/usePreviewFollow.js';
 import { UndoToastMessage } from './components/UndoToastMessage.js';
 import { getNotificationDuration } from './utils/env.js';
-import { MayHaveLandedError } from './unanswered.js';
+import { MayHaveLandedError, isGatewayFailure, isUnanswered } from './unanswered.js';
+import { releaseConflictsHold } from './release-hold.js';
+/** The collection at `path` in a collection tree. */
+const findCollection = (cols, path) => {
+    if (!cols)
+        return undefined;
+    for (const col of cols) {
+        if (col.path === path)
+            return col;
+        const found = findCollection(col.children, path);
+        if (found)
+            return found;
+    }
+    return undefined;
+};
 // Stable fallbacks, so reference resolution's memo and effect don't re-run on every render
 // while no entry is open.
 const EMPTY_SCHEMA = [];
@@ -168,6 +193,10 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
     // Reloads the open branch's comments after a request for changes, whose note is a comment; the
     // comment system is built further down.
     const reloadCommentsRef = useRef(() => { });
+    // Set once useBaseUpdate below exists; it depends on the drafts.
+    const requestLatestRef = useRef(async () => { });
+    const modifiedCountRef = useRef(0);
+    const namesBranchRef = useRef(() => false);
     const { branchName: branchNameState, setBranchName, branches, branchSummaries, currentBranch, currentAddress, listedBranch, namesBranch, urlBranchName, branchesLoadFailed, branchesLoaded, addCreatedBranch, handleSubmit, handleWithdraw, handleApprove, handleRequestChanges, handleDelete, handleArchive, handleReloadBranchData, loadBranches, } = useBranchManager({
         initialBranch: branchName,
         operatingMode,
@@ -177,6 +206,10 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
         getUnsaved: () => resolveUnsavedRef.current(),
         onStamped: (stamped) => applySubmitStampsRef.current(stamped),
         onChangesRequested: (branch) => reloadCommentsRef.current(branch),
+        // Only the open branch, with nothing unsaved: its wait and answer show where the user is.
+        latestChangesAfterWithdraw: (branch) => namesBranchRef.current(branch) && modifiedCountRef.current === 0
+            ? () => requestLatestRef.current()
+            : undefined,
     });
     // Content mutations (add/delete/rename/reorder entries) are locked whenever the
     // server says writes are blocked -- the protected base branch, or a workflow
@@ -196,6 +229,21 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
     // No lock reason is true yet while the list is unanswered; once it has failed, or answered
     // without this branch, the lock says which.
     const branchPending = !currentBranch && !branchesLoaded && !branchesLoadFailed;
+    // Conflicts a merge left on the open branch (api/merge-conflicts.ts): read while its listing
+    // names any, and the choices made on their cards that no save has sent yet.
+    const branchConflicts = useBranchConflictsData(apiClient, branchNameState, currentBranch?.conflictFiles, 
+    // Every viewer reads it, as a hold on the branch names no entry.
+    true);
+    const openConflictCount = currentBranch?.conflictFiles?.length
+        ? (branchConflicts.data?.openCount ?? currentBranch.conflictFiles.length)
+        : 0;
+    const conflictChoices = useConflictChoices(branchNameState);
+    // A save that sent choices re-reads what they resolved; set once the readers exist, below.
+    const conflictsSavedRef = useRef(() => { });
+    // An admin's "Keep your version" on a collection's conflicts; set once the resolver exists, below.
+    const keepConflictsRef = useRef(() => { });
+    // The "Get latest changes" toast's "Show changes"; set once the drawer exists, below.
+    const showConflictsRef = useRef(() => { });
     // The same inputs EditorHeader gives its own check, for the lock copy that names the way forward.
     const branchReviewRole = reviewRoleOf({
         status: currentBranch?.status,
@@ -244,6 +292,13 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
         sameBranch: namesBranch,
         urlBranchName,
         onContentRefresh: (branch) => reloadChangesRef.current(branch),
+        conflictResolutions: {
+            pending: conflictChoices.pending,
+            onSaved: (branch, contentId, sent) => {
+                conflictChoices.sent(branch, contentId, sent);
+                conflictsSavedRef.current();
+            },
+        },
         // To the entry menu, which names the entry opened; a dialog keeps focus.
         onHistoryRestore: () => requestAnimationFrame(() => {
             if (!document.activeElement?.closest('[role="dialog"]')) {
@@ -321,7 +376,7 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
         setPreviewError(null);
     }, [currentEntry?.contentId]);
     // 3. Draft manager (depends on branchNameState, selectedPath from useEntryManager)
-    const { drafts, setDrafts, loadedValues, setLoadedValues, loadedValue, effectiveValue, modifiedCount, editedFiles, handleSave, singleSaving, lastSaved, handleSaveAll, saveAllProgress, isSaveAllRunning, handleDiscardDrafts, handleDiscardFileDraft, handleReload, isSelectedDirty, resolveUnsaved, fieldErrors, draftStorageFailed, applySubmitStamps, } = useDraftManager({
+    const { drafts, setDrafts, loadedValues, setLoadedValues, loadedValue, effectiveValue, modifiedCount, editedFiles, handleSave, singleSaving, lastSaved, handleSaveAll, saveAllProgress, isSaveAllRunning, handleDiscardDrafts, handleDiscardFileDraft, handleReload, isSelectedDirty, isDirtyForEntry, resolveUnsaved, fieldErrors, draftStorageFailed, applySubmitStamps, } = useDraftManager({
         branchName: branchNameState,
         selectedPath,
         currentEntry,
@@ -341,10 +396,47 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
             void refreshEntries(branchNameState).catch((err) => console.error('Failed to refresh entries after save', err));
         },
         // An Undo built on a discarded draft would put back an item the server's copy already has.
-        onDraftsReset: (contentId) => dismissUndoToasts(contentId),
+        // A conflict choice is part of the draft, so it goes with it.
+        onDraftsReset: (contentId) => {
+            dismissUndoToasts(contentId);
+            conflictChoices.clear(contentId);
+        },
+        pendingIds: conflictChoices.pendingIds,
     });
     resolveUnsavedRef.current = resolveUnsaved;
     applySubmitStampsRef.current = applySubmitStamps;
+    // "Get latest changes" on the open branch: the worker rewrites its files meanwhile, so the form
+    // is read-only while it waits (`latestWaiting`), and every clean entry is read again after.
+    const currentSummary = branchSummaries.find((b) => b.name === currentBranch?.name);
+    const baseUpdate = useBaseUpdate({
+        branch: currentBranch,
+        operatingMode,
+        permitted: !!currentSummary && getBranchPermissions(currentSummary, userContext).canSubmit,
+        unsavedCount: modifiedCount,
+        onUpdated: () => {
+            setLoadedValues((prev) => Object.fromEntries(Object.entries(prev).filter(([contentId]) => draftsRef.current[contentId] !== undefined)));
+            void Promise.all([handleReloadBranchData(), refreshEntries(branchNameState)]).catch(console.error);
+        },
+        onShowConflicts: () => showConflictsRef.current(),
+    });
+    requestLatestRef.current = baseUpdate.request;
+    modifiedCountRef.current = modifiedCount;
+    namesBranchRef.current = (branch) => namesBranch(branch, branchNameState);
+    // The request in flight counts as waiting: a save landing before the worker reads the branch
+    // would make it fail.
+    const latestWait = baseUpdate.requesting && baseUpdate.wait === 'none' ? 'waiting' : baseUpdate.wait;
+    const latestWaiting = latestWait === 'waiting';
+    const baseUpdateControl = baseUpdate.available
+        ? {
+            wait: baseUpdate.wait,
+            requesting: baseUpdate.requesting,
+            blockedReason: baseUpdate.blockedReason,
+            tooltip: getLatestChangesTooltip(currentBranch?.baseBranch, userIsAdmin),
+            onRequest: () => void baseUpdate.request(),
+        }
+        : undefined;
+    // Content writes wait on the branch's lock, and on the latest changes coming in.
+    const contentLocked = branchContentLocked || latestWaiting;
     // 4. Branch actions (depends on resolveUnsaved, setBranchName)
     const { handleBranchChange, confirmCreate: confirmCreateBranch, handleCreateBranch, confirmOpen: branchConfirmOpen, } = useBranchActions({
         branchName: branchNameState,
@@ -408,7 +500,7 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
     });
     // Read-only content shows the saved value, never a draft; a restored draft is kept, unseen,
     // until it is discarded or the branch unlocks.
-    const contentReadOnly = branchContentLocked || currentEntry?.canEdit === false;
+    const contentReadOnly = contentLocked || currentEntry?.canEdit === false;
     const displayValue = contentReadOnly ? loadedValue : effectiveValue;
     // Read when an edit lands, which an upload or other async field work can do renders later.
     const contentReadOnlyRef = useRef(contentReadOnly);
@@ -504,7 +596,9 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
     };
     useEffect(() => () => dismissUndoToasts(), [currentEntry?.contentId, branchNameState]);
     // Only once the branch has answered, so the fail-closed lock while it loads raises no notice.
-    const hiddenDraftNotice = contentReadOnly && currentBranch !== undefined && !!currentEntry && isSelectedDirty();
+    const draftHidden = contentReadOnly && currentBranch !== undefined && !!currentEntry && isSelectedDirty();
+    // While the latest changes come in, the waiting notice says the draft comes back; it is the one notice.
+    const hiddenDraftNotice = draftHidden && !latestWaiting;
     const collectionLabels = useMemo(() => buildCollectionLabels(activeCollections), [activeCollections]);
     const schema = currentEntry?.schema ?? EMPTY_SCHEMA;
     // Field threads follow their items' keys, placed in their entry's value where it is at hand.
@@ -512,7 +606,7 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
         if (entry.path === currentEntry?.path)
             return displayValue;
         // As `displayValue` would show it: read-only content shows its saved value, not a draft.
-        const readOnly = branchContentLocked || entry.canEdit === false;
+        const readOnly = contentLocked || entry.canEdit === false;
         return (readOnly ? undefined : drafts[entry.contentId]) ?? loadedValues[entry.contentId];
     };
     const displayComments = useMemo(() => {
@@ -530,15 +624,7 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
             return path === thread.canopyPath ? thread : { ...thread, canopyPath: path };
         });
         // `entryValue` reads the open entry, its shown value, and the drafts and loads.
-    }, [
-        comments,
-        entriesState,
-        currentEntry,
-        displayValue,
-        drafts,
-        loadedValues,
-        branchContentLocked,
-    ]);
+    }, [comments, entriesState, currentEntry, displayValue, drafts, loadedValues, contentLocked]);
     // A jump into another entry waits for its value to place the thread; the stored path may be stale.
     const [pendingFieldJump, setPendingFieldJump] = useState(null);
     // A field whose comments are already open is still followed in the preview.
@@ -1012,18 +1098,6 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
         }
     };
     const handleReorderEntry = async (collectionPath, contentId, direction) => {
-        const findCollection = (cols, path) => {
-            if (!cols)
-                return undefined;
-            for (const col of cols) {
-                if (col.path === path)
-                    return col;
-                const found = findCollection(col.children, path);
-                if (found)
-                    return found;
-            }
-            return undefined;
-        };
         // Resolve against `collectionsFromApi`, NOT `activeCollections`: the latter
         // falls back to the build-time `collections` prop whenever the fetch is
         // still empty -- exactly the state mid-branch-switch. A write resolved
@@ -1107,6 +1181,11 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
             const entries = grouped.get(node.path) ?? [];
             const children = node.children?.map((child) => build(child)) ?? [];
             const unavailableRefs = unavailableSchemaRefs(node.entryTypes);
+            // Conflicts on the collection's settings or other files, which no entry's "Show changes"
+            // reaches; the API names them to admins only, by the collection's path.
+            const keepable = userIsAdmin
+                ? (branchConflicts.data?.conflicts ?? []).filter((c) => c.logicalPath === node.path && !entriesState.some((e) => e.contentId === c.contentId))
+                : [];
             // No entry can be created where every entry type is unavailable.
             const allUnavailable = !!node.entryTypes?.length && node.entryTypes.every((et) => et.unavailable);
             // A collection that holds only collections has no entry type to add (`entryTypes` is
@@ -1121,7 +1200,16 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
                 order: node.order,
                 entries: entries.length > 0 ? entries : undefined,
                 children: children.length > 0 ? children : undefined,
-                conflictNotice: !!(node.contentId && currentBranch?.conflictFiles?.includes(node.contentId)),
+                conflictNotice: !!(node.contentId && currentBranch?.conflictFiles?.includes(node.contentId)) ||
+                    keepable.length > 0,
+                ...(keepable.length > 0 && {
+                    conflictKeep: {
+                        label: keepable.every((c) => c.path.endsWith('.collection.json'))
+                            ? 'Keep your version of its settings'
+                            : 'Keep your version of its files',
+                        onKeep: () => keepConflictsRef.current(keepable),
+                    },
+                }),
                 unavailableSchemaRefs: unavailableRefs.length > 0 ? unavailableRefs : undefined,
                 addRefused: (addable && node.canAddEntry === false) || undefined,
                 onAdd: canAddEntry
@@ -1150,6 +1238,7 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
         currentBranch,
         schemaUnavailableKeys,
         userIsAdmin,
+        branchConflicts.data,
     ]);
     const findShortcut = modKeyLabel() === '⌘' ? { label: '⌘P', keys: 'Meta+P' } : { label: 'Ctrl+P', keys: 'Control+P' };
     // Mod+P opens a closed docked panel only until Enter, Escape from inside it or focus leaves it;
@@ -1284,7 +1373,11 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
         standIn: () => null,
     });
     const showChangesRef = useRef(null);
+    // A confirm never opens over the drawer, nor while it closes: its focus return would take
+    // focus out of the confirm. So "Delete entry" closes the drawer, and its exit opens the confirm.
+    const deleteAfterChangesRef = useRef();
     useEffect(() => {
+        deleteAfterChangesRef.current = undefined;
         setChangesOpen(false);
         setChangesShown(false);
     }, [branchNameState]);
@@ -1295,6 +1388,259 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
             id: changesSubject.contentId,
         }
         : undefined);
+    // The drawer's entry's conflicts, read while it shows one the branch lists.
+    const changesConflictTarget = (changesOpen || changesShown) &&
+        changesSubject?.contentId &&
+        currentBranch?.conflictFiles?.includes(changesSubject.contentId)
+        ? { logicalPath: changesSubject.logicalPath, id: changesSubject.contentId }
+        : undefined;
+    const entryConflict = useEntryConflictData(apiClient, branchNameState, changesConflictTarget);
+    conflictsSavedRef.current = () => {
+        void Promise.all([
+            branchConflicts.reload(),
+            entryConflict.reload(),
+            handleReloadBranchData(),
+        ]).catch(console.error);
+    };
+    // "Edit" on a card closes the drawer, and its exit focuses the field in the form.
+    const focusAfterChangesRef = useRef();
+    // An entry-level choice that replaces stored work, "Delete entry" or "Use latest version",
+    // confirms once the drawer has closed; any way out of the confirm but Confirm opens it again.
+    const confirmAfterChangesRef = useRef();
+    const focusConflictField = (field) => {
+        revealForm();
+        requestAnimationFrame(() => {
+            const id = currentEntry?.contentId;
+            const value = id && (draftsRef.current[id] ?? loadedValuesRef.current[id]);
+            const schema = currentEntry?.schema;
+            if (!value || !schema)
+                return;
+            const bodyField = currentEntry.format === 'md' || currentEntry.format === 'mdx'
+                ? findBodyFieldName(schema)
+                : undefined;
+            const at = canopyPathOf(value, placeOf(field), bodyField);
+            const target = at && findFieldTarget(formatCanopyPath(at));
+            if (target)
+                focusFieldTarget(target.element);
+        });
+    };
+    const resolveEntryConflict = async (logicalPath, id, mergeSha, choice) => {
+        const branch = branchNameState;
+        const failed = {
+            tone: 'error',
+            message: 'Couldn’t save your choice. Try again.',
+        };
+        let answer;
+        try {
+            answer = await apiClient.conflicts.resolveEntry({ branch, entryPath: logicalPath }, { id: id, mergeSha, choice });
+        }
+        catch (err) {
+            if (!isUnanswered(err))
+                return failed;
+        }
+        if (!answer || isGatewayFailure(answer) || answer.code === 'WRITE_OUTCOME_UNKNOWN') {
+            // Reading the conflict again settles it: the card goes if the choice went through.
+            void Promise.all([entryConflict.reload(), branchConflicts.reload()]).catch(console.error);
+            return {
+                tone: 'warning',
+                message: 'Your choice may have gone through even though the server didn’t answer. If this card is still here, choose again.',
+            };
+        }
+        if (!answer.ok) {
+            // The record moved on, or the entry moved or left the branch: what is left to choose shows.
+            if (answer.code === 'CONFLICT_CHANGED' || answer.code === 'ENTRY_GONE') {
+                void Promise.all([
+                    entryConflict.reload(),
+                    branchConflicts.reload(),
+                    refreshEntries(branch),
+                ]).catch(console.error);
+            }
+            if (answer.status !== 409)
+                return { ...failed, message: answer.error ?? failed.message };
+            const error = answer.error ?? failed.message;
+            // A latest version that can't replace this entry leaves keeping yours, then editing it.
+            return {
+                tone: 'warning',
+                message: choice === 'use-latest' && !answer.code
+                    ? `${error} Choose "${EDITOR_ACTIONS.keepYourVersion}", then edit it to match.`
+                    : error,
+            };
+        }
+        // The entry's file may have changed, so its saved copy is read again.
+        setLoadedValues((prev) => {
+            if (!(id in prev))
+                return prev;
+            const { [id]: _reread, ...rest } = prev;
+            return rest;
+        });
+        void Promise.all([
+            branchConflicts.reload(),
+            entryConflict.reload(),
+            handleReloadBranchData(),
+            refreshEntries(branch),
+        ]).catch(console.error);
+        return undefined;
+    };
+    // An admin's release of a branch held as its record of conflicts was set aside.
+    const handleReleaseConflictsHold = async () => {
+        const result = await releaseConflictsHold(apiClient, branchNameState);
+        if ('released' in result) {
+            notifications.show({
+                message: result.wasHeld === true
+                    ? 'Hold released.'
+                    : result.wasHeld === false
+                        ? 'This branch was already released.'
+                        : 'This branch is no longer on hold.',
+                color: 'green',
+            });
+            void branchConflicts.reload();
+        }
+        return result;
+    };
+    keepConflictsRef.current = (items) => {
+        void Promise.all(items.map((c) => c.logicalPath
+            ? resolveEntryConflict(c.logicalPath, c.contentId, c.mergeSha, 'keep')
+            : Promise.resolve(undefined))).then((answers) => {
+            const refusals = answers.filter((r) => r !== undefined);
+            if (refusals.length === 0)
+                return;
+            const more = refusals.length > 1 ? ` (${refusals.length} of ${items.length} weren’t kept.)` : '';
+            notifications.show({
+                message: `${refusals[0].message}${more}`,
+                color: refusals.some((r) => r.tone === 'error') ? 'red' : 'yellow',
+                autoClose: false,
+            });
+        });
+    };
+    const changesResolveEntry = changesSubject && entryConflict.data
+        ? async (choice) => {
+            const { contentId: id, mergeSha, kind } = entryConflict.data ?? {};
+            if (!id || !mergeSha)
+                return undefined;
+            if (choice === 'delete' || (choice === 'use-latest' && kind === 'unreadable')) {
+                confirmAfterChangesRef.current = {
+                    logicalPath: changesSubject.logicalPath,
+                    id,
+                    mergeSha,
+                    title: changesSubject.title,
+                    choice,
+                };
+                setChangesOpen(false);
+                return undefined;
+            }
+            return resolveEntryConflict(changesSubject.logicalPath, id, mergeSha, choice);
+        }
+        : undefined;
+    const confirmEntryChoice = (target) => {
+        const branch = branchNameState;
+        const deleting = target.choice === 'delete';
+        let confirmed = false;
+        openConfirm({
+            title: deleting ? 'Delete entry?' : 'Use the latest version?',
+            children: (_jsx(Text, { size: "sm", children: deleting
+                    ? `“${target.title}” was deleted in the latest version. Deleting it here too removes your changes to it.`
+                    : `Your saved changes to “${target.title}” are replaced by the latest version.` })),
+            labels: {
+                confirm: deleting ? EDITOR_ACTIONS.deleteEntry : EDITOR_ACTIONS.useLatestVersion,
+                cancel: 'Cancel',
+            },
+            confirmProps: { color: 'red' },
+            // Any way out but Confirm, Escape and the close button included, returns to "Show changes".
+            onClose: () => {
+                if (confirmed)
+                    return;
+                setChangesOpen(true);
+                setChangesShown(true);
+            },
+            onConfirm: () => {
+                confirmed = true;
+                void resolveEntryConflict(target.logicalPath, target.id, target.mergeSha, target.choice).then((refusal) => {
+                    if (refusal) {
+                        notifications.show({
+                            message: refusal.message,
+                            color: refusal.tone === 'error' ? 'red' : 'yellow',
+                            autoClose: false,
+                        });
+                    }
+                    else if (deleting) {
+                        closeEntry(target.logicalPath, branch);
+                    }
+                });
+            },
+        });
+    };
+    // A choice made on an earlier merge of a field no longer counts once the record moved on, and
+    // an entry whose conflicts are gone keeps none.
+    const retainChoices = conflictChoices.retain;
+    const keepEntryChoices = conflictChoices.keepEntries;
+    // An entry no longer listed with conflicts, resolved elsewhere or by a later merge, keeps none.
+    const listedConflicts = currentBranch?.conflictFiles?.length
+        ? branchConflicts.data?.conflicts
+        : currentBranch
+            ? []
+            : undefined;
+    const listedIds = listedConflicts?.map((c) => c.contentId).join(',');
+    useEffect(() => {
+        if (listedIds !== undefined)
+            keepEntryChoices(new Set(listedIds.split(',').filter(Boolean)));
+    }, [listedIds, keepEntryChoices]);
+    useEffect(() => {
+        const id = changesConflictTarget?.id;
+        if (!id || entryConflict.data === undefined)
+            return;
+        retainChoices(id, entryConflict.data?.fields ?? []);
+    }, [changesConflictTarget?.id, entryConflict.data, retainChoices]);
+    // The toast's "Show changes" opens the first entry with conflicts, then, once it is open and
+    // listed as changed, its drawer.
+    const [pendingConflictShow, setPendingConflictShow] = useState();
+    showConflictsRef.current = () => {
+        const branch = branchNameState;
+        void apiClient.conflicts
+            .list({ branch })
+            .then((answer) => {
+            if (branch !== currentBranchRef.current)
+                return;
+            const first = answer.ok
+                ? answer.data?.conflicts.find((c) => c.logicalPath && entriesState.some((e) => e.path === c.logicalPath))
+                : undefined;
+            if (!first?.logicalPath)
+                return;
+            setPendingConflictShow(first.logicalPath);
+            openEntry(first.logicalPath);
+        })
+            .catch(console.error);
+    };
+    useEffect(() => {
+        if (!pendingConflictShow)
+            return;
+        if (selectedPath !== pendingConflictShow) {
+            setPendingConflictShow(undefined);
+            return;
+        }
+        if (currentEntry?.path !== pendingConflictShow)
+            return;
+        const change = branchChanges.data?.entries.find((e) => e.status !== 'deleted' && e.logicalPath === pendingConflictShow);
+        if (!change)
+            return;
+        setPendingConflictShow(undefined);
+        showEntryChanges(change, currentEntry.label ?? currentEntry.slug ?? '', 'header');
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- showEntryChanges reads this render
+    }, [pendingConflictShow, selectedPath, currentEntry, branchChanges.data]);
+    const showOpenEntryChanges = () => {
+        const change = currentEntry &&
+            branchChanges.data?.entries.find((e) => e.status !== 'deleted' && e.logicalPath === currentEntry.path);
+        if (change)
+            showEntryChanges(change, currentEntry.label ?? currentEntry.slug ?? '', 'header');
+    };
+    // The open entry's conflicts, said above its form, with the way to "Show changes".
+    const openEntryConflictNotice = currentEntry?.contentId && currentBranch?.conflictFiles?.includes(currentEntry.contentId)
+        ? {
+            message: entryConflictNotice(branchConflicts.data?.conflicts.find((c) => c.contentId === currentEntry.contentId)),
+            onShowChanges: branchChanges.data?.entries.some((e) => e.status !== 'deleted' && e.logicalPath === currentEntry.path)
+                ? showOpenEntryChanges
+                : undefined,
+        }
+        : undefined;
     const openEntryChange = currentEntry &&
         branchChanges.data?.entries.find((e) => e.status !== 'deleted' && e.logicalPath === currentEntry.path);
     const referenceTitles = useMemo(() => new Map(entriesState.map((e) => [e.contentId, e.title ?? e.label])), [entriesState]);
@@ -1321,6 +1667,7 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
         const fields = entriesState.find((e) => e.path === entry.logicalPath)?.schema ??
             entriesState.find((e) => e.collectionPath === entry.collectionPath && e.entryType === entry.entryType)?.schema ??
             EMPTY_SCHEMA;
+        deleteAfterChangesRef.current = undefined;
         setChangesSubject({
             logicalPath: entry.logicalPath,
             contentId: entry.contentId,
@@ -1350,6 +1697,110 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
     const changesPullRequestUrl = isReviewer(userContext?.groups)
         ? currentBranch?.pullRequestUrl
         : undefined;
+    // The drawer's undo, delete and restore follow the form's rules: hidden without edit access,
+    // disabled with the branch lock's reason while the branch takes no writes. Undo writes the open
+    // entry's draft, through the functional update the remove-Undo uses, so it is an unsaved edit.
+    const changesSubjectOpen = !!changesSubject &&
+        !!currentEntry &&
+        changesSubject.status !== 'deleted' &&
+        changesSubject.logicalPath === currentEntry.path &&
+        (changesSubject.contentId === undefined || changesSubject.contentId === currentEntry.contentId);
+    const changesLockReason = latestWaiting
+        ? WAITING_NOTICE
+        : branchContentLocked
+            ? describeBranchLock({
+                branchStatus: currentBranch?.status,
+                branchReadOnly: currentBranch?.readOnly,
+                branchWriteBlocked: true,
+                branchPending,
+                branchMissing,
+                reviewing: branchReviewing,
+                pullRequestClosed: branchPullRequestClosed,
+                approveBlocked: currentBranch?.approveBlocked,
+            })
+            : undefined;
+    const changesUndo = changesSubjectOpen && currentEntry && displayValue
+        ? {
+            // What the form shows: a draft hidden behind a lock isn't what the cards compare.
+            value: displayValue,
+            saved: loadedValues[currentEntry.contentId],
+            update: (update) => {
+                if (contentReadOnlyRef.current)
+                    return;
+                const contentId = currentEntry.contentId;
+                setDrafts((prev) => {
+                    const value = prev[contentId] ?? loadedValuesRef.current[contentId];
+                    if (!value)
+                        return prev;
+                    const next = update(value);
+                    return next === value ? prev : { ...prev, [contentId]: next };
+                });
+            },
+            threadsWithin: (path) => openThreadsWithin(displayComments, currentEntry.path, path),
+        }
+        : undefined;
+    // An entry the branch deleted has no row to carry `canEdit`; its collection's `canAddEntry`
+    // stands in, and the server judges the entry's own path.
+    const deletedSubjectCollection = changesSubject?.status === 'deleted'
+        ? changesSubject.logicalPath.slice(0, changesSubject.logicalPath.lastIndexOf('/'))
+        : undefined;
+    const restoreRefusedByPath = deletedSubjectCollection !== undefined &&
+        findCollection(collectionsFromApi, deletedSubjectCollection)?.canAddEntry === false;
+    const changesRestoreEntry = changesSubject?.status === 'deleted' && changesSubject.contentId
+        ? async () => {
+            const { logicalPath, contentId, title } = changesSubject;
+            const branch = branchNameState;
+            let answer;
+            try {
+                answer = await apiClient.changes.restore({ branch, entryPath: logicalPath }, { id: contentId });
+            }
+            catch (err) {
+                if (!isUnanswered(err)) {
+                    return { tone: 'error', message: 'Couldn’t restore this entry. Try again.' };
+                }
+            }
+            // A 409 whose write may have run is as unanswered as a timeout.
+            const outcomeUnknown = !!answer &&
+                !answer.ok &&
+                (isGatewayFailure(answer) || answer.code === 'WRITE_OUTCOME_UNKNOWN');
+            if (answer && !answer.ok && !outcomeUnknown) {
+                return {
+                    tone: answer.status === 409 ? 'warning' : 'error',
+                    message: answer.error ?? 'Couldn’t restore this entry. Try again.',
+                };
+            }
+            const entries = await refreshEntries(branch).catch(() => undefined);
+            void branchChanges.reload();
+            if (answer?.ok && answer.data?.warning) {
+                notifications.show({ message: answer.data.warning, color: 'yellow' });
+            }
+            if (answer?.ok && !entries) {
+                notifications.show({
+                    message: `"${title}" is restored. Refresh the page to see it in the "Content" panel.`,
+                    color: 'yellow',
+                });
+                setChangesOpen(false);
+                return undefined;
+            }
+            // Unanswered, the entry list settles it: this entry, by id, listed again.
+            if (!answer?.ok &&
+                !entries?.some((e) => e.path === logicalPath && e.contentId === contentId)) {
+                return {
+                    tone: 'warning',
+                    message: `Restoring "${title}" may have gone through, but the server couldn’t confirm it. Check the "Content" panel for it before trying again.`,
+                };
+            }
+            setChangesOpen(false);
+            openEntry(logicalPath);
+            return undefined;
+        }
+        : undefined;
+    const changesDeleteEntry = changesSubjectOpen && changesSubject?.status === 'added'
+        ? () => {
+            deleteAfterChangesRef.current = changesSubject.logicalPath;
+            setChangesOpen(false);
+        }
+        : undefined;
     const runSaveAll = () => {
         void handleSaveAll()
             .then((result) => {
@@ -1574,7 +2025,7 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
             }
             : undefined, "data-testid": "content-panel", actions: _jsxs(_Fragment, { children: [navCollections &&
                     navCollections.length > 0 &&
-                    !branchContentLocked &&
+                    !contentLocked &&
                     (navCollections[0].onAdd || navCollections[0].onAddSubCollection) && (_jsxs(Menu, { shadow: "md", width: 200, withinPortal: true, position: "bottom-end", 
                     // Its items open dialogs outside the panel, which would close a transient one.
                     onOpen: keepContentPanelOpen, children: [_jsx(Tooltip, { label: "Content actions", withinPortal: true, children: _jsx(Menu.Target, { children: _jsx(ActionIcon, { variant: "subtle", color: "gray", "aria-label": "Content actions", children: _jsx(IconDots, { size: 16 }) }) }) }), _jsxs(Menu.Dropdown, { children: [navCollections[0].onAdd && (_jsx(Menu.Item, { leftSection: _jsx(IconPlus, { size: 14 }), onClick: () => navCollections[0].onAdd?.(), children: "Add entry\u2026" })), navCollections[0].onAddSubCollection && (_jsxs(_Fragment, { children: [navCollections[0].onAdd && _jsx(Menu.Divider, {}), _jsx(Menu.Label, { children: "Admin" }), _jsx(Menu.Item, { leftSection: _jsx(IconFolderPlus, { size: 14 }), onClick: () => navCollections[0].onAddSubCollection?.(), children: "Add collection\u2026" })] }))] })] })), _jsx(Tooltip, { label: "Collapse all folders", withinPortal: true, children: _jsx(ActionIcon, { variant: "subtle", color: "gray", onClick: handleCollapseAll, "aria-label": "Collapse all folders", children: _jsx(IconChevronUp, { size: 16 }) }) }), _jsx(Tooltip, { label: "Expand all folders", withinPortal: true, children: _jsx(ActionIcon, { variant: "subtle", color: "gray", onClick: handleExpandAll, "aria-label": "Expand all folders", children: _jsx(IconChevronDown, { size: 16 }) }) })] }), children: _jsx(Box, { px: "md", children: _jsx(EntryNavigator, { collections: navCollections, items: navCollections
@@ -1589,17 +2040,19 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
                         missing: e.status === 'missing' || undefined,
                         noPage: !e.previewSrc || undefined,
                         readOnly: e.canEdit === false || undefined,
-                    })), selectedPath: selectedPath, onSelect: openEntry, onTreeControllerReady: handleTreeControllerReady, expandedStateRef: treeExpandedStateRef, onExpandedStateChange: handleExpandedStateChange, onDeleteEntry: handleDeleteEntry, onRenameEntry: handleRenameEntry, onReorderEntry: userIsAdmin ? handleReorderEntry : undefined, hiddenRootPath: hiddenRootPath, loading: entriesInitializing, readOnly: branchContentLocked, readOnlyReason: branchPending
+                    })), selectedPath: selectedPath, onSelect: openEntry, onTreeControllerReady: handleTreeControllerReady, expandedStateRef: treeExpandedStateRef, onExpandedStateChange: handleExpandedStateChange, onDeleteEntry: handleDeleteEntry, onRenameEntry: handleRenameEntry, onReorderEntry: userIsAdmin ? handleReorderEntry : undefined, hiddenRootPath: hiddenRootPath, loading: entriesInitializing, readOnly: contentLocked, readOnlyReason: branchPending
                     ? undefined
-                    : describeBranchLock({
-                        branchStatus: currentBranch?.status,
-                        branchReadOnly: currentBranch?.readOnly,
-                        branchWriteBlocked: branchContentLocked,
-                        branchMissing,
-                        reviewing: branchReviewing,
-                        pullRequestClosed: branchPullRequestClosed,
-                        approveBlocked: currentBranch?.approveBlocked,
-                    }), dirtyPaths: dirtyPaths, reveal: contentReveal, onRevealed: () => setContentReveal(undefined), entryFilter: entryFilter === 'changed' && !changesOffered ? 'all' : entryFilter, onEntryFilterChange: setEntryFilter, onShowUnsaved: showUnsaved, onShowDeletedChanges: (entry, label) => showEntryChanges(entry, label, 'deleted row'), branchChanges: changesOffered
+                    : latestWaiting
+                        ? WAITING_NOTICE
+                        : describeBranchLock({
+                            branchStatus: currentBranch?.status,
+                            branchReadOnly: currentBranch?.readOnly,
+                            branchWriteBlocked: branchContentLocked,
+                            branchMissing,
+                            reviewing: branchReviewing,
+                            pullRequestClosed: branchPullRequestClosed,
+                            approveBlocked: currentBranch?.approveBlocked,
+                        }), dirtyPaths: dirtyPaths, reveal: contentReveal, onRevealed: () => setContentReveal(undefined), entryFilter: entryFilter === 'changed' && !changesOffered ? 'all' : entryFilter, onEntryFilterChange: setEntryFilter, onShowUnsaved: showUnsaved, onShowDeletedChanges: (entry, label) => showEntryChanges(entry, label, 'deleted row'), branchChanges: changesOffered
                     ? {
                         base: branchChanges.data?.base ?? currentBranch?.baseBranch ?? 'the base branch',
                         data: branchChanges.data,
@@ -1622,7 +2075,9 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
                     // branchWriteBlocked reuses branchContentLocked itself rather than
                     // re-deriving `?? true` a second time here, so there is exactly one
                     // fail-closed computation of "are writes blocked" in this component.
-                    branchIsProtected: currentBranch?.isProtected ?? true, branchServerProtected: currentBranch?.isProtected, branchReadOnly: currentBranch?.readOnly, branchHold: currentBranch?.hold, branchApproveBlocked: currentBranch?.approveBlocked, branchWriteBlocked: branchContentLocked, branchLoading: branchLoading, branchPending: branchPending, branchMissing: branchMissing, branchToggleRef: branchToggleRef, onBranchReloadData: () => {
+                    branchIsProtected: currentBranch?.isProtected ?? true, branchServerProtected: currentBranch?.isProtected, branchReadOnly: currentBranch?.readOnly, branchHold: currentBranch?.hold, openConflicts: openConflictCount, conflictRecordHeld: branchConflicts.data?.held
+                        ? { ...(userIsAdmin && { onRelease: handleReleaseConflictsHold }) }
+                        : undefined, branchApproveBlocked: currentBranch?.approveBlocked, branchWriteBlocked: branchContentLocked, branchLoading: branchLoading, branchPending: branchPending, branchMissing: branchMissing, branchToggleRef: branchToggleRef, baseUpdate: baseUpdateControl, latestWait: latestWait, onBranchReloadData: () => {
                         void Promise.all([handleReloadBranchData(), refreshEntries(branchNameState)]).catch(console.error);
                     }, onBranchDiscardDrafts: () => handleDiscardDrafts(() => branchToggleRef.current), onBranchManagerOpen: openBranchManager, onNewBranch: () => openBranchManager({ create: true }), onSaveAll: runSaveAll, saveAllProgress: saveAllProgress, 
                     // On any entry: EntryHeader's `saving` is the open entry's alone.
@@ -1655,7 +2110,7 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
                             // True exactly while the form below shows "Setting up…" or "Loading content…".
                             entryLoading: !currentEntry && ((!branchNameState && busy) || entriesInitializing), branchName: branchNameState, busy: busy, breadcrumbSegments: breadcrumbSegments, 
                             // A draft kept for an unavailable entry stays in storage but cannot be saved.
-                            hasUnsavedChanges: !currentEntryUnavailable && !contentReadOnly && isSelectedDirty(), entryHasDraft: isSelectedDirty(), entryReadOnly: currentEntry?.canEdit === false, entryUnavailable: currentEntryUnavailable, draftStorageFailed: draftStorageFailed, branchStatus: currentBranch?.status, branchReadOnly: currentBranch?.readOnly, branchWriteBlocked: branchContentLocked, branchLoading: branchLoading, branchPending: branchPending, branchMissing: branchMissing, branchReviewing: branchReviewing, branchPullRequestClosed: branchPullRequestClosed, branchApproveBlocked: currentBranch?.approveBlocked, onCollectionOpen: (path) => revealInContentPanel({ kind: 'collection', path }), onEntryReveal: () => currentEntry && revealInContentPanel({ kind: 'entry', path: currentEntry.path }), navigatorToggleRef: navigatorToggleRef, onShowChanges: openEntryChange
+                            hasUnsavedChanges: !currentEntryUnavailable && !contentReadOnly && isSelectedDirty(), entryHasDraft: isSelectedDirty(), entryReadOnly: currentEntry?.canEdit === false, entryUnavailable: currentEntryUnavailable, draftStorageFailed: draftStorageFailed, branchStatus: currentBranch?.status, branchReadOnly: currentBranch?.readOnly, branchWriteBlocked: branchContentLocked, writesWaitReason: latestWaiting ? WAITING_NOTICE : undefined, branchLoading: branchLoading, branchPending: branchPending, branchMissing: branchMissing, branchReviewing: branchReviewing, branchPullRequestClosed: branchPullRequestClosed, branchApproveBlocked: currentBranch?.approveBlocked, onCollectionOpen: (path) => revealInContentPanel({ kind: 'collection', path }), onEntryReveal: () => currentEntry && revealInContentPanel({ kind: 'entry', path: currentEntry.path }), navigatorToggleRef: navigatorToggleRef, onShowChanges: openEntryChange
                                 ? () => showEntryChanges(openEntryChange, currentEntry?.label ?? currentEntry?.slug ?? '', 'header')
                                 : undefined, showChangesPending: changesOffered && !!currentEntry, showChangesRef: showChangesRef, onFileReload: () => handleReload(() => navigatorToggleRef.current), onFileDiscardDraft: () => handleDiscardFileDraft(() => navigatorToggleRef.current), onEntryRename: () => currentEntry && handleRenameEntry(currentEntry.path, true), onEntryDelete: () => currentEntry && handleDeleteEntry(currentEntry.path, true), onSave: currentEntryUnavailable ? noop : handleSave, saveAllRunning: !!saveAllProgress, saving: singleSaving?.branch === branchNameState &&
                                 singleSaving.contentId === currentEntry?.contentId, savedSignal: lastSaved?.seq, savedHere: lastSaved?.branch === branchNameState &&
@@ -1674,12 +2129,12 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
                                         ? 'Setting up your branch workspace…'
                                         : entriesInitializing
                                             ? 'Loading content…'
-                                            : 'Select an item to start editing.' })) : currentEntryUnavailable ? (_jsx(UnavailableEntryNotice, { schemaRefs: currentEntry.unavailable ? [currentEntry.unavailable.schemaRef] : [] })) : currentEntry.canEdit === false ? (_jsx(NoEditPermissionNotice, { entryLabel: currentEntry.label })) : schema.length > 0 && displayValue ? (_jsx(EntryLinkContext.Provider, { value: entryLinkContextValue, children: _jsx(SiteMdxAllowContext.Provider, { value: mdxAllow, children: _jsx(PreviewFollowContext.Provider, { value: followInPreview ?? null, children: _jsx(FormRenderer, { notice: hiddenDraftNotice && (_jsx(ReadOnlyDraftNotice, { permanentlyReadOnly: (currentBranch?.isProtected ?? true) ||
-                                                        currentBranch?.status === 'archived', 
-                                                    // A hidden draft's discard changes nothing on screen, so it says so.
-                                                    onDiscard: () => handleDiscardFileDraft(() => navigatorToggleRef.current, {
-                                                        announce: true,
-                                                    }) })), fields: schema, value: displayValue, readOnly: contentReadOnly, onRemoved: handleFieldRemoved, savedValue: loadedValue, commentBlockedReason: commentBlockedReason, removedItemFieldLabel: commentFieldLabel, onGetUserMetadata: getCommentUserMetadata, header: {
+                                            : 'Select an item to start editing.' })) : currentEntryUnavailable ? (_jsx(UnavailableEntryNotice, { schemaRefs: currentEntry.unavailable ? [currentEntry.unavailable.schemaRef] : [] })) : currentEntry.canEdit === false ? (_jsx(NoEditPermissionNotice, { entryLabel: currentEntry.label })) : schema.length > 0 && displayValue ? (_jsx(EntryLinkContext.Provider, { value: entryLinkContextValue, children: _jsx(SiteMdxAllowContext.Provider, { value: mdxAllow, children: _jsx(PreviewFollowContext.Provider, { value: followInPreview ?? null, children: _jsx(FormRenderer, { notice: (latestWait !== 'none' || hiddenDraftNotice) && (_jsxs(_Fragment, { children: [latestWait !== 'none' && (_jsx(BaseUpdateNotice, { wait: latestWait, hidesDraft: draftHidden && latestWaiting })), hiddenDraftNotice && (_jsx(ReadOnlyDraftNotice, { permanentlyReadOnly: (currentBranch?.isProtected ?? true) ||
+                                                                currentBranch?.status === 'archived', 
+                                                            // A hidden draft's discard changes nothing on screen, so it says so.
+                                                            onDiscard: () => handleDiscardFileDraft(() => navigatorToggleRef.current, {
+                                                                announce: true,
+                                                            }) }))] })), fields: schema, value: displayValue, readOnly: contentReadOnly, onRemoved: handleFieldRemoved, savedValue: loadedValue, commentBlockedReason: commentBlockedReason, removedItemFieldLabel: commentFieldLabel, onGetUserMetadata: getCommentUserMetadata, header: {
                                                     title: currentEntry.label,
                                                     typeLabel: entryTypeLabel(activeCollections, currentEntry),
                                                 }, 
@@ -1692,11 +2147,14 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
                                                         const keyed = withItemKeys(schema, next, 'random');
                                                         setDrafts((prev) => ({ ...prev, [contentId]: keyed }));
                                                     }
-                                                }, customRenderers: customRenderers, branch: branchNameState, comments: displayComments, currentEntryPath: selectedPath, currentUserId: commentUserId, canResolve: canResolveAnyComment, focusedFieldPath: focusedFieldPath, highlightThreadId: highlightThreadId, onAddComment: handleAddDisplayedComment, onResolveThread: handleResolveThread, fieldErrors: fieldErrors, format: currentEntry.format, conflictNotice: !!(currentEntry?.contentId &&
-                                                    currentBranch?.conflictFiles?.includes(currentEntry.contentId)) }) }) }) })) : schema.length === 0 ? (_jsx(CenteredMessage, { children: "No fields to edit." })) : loadFailedKey !== `${branchNameState}:${currentEntry.contentId}` ? (_jsx(Stack, { gap: "lg", p: "md", "data-testid": "entry-loading-skeleton", children: [0, 1, 2].map((row) => (_jsxs(Stack, { gap: 6, children: [_jsx(Skeleton, { h: 12, w: 120 }), _jsx(Skeleton, { h: 36 })] }, row))) })) : (_jsx(Alert, { color: "red", variant: "light", m: "md", title: "This entry couldn't be loaded.", "data-testid": "entry-load-failed", children: _jsx(Button, { variant: "default", onClick: () => {
+                                                }, customRenderers: customRenderers, branch: branchNameState, comments: displayComments, currentEntryPath: selectedPath, currentUserId: commentUserId, canResolve: canResolveAnyComment, focusedFieldPath: focusedFieldPath, highlightThreadId: highlightThreadId, onAddComment: handleAddDisplayedComment, onResolveThread: handleResolveThread, fieldErrors: fieldErrors, format: currentEntry.format, conflictNotice: openEntryConflictNotice }) }) }) })) : schema.length === 0 ? (_jsx(CenteredMessage, { children: "No fields to edit." })) : loadFailedKey !== `${branchNameState}:${currentEntry.contentId}` ? (_jsx(Stack, { gap: "lg", p: "md", "data-testid": "entry-loading-skeleton", children: [0, 1, 2].map((row) => (_jsxs(Stack, { gap: 6, children: [_jsx(Skeleton, { h: 12, w: 120 }), _jsx(Skeleton, { h: 36 })] }, row))) })) : (_jsx(Alert, { color: "red", variant: "light", m: "md", title: "This entry couldn't be loaded.", "data-testid": "entry-load-failed", children: _jsx(Button, { variant: "default", onClick: () => {
                                             setLoadFailedKey(null);
                                             setLoadAttempt((attempt) => attempt + 1);
-                                        }, children: "Retry" }) })) }) })] }), overlays: _jsxs(_Fragment, { children: [_jsx(BranchesDrawer, { opened: branchManagerOpen, onClose: () => setBranchManagerOpen(false), confirmOpen: branchConfirmOpen, returnFocusTo: branchReturnTarget, children: _jsx(BranchManager, { startCreating: branchManagerOpening.create, branches: branchSummaries, mode: operatingMode, user: userContext, currentBranchName: currentBranch?.name ?? branchNameState, currentWorkflowBlockedReason: saveAllProgress ? 'Wait for Save all to finish.' : undefined, onSelect: async (name) => {
+                                        }, children: "Retry" }) })) }) })] }), overlays: _jsxs(_Fragment, { children: [_jsx(BranchesDrawer, { opened: branchManagerOpen, onClose: () => setBranchManagerOpen(false), confirmOpen: branchConfirmOpen, returnFocusTo: branchReturnTarget, children: _jsx(BranchManager, { startCreating: branchManagerOpening.create, branches: branchSummaries, mode: operatingMode, user: userContext, currentBranchName: currentBranch?.name ?? branchNameState, currentWorkflowBlockedReason: saveAllProgress
+                                    ? 'Wait for Save all to finish.'
+                                    : latestWaiting
+                                        ? WAITING_SUBMIT_REASON
+                                        : undefined, currentBaseUpdate: baseUpdateControl, onSelect: async (name) => {
                                     try {
                                         await handleBranchChange(name);
                                         setBranchManagerOpen(false);
@@ -1729,10 +2187,48 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
                                     if (namesBranch(name, branchNameState) && isSaveAllRunning())
                                         return;
                                     handleArchive(name).catch((err) => console.error(err));
-                                }, onClose: () => setBranchManagerOpen(false), comments: comments, currentUserId: commentUserId, canResolve: canResolveAnyComment, onAddComment: handleAddComment, onResolveThread: handleResolveThread, highlightThreadId: highlightThreadId, onGetUserMetadata: canResolveUserNames ? handleGetUserMetadata : undefined, onGetOwnerMetadata: getCommentUserMetadata, onGetCommentUserMetadata: getCommentUserMetadata }, branchManagerOpening.seq) }), changesSubject && (_jsx(LazyEntryChangesDrawer, { opened: changesOpen, onClose: () => setChangesOpen(false), onExited: () => setChangesShown(false), returnFocusTo: changesReturnTarget, base: branchChanges.data?.base ?? currentBranch?.baseBranch ?? 'the base branch', subject: {
+                                }, onClose: () => setBranchManagerOpen(false), comments: comments, currentUserId: commentUserId, canResolve: canResolveAnyComment, onAddComment: handleAddComment, onResolveThread: handleResolveThread, highlightThreadId: highlightThreadId, onGetUserMetadata: canResolveUserNames ? handleGetUserMetadata : undefined, onGetOwnerMetadata: getCommentUserMetadata, onGetCommentUserMetadata: getCommentUserMetadata }, branchManagerOpening.seq) }), changesSubject && (_jsx(LazyEntryChangesDrawer, { opened: changesOpen, onClose: () => setChangesOpen(false), onExited: () => {
+                                setChangesShown(false);
+                                const editing = focusAfterChangesRef.current;
+                                focusAfterChangesRef.current = undefined;
+                                if (editing)
+                                    focusConflictField(editing);
+                                const confirming = confirmAfterChangesRef.current;
+                                confirmAfterChangesRef.current = undefined;
+                                if (confirming)
+                                    confirmEntryChoice(confirming);
+                                const deleting = deleteAfterChangesRef.current;
+                                deleteAfterChangesRef.current = undefined;
+                                // Opened as from the entry menu, whose trigger stands in for the gone button.
+                                if (deleting && deleting === changesSubject.logicalPath) {
+                                    handleDeleteEntry(deleting, true);
+                                }
+                            }, returnFocusTo: changesReturnTarget, base: branchChanges.data?.base ?? currentBranch?.baseBranch ?? 'the base branch', subject: {
                                 ...changesSubject,
                                 unsavedEdits: changesSubject.logicalPath === currentEntry?.path && isSelectedDirty(),
-                            }, state: entryChange, referenceTitle: referenceTitle, onOpenEntry: changesOpenEntry, pullRequestUrl: changesPullRequestUrl })), branchNameState && (_jsx(CommentsPanel, { opened: commentsPanelOpen, branchName: branchLabel, comments: displayComments, canResolve: canResolveAnyComment, currentUserId: commentUserId, entryLabel: commentEntryLabel, fieldLabel: commentFieldLabel, onAddComment: handleAddDisplayedComment, onResolveThread: handleResolveThread, onClose: () => setCommentsPanelOpen(false), onJumpToField: jumpToThreadField, onGetUserMetadata: getCommentUserMetadata, onJumpToEntry: handleJumpToEntry, onJumpToBranch: handleJumpToBranch }, branchNameState)), userIsAdmin && (_jsx(GroupManager, { opened: groupManagerOpen, onClose: () => setGroupManagerOpen(false), returnFocusTo: settingsReturnTarget, internalGroups: groupsData, loading: groupsLoading, canEdit: userIsAdmin, onSave: handleSaveGroups, onSearchUsers: handleSearchUsers, onGetUserMetadata: handleGetUserMetadata, onSearchExternalGroups: handleSearchExternalGroups })), userIsAdmin && (_jsx(PermissionManager, { opened: permissionManagerOpen, onClose: () => setPermissionManagerOpen(false), returnFocusTo: settingsReturnTarget, collections: activeCollections, contentRoot: contentRoot, permissions: permissionsData, loading: permissionsLoading, canEdit: userIsAdmin, onSave: handleSavePermissions, onSearchUsers: handleSearchUsers, onGetUserMetadata: handleGetUserMetadata, onListGroups: handleListGroups })), userIsAdmin && (_jsx(SystemHealthPanel, { opened: systemHealthOpen, onClose: () => setSystemHealthOpen(false), returnFocusTo: settingsReturnTarget })), _jsx(MediaLibrary, { opened: mediaLibraryOpen, onClose: () => setMediaLibraryOpen(false), mode: "manage", returnFocusTo: () => mediaButtonRef.current }), userIsAdmin && (_jsx(CollectionEditor, { isOpen: collectionEditorOpen, editingCollection: editingCollection, parentPath: collectionEditorParentPath, availableSchemas: availableSchemas, onSave: handleCollectionSave, onAddEntryType: editingCollection
+                            }, state: entryChange, referenceTitle: referenceTitle, onOpenEntry: changesOpenEntry, pullRequestUrl: changesPullRequestUrl, undo: changesUndo, noEditReason: (changesSubjectOpen && currentEntry?.canEdit === false) || restoreRefusedByPath
+                                ? NO_EDIT_ACCESS_REASON
+                                : undefined, lockedReason: changesLockReason, onDeleteEntry: changesDeleteEntry, onRestoreEntry: 
+                            // A deleted entry with conflicts open is settled on its conflict card first: a
+                            // deleted-on-branch card restores it, and with field conflicts a restore would
+                            // bring back the latest version unchanged, which "Show changes" doesn't list,
+                            // leaving them with nowhere to be chosen. Once they're kept, this offers it.
+                            entryConflict.data ? undefined : changesRestoreEntry, conflicts: changesConflictTarget
+                                ? {
+                                    state: entryConflict,
+                                    adminBaseBranch: userIsAdmin ? currentBranch?.baseBranch : undefined,
+                                    choices: conflictChoices.choicesFor(changesConflictTarget.id),
+                                    onChoose: (field, choice, decided) => conflictChoices.choose(changesConflictTarget.id, field.key, field.mergeSha, choice, decided),
+                                    onEdit: changesSubjectOpen
+                                        ? (field) => {
+                                            focusAfterChangesRef.current = field;
+                                            setChangesOpen(false);
+                                        }
+                                        : undefined,
+                                    onResolveEntry: changesResolveEntry,
+                                    unsavedEdits: isDirtyForEntry(changesSubject.logicalPath),
+                                }
+                                : undefined })), branchNameState && (_jsx(CommentsPanel, { opened: commentsPanelOpen, branchName: branchLabel, comments: displayComments, canResolve: canResolveAnyComment, currentUserId: commentUserId, entryLabel: commentEntryLabel, fieldLabel: commentFieldLabel, onAddComment: handleAddDisplayedComment, onResolveThread: handleResolveThread, onClose: () => setCommentsPanelOpen(false), onJumpToField: jumpToThreadField, onGetUserMetadata: getCommentUserMetadata, onJumpToEntry: handleJumpToEntry, onJumpToBranch: handleJumpToBranch }, branchNameState)), userIsAdmin && (_jsx(GroupManager, { opened: groupManagerOpen, onClose: () => setGroupManagerOpen(false), returnFocusTo: settingsReturnTarget, internalGroups: groupsData, loading: groupsLoading, canEdit: userIsAdmin, onSave: handleSaveGroups, onSearchUsers: handleSearchUsers, onGetUserMetadata: handleGetUserMetadata, onSearchExternalGroups: handleSearchExternalGroups })), userIsAdmin && (_jsx(PermissionManager, { opened: permissionManagerOpen, onClose: () => setPermissionManagerOpen(false), returnFocusTo: settingsReturnTarget, collections: activeCollections, contentRoot: contentRoot, permissions: permissionsData, loading: permissionsLoading, canEdit: userIsAdmin, onSave: handleSavePermissions, onSearchUsers: handleSearchUsers, onGetUserMetadata: handleGetUserMetadata, onListGroups: handleListGroups })), userIsAdmin && (_jsx(SystemHealthPanel, { opened: systemHealthOpen, onClose: () => setSystemHealthOpen(false), returnFocusTo: settingsReturnTarget })), _jsx(MediaLibrary, { opened: mediaLibraryOpen, onClose: () => setMediaLibraryOpen(false), mode: "manage", returnFocusTo: () => mediaButtonRef.current }), userIsAdmin && (_jsx(CollectionEditor, { isOpen: collectionEditorOpen, editingCollection: editingCollection, parentPath: collectionEditorParentPath, availableSchemas: availableSchemas, onSave: handleCollectionSave, onAddEntryType: editingCollection
                                 ? (path, entryType) => addEntryType(path, entryType)
                                 : undefined, onUpdateEntryType: editingCollection
                                 ? (path, name, updates) => updateEntryType(path, name, updates)