canopycms 0.6.0 → 0.7.0

package/dist/content-id-index.js

@@ -25,6 +25,9 @@ import path from 'node:path';
 import { isValidId } from './id.js';
 import { isNotFoundError } from './utils/error.js';
 import { canopyLogWarn } from './utils/logger.js';
+import { entryLogicalPath, normalizeFilesystemPath } from './paths/normalize.js';
+import { parseTypedFilename } from './utils/typed-filename.js';
+import { getFormatExtension } from './utils/format.js';
 /** Logical path representing entries stored at the branch root (no parent collection). Rare in practice. */
 const EMPTY_LOGICAL_PATH = '';
 /**
@@ -39,6 +42,34 @@ function toLogicalCollectionPath(physicalPath) {
         .map((seg) => extractSlugFromFilename(seg))
         .join('/');
 }
+/** The extension of every ContentFormat, dot included; keyed so a new format fails to compile. */
+const ENTRY_EXTENSIONS = new Set(Object.keys({ md: true, mdx: true, json: true, yaml: true }).map((format) => getFormatExtension(format)));
+/**
+ * The path the editor lists the entry a file stores under (`EditorEntry.path`, which its
+ * `entry` param matches), or null for a file that cannot be a listed entry: outside
+ * `contentRoot`, under a dot-prefixed or `_ids_` segment, or not named
+ * `{type}.{slug}.{id}.{ext}` with a content format's extension (parseTypedFilename). The content root is kept as
+ * spelled, as the schema spells it; the directories below lose their IDs. No I/O, and no
+ * check that the directory is a collection or the type one of its entry types.
+ */
+export function entryLogicalPathOfFile(relativePath, contentRoot) {
+    const root = normalizeFilesystemPath(contentRoot);
+    const file = normalizeFilesystemPath(relativePath);
+    if (!file.startsWith(`${root}/`))
+        return null;
+    const below = file.slice(root.length + 1).split('/');
+    if (below.some((s) => s.startsWith('.') || s === '_ids_'))
+        return null;
+    const name = below[below.length - 1];
+    if (!ENTRY_EXTENSIONS.has(name.slice(name.lastIndexOf('.'))))
+        return null;
+    const parsed = parseTypedFilename(name);
+    if (!parsed)
+        return null;
+    const dirs = below.slice(0, -1);
+    const collection = dirs.length > 0 ? `${root}/${toLogicalCollectionPath(dirs.join('/'))}` : root;
+    return entryLogicalPath(collection, parsed.slug);
+}
 /**
  * Bidirectional ContentId <-> path index over `{type}.{slug}.{12-char-id}.{ext}`
  * files and `{slug}.{12-char-id}/` directories, scanned lazily on first access

package/dist/editor/BranchManager.d.ts

@@ -59,6 +59,8 @@ export declare const getBranchPermissions: (branch: BranchSummary, user: UserCon
     canSubmit: boolean;
     canWithdraw: boolean;
     canDelete: boolean;
+    /** Approve is open to this user now: a reviewer other than the creator, on a submitted branch with a live PR. */
+    canApprove: boolean;
     canRequestChanges: boolean;
 };
 export interface BranchManagerProps {
@@ -87,6 +89,7 @@ export interface BranchManagerProps {
     onDelete?: (name: string) => void;
     onSubmit?: (name: string) => void;
     onWithdraw?: (name: string) => void;
+    onApprove?: (name: string) => void;
     onRequestChanges?: (name: string) => void;
     onClose?: () => void;
     comments?: CommentThread[];

package/dist/editor/BranchManager.js

@@ -13,7 +13,8 @@ import { DestructiveMenuItem } from './components/DestructiveMenuItem.js';
 import { ReasonedMenuItem } from './components/ReasonedMenuItem.js';
 import { RelativeTime } from './components/RelativeTime.js';
 import { branchStatusPresentation } from './branch-status.js';
-import { EDITOR_ACTIONS } from './copy.js';
+import { CLOSED_PULL_REQUEST_REASON, EDITOR_ACTIONS } from './copy.js';
+import { isReviewerOfOthersReview } from '../authorization/review-role.js';
 import { SYSTEM_USER_ID } from '../system-users.js';
 /**
  * What the current user can do to a branch, by the backend's hybrid model. Workflow access
@@ -30,6 +31,7 @@ export const getBranchPermissions = (branch, user) => {
             canSubmit: false,
             canWithdraw: false,
             canDelete: false,
+            canApprove: false,
             canRequestChanges: false,
         };
     }
@@ -58,8 +60,8 @@ export const getBranchPermissions = (branch, user) => {
     // fail-open for anything constructing a BranchSummary directly.
     const canSubmit = canPerformWorkflowActions && !(branch.submitBlocked ?? true);
     // Withdraw: can perform workflow actions AND branch is submitted or
-    // approved -- 'approved' is included because withdraw is that status's only
-    // non-destructive exit, and getBranchPermissions must grant canWithdraw for
+    // approved -- 'approved' is included because withdraw is the author's way back from it (an
+    // author is offered no Request changes), and getBranchPermissions must grant canWithdraw for
     // it to be reachable. Allowed even when the PR was closed without merging:
     // that's the deliberate recovery path for a closed-unmerged PR (server-side
     // skip in api/branch-withdraw.ts). Not additionally gated on
@@ -73,26 +75,29 @@ export const getBranchPermissions = (branch, user) => {
         branch.status !== 'submitted' &&
         branch.status !== 'approved' &&
         !branch.isProtected;
-    // Request changes: Only Reviewers or Admins can request changes on submitted
-    // branches. Same closed-PR restriction as withdraw applies (converts PR to draft).
-    const canRequestChanges = (userIsAdmin || userIsReviewer) &&
-        branch.status === 'submitted' &&
-        branch.pullRequestState !== 'closed';
+    // Approve and Request changes: a Reviewer or Admin other than the creator, who for an author
+    // would only do what Withdraw does. Neither applies to the protected base branch, whose way
+    // out of review is Withdraw. A closed PR refuses both (Request changes converts the PR to
+    // a draft); Approve also needs the branch submitted, Request changes accepts approved too.
+    const reviewsOthers = (userIsAdmin || userIsReviewer) && !userIsCreator && !branch.isProtected;
+    const prLive = branch.pullRequestState !== 'closed';
+    const canApprove = reviewsOthers && branch.status === 'submitted' && prLive;
+    const canRequestChanges = reviewsOthers && (branch.status === 'submitted' || branch.status === 'approved') && prLive;
     return {
         hasWorkflowAccess: canPerformWorkflowActions,
         canSubmit,
         canWithdraw,
         canDelete,
+        canApprove,
         canRequestChanges,
     };
 };
 /** The lookup when a card has none: an owner reads "Name unavailable" and access users are counted, not named. */
 const noUserLookup = async () => null;
-const CLOSED_PULL_REQUEST_REASON = 'The pull request was closed on GitHub. Withdraw the branch from review, then submit it again to open a new one.';
 /**
  * The workflow action a branch's status calls for, or undefined when none applies: Submit for
- * an unprotected branch in editing, Withdraw once it is in review. 'approved' withdraws too, as
- * its only non-destructive exit. A user without workflow access is offered neither, since it
+ * an unprotected branch in editing, Withdraw once it is in review, 'approved' included: it is the
+ * author's way back. A user without workflow access is offered neither, since it
  * would never apply to them; a reason is given only for a block that depends on the branch's state.
  */
 const workflowAction = (b, perms, onSubmit, onWithdraw) => {
@@ -117,58 +122,84 @@ const workflowAction = (b, perms, onSubmit, onWithdraw) => {
     }
     return undefined;
 };
-/** Whether `user` reviews `b` rather than owns it: a reviewer or admin who neither made it nor was given access. */
-const isReviewerOfOthersSubmission = (b, user) => !!user &&
-    isReviewer(user.groups) &&
-    b.status === 'submitted' &&
-    b.createdBy !== user.userId &&
-    !b.access?.users?.includes(user.userId) &&
-    !user.groups?.some((g) => b.access?.groups?.includes(g));
+/** Whether `user` reviews `b` rather than owns it; see `isReviewerOfOthersReview`. */
+const reviewsOthersBranch = (b, user) => isReviewerOfOthersReview({
+    status: b.status,
+    createdBy: b.createdBy,
+    users: b.access?.users,
+    groups: b.access?.groups,
+    isProtected: b.isProtected,
+    pullRequestState: b.pullRequestState,
+}, user);
 /**
  * One branch: its state, and one primary action, with the rest in a "…" menu. The current branch
- * shows its workflow action, or Request changes to a reviewer looking at someone else's
- * submission; the others show Open, which the current one never needs. No action is shown twice.
+ * shows its workflow action; to a reviewer of someone else's submission it shows Approve, with
+ * Request changes beside it (Request changes alone once approved). Another such branch shows that
+ * reviewer Review, which opens it; the other cards show Open, which the current one never needs.
+ * No action is shown twice.
  */
-const BranchCard = ({ branch: b, isCurrent, workflowBlockedReason, user, onSelect, onSubmit, onWithdraw, onRequestChanges, onDelete, onGetUserMetadata, onGetOwnerMetadata = onGetUserMetadata, }) => {
+const BranchCard = ({ branch: b, isCurrent, workflowBlockedReason, user, onSelect, onSubmit, onWithdraw, onApprove, onRequestChanges, onDelete, onGetUserMetadata, onGetOwnerMetadata = onGetUserMetadata, }) => {
     const statusBadge = branchStatusPresentation(b.status, b.isProtected);
     const perms = getBranchPermissions(b, user);
     const action = workflowAction(b, perms, onSubmit, onWithdraw);
     const workflow = action && workflowBlockedReason ? { ...action, blockedReason: workflowBlockedReason } : action;
     const userIsAdmin = isAdmin(user?.groups);
-    const requestChanges = isReviewer(user?.groups) && b.status === 'submitted'
+    // The open branch holds back its review actions as it does its workflow action; the reason is
+    // given only for the open branch.
+    const heldBack = (a) => a && workflowBlockedReason ? { ...a, blockedReason: workflowBlockedReason } : a;
+    // Shown to a reviewer other than the creator; a closed PR or a held-back open branch blocks it.
+    const reviewsOthers = isReviewer(user?.groups) && !!user && b.createdBy !== user.userId && !b.isProtected;
+    const approve = heldBack(reviewsOthers && b.status === 'submitted'
+        ? {
+            label: EDITOR_ACTIONS.approve,
+            color: 'brand',
+            testId: `approve-branch-button-${b.name}`,
+            run: () => onApprove?.(b.name),
+            blockedReason: perms.canApprove ? undefined : CLOSED_PULL_REQUEST_REASON,
+        }
+        : undefined);
+    const requestChanges = heldBack(reviewsOthers && (b.status === 'submitted' || b.status === 'approved')
         ? {
             label: EDITOR_ACTIONS.requestChanges,
             color: 'orange',
             testId: `request-changes-branch-button-${b.name}`,
             run: () => onRequestChanges?.(b.name),
-            blockedReason: b.pullRequestState === 'closed' ? CLOSED_PULL_REQUEST_REASON : undefined,
+            blockedReason: perms.canRequestChanges ? undefined : CLOSED_PULL_REQUEST_REASON,
+            // With Approve above it, blocked by the same closed pull request, the reason prints once.
+            reasonShownBy: approve && !perms.canApprove && b.pullRequestState === 'closed'
+                ? approve.testId
+                : undefined,
         }
-        : undefined;
-    const primary = !isCurrent
-        ? undefined
-        : isReviewerOfOthersSubmission(b, user)
-            ? requestChanges
-            : workflow;
-    const menuActions = [workflow, requestChanges].filter((a) => !!a && a !== primary);
+        : undefined);
+    const reviewing = reviewsOthersBranch(b, user);
+    // Reviewing the open branch: Approve leads with Request changes beside it, or Request changes
+    // alone once approved. Reviewing another one, Review opens it and the actions wait in the menu.
+    const primary = !isCurrent ? undefined : reviewing ? (approve ?? requestChanges) : workflow;
+    const secondary = isCurrent && reviewing && approve ? requestChanges : undefined;
+    // Two visible actions, or the long "Withdraw from review", would crowd the title at the drawer's
+    // width, so they take a row below it. Open and Review stay beside the title.
+    const actionRow = !!secondary || primary?.label === EDITOR_ACTIONS.withdrawFromReview;
+    const menuActions = [approve, requestChanges, workflow].filter((a) => !!a && a !== primary && a !== secondary);
     const showViewPullRequest = !!b.pullRequestUrl;
     const showDelete = !b.isProtected && (userIsAdmin || (!!user && b.createdBy === user.userId));
     const hasMenu = menuActions.length > 0 || showViewPullRequest || showDelete;
     const menuLabel = `More actions for ${b.name}`;
     const [menuOpen, setMenuOpen] = useState(false);
-    return (_jsx(Paper, { withBorder: true, p: "md", shadow: "xs", "aria-current": isCurrent ? 'true' : undefined, "data-current": isCurrent || undefined, "data-testid": `branch-list-item-${b.name}`, children: _jsxs(Group, { justify: "space-between", align: "flex-start", wrap: "nowrap", children: [_jsxs(Stack, { gap: 4, children: [_jsxs(Group, { gap: "xs", children: [_jsx(Text, { fw: 600, children: b.name }), isCurrent && (_jsx(Badge, { color: "brand", variant: "filled", "data-testid": `branch-current-badge-${b.name}`, children: "Current" })), statusBadge && (_jsx(Badge, { color: statusBadge.color, variant: statusBadge.variant, "data-testid": `branch-status-badge-${b.name}`, "data-status": b.status, "data-protected": b.isProtected || undefined, children: statusBadge.label })), b.status === 'archived' && b.mergedAt && (_jsx(Badge, { color: "teal", variant: "light", "data-testid": `branch-merged-badge-${b.name}`, children: "Merged" })), b.pullRequestNumber && (_jsxs(Badge, { color: b.pullRequestState === 'closed'
-                                        ? 'red'
-                                        : b.pullRequestState === 'merged'
-                                            ? 'violet'
-                                            : 'blue', variant: "light", children: ["PR #", b.pullRequestNumber, b.pullRequestState === 'closed' ? ' (closed)' : ''] })), b.commentCount !== undefined && b.commentCount > 0 && (_jsxs(Badge, { color: "grape", variant: "light", children: [b.commentCount, " ", b.commentCount === 1 ? 'comment' : 'comments'] })), b.syncStatus === 'sync-failed' && (_jsx(Tooltip, { label: "GitHub sync failed \u2014 an admin can retry it from System health.", disabled: Boolean(b.syncFailureReason), multiline: true, maw: 320, children: _jsx(Badge, { color: "red", variant: "light", "data-testid": `sync-failed-badge-${b.name}`, children: "Sync failed" }) })), b.syncStatus === 'pending-sync' && (_jsx(Tooltip, { label: "Changes are on their way to GitHub.", children: _jsx(Badge, { color: "gray", variant: "light", "data-testid": `pending-sync-badge-${b.name}`, children: "Syncing\u2026" }) })), b.conflictStatus === 'conflicts-detected' && (_jsx(Tooltip, { label: "This branch's version was kept for conflicting entries during a rebase \u2014 review the flagged entries.", children: _jsxs(Badge, { color: "orange", variant: "light", "data-testid": `conflicts-badge-${b.name}`, children: ["Conflicts", b.conflictFiles?.length ? ` (${b.conflictFiles.length})` : ''] }) }))] }), b.syncStatus === 'sync-failed' && b.syncFailureReason && (_jsxs(Text, { size: "xs", c: "var(--canopy-danger-text)", maw: 480, "data-testid": `sync-failed-reason-${b.name}`, children: [b.syncFailureReason, b.status === 'submitted' && ' Withdraw it from review to make changes.'] })), _jsxs(Group, { gap: "xs", align: "center", children: [b.updatedAt && (_jsx(RelativeTime, { iso: b.updatedAt, prefix: "Updated ", size: "xs", c: "dimmed" })), b.createdBy && (_jsxs(Group, { gap: "xs", align: "center", wrap: "nowrap", children: [_jsx(Text, { size: "xs", c: "dimmed", children: "\u2022" }), _jsxs(Group, { gap: 4, align: "center", wrap: "nowrap", children: [_jsx(Text, { size: "xs", c: "dimmed", children: "Owner:" }), _jsx(UserBadge, { userId: b.createdBy, getUserMetadata: onGetOwnerMetadata ?? noUserLookup, variant: "avatar-name", size: "xs", showEmailTooltip: true, showBadge: true, badgeVariant: "light", color: "gray" })] })] }))] }), b.access && (_jsx(BranchAccessList, { users: b.access.users, groups: b.access.groups, withheldUsers: b.access.withheldUsers, withheldGroups: b.access.withheldGroups, getUserMetadata: onGetOwnerMetadata ?? noUserLookup }))] }), _jsxs(Group, { gap: 8, wrap: "nowrap", children: [!isCurrent && (_jsx(Button, { variant: "light", onClick: () => onSelect?.(b.name), "data-testid": `switch-to-branch-button-${b.name}`, children: "Open" })), primary && (_jsx(Tooltip, { label: primary.blockedReason, disabled: !primary.blockedReason, multiline: true, maw: 280, children: _jsx(Button, { variant: "light", color: primary.color, onClick: () => {
-                                    if (!primary.blockedReason)
-                                        primary.run();
-                                }, "data-disabled": primary.blockedReason ? true : undefined, "aria-disabled": primary.blockedReason ? true : undefined, "data-testid": primary.testId, children: primary.label }) })), hasMenu && (_jsxs(Menu, { withinPortal: true, shadow: "sm", position: "bottom-end", width: 280, onChange: setMenuOpen, children: [_jsx(Tooltip, { label: menuLabel, disabled: menuOpen, children: _jsx(Menu.Target, { children: _jsx(ActionIcon, { variant: "subtle", color: "gray", "aria-label": menuLabel, "data-testid": `branch-actions-menu-${b.name}`, children: _jsx(IconDots, { size: 16, "aria-hidden": true }) }) }) }), _jsxs(Menu.Dropdown, { children: [menuActions.map((action) => (_jsx(ReasonedMenuItem, { blockedReason: action.blockedReason, onClick: action.run, "data-testid": action.testId, children: action.label }, action.testId))), showViewPullRequest && (_jsx(Menu.Item, { component: "a", href: b.pullRequestUrl, target: "_blank", rel: "noopener noreferrer", leftSection: _jsx(IconExternalLink, { size: 14, "aria-hidden": true }), "data-testid": `view-pull-request-${b.name}`, children: b.pullRequestNumber
-                                                ? `View pull request #${b.pullRequestNumber}`
-                                                : 'View pull request' })), showDelete && (_jsxs(_Fragment, { children: [(menuActions.length > 0 || showViewPullRequest) && _jsx(Menu.Divider, {}), _jsx(DestructiveMenuItem, { "data-testid": `delete-branch-button-${b.name}`, blockedReason: b.status === 'submitted' || b.status === 'approved'
-                                                        ? 'This branch is in review. Withdraw it from review before deleting it.'
-                                                        : undefined, onClick: () => onDelete?.(b.name), children: "Delete branch" })] }))] })] }))] })] }) }));
+    return (_jsxs(Paper, { withBorder: true, p: "md", shadow: "xs", "aria-current": isCurrent ? 'true' : undefined, "data-current": isCurrent || undefined, "data-testid": `branch-list-item-${b.name}`, children: [_jsxs(Group, { justify: "space-between", align: "flex-start", wrap: "nowrap", children: [_jsxs(Stack, { gap: 4, children: [_jsxs(Group, { gap: "xs", children: [_jsx(Text, { fw: 600, children: b.name }), isCurrent && (_jsx(Badge, { color: "brand", variant: "filled", "data-testid": `branch-current-badge-${b.name}`, children: "Current" })), statusBadge && (_jsx(Badge, { color: statusBadge.color, variant: statusBadge.variant, "data-testid": `branch-status-badge-${b.name}`, "data-status": b.status, "data-protected": b.isProtected || undefined, children: statusBadge.label })), b.status === 'archived' && b.mergedAt && (_jsx(Badge, { color: "teal", variant: "light", "data-testid": `branch-merged-badge-${b.name}`, children: "Merged" })), b.pullRequestNumber && (_jsxs(Badge, { color: b.pullRequestState === 'closed'
+                                            ? 'red'
+                                            : b.pullRequestState === 'merged'
+                                                ? 'violet'
+                                                : 'blue', variant: "light", children: ["PR #", b.pullRequestNumber, b.pullRequestState === 'closed' ? ' (closed)' : ''] })), b.commentCount !== undefined && b.commentCount > 0 && (_jsxs(Badge, { color: "grape", variant: "light", children: [b.commentCount, " ", b.commentCount === 1 ? 'comment' : 'comments'] })), b.syncStatus === 'sync-failed' && (_jsx(Tooltip, { label: "GitHub sync failed \u2014 an admin can retry it from System health.", disabled: Boolean(b.syncFailureReason), multiline: true, maw: 320, children: _jsx(Badge, { color: "red", variant: "light", "data-testid": `sync-failed-badge-${b.name}`, children: "Sync failed" }) })), b.syncStatus === 'pending-sync' && (_jsx(Tooltip, { label: "Changes are on their way to GitHub.", children: _jsx(Badge, { color: "gray", variant: "light", "data-testid": `pending-sync-badge-${b.name}`, children: "Syncing\u2026" }) })), b.conflictStatus === 'conflicts-detected' && (_jsx(Tooltip, { label: "This branch's version was kept for conflicting entries during a rebase \u2014 review the flagged entries.", children: _jsxs(Badge, { color: "orange", variant: "light", "data-testid": `conflicts-badge-${b.name}`, children: ["Conflicts", b.conflictFiles?.length ? ` (${b.conflictFiles.length})` : ''] }) }))] }), b.syncStatus === 'sync-failed' && b.syncFailureReason && (_jsxs(Text, { size: "xs", c: "var(--canopy-danger-text)", maw: 480, "data-testid": `sync-failed-reason-${b.name}`, children: [b.syncFailureReason, b.status === 'submitted' && ' Withdraw it from review to make changes.'] })), _jsxs(Group, { gap: "xs", align: "center", children: [b.updatedAt && (_jsx(RelativeTime, { iso: b.updatedAt, prefix: "Updated ", size: "xs", c: "dimmed" })), b.createdBy && (_jsxs(Group, { gap: "xs", align: "center", wrap: "nowrap", children: [_jsx(Text, { size: "xs", c: "dimmed", children: "\u2022" }), _jsxs(Group, { gap: 4, align: "center", wrap: "nowrap", children: [_jsx(Text, { size: "xs", c: "dimmed", children: "Owner:" }), _jsx(UserBadge, { userId: b.createdBy, getUserMetadata: onGetOwnerMetadata ?? noUserLookup, variant: "avatar-name", size: "xs", showEmailTooltip: true, showBadge: true, badgeVariant: "light", color: "gray" })] })] }))] }), b.access && (_jsx(BranchAccessList, { users: b.access.users, groups: b.access.groups, withheldUsers: b.access.withheldUsers, withheldGroups: b.access.withheldGroups, getUserMetadata: onGetOwnerMetadata ?? noUserLookup }))] }), _jsxs(Group, { gap: 8, wrap: "nowrap", children: [!isCurrent && (_jsx(Button, { variant: "light", onClick: () => onSelect?.(b.name), "data-testid": reviewing ? `review-branch-button-${b.name}` : `switch-to-branch-button-${b.name}`, children: reviewing ? EDITOR_ACTIONS.review : 'Open' })), !actionRow && primary && _jsx(CardActionButton, { action: primary }), hasMenu && (_jsxs(Menu, { withinPortal: true, shadow: "sm", position: "bottom-end", width: 280, onChange: setMenuOpen, children: [_jsx(Tooltip, { label: menuLabel, disabled: menuOpen, children: _jsx(Menu.Target, { children: _jsx(ActionIcon, { variant: "subtle", color: "gray", "aria-label": menuLabel, "data-testid": `branch-actions-menu-${b.name}`, children: _jsx(IconDots, { size: 16, "aria-hidden": true }) }) }) }), _jsxs(Menu.Dropdown, { children: [menuActions.map((action) => (_jsx(ReasonedMenuItem, { blockedReason: action.blockedReason, showReason: !action.reasonShownBy, reasonId: `${action.testId}-reason`, reasonDescribedBy: action.reasonShownBy ? `${action.reasonShownBy}-reason` : undefined, onClick: action.run, "data-testid": action.testId, children: action.label }, action.testId))), showViewPullRequest && (_jsx(Menu.Item, { component: "a", href: b.pullRequestUrl, target: "_blank", rel: "noopener noreferrer", leftSection: _jsx(IconExternalLink, { size: 14, "aria-hidden": true }), "data-testid": `view-pull-request-${b.name}`, children: b.pullRequestNumber
+                                                    ? `View pull request #${b.pullRequestNumber}`
+                                                    : 'View pull request' })), showDelete && (_jsxs(_Fragment, { children: [(menuActions.length > 0 || showViewPullRequest) && _jsx(Menu.Divider, {}), _jsx(DestructiveMenuItem, { "data-testid": `delete-branch-button-${b.name}`, blockedReason: b.status === 'submitted' || b.status === 'approved'
+                                                            ? 'This branch is in review. Withdraw it from review before deleting it.'
+                                                            : undefined, onClick: () => onDelete?.(b.name), children: "Delete branch" })] }))] })] }))] })] }), actionRow && (_jsxs(Group, { justify: "flex-end", gap: 8, wrap: "nowrap", mt: "sm", "data-testid": `branch-action-row-${b.name}`, children: [secondary && _jsx(CardActionButton, { action: secondary }), primary && _jsx(CardActionButton, { action: primary })] }))] }));
 };
-export const BranchManager = ({ branches, mode, user, currentBranchName, currentWorkflowBlockedReason, startCreating = false, onSelect, onBeforeCreate, onCreate, onDelete, onSubmit, onWithdraw, onRequestChanges, onClose: _, comments = [], currentUserId, canResolve = false, onAddComment, onResolveThread, highlightThreadId, onGetUserMetadata, onGetOwnerMetadata, onGetCommentUserMetadata, }) => {
+const CardActionButton = ({ action }) => (_jsx(Tooltip, { label: action.blockedReason, disabled: !action.blockedReason, multiline: true, maw: 280, children: _jsx(Button, { variant: "light", color: action.color, onClick: () => {
+            if (!action.blockedReason)
+                action.run();
+        }, "data-disabled": action.blockedReason ? true : undefined, "aria-disabled": action.blockedReason ? true : undefined, "data-testid": action.testId, children: action.label }) }));
+export const BranchManager = ({ branches, mode, user, currentBranchName, currentWorkflowBlockedReason, startCreating = false, onSelect, onBeforeCreate, onCreate, onDelete, onSubmit, onWithdraw, onApprove, onRequestChanges, onClose: _, comments = [], currentUserId, canResolve = false, onAddComment, onResolveThread, highlightThreadId, onGetUserMetadata, onGetOwnerMetadata, onGetCommentUserMetadata, }) => {
     const supportsBranching = clientOperatingStrategy(mode).supportsBranching();
     const [showCreateForm, setShowCreateForm] = useState(startCreating);
     const [newBranchName, setNewBranchName] = useState('');
@@ -209,5 +240,5 @@ export const BranchManager = ({ branches, mode, user, currentBranchName, current
         ]
         : branches;
     const hasBranchThreads = comments.some((t) => t.type === 'branch');
-    return (_jsxs(Stack, { h: "100%", style: { display: 'flex', flexDirection: 'column' }, gap: 0, "data-testid": "branch-manager", children: [currentUserId && onAddComment && onResolveThread && hasBranchThreads && (_jsx(Stack, { pt: "sm", children: _jsx(BranchComments, { comments: comments, currentUserId: currentUserId, canResolve: canResolve, onAddComment: onAddComment, onResolveThread: onResolveThread, highlightThreadId: highlightThreadId, onGetUserMetadata: onGetCommentUserMetadata }) })), !!supportsBranching && (_jsxs(Stack, { gap: "sm", pt: "sm", children: [_jsx(Button, { variant: "light", size: "sm", fullWidth: true, onClick: () => setShowCreateForm(!showCreateForm), disabled: creating, "data-testid": "create-branch-button", children: showCreateForm ? 'Cancel' : `${EDITOR_ACTIONS.newBranch}…` }), _jsx(Collapse, { in: showCreateForm, children: _jsx(Paper, { withBorder: true, p: "md", children: _jsxs(Stack, { gap: "sm", children: [_jsx(TextInput, { label: "Branch name", placeholder: "feature/my-branch", value: newBranchName, onChange: (e) => setNewBranchName(e.target.value), required: true, disabled: creating, "data-autofocus": startCreating || undefined, "data-testid": "branch-name-input" }), _jsx(TextInput, { label: "Title", placeholder: "Brief description", value: newBranchTitle, onChange: (e) => setNewBranchTitle(e.target.value), disabled: creating, "data-testid": "branch-title-input" }), _jsx(Textarea, { label: "Description", placeholder: "Detailed description of the changes", value: newBranchDescription, onChange: (e) => setNewBranchDescription(e.target.value), minRows: 2, disabled: creating, "data-testid": "branch-description-textarea" }), _jsx(Button, { size: "sm", onClick: handleCreate, disabled: !newBranchName.trim(), loading: creating, fullWidth: true, "data-testid": "create-branch-submit", children: "Create branch" })] }) }) })] })), _jsx(ScrollArea, { style: { flex: 1 }, pb: "md", children: branches.length === 0 ? (_jsx(Text, { size: "sm", c: "dimmed", py: "md", children: !supportsBranching ? 'Branch management is not available.' : 'No branches available.' })) : (_jsx(Stack, { gap: "sm", children: orderedBranches.map((b) => (_jsx(BranchCard, { branch: b, isCurrent: b.name === currentBranchName, workflowBlockedReason: b.name === currentBranchName ? currentWorkflowBlockedReason : undefined, user: user, onSelect: onSelect, onSubmit: onSubmit, onWithdraw: onWithdraw, onRequestChanges: onRequestChanges, onDelete: onDelete, onGetUserMetadata: onGetUserMetadata, onGetOwnerMetadata: onGetOwnerMetadata }, b.name))) })) })] }));
+    return (_jsxs(Stack, { h: "100%", style: { display: 'flex', flexDirection: 'column' }, gap: 0, "data-testid": "branch-manager", children: [currentUserId && onAddComment && onResolveThread && hasBranchThreads && (_jsx(Stack, { pt: "sm", children: _jsx(BranchComments, { comments: comments, currentUserId: currentUserId, canResolve: canResolve, onAddComment: onAddComment, onResolveThread: onResolveThread, highlightThreadId: highlightThreadId, onGetUserMetadata: onGetCommentUserMetadata }) })), !!supportsBranching && (_jsxs(Stack, { gap: "sm", pt: "sm", children: [_jsx(Button, { variant: "light", size: "sm", fullWidth: true, onClick: () => setShowCreateForm(!showCreateForm), disabled: creating, "data-testid": "create-branch-button", children: showCreateForm ? 'Cancel' : `${EDITOR_ACTIONS.newBranch}…` }), _jsx(Collapse, { in: showCreateForm, children: _jsx(Paper, { withBorder: true, p: "md", children: _jsxs(Stack, { gap: "sm", children: [_jsx(TextInput, { label: "Branch name", placeholder: "feature/my-branch", value: newBranchName, onChange: (e) => setNewBranchName(e.target.value), required: true, disabled: creating, "data-autofocus": startCreating || undefined, "data-testid": "branch-name-input" }), _jsx(TextInput, { label: "Title", placeholder: "Brief description", value: newBranchTitle, onChange: (e) => setNewBranchTitle(e.target.value), disabled: creating, "data-testid": "branch-title-input" }), _jsx(Textarea, { label: "Description", placeholder: "Detailed description of the changes", value: newBranchDescription, onChange: (e) => setNewBranchDescription(e.target.value), minRows: 2, disabled: creating, "data-testid": "branch-description-textarea" }), _jsx(Button, { size: "sm", onClick: handleCreate, disabled: !newBranchName.trim(), loading: creating, fullWidth: true, "data-testid": "create-branch-submit", children: "Create branch" })] }) }) })] })), _jsx(ScrollArea, { style: { flex: 1 }, pb: "md", children: branches.length === 0 ? (_jsx(Text, { size: "sm", c: "dimmed", py: "md", children: !supportsBranching ? 'Branch management is not available.' : 'No branches available.' })) : (_jsx(Stack, { gap: "sm", children: orderedBranches.map((b) => (_jsx(BranchCard, { branch: b, isCurrent: b.name === currentBranchName, workflowBlockedReason: b.name === currentBranchName ? currentWorkflowBlockedReason : undefined, user: user, onSelect: onSelect, onSubmit: onSubmit, onWithdraw: onWithdraw, onApprove: onApprove, onRequestChanges: onRequestChanges, onDelete: onDelete, onGetUserMetadata: onGetUserMetadata, onGetOwnerMetadata: onGetOwnerMetadata }, b.name))) })) })] }));
 };

package/dist/editor/CanopyEditor.js

@@ -8,8 +8,8 @@ import { buildEditorCollections } from './editor-config.js';
 export const CanopyEditor = ({ config, entries = [], initialSelectedId, initialValues, renderPreview, onCreateEntry, branchName, customRenderers, }) => {
     const collections = useMemo(() => buildEditorCollections(config.flatSchema), [config.flatSchema]);
     // Empty string = branchless start; useBranchManager adopts the server's
-    // detected default branch on the first branches.list() load.
-    const resolvedBranchName = branchName ?? config.defaultActiveBranch ?? config.defaultBaseBranch ?? '';
+    // default branch on the first branches.list() load.
+    const resolvedBranchName = branchName ?? '';
     const resolvedTitle = config.editor?.title ?? 'CanopyCMS Editor';
     const resolvedTheme = config.editor?.theme ?? undefined;
     // The gate owns the SWRProvider (keyed by user id), so it sits between the API client and the

package/dist/editor/CanopyEditorPage.js

@@ -9,10 +9,9 @@ import { CanopyEditor } from './CanopyEditor.js';
  */
 export const CanopyEditorPage = (config, customRenderers) => {
     const CanopyEditorPageInner = ({ searchParams, }) => {
-        // No 'main' fallback: when nothing pins a branch, the editor starts
-        // branchless and adopts the server's detected default from the branches
-        // API (see useBranchManager.loadBranches).
-        const branchName = searchParams?.branch ?? config.defaultActiveBranch ?? config.defaultBaseBranch;
+        // Without ?branch= the editor starts branchless and useBranchManager adopts
+        // the branches API's defaultBranch.
+        const branchName = searchParams?.branch;
         const initialSelectedId = searchParams?.entry;
         return (_jsx(CanopyEditor, { config: config, branchName: branchName, initialSelectedId: initialSelectedId, entries: [], customRenderers: customRenderers }));
     };

package/dist/editor/Editor.js

@@ -24,6 +24,7 @@ import { PermissionManager } from './PermissionManager.js';
 import { SystemHealthPanel } from './admin/SystemHealthPanel.js';
 // Import directly from helpers to avoid server-only code in authorization barrel
 import { isAdmin, isPrivileged, isReviewer } from '../authorization/helpers.js';
+import { reviewRoleOf } from '../authorization/review-role.js';
 import { fieldBreadcrumb } from './field-breadcrumb.js';
 import { buildPreviewRoute, buildPreviewSrc, buildCollectionLabels, entryStatusLabel, entryTypeLabel, buildBreadcrumbSegments, entryNameSource, } from './editor-utils.js';
 import { useEditorLayout, useDraftManager, useEntryManager, useGroupManager, usePermissionManager, useCommentSystem, useBranchManager, useUserContext, useSchemaManager, } from './hooks/index.js';
@@ -44,6 +45,7 @@ import { ConfirmDeleteModal } from './components/ConfirmDeleteModal.js';
 import { ReferencedByList, referencedDeleteMessage } from './components/ReferencedByList.js';
 import { NoEditPermissionNotice } from './components/NoEditPermissionNotice.js';
 import { BranchNotAvailableNotice } from './components/BranchNotAvailableNotice.js';
+import { BranchesLoadFailedNotice } from './components/BranchesLoadFailedNotice.js';
 import { ReadOnlyDraftNotice } from './components/ReadOnlyDraftNotice.js';
 import { UnavailableEntryNotice } from './components/UnavailableEntryNotice.js';
 import { unavailableSchemaRefs } from './unavailable-entry-type.js';
@@ -160,7 +162,10 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
         labels: [],
     }));
     const applySubmitStampsRef = useRef(() => { });
-    const { branchName: branchNameState, setBranchName, branchSummaries, currentBranch, branchesLoadFailed, branchesLoaded, addCreatedBranch, handleSubmit, handleWithdraw, handleRequestChanges, handleDelete, handleReloadBranchData, loadBranches, } = useBranchManager({
+    // 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(() => { });
+    const { branchName: branchNameState, setBranchName, branchSummaries, currentBranch, branchesLoadFailed, branchesLoaded, addCreatedBranch, handleSubmit, handleWithdraw, handleApprove, handleRequestChanges, handleDelete, handleReloadBranchData, loadBranches, } = useBranchManager({
         initialBranch: branchName,
         operatingMode,
         setBusy: setBranchesLoading,
@@ -168,6 +173,7 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
         // The draft manager comes later, as it depends on this hook's branch.
         getUnsaved: () => resolveUnsavedRef.current(),
         onStamped: (stamped) => applySubmitStampsRef.current(stamped),
+        onChangesRequested: (branch) => reloadCommentsRef.current(branch),
     });
     // Content mutations (add/delete/rename/reorder entries) are locked whenever the
     // server says writes are blocked -- the protected base branch, or a workflow
@@ -185,6 +191,17 @@ 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;
+    // The same inputs EditorHeader gives its own check, for the lock copy that names the way forward.
+    const branchReviewRole = reviewRoleOf({
+        status: currentBranch?.status,
+        createdBy: currentBranch?.createdBy,
+        users: currentBranch?.access.allowedUsers,
+        groups: currentBranch?.access.allowedGroups,
+        isProtected: currentBranch?.isProtected ?? true,
+        pullRequestState: currentBranch?.pullRequestState,
+    }, userContext);
+    const branchReviewing = branchReviewRole === 'reviewing';
+    const branchPullRequestClosed = branchReviewRole === 'reviewing-closed';
     const branchMissing = !currentBranch && branchesLoaded;
     // The bar's lock-state row, with the inputs EditorHeader gets, for the states that must agree.
     const branchBarState = branchBarStatus({
@@ -226,6 +243,8 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
     // The "Not available" empty states wait for the load to answer with nothing: content that does
     // load, for a branch the list lags in granting, shows as usual.
     const branchShowsNotAvailable = branchNotAvailable && !entriesInitializing && entriesState.length === 0;
+    // An unpinned editor takes its branch from the branch list, so without the list it has none.
+    const branchListFailed = !branchNameState && branchesLoadFailed;
     // The content overlay and a maximized preview hide the form; `navigatorOpen` is only the
     // overlay's. Anything that focuses something in the form reveals it first. Opening an entry
     // closes the overlay only, so the preview stays maximized across entries (see
@@ -336,7 +355,7 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
         await handleBranchChange(branch);
     };
     // 5. Comment system (depends on branchNameState)
-    const { comments, getCommentUser, focusedFieldPath, highlightThreadId, commentsPanelOpen, setCommentsPanelOpen, handleAddComment, handleResolveThread, handleJumpToField, handleJumpToEntry, handleJumpToBranch, } = useCommentSystem({
+    const { comments, getCommentUser, focusedFieldPath, highlightThreadId, commentsPanelOpen, setCommentsPanelOpen, handleAddComment, handleResolveThread, handleJumpToField, handleJumpToEntry, handleJumpToBranch, loadComments, } = useCommentSystem({
         branchName: branchNameState,
         selectedPath,
         currentEntry,
@@ -347,6 +366,10 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
         onCommentsChange: setCommentsForBranchSummaries,
         onRevealForm: revealForm,
     });
+    reloadCommentsRef.current = (branch) => {
+        if (sanitizeBranchName(branch) === sanitizeBranchName(branchNameState))
+            void loadComments(branch);
+    };
     const { groupsData, groupsLoading, handleSaveGroups, handleSearchUsers, handleGetUserMetadata, handleSearchExternalGroups, } = useGroupManager({ isOpen: groupManagerOpen });
     // The comments and branches responses name their people, without email; a privileged lookup
     // adds the email.
@@ -1368,7 +1391,7 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
             display: 'flex',
             alignItems: 'center',
             justifyContent: 'center',
-        }, children: !currentEntry && branchShowsNotAvailable ? (_jsx(BranchNotAvailableNotice, { align: "center", "data-testid": "preview-branch-not-available" })) : (_jsx(Text, { size: "sm", c: "dimmed", children: !branchNameState && busy
+        }, children: !currentEntry && branchShowsNotAvailable ? (_jsx(BranchNotAvailableNotice, { align: "center", "data-testid": "preview-branch-not-available" })) : branchListFailed ? (_jsx(BranchesLoadFailedNotice, { align: "center", "data-testid": "preview-branches-load-failed" })) : (_jsx(Text, { size: "sm", c: "dimmed", children: !branchNameState && busy
                 ? 'Setting up your branch workspace…'
                 : entriesInitializing
                     ? 'Loading content…'
@@ -1396,8 +1419,8 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
     }, [tabTitle]);
     const openBranchManager = (options) => {
         openBranchesDrawer(options?.create === true);
-        // Always retry, not only when branchless. Opening the manager is
-        // the one in-app retry for a failed branches fetch, and the fetch
+        // Always retry, not only when branchless. Besides the form pane's Retry on a
+        // branchless start, opening the manager retries a failed branches fetch, and the fetch
         // is terminal on its own: SWRProvider sets shouldRetryOnError and
         // revalidateOnFocus false, and useBranchesData's refreshInterval
         // is 0 without data. Reloading is idempotent.
@@ -1434,6 +1457,8 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
                         branchReadOnly: currentBranch?.readOnly,
                         branchWriteBlocked: branchContentLocked,
                         branchMissing,
+                        reviewing: branchReviewing,
+                        pullRequestClosed: branchPullRequestClosed,
                     }), dirtyPaths: dirtyPaths, reveal: contentReveal, onRevealed: () => setContentReveal(undefined), changedOnly: changedOnly, onChangedOnlyChange: setChangedOnly, unsavedCount: modifiedCount, unsavedEntries: editedFiles, entryListFailed: entriesLoadFailed && entriesState.length === 0, branchNotAvailable: branchShowsNotAvailable, onSwitchBranch: () => openBranchManager(), filterRef: entryFilterRef, filterShortcut: findShortcut, onFilterEnter: contentPanelTransient
                     ? (path) => {
                         openEntry(path);
@@ -1441,7 +1466,7 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
                         setFormFocusPath(path);
                     }
                     : undefined, onFilterEscape: contentPanelTransient ? () => setContentPanelTransient(false) : undefined, onRowMenuOpen: keepContentPanelOpen }) }) }));
-    return (_jsx(CanopyCMSProvider, { ...(themeOptions ?? {}), children: _jsx(AssetContextProvider, { basePath: basePath, children: _jsx(EditorShell, { topBar: _jsx(EditorHeader, { branchName: branchNameState, branchStatus: currentBranch?.status, busy: busy, modifiedCount: modifiedCount, onShowUnsaved: showUnsaved, draftStorageFailed: draftStorageFailed, userContext: userContext, branchCreatedBy: currentBranch?.createdBy, branchAccess: currentBranch?.access, 
+    return (_jsx(CanopyCMSProvider, { ...(themeOptions ?? {}), children: _jsx(AssetContextProvider, { basePath: basePath, children: _jsx(EditorShell, { topBar: _jsx(EditorHeader, { branchName: branchNameState, branchStatus: currentBranch?.status, busy: busy, modifiedCount: modifiedCount, onShowUnsaved: showUnsaved, draftStorageFailed: draftStorageFailed, userContext: userContext, branchCreatedBy: currentBranch?.createdBy, branchPullRequestState: currentBranch?.pullRequestState, branchAccess: currentBranch?.access, 
                     // Fail-closed for the same reason branchContentLocked above is:
                     // isProtected/writeBlocked gate real actions in EditorHeader and EntryHeader
                     // (hiding Submit, disabling Save and Save all), so a missing wire value must read as
@@ -1463,6 +1488,14 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
                         if (branchNameState && !isSaveAllRunning()) {
                             handleWithdraw(branchNameState, returnFocusTo).catch(console.error);
                         }
+                    }, onApprove: (returnFocusTo) => {
+                        if (branchNameState && !isSaveAllRunning()) {
+                            handleApprove(branchNameState, returnFocusTo).catch(console.error);
+                        }
+                    }, onRequestChanges: (returnFocusTo) => {
+                        if (branchNameState && !isSaveAllRunning()) {
+                            handleRequestChanges(branchNameState, returnFocusTo).catch(console.error);
+                        }
                     } }), rail: _jsx(EditorRail, { contentPanelOpen: contentPanelShown, contentPanelId: CONTENT_PANEL_ID, onContentToggle: () => contentPanelTransient
                         ? keepContentPanelOpen()
                         : contentPanelShown
@@ -1474,7 +1507,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, onCollectionOpen: (path) => revealInContentPanel({ kind: 'collection', path }), onEntryReveal: () => currentEntry && revealInContentPanel({ kind: 'entry', path: currentEntry.path }), navigatorToggleRef: navigatorToggleRef, 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 &&
+                            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, onCollectionOpen: (path) => revealInContentPanel({ kind: 'collection', path }), onEntryReveal: () => currentEntry && revealInContentPanel({ kind: 'entry', path: currentEntry.path }), navigatorToggleRef: navigatorToggleRef, 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 &&
                                 lastSaved.contentId === currentEntry?.contentId }), _jsx(Box, { style: { flex: '1 1 0%', minHeight: 0 }, children: _jsx(PaneLayout, { formAside: contentPanelDocked && layout === 'stacked' ? contentPanel : undefined, formOverlay: contentPanelDocked ? undefined : contentPanel, formInert: contentOverlayShown, previewMaximized: previewShownMaximized, 
                                 // Sizing the pane, by pointer or key, gives the page the pane's width.
@@ -1487,7 +1520,7 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
                                     setPreviewWidth('fit');
                                 }, preview: renderPreview && currentEntry && !currentEntryUnavailable
                                     ? renderPreview(currentEntry, displayValue)
-                                    : defaultPreview, form: !currentEntry && branchShowsNotAvailable ? (_jsx(Center, { h: "100%", children: _jsx(BranchNotAvailableNotice, { align: "center", onSwitchBranch: () => openBranchManager(), "data-testid": "form-branch-not-available" }) })) : !currentEntry ? (_jsx(CenteredMessage, { children: !branchNameState && busy
+                                    : defaultPreview, form: !currentEntry && branchShowsNotAvailable ? (_jsx(Center, { h: "100%", children: _jsx(BranchNotAvailableNotice, { align: "center", onSwitchBranch: () => openBranchManager(), "data-testid": "form-branch-not-available" }) })) : branchListFailed ? (_jsx(Center, { h: "100%", children: _jsx(BranchesLoadFailedNotice, { align: "center", onRetry: () => void loadBranches().catch(console.error), retrying: busy, "data-testid": "form-branches-load-failed" }) })) : !currentEntry ? (_jsx(CenteredMessage, { children: !branchNameState && busy
                                         ? 'Setting up your branch workspace…'
                                         : entriesInitializing
                                             ? 'Loading content…'
@@ -1532,7 +1565,13 @@ const EditorContent = ({ entries, title, siteTitle = title, branchName = '', col
                                     if (name === branchNameState && isSaveAllRunning())
                                         return;
                                     handleWithdraw(name).catch((err) => console.error(err));
+                                }, onApprove: (name) => {
+                                    if (name === branchNameState && isSaveAllRunning())
+                                        return;
+                                    handleApprove(name).catch((err) => console.error(err));
                                 }, onRequestChanges: (name) => {
+                                    if (name === branchNameState && isSaveAllRunning())
+                                        return;
                                     handleRequestChanges(name).catch((err) => console.error(err));
                                 }, onDelete: (name) => {
                                     handleDelete(name).catch((err) => console.error(err));

package/dist/editor/branch-lock.d.ts

@@ -8,6 +8,13 @@ export interface BranchLockInput {
     branchPending?: boolean;
     /** The branch list answered without this branch: no access to it, or it no longer exists. */
     branchMissing?: boolean;
+    /** The user reviews this branch (`isReviewerOfOthersReview`), so Approve and Request changes lead, not Withdraw. */
+    reviewing?: boolean;
+    /**
+     * The user would review this branch but its pull request was closed (`reviewRoleOf`), so the
+     * way forward is Withdraw and the reason says why Approve is not offered.
+     */
+    pullRequestClosed?: boolean;
 }
 /**
  * Which lock applies. `branchWriteBlocked` is the server's own answer (getBranchProtection), so

package/dist/editor/branch-lock.js

@@ -1,4 +1,5 @@
 import { branchStatusPresentation } from './branch-status.js';
+import { CLOSED_PULL_REQUEST_REASON } from './copy.js';
 /**
  * Which lock applies. `branchWriteBlocked` is the server's own answer (getBranchProtection), so
  * nothing offers a write the API would reject; `branchReadOnly` only picks the message, and
@@ -26,10 +27,16 @@ export function describeBranchLock(lock) {
                 : 'Branch details could not be loaded. Use "Refresh branch" to try again.';
     if (!statusLocked)
         return undefined;
+    if (lock.pullRequestClosed)
+        return CLOSED_PULL_REQUEST_REASON;
     if (lock.branchStatus === 'submitted')
-        return 'This branch is in review. Withdraw it to make changes.';
+        return lock.reviewing
+            ? 'This branch is in review. Approve it, or request changes to send it back to its editor.'
+            : 'This branch is in review. Withdraw it to make changes.';
     if (lock.branchStatus === 'approved')
-        return 'This branch is approved. Withdraw it to make changes.';
+        return lock.reviewing
+            ? 'This branch is approved. Request changes to send it back to its editor.'
+            : 'This branch is approved. Withdraw it to make changes.';
     return `This branch is ${lock.branchStatus}. Its content is read-only.`;
 }
 const capitalize = (text) => text.charAt(0).toUpperCase() + text.slice(1);

package/dist/editor/client-reference-resolver.d.ts

@@ -38,9 +38,11 @@ export declare function expireReferences(cache: ReferenceCache): void;
 /**
  * The draft as the preview sees it, computed synchronously from the cache.
  *
- * Each reference becomes its cached value (the target, or an `unavailable` reference), or `null`
- * while it has none (still resolving, a failed lookup, or a malformed id). A list field's array maps element by element, a
- * non-string element to `null`; anything else is left as the form holds it, as on the server.
+ * Each id becomes its cached value (the target, or an `unavailable` reference), or `null` while it
+ * has none (still resolving, a failed lookup, or a malformed id). A reference the form holds as an
+ * object is the target the entry's read resolved, and passes through as it is, alone or in a list.
+ * A list field's array maps element by element, any other non-string element to `null`; anything
+ * else is left as the form holds it, as on the server.
  * `loadingState` holds a boolean only at reference positions, `true` while resolving, at the
  * reference's own path (`boolean[]` for a list).
  */

package/dist/editor/client-reference-resolver.js

@@ -1,7 +1,7 @@
 import { createApiClient } from '../api/client.js';
 import { flattenGroupFields } from '../utils/flatten-group-fields.js';
 import { isValidContentId } from '../paths/validation.js';
-import { traverseFields } from '../validation/field-traversal.js';
+import { referenceValueId, traverseFields } from '../validation/field-traversal.js';
 /** The resolve-references endpoint's per-request id cap (`MAX_RESOLVE_REFERENCE_IDS`). */
 const MAX_IDS_PER_REQUEST = 100;
 /**
@@ -135,9 +135,11 @@ function setCreating(root, path, leaf, source) {
 /**
  * The draft as the preview sees it, computed synchronously from the cache.
  *
- * Each reference becomes its cached value (the target, or an `unavailable` reference), or `null`
- * while it has none (still resolving, a failed lookup, or a malformed id). A list field's array maps element by element, a
- * non-string element to `null`; anything else is left as the form holds it, as on the server.
+ * Each id becomes its cached value (the target, or an `unavailable` reference), or `null` while it
+ * has none (still resolving, a failed lookup, or a malformed id). A reference the form holds as an
+ * object is the target the entry's read resolved, and passes through as it is, alone or in a list.
+ * A list field's array maps element by element, any other non-string element to `null`; anything
+ * else is left as the form holds it, as on the server.
  * `loadingState` holds a boolean only at reference positions, `true` while resolving, at the
  * reference's own path (`boolean[]` for a list).
  */
@@ -146,7 +148,10 @@ export function applyReferenceCache(fields, value, branch, cache) {
     const loadingState = {};
     const copies = new WeakSet();
     const lookup = (id) => {
-        if (typeof id !== 'string' || !isValidContentId(id))
+        if (typeof id !== 'string') {
+            return { value: referenceValueId(id) === undefined ? null : id, loading: false };
+        }
+        if (!isValidContentId(id))
             return { value: null, loading: false };
         const entry = cache.get(cacheKey(branch, id));
         return entry ? { value: entry.value, loading: false } : { value: null, loading: true };

package/dist/editor/components/BranchesLoadFailedNotice.d.ts

@@ -0,0 +1,13 @@
+export interface BranchesLoadFailedNoticeProps {
+    /** Loads the branch list again. Without it the notice is text alone. */
+    onRetry?: () => void;
+    /** A retry is in flight. */
+    retrying?: boolean;
+    align?: 'flex-start' | 'center';
+    'data-testid'?: string;
+}
+/**
+ * The error state of an editor no branch is pinned in, while the branch list it takes its
+ * branch from has failed to load. It outlasts the dismissible toast for the same failure.
+ */
+export declare function BranchesLoadFailedNotice({ onRetry, retrying, align, 'data-testid': testId, }: BranchesLoadFailedNoticeProps): import("react/jsx-runtime").JSX.Element;