canopycms 0.12.0 → 0.13.0

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,7 +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 { NO_EDIT_ACCESS_REASON } from './copy.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';
@@ -69,6 +79,7 @@ import { PreviewFollowContext, usePreviewFollow } from './hooks/usePreviewFollow
 import { UndoToastMessage } from './components/UndoToastMessage.js';
 import { getNotificationDuration } from './utils/env.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)
@@ -182,6 +193,12 @@ 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);
+    // Set once the entries and the changes read exist.
+    const rereadPinnedBranchRef = useRef(async () => { });
     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,
@@ -191,6 +208,11 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
         getUnsaved: () => resolveUnsavedRef.current(),
         onStamped: (stamped) => applySubmitStampsRef.current(stamped),
         onChangesRequested: (branch) => reloadCommentsRef.current(branch),
+        onReviewPinned: (branch) => rereadPinnedBranchRef.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
@@ -210,6 +232,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,
@@ -236,7 +273,8 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
     // Set once the branch actions below exist; they depend on the drafts, which depend on the entries.
     const switchBranchRef = useRef(async () => { });
     // Set once the changes read exists; it waits on the panel state, declared after the entries.
-    const reloadChangesRef = useRef(() => { });
+    const reloadChangesRef = useRef(async () => { });
+    const rereadChangesRef = useRef(async () => { });
     // 2. Entry manager (depends on branchNameState, owns selectedPath)
     const { selectedPath, setSelectedPath, closeEntry, entries: entriesState, collections: collectionsFromApi, currentEntry, availableSchemas, entriesInitializing, entriesLoadFailed, navigatorOpen, setNavigatorOpen, refreshEntries, refreshContent, handleCreateEntry, renameEntry, loadEntry, readEntryValue, saveEntry, getEntryVersion, adoptEntryVersion, followMovedEntry, recreateEntry, createModalOpen, createModalCollection, createModalError, createModalCreating, createModalExistingSlugs, handleCreateModalSubmit, closeCreateModal, } = useEntryManager({
         initialEntries: entries,
@@ -257,7 +295,14 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
         // A short name in the URL is no switch to another branch.
         sameBranch: namesBranch,
         urlBranchName,
-        onContentRefresh: (branch) => reloadChangesRef.current(branch),
+        onContentRefresh: (branch) => void 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"]')) {
@@ -335,7 +380,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, forgetLoadedValues, readGeneration, loadedValue, effectiveValue, modifiedCount, editedFiles, handleSave, singleSaving, lastSaved, handleSaveAll, saveAllProgress, isSaveAllRunning, handleDiscardDrafts, handleDiscardFileDraft, handleReload, isSelectedDirty, isDirtyForEntry, resolveUnsaved, fieldErrors, draftStorageFailed, applySubmitStamps, } = useDraftManager({
         branchName: branchNameState,
         selectedPath,
         currentEntry,
@@ -355,10 +400,58 @@ 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;
+    // The open branch was pinned for its reviews: its entries, their changes and every clean entry
+    // are read again, every one while it is locked, which shows the saved copy over a draft.
+    rereadPinnedBranchRef.current = async (branch) => {
+        if (!namesBranch(branch, branchNameState))
+            return;
+        forgetLoadedValues((id) => !branchContentLocked && draftsRef.current[id] !== undefined);
+        await Promise.all([
+            refreshEntries(branchNameState, { withChanges: false }),
+            rereadChangesRef.current(),
+        ]);
+    };
+    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,
@@ -422,7 +515,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);
@@ -518,7 +611,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.
@@ -526,7 +621,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(() => {
@@ -544,15 +639,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.
@@ -720,6 +807,8 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
         // write still the state of the branch on screen?".
         const requestBranch = branchNameState;
         const inFlightKey = `${requestBranch}:${contentId ?? ''}`;
+        const generation = readGeneration.current;
+        const loadingKey = `${inFlightKey}#${generation}`;
         const load = async () => {
             if (!currentEntry || !contentId || loadedValues[contentId] !== undefined)
                 return;
@@ -729,13 +818,13 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
             // Guard against overlapping renders re-firing the same in-flight load
             // (e.g. `currentEntry` getting a new object reference from an entries
             // refresh while the fetch below is still pending).
-            if (loadingEntryIdsRef.current.has(inFlightKey))
+            if (loadingEntryIdsRef.current.has(loadingKey))
                 return;
-            loadingEntryIdsRef.current.add(inFlightKey);
+            loadingEntryIdsRef.current.add(loadingKey);
             setEntriesLoading(true);
             setLoadFailedKey((failed) => (failed === inFlightKey ? null : failed));
             try {
-                const loaded = await loadEntry(currentEntry);
+                const loaded = await loadEntry(currentEntry, () => readGeneration.current === generation);
                 // A branch switch during the await makes this response another
                 // branch's content. Writing it would (a) show it as the new branch's
                 // content and (b) satisfy the skip gate above, permanently suppressing
@@ -744,6 +833,8 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
                 // instead; the new branch has its own load running under its own key.
                 if (currentBranchRef.current !== requestBranch)
                     return;
+                if (readGeneration.current !== generation)
+                    return;
                 setLoadedValues((prev) => ({ ...prev, [contentId]: loaded }));
                 // No draft is seeded here. `effectiveValue` is
                 // `drafts[id] ?? loadedValues[id]`, so the form renders from the line
@@ -753,7 +844,7 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
                 // session as a dirty, stale full-content snapshot.
             }
             finally {
-                loadingEntryIdsRef.current.delete(inFlightKey);
+                loadingEntryIdsRef.current.delete(loadingKey);
                 // Clear the shared flag if this load's entry is still selected on the
                 // branch it was loaded for, OR if no other load remains in flight. The
                 // second arm matters when the user navigates from a slow-loading entry
@@ -762,7 +853,8 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
                 // this stale settle would leave `entriesLoading` (and therefore
                 // `busy`) stuck true with nothing left to clear it.
                 if ((currentBranchRef.current === requestBranch &&
-                    currentContentIdRef.current === contentId) ||
+                    currentContentIdRef.current === contentId &&
+                    readGeneration.current === generation) ||
                     loadingEntryIdsRef.current.size === 0) {
                     setEntriesLoading(false);
                 }
@@ -778,7 +870,9 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
             // Same staleness guard as above: don't tell the user an entry failed
             // to load when they've already navigated to a different one (or to a
             // different branch).
-            if (currentBranchRef.current === requestBranch && currentContentIdRef.current === contentId) {
+            if (currentBranchRef.current === requestBranch &&
+                currentContentIdRef.current === contentId &&
+                readGeneration.current === generation) {
                 notifications.show({ message: 'Failed to load entry', color: 'red' });
                 setLoadFailedKey(inFlightKey);
             }
@@ -1109,6 +1203,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
@@ -1123,7 +1222,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
@@ -1152,6 +1260,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;
@@ -1261,10 +1370,11 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
     const changesAvailable = !!currentBranch && currentBranch.isProtected === false;
     const changesRead = (contentPanelShown || !!currentEntry) && changesAvailable;
     const branchChanges = useBranchChangesData(apiClient, branchNameState, changesRead);
-    reloadChangesRef.current = (branch) => {
+    reloadChangesRef.current = async (branch) => {
         if (branch === branchNameState)
-            void branchChanges.reload();
+            await branchChanges.reload();
     };
+    rereadChangesRef.current = branchChanges.reread;
     // Submit, withdraw and a review move the branch's status, which no entries refresh follows.
     const changesStatusRef = useRef({ branch: branchNameState, status: currentBranch?.status });
     useEffect(() => {
@@ -1301,6 +1411,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, entryGone) => {
+        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, ...(entryGone && { entryGone }) });
+        }
+        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, { entryGone }) => {
+            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, entryGone);
+        }
+        : 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]);
@@ -1365,18 +1728,20 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
         changesSubject.status !== 'deleted' &&
         changesSubject.logicalPath === currentEntry.path &&
         (changesSubject.contentId === undefined || changesSubject.contentId === currentEntry.contentId);
-    const changesLockReason = branchContentLocked
-        ? describeBranchLock({
-            branchStatus: currentBranch?.status,
-            branchReadOnly: currentBranch?.readOnly,
-            branchWriteBlocked: true,
-            branchPending,
-            branchMissing,
-            reviewing: branchReviewing,
-            pullRequestClosed: branchPullRequestClosed,
-            approveBlocked: currentBranch?.approveBlocked,
-        })
-        : undefined;
+    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.
@@ -1683,7 +2048,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
@@ -1698,17 +2063,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,
@@ -1731,7 +2098,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, latestChangesWaiting: baseUpdate.latestChangesWaiting, 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.
@@ -1764,7 +2133,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 &&
@@ -1783,12 +2152,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),
                                                 }, 
@@ -1801,11 +2170,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);
@@ -1840,6 +2212,14 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
                                     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);
+                                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.
@@ -1851,7 +2231,27 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
                                 unsavedEdits: changesSubject.logicalPath === currentEntry?.path && isSelectedDirty(),
                             }, 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: changesRestoreEntry })), 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
+                                : 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)