canopycms 0.0.68-int.98 → 0.1.0

package/dist/dangling-reference-log.d.ts

@@ -0,0 +1,17 @@
+export interface DanglingReferenceSite {
+    /** Workspace the entry was read from, so two branches' identical paths warn separately. */
+    root: string;
+    /** Logical path of the referring entry, when the caller knows it. */
+    entry?: string;
+    /** Field path in `traverseFields`' format, e.g. `blocks[2].author` or `reviewers[1]`. */
+    path: string;
+    /** The id that names no readable entry. */
+    id: string;
+}
+/** Warn once per process that a reference names no readable entry. */
+export declare function warnDanglingReference(site: DanglingReferenceSite): void;
+/**
+ * Forget every reported reference.
+ * @internal Exported for tests.
+ */
+export declare function resetDanglingReferenceWarnings(): void;

package/dist/dangling-reference-log.js

@@ -0,0 +1,29 @@
+import { canopyLogWarn } from './utils/logger.js';
+/**
+ * Bounds the dedupe set below. A process that has seen this many distinct dangling references
+ * stops warning about new ones rather than growing without limit; the build guard still counts
+ * every one.
+ */
+const MAX_WARNED = 1000;
+/**
+ * Dangling references already reported by this process. A log dedupe only, never consulted for
+ * content, so its module lifetime carries none of the staleness hazards in docs/concurrency.md:
+ * at worst a reference repaired and broken again is not re-reported until restart.
+ */
+const warned = new Set();
+/** Warn once per process that a reference names no readable entry. */
+export function warnDanglingReference(site) {
+    const key = `${site.root}\0${site.entry ?? ''}\0${site.path}\0${site.id}`;
+    if (warned.has(key) || warned.size >= MAX_WARNED)
+        return;
+    warned.add(key);
+    canopyLogWarn(`CanopyCMS: ${site.entry ?? 'an entry'} field "${site.path}" references missing entry ${site.id}; ` +
+        'it resolves as unavailable until the reference is repointed or cleared.');
+}
+/**
+ * Forget every reported reference.
+ * @internal Exported for tests.
+ */
+export function resetDanglingReferenceWarnings() {
+    warned.clear();
+}

package/dist/dev-content-watcher.d.ts

@@ -15,7 +15,7 @@
  * Divergence is a CONDITION, not an event: it holds until someone runs `sync push`, so the report
  * must not repeat into a scrolling request log (`reportOnce`) yet must be hard to scroll past (the
  * gutter block). A log cannot hold a condition; see
- * `.claude/future-tasks/dev-divergence-in-app-surface.md` for the in-app surface that would
+ * safeinsights/canopycms#654 for the in-app surface that would
  * replace the terminal as its primary home.
  *
  * All logic lives here; framework adapters call startDevContentWatcher() once at dev startup (see

package/dist/dev-content-watcher.js

@@ -15,7 +15,7 @@
  * Divergence is a CONDITION, not an event: it holds until someone runs `sync push`, so the report
  * must not repeat into a scrolling request log (`reportOnce`) yet must be hard to scroll past (the
  * gutter block). A log cannot hold a condition; see
- * `.claude/future-tasks/dev-divergence-in-app-surface.md` for the in-app surface that would
+ * safeinsights/canopycms#654 for the in-app surface that would
  * replace the terminal as its primary home.
  *
  * All logic lives here; framework adapters call startDevContentWatcher() once at dev startup (see

package/dist/editor/BranchManager.d.ts

@@ -12,6 +12,10 @@ export interface BranchSummary {
     access?: {
         users?: string[];
         groups?: string[];
+        managerOrAdminAllowed?: boolean;
+        /** Entries the server withheld from this viewer; see `BranchListItem.withheldAccess`. */
+        withheldUsers?: number;
+        withheldGroups?: number;
     };
     pullRequestUrl?: string;
     pullRequestNumber?: number;
@@ -42,15 +46,16 @@ export interface UserContext {
     groups?: string[];
 }
 /**
- * Compute what actions the current user can perform on a branch.
- * Uses the same hybrid permission model as the backend:
- * - Creator can always submit/withdraw
- * - Users in branch ACL can submit/withdraw
- * - System branches can be submitted/withdrawn by anyone with access
- * - Admins/Reviewers always have access
+ * What the current user can do to a branch, by the backend's hybrid model. Workflow access
+ * (`hasWorkflowAccess`) goes to the creator, the users and groups on the branch's access list,
+ * anyone on a system branch other than the protected base, and reviewers and admins; a
+ * `managerOrAdminAllowed` lockdown leaves only reviewers and admins. Submit also
+ * needs the server's `submitBlocked` to be false; Withdraw needs the branch submitted or approved.
  * @internal Exported for tests.
  */
 export declare const getBranchPermissions: (branch: BranchSummary, user: UserContext | undefined) => {
+    /** Creator, someone given access, a system branch, a reviewer or an admin: who may submit or withdraw. */
+    hasWorkflowAccess: boolean;
     canSubmit: boolean;
     canWithdraw: boolean;
     canDelete: boolean;
@@ -61,7 +66,13 @@ export interface BranchManagerProps {
     mode: OperatingMode;
     /** Current user context for permission checks */
     user?: UserContext;
+    /** The branch the editor has open: listed first, marked, and offered its workflow action rather than Open. */
+    currentBranchName?: string;
+    /** Why the open branch's Submit or Withdraw must wait, such as a Save all still writing it. */
+    currentWorkflowBlockedReason?: string;
     onSelect?: (name: string) => void;
+    /** Awaited before the spinner starts, so a confirmation it shows never reads as a hung create. `false` abandons the create. */
+    onBeforeCreate?: () => Promise<boolean>;
     /**
      * Resolving `false` means the branch was not created, so the form stays open
      * with the user's values; any other return (including none) closes it.
@@ -78,11 +89,16 @@ export interface BranchManagerProps {
     onClose?: () => void;
     comments?: CommentThread[];
     currentUserId?: string;
+    /** Whether the user may resolve any comment thread; a thread's author always may resolve it. */
     canResolve?: boolean;
     onAddComment?: (text: string, type: 'field' | 'entry' | 'branch', entryPath?: string, canopyPath?: string, threadId?: string) => Promise<void>;
     onResolveThread?: (threadId: string) => Promise<void>;
     highlightThreadId?: string;
-    /** Optional function to fetch user metadata for displaying user badges */
+    /** Names people without `onGetOwnerMetadata`; with neither, access users are counted and owners read "Name unavailable" */
     onGetUserMetadata?: (userId: string) => Promise<UserSearchResult | null>;
+    /** Names branch owners and access users; the branch listing seeds owners only */
+    onGetOwnerMetadata?: (userId: string) => Promise<UserSearchResult | null>;
+    /** Names the people in branch comments; without it they show as ids */
+    onGetCommentUserMetadata?: (userId: string) => Promise<UserSearchResult | null>;
 }
 export declare const BranchManager: React.FC<BranchManagerProps>;

package/dist/editor/BranchManager.js

@@ -1,25 +1,32 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useRef, useState } from 'react';
-import { Badge, Button, Group, Paper, ScrollArea, Stack, Text, TextInput, Textarea, Collapse, Tooltip, } from '@mantine/core';
+import { ActionIcon, Badge, Button, Group, Menu, Paper, ScrollArea, Stack, Text, TextInput, Textarea, Collapse, Tooltip, } from '@mantine/core';
+import { IconDots, IconExternalLink } from '@tabler/icons-react';
 import { BranchComments } from './comments/BranchComments.js';
 import { UserBadge } from './components/UserBadge.js';
+import { BranchAccessList } from './components/BranchAccessList.js';
 // Import directly from helpers to avoid server-only code in authorization barrel
-import { isAdmin, isReviewer } from '../authorization/helpers.js';
+import { isAdmin, isLockedOutOfBranch, isReviewer } from '../authorization/helpers.js';
 import { clientOperatingStrategy } from '../operating-mode/client.js';
-import { formatRelativeTime } from './relative-time.js';
+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 { SYSTEM_USER_ID } from '../system-users.js';
 /**
- * Compute what actions the current user can perform on a branch.
- * Uses the same hybrid permission model as the backend:
- * - Creator can always submit/withdraw
- * - Users in branch ACL can submit/withdraw
- * - System branches can be submitted/withdrawn by anyone with access
- * - Admins/Reviewers always have access
+ * What the current user can do to a branch, by the backend's hybrid model. Workflow access
+ * (`hasWorkflowAccess`) goes to the creator, the users and groups on the branch's access list,
+ * anyone on a system branch other than the protected base, and reviewers and admins; a
+ * `managerOrAdminAllowed` lockdown leaves only reviewers and admins. Submit also
+ * needs the server's `submitBlocked` to be false; Withdraw needs the branch submitted or approved.
  * @internal Exported for tests.
  */
 export const getBranchPermissions = (branch, user) => {
     if (!user) {
         return {
+            hasWorkflowAccess: false,
             canSubmit: false,
             canWithdraw: false,
             canDelete: false,
@@ -30,13 +37,14 @@ export const getBranchPermissions = (branch, user) => {
     const userIsReviewer = isReviewer(user.groups);
     const userIsCreator = branch.createdBy === user.userId;
     // The system-branch grant is disabled on the protected base branch -- its
-    // auto-provision marker (createdBy: 'canopycms-system') would otherwise let
+    // auto-provision marker (createdBy: SYSTEM_USER_ID) would otherwise let
     // anyone with general access submit/withdraw/delete it.
-    const isSystemBranch = branch.createdBy === 'canopycms-system' && !branch.isProtected;
+    const isSystemBranch = branch.createdBy === SYSTEM_USER_ID && !branch.isProtected;
     const userInACL = (branch.access?.users?.includes(user.userId) ||
         user.groups?.some((g) => branch.access?.groups?.includes(g))) ??
         false;
-    const canPerformWorkflowActions = userIsCreator || userInACL || isSystemBranch || userIsAdmin || userIsReviewer;
+    const canPerformWorkflowActions = !isLockedOutOfBranch(branch.access, user.groups) &&
+        (userIsCreator || userInACL || isSystemBranch || userIsAdmin || userIsReviewer);
     // Submit: can perform workflow actions AND the server says submit isn't
     // blocked. `submitBlocked` is the server's own compound answer -- status
     // past 'editing' OR the protected base branch -- computed once in
@@ -70,13 +78,97 @@ export const getBranchPermissions = (branch, user) => {
     const canRequestChanges = (userIsAdmin || userIsReviewer) &&
         branch.status === 'submitted' &&
         branch.pullRequestState !== 'closed';
-    return { canSubmit, canWithdraw, canDelete, canRequestChanges };
+    return {
+        hasWorkflowAccess: canPerformWorkflowActions,
+        canSubmit,
+        canWithdraw,
+        canDelete,
+        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
+ * 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) => {
+    if (!perms.hasWorkflowAccess)
+        return undefined;
+    if (b.status === 'submitted' || b.status === 'approved') {
+        return {
+            label: EDITOR_ACTIONS.withdrawFromReview,
+            color: 'orange',
+            testId: `withdraw-branch-button-${b.name}`,
+            run: () => onWithdraw?.(b.name),
+        };
+    }
+    if (b.status === 'editing' && !b.isProtected) {
+        return {
+            label: EDITOR_ACTIONS.submitForReview,
+            color: 'brand',
+            testId: `submit-branch-button-${b.name}`,
+            run: () => onSubmit?.(b.name),
+            blockedReason: perms.canSubmit ? undefined : "This branch can't be submitted right now.",
+        };
+    }
+    return undefined;
 };
-const statusColorMap = {
-    editing: { color: 'brand', variant: 'light' },
-    submitted: { color: 'green', variant: 'light' },
+/** 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));
+/**
+ * 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.
+ */
+const BranchCard = ({ branch: b, isCurrent, workflowBlockedReason, user, onSelect, onSubmit, onWithdraw, 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'
+        ? {
+            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,
+        }
+        : undefined;
+    const primary = !isCurrent
+        ? undefined
+        : isReviewerOfOthersSubmission(b, user)
+            ? requestChanges
+            : workflow;
+    const menuActions = [workflow, requestChanges].filter((a) => !!a && a !== primary);
+    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" })] }))] })] }))] })] }) }));
 };
-export const BranchManager = ({ branches, mode, user, onSelect, onCreate, onDelete, onSubmit, onWithdraw, onRequestChanges, onClose: _, comments = [], currentUserId, canResolve = false, onAddComment, onResolveThread, highlightThreadId, onGetUserMetadata, }) => {
+export const BranchManager = ({ branches, mode, user, currentBranchName, currentWorkflowBlockedReason, onSelect, onBeforeCreate, onCreate, onDelete, onSubmit, onWithdraw, onRequestChanges, onClose: _, comments = [], currentUserId, canResolve = false, onAddComment, onResolveThread, highlightThreadId, onGetUserMetadata, onGetOwnerMetadata, onGetCommentUserMetadata, }) => {
     const supportsBranching = clientOperatingStrategy(mode).supportsBranching();
     const [showCreateForm, setShowCreateForm] = useState(false);
     const [newBranchName, setNewBranchName] = useState('');
@@ -89,8 +181,10 @@ export const BranchManager = ({ branches, mode, user, onSelect, onCreate, onDele
         if (creatingRef.current || !newBranchName.trim())
             return;
         creatingRef.current = true;
-        setCreating(true);
         try {
+            if (onBeforeCreate && !(await onBeforeCreate()))
+                return;
+            setCreating(true);
             const created = await onCreate?.({
                 name: newBranchName.trim(),
                 title: newBranchTitle.trim() || undefined,
@@ -108,40 +202,11 @@ export const BranchManager = ({ branches, mode, user, onSelect, onCreate, onDele
             setCreating(false);
         }
     };
-    return (_jsxs(Stack, { h: "100%", style: { display: 'flex', flexDirection: 'column' }, gap: 0, "data-testid": "branch-manager", children: [currentUserId && onAddComment && onResolveThread && (_jsx(Stack, { pt: "sm", children: _jsx(BranchComments, { comments: comments, currentUserId: currentUserId, canResolve: canResolve, onAddComment: onAddComment, onResolveThread: onResolveThread, highlightThreadId: highlightThreadId, onGetUserMetadata: onGetUserMetadata }) })), !!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' : 'Create New Branch' }), _jsx(Collapse, { in: showCreateForm, children: _jsx(Paper, { withBorder: true, p: "md", radius: "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-testid": "branch-name-input" }), _jsx(TextInput, { label: "Title (optional)", placeholder: "Brief description", value: newBranchTitle, onChange: (e) => setNewBranchTitle(e.target.value), disabled: creating, "data-testid": "branch-title-input" }), _jsx(Textarea, { label: "Description (optional)", 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, { 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: branches.map((b) => {
-                        const statusColor = statusColorMap[b.status] ?? {
-                            color: 'neutral',
-                            variant: 'light',
-                        };
-                        const perms = getBranchPermissions(b, user);
-                        return (_jsx(Paper, { withBorder: true, radius: "md", p: "md", shadow: "xs", "data-testid": `branch-list-item-${b.name}`, children: _jsxs(Group, { justify: "space-between", align: "flex-start", children: [_jsxs(Stack, { gap: 4, children: [_jsxs(Group, { gap: "xs", children: [_jsx(Text, { fw: 600, children: b.name }), _jsx(Badge, { color: statusColor.color, variant: statusColor.variant, "data-testid": `branch-status-badge-${b.name}`, children: b.status }), b.status === 'archived' && b.mergedAt && (_jsx(Badge, { color: "teal", variant: "light", "data-testid": `branch-merged-badge-${b.name}`, children: "Merged" })), b.isProtected && (_jsx(Badge, { color: "neutral", variant: "outline", "data-testid": `branch-protected-badge-${b.name}`, children: "Protected" })), 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: b.syncFailureReason
-                                                            ? `GitHub sync failed: ${b.syncFailureReason}`
-                                                            : 'GitHub sync failed — an admin can retry it from System health.', 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})` : ''] }) }))] }), _jsxs(Group, { gap: "xs", align: "center", children: [b.updatedAt && (_jsx(Tooltip, { label: new Date(b.updatedAt).toLocaleString(), children: _jsxs(Text, { size: "xs", c: "dimmed", children: ["Updated ", formatRelativeTime(b.updatedAt)] }) })), b.createdBy && (_jsxs(_Fragment, { children: [_jsx(Text, { size: "xs", c: "dimmed", children: "\u2022" }), _jsx(Text, { size: "xs", c: "dimmed", children: "Owner:" }), onGetUserMetadata ? (_jsx(UserBadge, { userId: b.createdBy, getUserMetadata: onGetUserMetadata, variant: "avatar-name", size: "xs", showEmailTooltip: true, showBadge: true, badgeVariant: "light", color: "gray" })) : (_jsx(Text, { size: "xs", c: "dimmed", children: b.createdBy }))] })), b.pullRequestUrl && (_jsxs(_Fragment, { children: [_jsx(Text, { size: "xs", c: "dimmed", children: "\u2022" }), _jsx(Text, { size: "xs", c: "blue", component: "a", href: b.pullRequestUrl, target: "_blank", rel: "noopener noreferrer", style: {
-                                                                    textDecoration: 'underline',
-                                                                    cursor: 'pointer',
-                                                                }, children: "View PR" })] }))] }), b.access && (_jsxs(Group, { gap: 6, children: [b.access.users?.map((u) => onGetUserMetadata ? (_jsx(UserBadge, { userId: u, getUserMetadata: onGetUserMetadata, variant: "avatar-only", size: "xs", showEmailTooltip: true }, u)) : (_jsx(Badge, { variant: "outline", color: "neutral", children: u }, u))), b.access.groups?.map((g) => (_jsx(Badge, { variant: "outline", color: "neutral", children: g }, g)))] }))] }), _jsxs(Group, { gap: 8, children: [_jsx(Button, { size: "xs", variant: "light", onClick: () => onSelect?.(b.name), "data-testid": `switch-to-branch-button-${b.name}`, children: "Open" }), b.status === 'submitted' || b.status === 'approved' ? (_jsx(Tooltip, { label: "Only the branch creator can withdraw", disabled: perms.canWithdraw, children: _jsx(Button, { size: "xs", variant: "light", color: "orange", onClick: () => onWithdraw?.(b.name), disabled: !perms.canWithdraw, "data-testid": `withdraw-branch-button-${b.name}`, children: "Withdraw" }) })) : (_jsx(Tooltip, { label: b.isProtected
-                                                    ? 'The base branch cannot be submitted'
-                                                    : // A status arm: canSubmit folds in the server's status rule as
-                                                        // well as the base-branch one, so an archived (or any
-                                                        // non-editing) branch reads its own reason instead of the
-                                                        // generic "Only the branch creator can submit".
-                                                        b.status !== 'editing'
-                                                            ? `A branch with status "${b.status}" cannot be submitted`
-                                                            : 'Only the branch creator can submit', disabled: perms.canSubmit, children: _jsx(Button, { size: "xs", variant: "light", color: "green", onClick: () => onSubmit?.(b.name), disabled: !perms.canSubmit, "data-testid": `submit-branch-button-${b.name}`, children: "Submit" }) })), _jsx(Tooltip, { label: b.pullRequestState === 'closed'
-                                                    ? 'PR was closed on GitHub without merging'
-                                                    : 'Only Reviewers or Admins can request changes', disabled: perms.canRequestChanges, children: _jsx(Button, { size: "xs", variant: "outline", color: "neutral", onClick: () => onRequestChanges?.(b.name), disabled: !perms.canRequestChanges, "data-testid": `request-changes-branch-button-${b.name}`, children: "Request changes" }) }), _jsx(Tooltip, { label: b.isProtected
-                                                    ? 'The base branch cannot be deleted'
-                                                    : // A status arm, mirroring the Submit tooltip above: without it,
-                                                        // a branch blocked by its own status reads the generic "Only
-                                                        // Admin or branch creator can delete" instead of naming the open
-                                                        // PR. 'approved' is included alongside 'submitted' since both
-                                                        // mean an open PR is blocking deletion.
-                                                        b.status === 'submitted' || b.status === 'approved'
-                                                            ? `Cannot delete branch with open PR (status "${b.status}")`
-                                                            : 'Only Admin or branch creator can delete', disabled: perms.canDelete, children: _jsx(Button, { size: "xs", variant: "outline", color: "red", onClick: () => onDelete?.(b.name), disabled: !perms.canDelete, "data-testid": `delete-branch-button-${b.name}`, children: "Delete" }) })] })] }) }, b.name));
-                    }) })) })] }));
+    const orderedBranches = currentBranchName
+        ? [
+            ...branches.filter((b) => b.name === currentBranchName),
+            ...branches.filter((b) => b.name !== currentBranchName),
+        ]
+        : branches;
+    return (_jsxs(Stack, { h: "100%", style: { display: 'flex', flexDirection: 'column' }, gap: 0, "data-testid": "branch-manager", children: [currentUserId && onAddComment && onResolveThread && (_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-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))) })) })] }));
 };

package/dist/editor/CanopyEditor.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 import type { CanopyClientConfig } from '../config/index.js';
 import type { EditorProps } from './Editor.js';
-export interface CanopyEditorProps extends Omit<EditorProps, 'collections' | 'previewBaseByCollection' | 'previewPrefix' | 'title' | 'subtitle' | 'themeOptions' | 'entries' | 'contentRoot' | 'operatingMode'> {
+export interface CanopyEditorProps extends Omit<EditorProps, 'collections' | 'previewBaseByCollection' | 'previewPrefix' | 'mdxAllow' | 'title' | 'themeOptions' | 'entries' | 'contentRoot' | 'operatingMode'> {
     config: CanopyClientConfig;
     entries?: EditorProps['entries'];
 }

package/dist/editor/CanopyEditor.js

@@ -11,10 +11,9 @@ export const CanopyEditor = ({ config, entries = [], initialSelectedId, initialV
     // detected default branch on the first branches.list() load.
     const resolvedBranchName = branchName ?? config.defaultActiveBranch ?? config.defaultBaseBranch ?? '';
     const resolvedTitle = config.editor?.title ?? 'CanopyCMS Editor';
-    const resolvedSubtitle = config.editor?.subtitle;
     const resolvedTheme = config.editor?.theme ?? undefined;
     // The gate owns the SWRProvider (keyed by user id), so it sits between the API client and the
     // editor: see EditorAuthGate for what a signed-out or lapsed session renders.
-    return (_jsx(ApiClientProvider, { basePath: config.basePath, children: _jsx(EditorAuthGate, { SignInComponent: config.editor?.SignInComponent, themeOptions: resolvedTheme, children: _jsx(Editor, { entries: entries, title: resolvedTitle, subtitle: resolvedSubtitle, branchName: resolvedBranchName, operatingMode: config.mode, initialSelectedId: initialSelectedId, initialValues: initialValues, renderPreview: renderPreview, onCreateEntry: onCreateEntry, customRenderers: customRenderers, collections: collections, contentRoot: config.contentRoot, entryLinkUrl: config.entryLinkUrl, previewBaseByCollection: config.editor?.previewBase, previewPrefix: config.editor?.previewPrefix, assetBaseUrl: config.assetBaseUrl, basePath: config.basePath, themeOptions: resolvedTheme, AccountComponent: config.editor?.AccountComponent, onAccountClick: config.editor?.onAccountClick, onLogoutClick: config.editor?.onLogoutClick }) }) }));
+    return (_jsx(ApiClientProvider, { basePath: config.basePath, editorMode: config.mode, children: _jsx(EditorAuthGate, { SignInComponent: config.editor?.SignInComponent, themeOptions: resolvedTheme, editorMode: config.mode, children: _jsx(Editor, { entries: entries, title: resolvedTitle, branchName: resolvedBranchName, operatingMode: config.mode, initialSelectedId: initialSelectedId, initialValues: initialValues, renderPreview: renderPreview, onCreateEntry: onCreateEntry, customRenderers: customRenderers, collections: collections, contentRoot: config.contentRoot, entryLinkUrl: config.entryLinkUrl, previewBaseByCollection: config.editor?.previewBase, previewPrefix: config.editor?.previewPrefix, mdxAllow: config.mdxAllow, basePath: config.basePath, themeOptions: resolvedTheme, AccountComponent: config.editor?.AccountComponent, onAccountClick: config.editor?.onAccountClick, onLogoutClick: config.editor?.onLogoutClick }) }) }));
 };
 export default CanopyEditor;

package/dist/editor/CommentsPanel.d.ts

@@ -2,9 +2,19 @@ import React from 'react';
 import type { CommentThread } from '../comment-store.js';
 import type { UserSearchResult } from '../auth/types.js';
 export interface CommentsPanelProps {
+    /**
+     * Whether the drawer is open. The panel stays mounted while closed, so the composer text and
+     * reply drafts survive a close; key it by branch to reset them for another one. It refuses to
+     * close while a write is in flight, since the drawer unmounts its contents on close, and each
+     * thread's busy state and error with them.
+     */
+    opened: boolean;
     branchName: string;
     comments: CommentThread[];
+    /** Whether the user may resolve any thread; a thread's own author always may resolve it. */
     canResolve: boolean;
+    /** The user the panel is for, to tell which threads they started. */
+    currentUserId: string;
     onAddComment: (text: string, type: 'field' | 'entry' | 'branch', entryPath?: string, canopyPath?: string, threadId?: string) => Promise<void>;
     onResolveThread: (threadId: string) => Promise<void>;
     onClose: () => void;
@@ -16,5 +26,9 @@ export interface CommentsPanelProps {
     onJumpToBranch?: (threadId: string) => void;
     /** Optional function to fetch user metadata for displaying user badges */
     onGetUserMetadata?: (userId: string) => Promise<UserSearchResult | null>;
+    /** An entry's title for a thread's heading; without an answer the heading shows its path. */
+    entryLabel?: (entryPath: string) => string | undefined;
+    /** A field thread's breadcrumb for its heading; without an answer the heading shows its path. */
+    fieldLabel?: (thread: CommentThread) => string | undefined;
 }
 export declare const CommentsPanel: React.FC<CommentsPanelProps>;

package/dist/editor/CommentsPanel.js

@@ -1,66 +1,91 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState } from 'react';
-import { Badge, Button, Drawer, Group, Paper, ScrollArea, Stack, Text, Textarea, Title, Switch, } from '@mantine/core';
+import { useId, useRef, useState } from 'react';
+import { Badge, Button, Drawer, Group, Paper, ScrollArea, Stack, Text, Textarea, Title, Switch, Tooltip, VisuallyHidden, } from '@mantine/core';
 import { UserBadge } from './components/UserBadge.js';
-import { formatRelativeTime } from './relative-time.js';
-export const CommentsPanel = ({ branchName, comments, canResolve, onAddComment, onResolveThread, onClose, onJumpToField, onJumpToEntry, onJumpToBranch, onGetUserMetadata, }) => {
+import { userIdLabel } from './user-display.js';
+import { RelativeTime } from './components/RelativeTime.js';
+import { ThreadReplyControls } from './comments/ThreadReplyControls.js';
+import { useTrackedWrites } from './comments/use-tracked-writes.js';
+import { CloseRefusedNotice } from './comments/CloseRefusedNotice.js';
+import { ON_REMOVED_ITEM } from './comments/item-anchor-copy.js';
+import { CommentWriteAlert, toCommentWriteFailure, } from './comments/CommentWriteAlert.js';
+/**
+ * A jump button that stays focusable while a write is in flight (`aria-disabled`, not `disabled`),
+ * so its reason opens on keyboard focus and touch as well as hover.
+ */
+const JumpButton = ({ blocked, onClick, children }) => (_jsx(Tooltip, { label: "Your change is still saving. Try again once it finishes.", disabled: !blocked, multiline: true, maw: 280, children: _jsx(Button, { variant: "light", onClick: () => {
+            if (!blocked)
+                onClick();
+        }, "data-disabled": blocked ? true : undefined, "aria-disabled": blocked ? true : undefined, children: children }) }));
+const THREAD_KIND_LABELS = { field: 'Field', entry: 'Entry', branch: 'Branch' };
+export const CommentsPanel = ({ opened, branchName, comments, canResolve, currentUserId, onAddComment, onResolveThread, onClose, onJumpToField, onJumpToEntry, onJumpToBranch, onGetUserMetadata, entryLabel, fieldLabel, }) => {
     const [newCommentText, setNewCommentText] = useState('');
-    const [replyTo, setReplyTo] = useState(null);
+    const [replyDrafts, setReplyDrafts] = useState({});
     const [showResolved, setShowResolved] = useState(false);
     const [isSubmitting, setIsSubmitting] = useState(false);
+    const [error, setError] = useState(null);
+    const { inFlight, track, holdOpen, closeRefused } = useTrackedWrites();
+    const addComment = track(onAddComment);
+    const resolveThread = track(onResolveThread);
+    const close = () => {
+        if (!holdOpen())
+            onClose();
+    };
+    // A jump hands focus to its target (the field's or entry's comment popover, or the branches
+    // drawer), so the drawer returns none: its return would land after the target took focus.
+    const [jumping, setJumping] = useState(false);
+    if (opened && jumping)
+        setJumping(false);
+    const jump = (go) => {
+        setJumping(true);
+        go();
+        onClose();
+    };
+    // A resolved thread's card leaves the list with the focused button, so focus lands here.
+    const threadCountRef = useRef(null);
+    // With resolved threads shown, the card stays and its heading takes the focus instead.
+    const headingRefs = useRef(new Map());
+    const idPrefix = useId();
+    const headingId = (threadId) => `${idPrefix}-heading-${threadId}`;
     const filteredThreads = showResolved ? comments : comments.filter((t) => !t.resolved);
     const handleAddComment = async () => {
         if (!newCommentText.trim())
             return;
         setIsSubmitting(true);
+        setError(null);
         try {
-            if (replyTo) {
-                const thread = comments.find((t) => t.id === replyTo);
-                if (thread) {
-                    await onAddComment(newCommentText, thread.type, thread.entryPath, thread.canopyPath, replyTo);
-                }
-            }
-            else {
-                await onAddComment(newCommentText, 'branch', undefined, undefined, undefined);
-            }
+            await addComment(newCommentText, 'branch', undefined, undefined, undefined);
             setNewCommentText('');
-            setReplyTo(null);
-        }
-        finally {
-            setIsSubmitting(false);
         }
-    };
-    const handleResolve = async (threadId) => {
-        setIsSubmitting(true);
-        try {
-            await onResolveThread(threadId);
+        catch (err) {
+            setError(toCommentWriteFailure(err));
         }
         finally {
             setIsSubmitting(false);
         }
     };
-    return (_jsx(Drawer, { opened: true, onClose: onClose, position: "right", size: 420, title: _jsxs("div", { children: [_jsx(Title, { order: 4, children: "Comments" }), _jsx(Text, { size: "xs", c: "dimmed", children: branchName })] }), children: _jsxs(Stack, { gap: "md", h: "100%", style: { display: 'flex', flexDirection: 'column' }, children: [_jsx(Paper, { withBorder: true, p: "md", children: _jsxs(Stack, { gap: "sm", children: [replyTo && (_jsxs(Group, { justify: "space-between", children: [_jsx(Text, { size: "xs", c: "dimmed", children: "Replying to thread" }), _jsx(Button, { size: "xs", variant: "subtle", onClick: () => setReplyTo(null), children: "Cancel" })] })), !replyTo && (_jsxs(Text, { size: "xs", c: "dimmed", children: ["Posts a branch-level comment on \"", branchName, "\". Use a field's \"New comment\" link for field-specific threads."] })), _jsx(Textarea, { placeholder: replyTo ? 'Write a reply...' : 'Write a comment...', value: newCommentText, onChange: (e) => setNewCommentText(e.target.value), minRows: 3, disabled: isSubmitting, "data-testid": "comment-textarea" }), _jsx(Button, { onClick: handleAddComment, size: "sm", loading: isSubmitting, disabled: !newCommentText.trim(), "data-testid": "comment-submit", children: replyTo ? 'Reply' : 'Add Comment' })] }) }), _jsxs(Group, { justify: "space-between", children: [_jsxs(Text, { size: "sm", fw: 500, children: [filteredThreads.length, " ", filteredThreads.length === 1 ? 'thread' : 'threads'] }), _jsx(Switch, { label: "Show resolved", checked: showResolved, onChange: (e) => setShowResolved(e.currentTarget.checked), size: "sm" })] }), _jsx(ScrollArea, { style: { flex: 1 }, children: filteredThreads.length === 0 ? (_jsx(Text, { size: "sm", c: "dimmed", ta: "center", py: "xl", children: showResolved ? 'No comments yet' : 'No unresolved comments' })) : (_jsx(Stack, { gap: "md", children: filteredThreads.map((thread) => (_jsx(Paper, { withBorder: true, p: "md", bg: thread.resolved ? 'gray.0' : undefined, "data-testid": "comment-thread", children: _jsxs(Stack, { gap: "xs", children: [_jsxs(Group, { justify: "space-between", align: "flex-start", children: [_jsxs(Group, { gap: "xs", children: [_jsx(Badge, { size: "xs", variant: "outline", color: thread.type === 'field'
-                                                            ? 'blue'
-                                                            : thread.type === 'entry'
-                                                                ? 'grape'
-                                                                : 'gray', children: thread.type }), thread.entryPath && (_jsx(Badge, { size: "xs", variant: "light", children: thread.entryPath })), thread.canopyPath && (_jsx(Badge, { size: "xs", variant: "dot", children: thread.canopyPath })), thread.resolved && (_jsx(Badge, { size: "xs", color: "green", variant: "light", children: "Resolved" }))] }), _jsx(Group, { gap: "xs", children: canResolve && !thread.resolved && (_jsx(Button, { size: "xs", variant: "subtle", color: "green", onClick: () => handleResolve(thread.id), loading: isSubmitting, children: "Resolve" })) })] }), _jsxs(Group, { gap: "xs", children: [thread.type === 'field' &&
+    const threadHeading = (thread) => {
+        const kind = THREAD_KIND_LABELS[thread.type];
+        if (!thread.entryPath)
+            return kind;
+        const entry = entryLabel?.(thread.entryPath) ?? thread.entryPath;
+        const field = thread.canopyPath ? (fieldLabel?.(thread) ?? thread.canopyPath) : undefined;
+        return `${kind} · ${field ? `${entry} › ${field}` : entry}`;
+    };
+    return (_jsx(Drawer, { opened: opened, onClose: close, returnFocus: !jumping, position: "right", size: 420, title: _jsxs("div", { children: [_jsx(Title, { order: 4, children: "Comments" }), _jsx(Text, { size: "xs", c: "dimmed", children: branchName })] }), children: _jsxs(Stack, { gap: "md", h: "100%", style: { display: 'flex', flexDirection: 'column' }, children: [_jsx(CloseRefusedNotice, { refused: closeRefused }), _jsx(Paper, { withBorder: true, p: "md", children: _jsxs(Stack, { gap: "sm", children: [_jsxs(Text, { size: "xs", c: "dimmed", children: ["Posts a branch-level comment on \"", branchName, "\". To comment on a field, use its comment icon."] }), _jsx(Textarea, { placeholder: "Add a comment\u2026", "aria-label": "New branch comment", value: newCommentText, onChange: (e) => setNewCommentText(e.target.value), minRows: 3, disabled: isSubmitting, "data-testid": "comment-textarea" }), error && _jsx(CommentWriteAlert, { failure: error, onClose: () => setError(null) }), _jsx(Button, { onClick: handleAddComment, size: "sm", loading: isSubmitting, disabled: !newCommentText.trim(), "data-testid": "comment-submit", children: "Comment" })] }) }), _jsxs(Group, { justify: "space-between", children: [_jsxs(Text, { ref: threadCountRef, size: "sm", fw: 500, tabIndex: -1, children: [filteredThreads.length, " ", filteredThreads.length === 1 ? 'thread' : 'threads'] }), _jsx(Switch, { label: "Show resolved", checked: showResolved, onChange: (e) => setShowResolved(e.currentTarget.checked), size: "sm" })] }), _jsx(ScrollArea, { style: { flex: 1 }, children: filteredThreads.length === 0 ? (_jsx(Text, { size: "sm", c: "dimmed", ta: "center", py: "xl", children: showResolved ? 'No comments yet' : 'No unresolved comments' })) : (_jsx(Stack, { gap: "md", children: filteredThreads.map((thread) => (_jsx(Paper, { withBorder: true, p: "md", component: "article", "aria-labelledby": headingId(thread.id), bg: thread.resolved ? 'var(--mantine-color-default-hover)' : undefined, "data-testid": "comment-thread", children: _jsxs(Stack, { gap: "xs", children: [_jsxs(Group, { gap: "xs", children: [_jsxs(Text, { id: headingId(thread.id), ref: (node) => {
+                                                    if (node)
+                                                        headingRefs.current.set(thread.id, node);
+                                                    else
+                                                        headingRefs.current.delete(thread.id);
+                                                }, size: "xs", fw: 600, tabIndex: -1, "data-testid": "comment-thread-heading", children: [threadHeading(thread), thread.onRemovedItem && (_jsxs(VisuallyHidden, { children: [", ", ON_REMOVED_ITEM.toLowerCase()] }))] }), thread.resolved && (_jsx(Badge, { size: "xs", color: "green", variant: "light", children: "Resolved" })), thread.onRemovedItem && (_jsx(Badge, { size: "xs", color: "gray", variant: "light", c: "var(--mantine-color-text)", children: ON_REMOVED_ITEM }))] }), _jsxs(Group, { gap: "xs", children: [thread.type === 'field' &&
                                                 thread.entryPath &&
                                                 thread.canopyPath &&
-                                                onJumpToField && (_jsx(Button, { size: "xs", variant: "light", onClick: () => {
-                                                    onJumpToField(thread.entryPath, thread.canopyPath, thread.id);
-                                                    onClose();
-                                                }, children: "Jump to field" })), thread.type === 'entry' && thread.entryPath && onJumpToEntry && (_jsx(Button, { size: "xs", variant: "light", onClick: () => {
-                                                    onJumpToEntry(thread.entryPath, thread.id);
-                                                    onClose();
-                                                }, children: "Jump to entry" })), thread.type === 'branch' && onJumpToBranch && (_jsx(Button, { size: "xs", variant: "light", onClick: () => {
-                                                    onJumpToBranch(thread.id);
-                                                    onClose();
-                                                }, children: "Open branch discussion" }))] }), thread.comments.map((comment, idx) => (_jsxs("div", { children: [idx > 0 && (_jsx("div", { style: {
-                                                    borderTop: '1px solid var(--mantine-color-gray-3)',
+                                                !thread.onRemovedItem &&
+                                                onJumpToField && (_jsx(JumpButton, { blocked: inFlight > 0, onClick: () => jump(() => onJumpToField(thread.entryPath, thread.canopyPath, thread.id)), children: "Jump to field" })), (thread.type === 'entry' || thread.onRemovedItem) &&
+                                                thread.entryPath &&
+                                                onJumpToEntry && (_jsx(JumpButton, { blocked: inFlight > 0, onClick: () => jump(() => onJumpToEntry(thread.entryPath, thread.id)), children: "Jump to entry" })), thread.type === 'branch' && onJumpToBranch && (_jsx(JumpButton, { blocked: inFlight > 0, onClick: () => jump(() => onJumpToBranch(thread.id)), children: "Open branch discussion" }))] }), thread.comments.map((comment, idx) => (_jsxs("div", { children: [idx > 0 && (_jsx("div", { style: {
+                                                    borderTop: '1px solid var(--mantine-color-default-border)',
                                                     margin: '8px 0',
-                                                } })), _jsxs(Stack, { gap: 4, children: [_jsxs(Group, { gap: "xs", children: [onGetUserMetadata ? (_jsx(UserBadge, { userId: comment.userId, getUserMetadata: onGetUserMetadata, variant: "avatar-name", size: "xs", showEmailTooltip: true, showBadge: true, badgeVariant: "light", color: "gray" })) : (_jsx(Text, { size: "xs", fw: 500, children: comment.userId })), _jsx(Text, { size: "xs", c: "dimmed", title: new Date(comment.timestamp).toLocaleString(), children: formatRelativeTime(comment.timestamp) })] }), _jsx(Text, { size: "sm", style: { whiteSpace: 'pre-wrap' }, children: comment.text })] })] }, comment.id))), !thread.resolved && (_jsx(Button, { size: "xs", variant: "subtle", onClick: () => {
-                                            setReplyTo(thread.id);
-                                            setNewCommentText('');
-                                        }, mt: "xs", children: "Reply" }))] }) }, thread.id))) })) })] }) }));
+                                                } })), _jsxs(Stack, { gap: 4, children: [_jsxs(Group, { gap: "xs", children: [onGetUserMetadata ? (_jsx(UserBadge, { userId: comment.userId, getUserMetadata: onGetUserMetadata, variant: "avatar-name", size: "xs", showEmailTooltip: true, showBadge: true, badgeVariant: "light", color: "gray" })) : (_jsx(Text, { size: "xs", fw: 500, children: userIdLabel(comment.userId) })), _jsx(RelativeTime, { iso: comment.timestamp, size: "xs", c: "dimmed" })] }), _jsx(Text, { size: "sm", style: { whiteSpace: 'pre-wrap' }, children: comment.text })] })] }, comment.id))), !thread.resolved && (_jsx(ThreadReplyControls, { thread: thread, onAddReply: (text) => addComment(text, thread.type, thread.entryPath, thread.canopyPath, thread.id), onResolve: () => resolveThread(thread.id), focusAfterResolve: () => showResolved ? headingRefs.current.get(thread.id) : threadCountRef.current, currentUserId: currentUserId, canResolve: canResolve, replyText: replyDrafts[thread.id] ?? '', onReplyTextChange: (text) => setReplyDrafts((prev) => ({ ...prev, [thread.id]: text })) }))] }) }, thread.id))) })) })] }) }));
 };