canopycms 0.0.68-int.98 → 0.1.0

package/dist/editor/hooks/useBranchManager.js

@@ -1,9 +1,11 @@
 'use client';
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useCallback, useEffect, useMemo, useState } from 'react';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useSWRConfig } from 'swr';
-import { Text } from '@mantine/core';
-import { modals } from '@mantine/modals';
+import { Alert, Stack, Text } from '@mantine/core';
+import { IconAlertTriangle } from '@tabler/icons-react';
+import { openConfirm } from '../utils/confirm-modal.js';
+import { EDITOR_ACTIONS } from '../copy.js';
 import { notifications } from '@mantine/notifications';
 import { useApiClient } from '../context/index.js';
 import { BRANCHES_KEY, fetchBranches, useBranchesData } from './useBranchesData.js';
@@ -12,6 +14,18 @@ import { BRANCHES_KEY, fetchBranches, useBranchesData } from './useBranchesData.
 // which breaks adopters' production `next build` of the editor bundle.
 // paths/branch-name.ts is the dependency-free home of sanitizeBranchName.
 import { sanitizeBranchName } from '../../paths/branch-name.js';
+import { RetryToastMessage } from '../components/RetryToastMessage.js';
+import { isNonApiResponse } from '../../api/client.js';
+import { isGatewayFailure, isUnanswered, UnansweredError } from '../unanswered.js';
+import { describeUnsaved } from './useBranchActions.js';
+const BRANCHES_LOAD_FAILED_TOAST_ID = 'canopy-branches-load-failed';
+const BRANCH_OUTCOME_UNKNOWN_TOAST_ID = 'canopy-branch-outcome-unknown';
+/** The error a refused branch action throws; a gateway's 5xx says nothing of whether it ran. */
+function actionError(result, fallback) {
+    return isGatewayFailure(result) ? new UnansweredError() : new Error(result.error || fallback);
+}
+/** @internal Exported for tests. */
+export const branchActionOutcomeUnknown = (action) => `${action} may have gone through even though the server didn't answer. Check the branch's status before trying again.`;
 /**
  * Wire a confirm modal's exits so exactly ONE of {confirmed, dismissed} runs,
  * whichever happens first.
@@ -24,6 +38,9 @@ import { sanitizeBranchName } from '../../paths/branch-name.js';
  * handler would settle the caller's promise before the confirmed work had
  * even run. Claiming the first exit resolves both.
  */
+const submittedMessage = (stampedCount) => stampedCount === 0
+    ? 'Branch submitted for review'
+    : `Branch submitted for review. Dates set on ${stampedCount} new ${stampedCount === 1 ? 'entry' : 'entries'}.`;
 const confirmModalHandlers = (onConfirm, onDismiss) => {
     let settled = false;
     const claim = () => {
@@ -49,40 +66,84 @@ const confirmModalHandlers = (onConfirm, onDismiss) => {
         },
     };
 };
-const showSubmitConfirmation = (branchName, onConfirm, onDismiss) => {
-    modals.openConfirmModal({
-        title: 'Submit Branch for Review',
-        children: (_jsx(Text, { size: "sm", style: { whiteSpace: 'pre-line' }, children: `Are you sure you want to submit "${branchName}" for review?\n\nThis will:\n• Create a pull request for review\n• Change the branch status to "submitted"\n• Notify reviewers of pending changes` })),
-        labels: { confirm: 'Submit Branch', cancel: 'Cancel' },
-        confirmProps: { color: 'brand' },
+/**
+ * With `unsaved` edits on the branch, the dialog says they are left out: a submit sends only what
+ * is saved, and the branch is read-only in review, so they wait as drafts until it is editable.
+ */
+const showSubmitConfirmation = (branchName, unsaved, onConfirm, onDismiss) => {
+    const leftOut = unsaved && unsaved.count > 0 ? unsaved : undefined;
+    openConfirm({
+        title: EDITOR_ACTIONS.submitForReview,
+        children: (_jsxs(Stack, { gap: "sm", children: [leftOut && (_jsxs(Alert, { color: "yellow", icon: _jsx(IconAlertTriangle, { size: 16 }), title: `${leftOut.count} ${leftOut.count === 1 ? "entry has unsaved changes that won't" : "entries have unsaved changes that won't"} be submitted`, "data-testid": "submit-unsaved-warning", children: [describeUnsaved(leftOut), " To include them, cancel and save first. If you submit now, those changes stay unsaved on this branch while it is in review."] })), _jsx(Text, { size: "sm", style: { whiteSpace: 'pre-line' }, children: `Submit "${branchName}" for review?\n\nThis will:\n• Create a pull request for review\n• Change the branch status to "In review"\n• Notify reviewers of pending changes` })] })),
+        labels: {
+            confirm: leftOut ? 'Submit anyway' : EDITOR_ACTIONS.submitForReview,
+            cancel: 'Cancel',
+        },
+        confirmProps: { color: 'brand', 'data-testid': 'confirm-submit-branch' },
         ...confirmModalHandlers(onConfirm, onDismiss),
     });
 };
-const showWithdrawConfirmation = (branchName, onConfirm, onDismiss) => {
-    modals.openConfirmModal({
-        title: 'Withdraw Branch from Review',
-        children: (_jsx(Text, { size: "sm", style: { whiteSpace: 'pre-line' }, children: `Are you sure you want to withdraw "${branchName}" from review?\n\nThis will:\n• Convert the pull request to a draft\n• Change the branch status back to "editing"\n• Remove from review queue` })),
-        labels: { confirm: 'Withdraw Branch', cancel: 'Cancel' },
-        confirmProps: { color: 'orange' },
+/**
+ * The withdraw dialog's pull-request bullet, matching what api/branch-withdraw.ts does: an open
+ * PR becomes a draft; a closed one is left alone and its number dropped from the branch, so a
+ * resubmit opens a new one. A merged PR archives its branch, which withdraw refuses, so that
+ * bullet is only seen on a listing that lags.
+ * @internal Exported for tests.
+ */
+export function withdrawPullRequestBullet(pr) {
+    if (!pr.pullRequestNumber)
+        return undefined;
+    const label = `pull request #${pr.pullRequestNumber}`;
+    if (pr.pullRequestState === 'closed') {
+        return `Leave the closed ${label} as it is; submitting again opens a new one`;
+    }
+    if (pr.pullRequestState === 'merged')
+        return `Leave the merged ${label} as it is`;
+    return `Convert ${label} to a draft`;
+}
+const showWithdrawConfirmation = (branchName, pr, onConfirm, onDismiss) => {
+    const bullets = [
+        withdrawPullRequestBullet(pr),
+        'Change the branch status back to "editing"',
+        'Remove from review queue',
+    ].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' },
+        confirmProps: { color: 'orange', 'data-testid': 'confirm-withdraw-branch' },
+        ...confirmModalHandlers(onConfirm, onDismiss),
+    });
+};
+const showRequestChangesConfirmation = (branchName, onConfirm, onDismiss) => {
+    openConfirm({
+        title: EDITOR_ACTIONS.requestChanges,
+        children: (_jsx(Text, { size: "sm", style: { whiteSpace: 'pre-line' }, children: `Send "${branchName}" back to its editor?\n\nThis will:\n• Change the branch status back to "editing"\n• Let its editor change it and submit again` })),
+        labels: { confirm: EDITOR_ACTIONS.requestChanges, cancel: 'Cancel' },
+        confirmProps: { color: 'red', 'data-testid': 'confirm-request-changes' },
         ...confirmModalHandlers(onConfirm, onDismiss),
     });
 };
 /**
- * Unlike submit/withdraw (both reversible), delete is irreversible -- it
- * unlinks branch.json, removes the clone, and removes the branch head from
- * the local git mirror. Before this, `handleDelete` below called
- * `apiClient.branches.delete` immediately on click with no confirmation
- * anywhere in the chain (BranchManager.tsx's delete button calls `onDelete`
- * directly), while submit and withdraw -- both reversible -- each went
- * through this same `modals.openConfirmModal` pattern. This closes that gap;
- * `color: 'red'` marks it as the destructive one, matching the button's own
- * color in BranchManager.tsx.
+ * Delete is the one irreversible branch action: it unlinks branch.json and removes the clone,
+ * the local mirror's head and, for a branch with a PR, the GitHub branch. BranchManager.tsx's
+ * delete menu item calls `onDelete` directly, so this dialog is the only confirmation; `color:
+ * 'red'` matches that item.
  */
-const showDeleteConfirmation = (branchName, onConfirm, onDismiss) => {
-    modals.openConfirmModal({
-        title: 'Delete Branch',
-        children: (_jsx(Text, { size: "sm", style: { whiteSpace: 'pre-line' }, children: `Are you sure you want to delete "${branchName}"?\n\nThis will:\n• Permanently remove the branch and its clone\n• Discard any unsaved or unmerged changes\n\nThis cannot be undone.` })),
-        labels: { confirm: 'Delete Branch', cancel: 'Cancel' },
+const showDeleteConfirmation = (branchName, pr, onConfirm, onDismiss) => {
+    // The server deletes the GitHub branch only for a branch with a PR (api/github-sync.ts's
+    // syncDeleteRemoteBranch); GitHub closes a PR whose branch is deleted.
+    const bullets = [
+        'Permanently remove the branch and its clone',
+        pr.pullRequestNumber
+            ? `Delete its branch on GitHub too, which closes pull request #${pr.pullRequestNumber} if it is still open`
+            : undefined,
+        'Discard any unsaved or unmerged changes',
+    ].filter((b) => b !== undefined);
+    openConfirm({
+        title: 'Delete branch',
+        children: (_jsx(Text, { size: "sm", style: { whiteSpace: 'pre-line' }, children: `Delete "${branchName}"?\n\nThis will:\n${bullets.map((b) => `• ${b}`).join('\n')}\n\nThis cannot be undone.` })),
+        labels: { confirm: 'Delete branch', cancel: 'Cancel' },
         // data-testid is load-bearing, not decoration: the e2e helper
         // (apps/test-app/e2e/fixtures/branch-page.ts's deleteBranch) already
         // anticipated a delete confirmation and clicks
@@ -137,7 +198,7 @@ function reconcilePendingBranches(pending, listed, receivedAt) {
  */
 export function useBranchManager(options) {
     const apiClient = useApiClient();
-    const { mutate: globalMutate } = useSWRConfig();
+    const { cache, mutate: globalMutate } = useSWRConfig();
     const [branchName, setBranchName] = useState(options.initialBranch);
     const { data: branchesData, error: branchesError, isValidating: branchesIsValidating, } = useBranchesData(apiClient);
     const [pendingBranches, setPendingBranches] = useState([]);
@@ -148,15 +209,25 @@ export function useBranchManager(options) {
             { branch, addedAt: Date.now() },
         ]);
     }, []);
-    // After a server-side change to a pending branch, its overlaid copy is stale,
-    // and a lagging listing would show it (a submitted branch as still writable).
-    // Forgetting it leaves the listings alone to decide, failing closed if they lag.
     const forgetCreatedBranch = (name) => {
         setPendingBranches((prev) => {
             const kept = prev.filter((p) => p.branch.name !== name);
             return kept.length === prev.length ? prev : kept;
         });
     };
+    // After a workflow action, a pending branch's overlaid copy is stale. The
+    // server's returned copy replaces it, so a listing that still lacks the
+    // branch shows its new status instead of hiding it; without one, forgetting
+    // it fails closed rather than showing the pre-action state.
+    const updateCreatedBranch = (name, branch) => {
+        if (!branch) {
+            forgetCreatedBranch(name);
+            return;
+        }
+        setPendingBranches((prev) => prev.some((p) => p.branch.name === name)
+            ? prev.map((p) => (p.branch.name === name ? { ...p, branch } : p))
+            : prev);
+    };
     // Each received listing is a new `branchesData` (see `BranchesData.receivedAt`);
     // the grace window is measured to its arrival.
     useEffect(() => {
@@ -170,25 +241,33 @@ export function useBranchManager(options) {
             setBranchName(branchesData.defaultBranch);
         }
     }, [branchesData, branchName]);
+    // One toast, replaced on each failure (a shown id ignores `show`); sticky because the editor
+    // cannot function without the branch list.
+    const showBranchesLoadFailed = (message) => {
+        notifications.hide(BRANCHES_LOAD_FAILED_TOAST_ID);
+        notifications.show({
+            id: BRANCHES_LOAD_FAILED_TOAST_ID,
+            title: 'Could not load branches',
+            message: (_jsx(RetryToastMessage, { message: message, onRetry: () => {
+                    notifications.hide(BRANCHES_LOAD_FAILED_TOAST_ID);
+                    void reloadBranches();
+                } })),
+            color: 'red',
+            autoClose: false,
+        });
+    };
     // Surfaces/clears the sticky error toast the same way loadBranches() does.
     useEffect(() => {
         if (branchesError) {
             console.error(branchesError);
-            const message = branchesError instanceof Error ? branchesError.message : 'Failed to load branches';
-            // Fixed id: retries update the existing toast instead of stacking; sticky
-            // because the editor cannot function without the branch list.
-            notifications.show({
-                id: 'canopy-branches-load-failed',
-                message,
-                color: 'red',
-                autoClose: false,
-            });
+            showBranchesLoadFailed(branchesError instanceof Error ? branchesError.message : 'Failed to load branches');
         }
         else if (branchesData) {
             // A previous failure may have left the sticky error toast up; clear it
             // now that loading succeeded (provisioning failures are often transient).
-            notifications.hide('canopy-branches-load-failed');
+            notifications.hide(BRANCHES_LOAD_FAILED_TOAST_ID);
         }
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- showBranchesLoadFailed is new every render and reads nothing that changes
     }, [branchesData, branchesError]);
     // Mirrors the automatic load's in-flight state onto the shared busy flag,
     // matching loadBranches()'s own setBusy bracket below for explicit reloads.
@@ -214,6 +293,9 @@ export function useBranchManager(options) {
                 access: {
                     users: b.access.allowedUsers,
                     groups: b.access.allowedGroups,
+                    managerOrAdminAllowed: b.access.managerOrAdminAllowed,
+                    withheldUsers: b.withheldAccess?.users,
+                    withheldGroups: b.withheldAccess?.groups,
                 },
                 pullRequestUrl: b.pullRequestUrl,
                 pullRequestNumber: b.pullRequestNumber,
@@ -253,136 +335,250 @@ export function useBranchManager(options) {
     // bound hook (and anything else reading BRANCHES_KEY) picks it up.
     // Side effects (default-branch adoption, error/success notifications) are
     // driven by the effects above, which react to that same cache write.
-    const loadBranches = async () => {
+    // Resolves to the fresh listing, or undefined when the fetch failed.
+    const reloadBranches = async () => {
         options.setBusy(true);
         try {
-            const fresh = await fetchBranches(apiClient);
+            const fresh = await fetchBranches(apiClient, { cache, mutate: globalMutate });
             await globalMutate(BRANCHES_KEY, fresh, { revalidate: false });
+            return fresh;
         }
         catch (err) {
             console.error(err);
-            const message = err instanceof Error ? err.message : 'Failed to load branches';
-            notifications.show({
-                id: 'canopy-branches-load-failed',
-                message,
-                color: 'red',
-                autoClose: false,
-            });
+            showBranchesLoadFailed(err instanceof Error ? err.message : 'Failed to load branches');
+            return undefined;
         }
         finally {
             options.setBusy(false);
         }
     };
-    const handleSubmit = async (branchNameToSubmit) => {
-        return new Promise((resolve, reject) => {
-            showSubmitConfirmation(branchNameToSubmit, async () => {
+    const loadBranches = async () => {
+        await reloadBranches();
+    };
+    // The confirm dialogs' handlers run long after the render that opened them, so they read
+    // these at confirm time rather than from that render's closure.
+    const latest = useRef({ branchName, branches, branchesData });
+    latest.current = { branchName, branches, branchesData };
+    // A legacy deep link can carry the raw form of a listed name; the actions key, look up and
+    // send the listed name, resolved the way `currentBranch` resolves it.
+    const listedName = (name) => latest.current.branches.some((b) => b.name === name) ? name : sanitizeBranchName(name);
+    const pullRequestOf = (name) => {
+        const b = latest.current.branches.find((x) => x.name === name);
+        return { pullRequestNumber: b?.pullRequestNumber, pullRequestState: b?.pullRequestState };
+    };
+    // Keys of the actions whose confirm is open or whose work is in flight.
+    const actionsInFlight = useRef(new Set());
+    /**
+     * Runs `run` unless the same action on the same branch already has its confirm open or its
+     * work in flight; then this request opens nothing and resolves at once. Mantine closes only
+     * the confirm that was confirmed, so a second one opened by a repeated click would stay up
+     * after the action succeeded.
+     */
+    const singleFlight = async (action, branch, run) => {
+        const key = JSON.stringify([action, branch]);
+        if (actionsInFlight.current.has(key))
+            return;
+        actionsInFlight.current.add(key);
+        try {
+            await run();
+        }
+        finally {
+            actionsInFlight.current.delete(key);
+        }
+    };
+    // A workflow action that got no answer may have gone through, so the list reloads to show
+    // where the branch stands rather than inviting a blind retry.
+    const showOutcomeUnknown = (action) => {
+        notifications.hide(BRANCH_OUTCOME_UNKNOWN_TOAST_ID);
+        notifications.show({
+            id: BRANCH_OUTCOME_UNKNOWN_TOAST_ID,
+            message: branchActionOutcomeUnknown(action),
+            color: 'yellow',
+            autoClose: false,
+            withCloseButton: true,
+        });
+    };
+    const reportActionFailure = async (err, fallback, action) => {
+        if (isUnanswered(err)) {
+            showOutcomeUnknown(action);
+            await loadBranches();
+            return;
+        }
+        notifications.show({ message: err instanceof Error ? err.message : fallback, color: 'red' });
+    };
+    const handleSubmit = (requested) => {
+        const branchNameToSubmit = listedName(requested);
+        return singleFlight('submit', branchNameToSubmit, async () => {
+            // Drafts belong to the open branch, so only its submit can leave edits behind. Without
+            // that check the dialog opens in this same tick.
+            const checking = branchNameToSubmit === listedName(latest.current.branchName)
+                ? options.getUnsaved?.().catch((err) => {
+                    console.error(err);
+                    return undefined;
+                })
+                : undefined;
+            // Checking can wait on draft verification, so the busy state shows it is working meanwhile.
+            if (checking)
                 options.setBusy(true);
-                try {
-                    const result = await apiClient.workflow.submit({
-                        branch: branchNameToSubmit,
-                    });
-                    if (!result.ok) {
-                        throw new Error(result.error || 'Failed to submit branch');
+            const unsaved = checking && (await checking.finally(() => options.setBusy(false)));
+            return new Promise((resolve, reject) => {
+                showSubmitConfirmation(branchNameToSubmit, unsaved, async () => {
+                    // A listing that arrived while the dialog was open may show the branch already
+                    // submitted; submitting it again would only fail.
+                    const listed = latest.current.branches.find((b) => b.name === branchNameToSubmit);
+                    if (listed?.status === 'submitted') {
+                        notifications.show({
+                            message: 'Branch is already submitted for review',
+                            color: 'blue',
+                        });
+                        resolve();
+                        return;
                     }
-                    notifications.show({
-                        message: 'Branch submitted for review',
-                        color: 'green',
-                    });
-                    forgetCreatedBranch(branchNameToSubmit);
-                    await loadBranches();
-                    resolve();
-                }
-                catch (err) {
-                    const message = err instanceof Error ? err.message : 'Failed to submit branch';
-                    notifications.show({ message, color: 'red' });
-                    reject(err);
-                }
-                finally {
-                    options.setBusy(false);
-                }
-            }, 
-            // Dismissal is not an error. Rejecting here meant clicking Cancel
-            // logged a console error at the only call site (Editor.tsx catches
-            // these into console.error), which is both noise and a trip hazard
-            // for the CI=1 stray-console gate. Settled once, by onCancel OR
-            // onClose, so an Escape/overlay dismissal can't leave this pending.
-            () => resolve());
+                    options.setBusy(true);
+                    try {
+                        const result = await apiClient.workflow.submit({
+                            branch: branchNameToSubmit,
+                        });
+                        if (!result.ok)
+                            throw actionError(result, 'Failed to submit branch');
+                        const stamped = result.data?.stamped;
+                        if (stamped && branchNameToSubmit === listedName(latest.current.branchName)) {
+                            options.onStamped?.(stamped);
+                        }
+                        notifications.show({
+                            message: submittedMessage(stamped?.length ?? 0),
+                            color: 'green',
+                        });
+                        updateCreatedBranch(branchNameToSubmit, result.data?.branch);
+                        await loadBranches();
+                        resolve();
+                    }
+                    catch (err) {
+                        await reportActionFailure(err, 'Failed to submit branch', EDITOR_ACTIONS.submitForReview);
+                        reject(err);
+                    }
+                    finally {
+                        options.setBusy(false);
+                    }
+                }, 
+                // Dismissal is not an error: the call sites log rejections to the console. Settled
+                // once, by onCancel OR onClose, so an Escape/overlay dismissal can't leave this pending.
+                () => resolve());
+            });
         });
     };
-    const handleWithdraw = async (branchNameToWithdraw) => {
-        return new Promise((resolve, reject) => {
-            showWithdrawConfirmation(branchNameToWithdraw, async () => {
+    const handleWithdraw = (requested) => {
+        const branchNameToWithdraw = listedName(requested);
+        return singleFlight('withdraw', branchNameToWithdraw, () => new Promise((resolve, reject) => {
+            showWithdrawConfirmation(branchNameToWithdraw, pullRequestOf(branchNameToWithdraw), async () => {
                 options.setBusy(true);
                 try {
                     const result = await apiClient.workflow.withdraw({
                         branch: branchNameToWithdraw,
                     });
-                    if (!result.ok) {
-                        throw new Error(result.error || 'Failed to withdraw branch');
-                    }
+                    if (!result.ok)
+                        throw actionError(result, 'Failed to withdraw branch');
                     notifications.show({ message: 'Branch withdrawn', color: 'blue' });
-                    forgetCreatedBranch(branchNameToWithdraw);
+                    updateCreatedBranch(branchNameToWithdraw, result.data?.branch);
                     await loadBranches();
                     resolve();
                 }
                 catch (err) {
-                    const message = err instanceof Error ? err.message : 'Failed to withdraw branch';
-                    notifications.show({ message, color: 'red' });
+                    await reportActionFailure(err, 'Failed to withdraw branch', EDITOR_ACTIONS.withdrawFromReview);
                     reject(err);
                 }
                 finally {
                     options.setBusy(false);
                 }
             }, () => resolve());
-        });
+        }));
     };
-    const handleRequestChanges = async (branchNameForChanges) => {
-        options.setBusy(true);
-        try {
-            const result = await apiClient.workflow.requestChanges({ branch: branchNameForChanges });
-            if (!result.ok) {
-                throw new Error(result.error || 'Failed to request changes');
+    const handleRequestChanges = (branchNameForChanges) => singleFlight('request-changes', branchNameForChanges, () => new Promise((resolve) => {
+        showRequestChangesConfirmation(branchNameForChanges, async () => {
+            options.setBusy(true);
+            try {
+                const result = await apiClient.workflow.requestChanges({
+                    branch: branchNameForChanges,
+                });
+                if (!result.ok)
+                    throw actionError(result, 'Failed to request changes');
+                notifications.show({ message: 'Changes requested', color: 'blue' });
+                updateCreatedBranch(branchNameForChanges, result.data?.branch);
+                await loadBranches();
             }
-            notifications.show({ message: 'Changes requested', color: 'orange' });
-            forgetCreatedBranch(branchNameForChanges);
-            await loadBranches();
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : 'Failed to request changes';
-            notifications.show({ message, color: 'red' });
-        }
-        finally {
-            options.setBusy(false);
+            catch (err) {
+                await reportActionFailure(err, 'Failed to request changes', EDITOR_ACTIONS.requestChanges);
+            }
+            finally {
+                options.setBusy(false);
+                resolve();
+            }
+        }, () => resolve());
+    }));
+    /** After a delete: drop it from the created-branch overlay, and leave it if it is open. */
+    const leaveDeletedBranch = (deleted, fresh) => {
+        forgetCreatedBranch(deleted);
+        // Matched the way `currentBranch` resolves a name, since the deleted branch is no longer
+        // listed to resolve against.
+        const open = latest.current.branchName;
+        if (open === deleted || sanitizeBranchName(open) === deleted) {
+            // Nothing is left to keep, so no unsaved-changes prompt. With no default known yet, the
+            // empty name lets the default-branch adoption effect pick it.
+            setBranchName(fresh?.defaultBranch ?? latest.current.branchesData?.defaultBranch ?? '');
         }
     };
-    const handleDelete = async (branchNameToDelete) => {
-        return new Promise((resolve) => {
-            showDeleteConfirmation(branchNameToDelete, async () => {
+    const handleDelete = (requested) => {
+        const branchNameToDelete = listedName(requested);
+        return singleFlight('delete', branchNameToDelete, () => new Promise((resolve) => {
+            showDeleteConfirmation(branchNameToDelete, pullRequestOf(branchNameToDelete), async () => {
                 options.setBusy(true);
                 try {
                     const result = await apiClient.branches.delete({
                         branch: branchNameToDelete,
                     });
-                    if (!result.ok) {
-                        throw new Error(result.error || 'Failed to delete branch');
+                    // The API's own 404: the branch is already gone, by an earlier unanswered delete or
+                    // another user's.
+                    if (!result.ok && result.status === 404 && !isNonApiResponse(result)) {
+                        notifications.show({ message: 'Branch deleted', color: 'green' });
+                        leaveDeletedBranch(branchNameToDelete, await reloadBranches());
+                        return;
                     }
-                    notifications.show({ message: 'Branch deleted', color: 'green' });
-                    forgetCreatedBranch(branchNameToDelete);
-                    await loadBranches();
+                    if (!result.ok)
+                        throw actionError(result, 'Failed to delete branch');
+                    const cleanupWarning = result.data?.cleanupWarning;
+                    notifications.show(cleanupWarning
+                        ? {
+                            message: `Branch deleted, with a warning: ${cleanupWarning}`,
+                            color: 'yellow',
+                            autoClose: false,
+                        }
+                        : { message: 'Branch deleted', color: 'green' });
+                    leaveDeletedBranch(branchNameToDelete, await reloadBranches());
                 }
                 catch (err) {
-                    const message = err instanceof Error ? err.message : 'Failed to delete branch';
-                    notifications.show({ message, color: 'red' });
+                    if (!isUnanswered(err)) {
+                        await reportActionFailure(err, 'Failed to delete branch', 'Delete branch');
+                        return;
+                    }
+                    // Settled by the list: unlisted, and not created too recently to be listed, means deleted.
+                    const fresh = await reloadBranches();
+                    const recent = pendingBranches.filter((p) => Date.now() - p.addedAt <= CREATED_BRANCH_GRACE_MS);
+                    const listed = mergePendingBranches(fresh?.branches ?? [], recent).some((b) => sanitizeBranchName(b.name) === sanitizeBranchName(branchNameToDelete));
+                    if (fresh && !listed) {
+                        notifications.show({ message: 'Branch deleted', color: 'green' });
+                        leaveDeletedBranch(branchNameToDelete, fresh);
+                    }
+                    else {
+                        showOutcomeUnknown('Delete branch');
+                    }
                 }
                 finally {
                     options.setBusy(false);
-                    // Resolve regardless of API success/failure, matching the
-                    // pre-confirmation behavior (errors were shown as a toast, not
-                    // rethrown). Cancellation resolves too -- see below.
+                    // Failures surface as the toast above, never as a rejection; cancelling resolves too.
                     resolve();
                 }
             }, () => resolve());
-        });
+        }));
     };
     const handleReloadBranchData = async () => {
         await loadBranches();

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

@@ -11,7 +11,7 @@
  * })` -- see the comment on `fetchBranches` for why it doesn't just call
  * `mutate()` to revalidate.
  */
-import { type SWRResponse } from 'swr';
+import { type Cache, type ScopedMutator, type SWRResponse } from 'swr';
 import type { ApiClient } from '../context/index.js';
 import type { BranchListItem } from '../../api/branch.js';
 /** Cache key for the branches list. */
@@ -27,10 +27,14 @@ export interface BranchesData {
     receivedAt: number;
 }
 /**
- * Fetch the branches list. Exported for direct testing and for the
- * imperative reload path.
+ * Fetch the branches list, writing the owners it names into the user-metadata cache before the
+ * listing lands, so owner badges render named. Exported for direct testing and for the imperative
+ * reload path.
  */
-export declare function fetchBranches(apiClient: Pick<ApiClient, 'branches'>): Promise<BranchesData>;
+export declare function fetchBranches(apiClient: Pick<ApiClient, 'branches'>, swr: {
+    cache: Cache;
+    mutate: ScopedMutator;
+}): Promise<BranchesData>;
 /**
  * How often to re-poll while at least one branch is mid-flight, in ms.
  * Only ever active in the transient window below, so this is not a