canopycms 0.12.0 → 0.13.0

package/dist/editor/hooks/useBaseUpdate.d.ts

@@ -0,0 +1,38 @@
+import type { BranchListItem } from '../../api/branch.js';
+import type { OperatingMode } from '../../operating-mode/types.js';
+import { type BaseUpdateWait } from '../base-update-wait.js';
+export interface UseBaseUpdateOptions {
+    /** The open branch. */
+    branch: BranchListItem | undefined;
+    operatingMode: OperatingMode;
+    /** The user may take the branch's workflow actions, which asking for the latest changes is. */
+    permitted: boolean;
+    /** Entries with unsaved changes on the branch; asking waits until they are saved. */
+    unsavedCount: number;
+    /** Re-read the branch's entries and the open one, keeping drafts: the worker rewrote them. */
+    onUpdated: () => void;
+    /** Opens the branch's conflicts, offered by the toast of a merge that left some. */
+    onShowConflicts?: () => void;
+}
+export interface UseBaseUpdateReturn {
+    /** "Get latest changes" applies here: a worker answers, the branch is editing, the user may ask. */
+    available: boolean;
+    /** The open branch's wait; `waiting` makes its form read-only. */
+    wait: BaseUpdateWait;
+    /** The open branch's request itself is in flight. */
+    requesting: boolean;
+    /** Why it can't be asked now; undefined when it can. */
+    blockedReason?: string;
+    /** Asks for the open branch, unless unsaved changes hold it. */
+    request: () => Promise<void>;
+    /** The base has changes the branch's saved work keeps the automatic sync from bringing in. */
+    latestChangesWaiting: boolean;
+}
+/**
+ * "Get latest changes" for the open branch: asks, then re-reads the branch list while the branch
+ * waits, and reports the worker's answer in a toast once it lands. Only a wait this tab saw end
+ * reports, so a reload onto an answered request stays quiet. The wait is timed by the server's
+ * clock (server-clock.ts), and a request this tab made counts even when a listing fetched before
+ * it lands after it.
+ */
+export declare function useBaseUpdate(options: UseBaseUpdateOptions): UseBaseUpdateReturn;

package/dist/editor/hooks/useBaseUpdate.js

@@ -0,0 +1,279 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useSWRConfig } from 'swr';
+import { notifications } from '@mantine/notifications';
+import { clientOperatingStrategy } from '../../operating-mode/client.js';
+import { isBaseUpdatePending } from '../../base-update.js';
+import { useApiClient } from '../context/index.js';
+import { getErrorMessage } from '../../utils/error.js';
+import { BRANCHES_KEY } from './useBranchesData.js';
+import { RetryToastMessage } from '../components/RetryToastMessage.js';
+import { EDITOR_ACTIONS } from '../copy.js';
+import { GAVE_UP_MESSAGE, REQUEST_FAILED_MESSAGE, SAVE_FIRST_REASON, UNANSWERED_MESSAGE, baseUpdatePollMs, baseUpdateResultMessage, baseUpdateWait, nextBaseUpdateWaitChange, } from '../base-update-wait.js';
+import { serverNow } from '../server-clock.js';
+import { UnansweredError, isGatewayFailure, isUnanswered } from '../unanswered.js';
+const RESULT_TOAST_ID = 'canopy-base-update-result';
+/** Writes the branch a request answered into the listing, so its wait shows at once. */
+function withBranch(data, branch) {
+    if (!data)
+        return data;
+    return { ...data, branches: data.branches.map((b) => (b.name === branch.name ? branch : b)) };
+}
+/** Whether `a` is a later request time than `b`, an absent one being earliest. */
+const laterThan = (a, b) => b === undefined || Date.parse(a) > Date.parse(b);
+const sameBranch = (branch, record) => record?.name === branch.name && record.createdAt === branch.createdAt;
+/** The listed branch, carrying this tab's newer request. */
+function withAsked(branch, asked) {
+    if (!branch || !sameBranch(branch, asked))
+        return branch;
+    return laterThan(asked.requestedAt, branch.baseUpdateRequestedAt)
+        ? { ...branch, baseUpdateRequestedAt: asked.requestedAt }
+        : branch;
+}
+/** The branch, carrying the answer this tab already reported when the listing hasn't caught up. */
+function withSettled(branch, settled) {
+    if (!branch || !sameBranch(branch, settled))
+        return branch;
+    // Read before the answer, so what it says was waiting has come in.
+    const cameIn = settled.lastBaseUpdate.outcome !== 'failed' ? { latestChangesWaiting: undefined } : {};
+    if (!isBaseUpdatePending(branch)) {
+        return laterThan(settled.requestedAt, branch.baseUpdateRequestedAt)
+            ? { ...branch, ...cameIn }
+            : branch;
+    }
+    return laterThan(branch.baseUpdateRequestedAt ?? '', settled.requestedAt) &&
+        branch.baseUpdateRequestedAt !== undefined
+        ? branch
+        : {
+            ...branch,
+            baseUpdateRequestedAt: settled.requestedAt,
+            lastBaseUpdate: settled.lastBaseUpdate,
+            ...cameIn,
+        };
+}
+/**
+ * A toast in the one slot this hook uses, replacing what it showed before. `onAction` offers
+ * Retry, or `actionLabel`.
+ */
+function showResult(color, message, onAction, actionLabel) {
+    notifications.hide(RESULT_TOAST_ID);
+    notifications.show({
+        id: RESULT_TOAST_ID,
+        color,
+        autoClose: color === 'green' ? undefined : false,
+        message: onAction ? (_jsx(RetryToastMessage, { message: message, onRetry: onAction, actionLabel: actionLabel })) : (message),
+    });
+}
+/**
+ * "Get latest changes" for the open branch: asks, then re-reads the branch list while the branch
+ * waits, and reports the worker's answer in a toast once it lands. Only a wait this tab saw end
+ * reports, so a reload onto an answered request stays quiet. The wait is timed by the server's
+ * clock (server-clock.ts), and a request this tab made counts even when a listing fetched before
+ * it lands after it.
+ */
+export function useBaseUpdate(options) {
+    const { operatingMode, permitted, unsavedCount, onUpdated } = options;
+    const apiClient = useApiClient();
+    const { mutate } = useSWRConfig();
+    const [requestingFor, setRequestingFor] = useState(null);
+    // The last request this tab made, by branch, which a listing that predates it can't undo.
+    const [asked, setAsked] = useState(null);
+    // The last answer this tab reported, by branch, which a listing that predates it can't undo:
+    // another host can serve the branch list from an older snapshot.
+    const [settled, setSettled] = useState(null);
+    const [, setTick] = useState(0);
+    const listed = options.branch;
+    const name = listed?.name;
+    const branch = withSettled(withAsked(listed, asked), settled);
+    const available = !!branch &&
+        clientOperatingStrategy(operatingMode).syncsBranchesWithBase() &&
+        branch.status === 'editing' &&
+        branch.isProtected === false &&
+        permitted;
+    const wait = baseUpdateWait(branch, serverNow());
+    const requestedAt = branch?.baseUpdateRequestedAt;
+    const answer = branch?.lastBaseUpdate;
+    const status = branch?.status;
+    const createdAt = branch?.createdAt;
+    // The wait changes on its own at the slow and give-up marks; nothing else would re-render then.
+    const changeAt = nextBaseUpdateWaitChange(branch, serverNow());
+    useEffect(() => {
+        if (changeAt === undefined)
+            return;
+        const timer = setTimeout(() => setTick((n) => n + 1), Math.max(0, changeAt - serverNow()) + 50);
+        return () => clearTimeout(timer);
+    }, [changeAt]);
+    // Re-read the listing while the branch waits, on a timer of its own: SWR stops polling a key
+    // whose last fetch failed, and one failed read must not end the wait. Each read starts only once
+    // the last has settled, since SWR drops an in-flight read's result when another starts.
+    const pollMs = baseUpdatePollMs(wait);
+    useEffect(() => {
+        if (pollMs === 0)
+            return;
+        let stopped = false;
+        let timer;
+        const next = () => {
+            timer = setTimeout(async () => {
+                if (typeof document === 'undefined' || document.visibilityState !== 'hidden') {
+                    await mutate(BRANCHES_KEY).catch(() => undefined);
+                }
+                if (!stopped)
+                    next();
+            }, pollMs);
+        };
+        next();
+        return () => {
+            stopped = true;
+            clearTimeout(timer);
+        };
+    }, [pollMs, mutate]);
+    const latest = useRef({ name, unsavedCount, available });
+    latest.current = { name, unsavedCount, available };
+    const onUpdatedRef = useRef(onUpdated);
+    onUpdatedRef.current = onUpdated;
+    const onShowConflictsRef = useRef(options.onShowConflicts);
+    onShowConflictsRef.current = options.onShowConflicts;
+    const requestRef = useRef(async () => { });
+    // Stable, and reads only refs, so the toasts that carry it keep working.
+    const retry = useCallback(() => {
+        notifications.hide(RESULT_TOAST_ID);
+        void requestRef.current();
+    }, []);
+    const report = useCallback((on, result) => {
+        setSettled({ ...on, lastBaseUpdate: result });
+        if (result.outcome !== 'failed')
+            onUpdatedRef.current();
+        if (result.outcome === 'conflicts') {
+            // The toast counts the choices left, which the branch's conflicts hold.
+            void apiClient.conflicts
+                .list({ branch: on.name })
+                .then((answer) => (answer.ok ? answer.data?.openCount : undefined))
+                .catch(() => undefined)
+                .then((count) => {
+                if (latest.current.name !== on.name)
+                    return;
+                const { color, message } = baseUpdateResultMessage(result, count);
+                const show = () => {
+                    notifications.hide(RESULT_TOAST_ID);
+                    onShowConflictsRef.current?.();
+                };
+                showResult(color, message, onShowConflictsRef.current && count !== 0 ? show : undefined, EDITOR_ACTIONS.showChanges);
+            });
+            return;
+        }
+        const { color, message } = baseUpdateResultMessage(result);
+        // Retry only for someone who may ask; another viewer just learns how it went.
+        const canRetry = result.outcome === 'failed' && latest.current.available;
+        showResult(color, message, canRetry ? retry : undefined);
+    }, [apiClient, retry]);
+    // A result is about the branch it came from: switching away closes it.
+    useEffect(() => () => {
+        notifications.hide(RESULT_TOAST_ID);
+    }, [name]);
+    // A wait this tab saw, by branch and request, reports when its answer lands, even after the
+    // editor stopped waiting on it; giving up says so, once.
+    const watched = useRef(undefined);
+    useEffect(() => {
+        if (!name || !requestedAt)
+            return;
+        const seen = watched.current;
+        const same = seen?.name === name && seen.requestedAt === requestedAt;
+        if (wait !== 'none') {
+            if (!same)
+                watched.current = { name, requestedAt, gaveUp: false };
+            return;
+        }
+        if (!seen || !same)
+            return;
+        if (answer &&
+            !isBaseUpdatePending({ baseUpdateRequestedAt: requestedAt, lastBaseUpdate: answer })) {
+            watched.current = undefined;
+            report({ name, createdAt: createdAt ?? '', requestedAt }, answer);
+        }
+        else if (!seen.gaveUp && status === 'editing') {
+            seen.gaveUp = true;
+            showResult('yellow', GAVE_UP_MESSAGE);
+        }
+    }, [name, createdAt, requestedAt, answer, wait, status, report]);
+    const request = useCallback(async () => {
+        const target = latest.current.name;
+        if (!target)
+            return;
+        if (latest.current.unsavedCount > 0) {
+            showResult('yellow', SAVE_FIRST_REASON);
+            return;
+        }
+        // What lands after the user moved to another branch is about that one, not this.
+        const stillOpen = () => latest.current.name === target;
+        setRequestingFor(target);
+        try {
+            try {
+                const result = await apiClient.workflow.updateFromBase({ branch: target });
+                if (isGatewayFailure(result))
+                    throw new UnansweredError();
+                if (result.ok && result.data) {
+                    const { branch: answered, requestedAt: at } = result.data;
+                    await mutate(BRANCHES_KEY, (data) => withBranch(data, answered), {
+                        revalidate: false,
+                    });
+                    if (!stillOpen())
+                        return;
+                    const on = { name: target, createdAt: answered.createdAt, requestedAt: at };
+                    setAsked(on);
+                    if (!isBaseUpdatePending(answered) && answered.lastBaseUpdate) {
+                        report(on, answered.lastBaseUpdate);
+                    }
+                    else {
+                        watched.current = { name: target, requestedAt: at, gaveUp: false };
+                    }
+                    return;
+                }
+                // A refusal can mean the branch moved on (submitted meanwhile): re-read it, and offer Retry
+                // only if it can still ask.
+                const fresh = await mutate(BRANCHES_KEY);
+                if (!stillOpen())
+                    return;
+                const now = fresh?.branches.find((b) => b.name === target);
+                const canRetry = now === undefined || now.status === 'editing';
+                // A 409 is a conflict with the branch's state, which the guidelines colour yellow.
+                showResult(result.status === 409 ? 'yellow' : 'red', result.error ?? REQUEST_FAILED_MESSAGE, canRetry ? retry : undefined);
+            }
+            catch (err) {
+                if (!isUnanswered(err))
+                    throw err;
+                // It may have gone through, and a reload that shows the wait settles it.
+                const fresh = await mutate(BRANCHES_KEY);
+                if (!stillOpen())
+                    return;
+                const reloaded = fresh?.branches.find((b) => b.name === target);
+                if (baseUpdateWait(reloaded, serverNow()) === 'none') {
+                    showResult('yellow', UNANSWERED_MESSAGE, retry);
+                }
+            }
+        }
+        catch (err) {
+            if (!stillOpen())
+                return;
+            notifications.hide(RESULT_TOAST_ID);
+            notifications.show({
+                id: RESULT_TOAST_ID,
+                color: 'red',
+                autoClose: false,
+                message: (_jsx(RetryToastMessage, { message: REQUEST_FAILED_MESSAGE, onRetry: retry, details: getErrorMessage(err) })),
+            });
+        }
+        finally {
+            setRequestingFor((current) => (current === target ? null : current));
+        }
+    }, [apiClient, mutate, report, retry]);
+    requestRef.current = request;
+    return {
+        available,
+        wait,
+        requesting: !!name && requestingFor === name,
+        blockedReason: unsavedCount > 0 ? SAVE_FIRST_REASON : undefined,
+        request,
+        latestChangesWaiting: available && !!branch?.latestChangesWaiting,
+    };
+}

package/dist/editor/hooks/useBranchChangesData.d.ts

@@ -45,7 +45,13 @@ interface ChangesState<T, E> {
      */
     reload: () => Promise<void>;
 }
-export type BranchChangesState = ChangesState<BranchChangesData, BranchChangesError>;
+export type BranchChangesState = ChangesState<BranchChangesData, BranchChangesError> & {
+    /**
+     * Reads the list afresh, shown or not, rejecting when the read fails, and empties every entry
+     * change of the branch, so none shows a comparison read before this.
+     */
+    reread: () => Promise<void>;
+};
 /**
  * The branch's changes. `reload` also revalidates every entry change of the branch that is
  * shown, so one save refreshes the list and an open "Show changes" alike.

package/dist/editor/hooks/useBranchChangesData.js

@@ -98,12 +98,25 @@ export function useBranchChangesData(apiClient, branch, enabled) {
             mutateKeys((k) => typeof k === 'string' && k.startsWith(entryPrefix)),
         ]);
     }, [mutate, mutateKeys, branch]);
+    const reread = useCallback(async () => {
+        if (!branch)
+            return;
+        const entryPrefix = `${branchChangesKey(branch)}:`;
+        const [fresh] = await Promise.all([
+            fetchBranchChanges(apiClient, branch),
+            mutateKeys((k) => typeof k === 'string' && k.startsWith(entryPrefix), undefined, {
+                revalidate: true,
+            }),
+        ]);
+        await mutateKeys(branchChangesKey(branch), fresh, { revalidate: false });
+    }, [apiClient, mutateKeys, branch]);
     return {
         data: swr.data,
         error: key && swr.error !== undefined ? toError(swr.error) : undefined,
         isLoading: swr.isLoading,
         isValidating: swr.isValidating,
         reload,
+        reread,
     };
 }
 /** One entry's change on the branch, fetched while `target` is set (the drawer is open). */

package/dist/editor/hooks/useBranchManager.d.ts

@@ -51,7 +51,7 @@ interface BranchSummary {
     syncFailureReason?: string;
     /** Whether this branch has unresolved merge conflicts with the base branch */
     conflictStatus?: ConflictStatus;
-    /** ContentIds of entries where --theirs was applied during rebase; cleared on clean rebase */
+    /** ContentIds of entries with a merge conflict a person has yet to resolve */
     conflictFiles?: string[];
     /** What is stuck and needs a person (api/branch.ts). */
     hold?: BranchHold;
@@ -92,6 +92,13 @@ export interface UseBranchManagerOptions {
     onStamped?: (stamped: StampedEntry[]) => void;
     /** A request for changes went through; the branch may now carry the reviewer's note as a comment. */
     onChangesRequested?: (branchName: string) => void;
+    /** A branch is being pinned for its reviews: read its content again if it is open, settling once read. */
+    onReviewPinned?: (branchName: string) => Promise<void> | void;
+    /**
+     * How to ask for the latest changes on `branchName` once it is withdrawn, or undefined where
+     * that can't apply. With it, withdrawing a branch that conflicts with its base asks right after.
+     */
+    latestChangesAfterWithdraw?: (branchName: string) => (() => Promise<void>) | undefined;
 }
 export interface UseBranchManagerReturn {
     /**

package/dist/editor/hooks/useBranchManager.js

@@ -6,7 +6,8 @@ import { Alert, Stack, Text } from '@mantine/core';
 import { IconAlertTriangle } from '@tabler/icons-react';
 import { openConfirm } from '../utils/confirm-modal.js';
 import { focusReturnProps } from '../utils/focus-return.js';
-import { EDITOR_ACTIONS } from '../copy.js';
+import { EDITOR_ACTIONS, WITHDRAW_AND_GET_LATEST } from '../copy.js';
+import { clientOperatingStrategy } from '../../operating-mode/client.js';
 import { notifications } from '@mantine/notifications';
 import { useApiClient, useBranchSegments } from '../context/index.js';
 import { BRANCHES_KEY, fetchBranches, useBranchesData } from './useBranchesData.js';
@@ -32,6 +33,13 @@ class StaleStatusError extends Error {
         this.name = 'StaleStatusError';
     }
 }
+/** The API's `BRANCH_MOVED`: the branch's head isn't the one the reviewer's page was pinned to. */
+class BranchMovedError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'BranchMovedError';
+    }
+}
 /** An answer that refused the action, with its HTTP status: a 4xx is a refusal no retry passes. */
 class RefusedError extends Error {
     constructor(message, status) {
@@ -50,7 +58,13 @@ function actionError(result, fallback, staleIsConflict = false) {
     const message = result.error || fallback;
     if (result.ok)
         return new Error(message);
-    return staleIsConflict && result.status === 409 && !isNonApiResponse(result)
+    if (result.code === 'BRANCH_MOVED')
+        return new BranchMovedError(message);
+    // Open conflicts refuse the action where the branch still is, so they are no stale status.
+    return staleIsConflict &&
+        result.status === 409 &&
+        result.code !== 'OPEN_CONFLICTS' &&
+        !isNonApiResponse(result)
         ? new StaleStatusError(message)
         : new RefusedError(message, result.status);
 }
@@ -142,16 +156,22 @@ export function withdrawPullRequestBullet(pr) {
         return `Leave the merged ${label} as it is`;
     return `Convert ${label} to a draft`;
 }
-const showWithdrawConfirmation = (branchName, pr, onConfirm, onDismiss, returnFocusTo) => {
+const showWithdrawConfirmation = (branchName, pr, onConfirm, onDismiss, returnFocusTo, 
+/** The branch conflicts with its base, so withdrawing also gets the latest changes. */
+thenGetLatest = false) => {
     const bullets = [
         withdrawPullRequestBullet(pr),
         'Change the branch status back to “editing”',
         'Remove from review queue',
+        thenGetLatest ? 'Bring in the latest changes made on the site' : undefined,
     ].filter((b) => b !== undefined);
     openConfirm({
         title: EDITOR_ACTIONS.withdrawFromReview,
         children: (_jsx(Text, { size: "sm", style: { whiteSpace: 'pre-line' }, children: `Withdraw “${branchName}” from review?\n\nThis will:\n${bullets.map((b) => `• ${b}`).join('\n')}` })),
-        labels: { confirm: EDITOR_ACTIONS.withdrawFromReview, cancel: 'Cancel' },
+        labels: {
+            confirm: thenGetLatest ? WITHDRAW_AND_GET_LATEST : EDITOR_ACTIONS.withdrawFromReview,
+            cancel: 'Cancel',
+        },
         confirmProps: { color: 'orange', 'data-testid': 'confirm-withdraw-branch' },
         ...confirmModalHandlers(onConfirm, onDismiss),
         ...focusReturnProps(returnFocusTo),
@@ -467,6 +487,52 @@ export function useBranchManager(options) {
     // these at confirm time rather than from that render's closure.
     const latest = useRef({ branchName, resolved, branches, branchesData });
     latest.current = { branchName, resolved, branches, branchesData };
+    // The head a review sends, never newer than what the page shows of the branch. One not shown
+    // follows each listing; opening one, a head listed for the open one while its pin is null, and a
+    // refusal's recovery pin it from a listing already fetched once its content is read again.
+    const reviewPins = useRef(new Map());
+    const shown = useRef(new Set());
+    const pinning = useRef(new Map());
+    const lastOpen = useRef(undefined);
+    const pinThenReread = async (branch, data) => {
+        const headSha = data?.branches.find((b) => b.name === branch)?.headSha;
+        const claim = Symbol(branch);
+        pinning.current.set(branch, claim);
+        reviewPins.current.set(branch, null);
+        try {
+            if (headSha)
+                await options.onReviewPinned?.(branch);
+            // A failed read leaves it null, for the next listing to try again.
+            if (pinning.current.get(branch) === claim)
+                reviewPins.current.set(branch, headSha ?? null);
+        }
+        finally {
+            if (pinning.current.get(branch) === claim)
+                pinning.current.delete(branch);
+        }
+    };
+    useEffect(() => {
+        const listed = branchesData?.branches ?? [];
+        for (const b of listed) {
+            if (!shown.current.has(b.name))
+                reviewPins.current.set(b.name, b.headSha ?? null);
+        }
+        const open = currentBranchName && listed.find((b) => b.name === currentBranchName);
+        if (!open)
+            return;
+        const firstHead = open.headSha && reviewPins.current.get(open.name) === null && !pinning.current.has(open.name);
+        // Coming back to a branch opens it again: its entries are read afresh, so its pin is too.
+        const reopened = lastOpen.current !== open.name;
+        lastOpen.current = open.name;
+        if (!shown.current.has(open.name) || firstHead || reopened) {
+            shown.current.add(open.name);
+            pinThenReread(open.name, branchesData).catch(console.error);
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- `pinThenReread` reads only refs and options
+    }, [branchesData, currentBranchName]);
+    const reviewedHead = (branch) => ({
+        headSha: reviewPins.current.get(branch) ?? undefined,
+    });
     // A card, deep link or URL can carry a short name, an exact form or the raw form of a listed
     // name; the actions resolve it once, the way an arriving name resolves, then key, look up and
     // send the listed name.
@@ -577,6 +643,11 @@ export function useBranchManager(options) {
         }
     };
     const reviewFailureId = (kind, branch) => `canopy-${kind}-failed-${branch}`;
+    /** A verdict that went through answers either kind's refusal. */
+    const hideReviewFailures = (branch) => {
+        notifications.hide(reviewFailureId('approve', branch));
+        notifications.hide(reviewFailureId('request-changes', branch));
+    };
     const submitRefusedId = (branch) => `canopy-submit-refused-${branch}`;
     const deleteRefusedId = (branch) => `canopy-delete-refused-${branch}`;
     /**
@@ -586,6 +657,22 @@ export function useBranchManager(options) {
      * submit didn't finish (see `showLeftReview`, which shows the server's reason either way).
      */
     const reportReviewFailure = async (err, kind, branch, details) => {
+        if (err instanceof BranchMovedError) {
+            // A listing that fails, or leaves the branch out, pins none for now.
+            void pinThenReread(branch, await reloadBranches()).catch(console.error);
+            const id = reviewFailureId(kind, branch);
+            notifications.hide(id);
+            notifications.show({
+                id,
+                message: details.note
+                    ? `${err.message} Your note is kept for when you request changes again.`
+                    : err.message,
+                color: 'yellow',
+                autoClose: false,
+                withCloseButton: true,
+            });
+            return;
+        }
         if (err instanceof StaleStatusError) {
             showLeftReview(branch, err.message, details.note);
             // What the branch is now decides whether a Request changes note is still wanted.
@@ -609,8 +696,9 @@ export function useBranchManager(options) {
             notifications.show({
                 id,
                 message: details.note ? (_jsx(NoteNotSavedMessage, { message: message, note: details.note, hint: "Copy it to keep it." })) : (message),
-                color: 'red',
-                ...(details.note ? { autoClose: false } : {}),
+                // A 409, such as open conflicts, loses nothing and says what to do: yellow, until read.
+                color: err.status === 409 ? 'yellow' : 'red',
+                ...(details.note || err.status === 409 ? { autoClose: false, withCloseButton: true } : {}),
             });
             await loadBranches();
             return;
@@ -719,6 +807,12 @@ export function useBranchManager(options) {
     const handleWithdraw = (requested, returnFocusTo) => {
         const branchNameToWithdraw = listedName(requested);
         return singleFlight('withdraw', branchNameToWithdraw, () => new Promise((resolve, reject) => {
+            // The conflict that held it in review is what the latest changes settle.
+            const requestLatest = clientOperatingStrategy(options.operatingMode).syncsBranchesWithBase() &&
+                listedBranch(branchNameToWithdraw)?.hold?.kind === 'conflicts'
+                ? options.latestChangesAfterWithdraw?.(branchNameToWithdraw)
+                : undefined;
+            const thenGetLatest = !!requestLatest;
             showWithdrawConfirmation(shownName(branchNameToWithdraw), pullRequestOf(branchNameToWithdraw), async () => {
                 options.setBusy(true);
                 try {
@@ -731,6 +825,9 @@ export function useBranchManager(options) {
                     updateCreatedBranch(branchNameToWithdraw, result.data?.branch);
                     await loadBranches();
                     resolve();
+                    // Reports its own outcome, so a failure here never reads as a failed withdraw.
+                    if (requestLatest)
+                        void requestLatest();
                 }
                 catch (err) {
                     await reportActionFailure(err, 'Failed to withdraw branch', EDITOR_ACTIONS.withdrawFromReview);
@@ -739,7 +836,7 @@ export function useBranchManager(options) {
                 finally {
                     options.setBusy(false);
                 }
-            }, () => resolve(), returnFocusTo);
+            }, () => resolve(), returnFocusTo, thenGetLatest);
         }));
     };
     const handleArchive = (requested) => {
@@ -787,12 +884,10 @@ export function useBranchManager(options) {
             showApproveConfirmation(shownName(branchNameToApprove), pullRequestOf(branchNameToApprove), async () => {
                 options.setBusy(true);
                 try {
-                    const result = await apiClient.workflow.approve({
-                        branch: sendName(branchNameToApprove),
-                    });
+                    const result = await apiClient.workflow.approve({ branch: sendName(branchNameToApprove) }, reviewedHead(branchNameToApprove));
                     if (!result.ok)
                         throw actionError(result, 'Failed to approve branch', true);
-                    notifications.hide(reviewFailureId('approve', branchNameToApprove));
+                    hideReviewFailures(branchNameToApprove);
                     notifications.show({ message: 'Branch approved', color: 'green' });
                     updateCreatedBranch(branchNameToApprove, result.data?.branch);
                     await loadBranches();
@@ -825,11 +920,11 @@ export function useBranchManager(options) {
             }, async (note) => {
                 options.setBusy(true);
                 try {
-                    const result = await apiClient.workflow.requestChanges({ branch: sendName(branchNameForChanges) }, { note: note.trim() || undefined });
+                    const result = await apiClient.workflow.requestChanges({ branch: sendName(branchNameForChanges) }, { note: note.trim() || undefined, ...reviewedHead(branchNameForChanges) });
                     if (!result.ok)
                         throw actionError(result, 'Failed to request changes', true);
                     noteDrafts.current.delete(branchNameForChanges);
-                    notifications.hide(reviewFailureId('request-changes', branchNameForChanges));
+                    hideReviewFailures(branchNameForChanges);
                     notifications.show({ message: 'Changes requested', color: 'blue' });
                     // The note is saved apart from the status change, so it can fail on its own;
                     // the warning stays up, with the note to copy, because the words are not saved.

package/dist/editor/hooks/useBranchesData.js

@@ -15,6 +15,7 @@
 import useSWR, { useSWRConfig } from 'swr';
 import { isNonApiResponse } from '../../api/client.js';
 import { seedUserProfiles } from './useUserMetadata.js';
+import { noteServerTime } from '../server-clock.js';
 /** Cache key for the branches list. */
 export const BRANCHES_KEY = 'canopy:branches';
 /**
@@ -33,6 +34,8 @@ export async function fetchBranches(apiClient, swr) {
     if (!result.ok) {
         throw new Error(result.error ?? `Failed to load branches: ${result.status}`);
     }
+    if (result.data?.serverTime !== undefined)
+        noteServerTime(result.data.serverTime);
     const users = result.data?.users ?? [];
     await seedUserProfiles(swr, users);
     return {

package/dist/editor/hooks/useConflictChoices.d.ts

@@ -0,0 +1,24 @@
+import type { ResolvedFieldConflict } from '../../merge-conflicts.js';
+import type { EntryChoices, FieldChoice } from '../conflict-choices.js';
+export interface UseConflictChoicesReturn {
+    /** The open branch's choices for an entry, by conflict key. */
+    choicesFor: (contentId: string) => EntryChoices;
+    /** Records a choice, or clears it with undefined. */
+    choose: (contentId: string, key: string, mergeSha: string, choice: FieldChoice | undefined, decided: boolean) => void;
+    /** Entries with a decided choice no save has sent. */
+    pendingIds: ReadonlySet<string>;
+    /** What a save of an entry on `branch` resolves; nothing for another branch. */
+    pending: (branch: string, contentId: string) => ResolvedFieldConflict[];
+    /** Drops the choices a save sent: resolved, or no longer open. */
+    sent: (branch: string, contentId: string, resolved: readonly ResolvedFieldConflict[]) => void;
+    /** Drops an entry's choices, or every entry's when `contentId` is undefined. */
+    clear: (contentId?: string) => void;
+    /** Keeps only the choices of the entries `open` names, which have conflicts open. */
+    keepEntries: (open: ReadonlySet<string>) => void;
+    /** Keeps only an entry's choices for the conflicts `open` names, each on its merge. */
+    retain: (contentId: string, open: ReadonlyArray<{
+        key: string;
+        mergeSha: string;
+    }>) => void;
+}
+export declare function useConflictChoices(branch: string): UseConflictChoicesReturn;