canopycms 0.7.1 → 0.8.1

package/dist/content-reader.js

@@ -1,8 +1,10 @@
-import { loadBranchContext, loadOrCreateBranchContext } from './branch-workspace.js';
+import { loadOrCreateBranchContext } from './branch-workspace.js';
+import { resolveBranchParam } from './branch-param.js';
 import { SchemaUnavailableError } from './schema/schema-unavailable-error.js';
 import { ContentStore, ContentStoreError } from './content-store.js';
 import { namesNoWorkspace, resolveBranchPaths, } from './paths/index.js';
 import { trimSlashes } from './paths/normalize.js';
+import { exactBranchName, isExactBranchForm } from './paths/validation.js';
 import { computeEntryUrl, isIndexSlug } from './utils/entry-url.js';
 import { isDeployedStatic, isBuildMode, readsFromCheckout } from './build-mode.js';
 import { isNotFoundError } from './utils/error.js';
@@ -14,6 +16,11 @@ import { CONTENT_READER_USER_ID } from './system-users.js';
  * reads as NOT_FOUND unless `allowCreateBranch` or a `getBranchContext` resolver says otherwise.
  */
 export const createContentReader = (options) => {
+    const { read } = createContentReaderInternal(options);
+    return { read };
+};
+/** @internal {@link createContentReader} plus `readFirst`, for context.ts. */
+export const createContentReaderInternal = (options) => {
     const services = options.services;
     const operatingMode = services.config.mode;
     const basePathOverride = options.basePathOverride;
@@ -40,28 +47,33 @@ export const createContentReader = (options) => {
                 throw new ContentStoreError(`Branch not found: ${branchName}`, 'NOT_FOUND');
             return resolved;
         }
-        if (allowCreateBranch) {
-            return loadOrCreateBranchContext({
+        // An existing branch resolves first, so a short name reads its namespace branch; only a
+        // name that resolves to none is provisioned.
+        const existing = await resolveBranchParam(branchName, services.config, {
+            basePathOverride,
+        }).catch((err) => {
+            if (namesNoWorkspace(err))
+                return null;
+            throw err;
+        });
+        if (existing)
+            return existing;
+        // The exact form provisions the branch its full name names; a malformed one names none.
+        const named = isExactBranchForm(branchName) ? exactBranchName(branchName) : branchName;
+        if (allowCreateBranch && named !== null) {
+            const context = await loadOrCreateBranchContext({
                 config: services.config,
-                branchName,
+                branchName: named,
                 mode: operatingMode,
                 basePathOverride,
                 createdBy,
                 remoteUrl: services.config.defaultRemoteUrl,
             });
+            // A workspace already at this name's key that holds another branch is that branch's.
+            if (context.branch.name === named)
+                return context;
         }
-        const existing = await loadBranchContext({
-            branchName,
-            mode: operatingMode,
-            basePathOverride,
-        }).catch((err) => {
-            if (namesNoWorkspace(err))
-                return null;
-            throw err;
-        });
-        if (!existing)
-            throw new ContentStoreError(`Branch not found: ${branchName}`, 'NOT_FOUND');
-        return existing;
+        throw new ContentStoreError(`Branch not found: ${branchName}`, 'NOT_FOUND');
     };
     const resolveStore = async (branchName) => {
         const context = await resolveBranchContext(branchName);
@@ -120,9 +132,9 @@ export const createContentReader = (options) => {
         const url = encodedSlug ? `${trimmed}/${encodedSlug}` : trimmed || '/';
         return appendBranch(url);
     };
-    const readDocument = async (input) => {
-        const { entryPath, slug, branchName, user } = resolveTarget(input);
-        const { context, branchRoot, store } = await resolveStore(branchName);
+    const readDocument = async (input, resolved) => {
+        const { entryPath, slug, user } = resolveTarget(input);
+        const { context, branchRoot, store } = resolved;
         // Rule 1 of urlAddressableOnly (see ReadContentInput): a published URL's non-slug segments
         // are collection names, so a candidate landing on an entry-TYPE item can only ever produce a
         // URL enumeration never emits. NO_SCHEMA_ITEM is what assertCollection raises for exactly
@@ -209,9 +221,9 @@ export const createContentReader = (options) => {
             throw err;
         }
     };
-    const read = async (input, message) => {
+    const readResolved = async (input, resolved, message) => {
         const { entryPath, slug, branchName } = resolveTarget(input);
-        const result = await readDocument(input);
+        const result = await readDocument(input, resolved);
         if (!result || typeof result.doc !== 'object' || !('data' in result.doc)) {
             const defaultMessage = `Content not found for ${entryPath}${slug ? `/${slug}` : ''} on branch ${branchName}`;
             throw new ContentStoreError(message ?? defaultMessage, 'NOT_FOUND');
@@ -235,5 +247,37 @@ export const createContentReader = (options) => {
         });
         return { data, path, meta: { physicalPath, entryType, entryId, slug: entrySlug, urlPath } };
     };
-    return { read };
+    const read = async (input, message) => {
+        const { branchName } = resolveTarget(input);
+        return readResolved(input, await resolveStore(branchName), message);
+    };
+    const readFirst = async (inputs, isMiss) => {
+        const [first] = inputs;
+        if (!first)
+            return null;
+        if (inputs.some((input) => input.branch !== first.branch || input.user !== first.user)) {
+            throw new Error('readFirst: every input must name the same branch and user');
+        }
+        let resolved;
+        try {
+            resolved = await resolveStore(resolveTarget(first).branchName);
+        }
+        catch (err) {
+            if (isMiss(err, first))
+                return null;
+            throw err;
+        }
+        for (const input of inputs) {
+            try {
+                return await readResolved(input, resolved);
+            }
+            catch (err) {
+                if (isMiss(err, input))
+                    continue;
+                throw err;
+            }
+        }
+        return null;
+    };
+    return { read, readFirst };
 };

package/dist/context.js

@@ -1,9 +1,10 @@
 import { isDeployedStatic, isBuildMode, readsFromCheckout, STATIC_DEPLOY_USER } from './build-mode.js';
-import { createContentReader } from './content-reader.js';
+import { createContentReaderInternal } from './content-reader.js';
 import { ContentStoreError } from './content-store.js';
 import { createLogicalPath, namesNoWorkspace, parseSlug, resolveBranchPaths, } from './paths/index.js';
 import { resolveUrlPathCandidates } from './url-path-resolver.js';
-import { loadBranchContext, loadOrCreateBranchContext } from './branch-workspace.js';
+import { loadOrCreateBranchContext } from './branch-workspace.js';
+import { resolveBranchParam } from './branch-param.js';
 import { buildContentTree as buildContentTreeImpl, } from './content-tree.js';
 import { listEntries as listEntriesImpl, } from './content-listing.js';
 import { createDebugLogger } from './utils/debug.js';
@@ -34,13 +35,13 @@ function isBranchOption(branch) {
     return branch == null || typeof branch === 'string';
 }
 /**
- * A branch that already has a workspace, or null. A name that cannot name one
- * is null too (`namesNoWorkspace`): it arrives from the request, so it reads as
- * not-found rather than failing the page.
+ * The existing branch `param` names (`resolveBranchParam`), or null. A name that cannot name one
+ * is null too (`namesNoWorkspace`): it arrives from the request, so it reads as not-found rather
+ * than failing the page.
  */
-async function loadExistingBranch(branchName, mode) {
+async function loadExistingBranch(param, config) {
     try {
-        return await loadBranchContext({ branchName, mode });
+        return await resolveBranchParam(param, config);
     }
     catch (err) {
         if (namesNoWorkspace(err))
@@ -119,7 +120,7 @@ export function createCanopyContext(options) {
                     remoteUrl: services.config.defaultRemoteUrl,
                 });
             }
-            const context = await loadExistingBranch(requested, services.config.mode);
+            const context = await loadExistingBranch(requested, services.config);
             if (!context)
                 return null;
             if (enforceAcls && !services.checkBranchAccess(context, user).allowed)
@@ -128,7 +129,7 @@ export function createCanopyContext(options) {
         };
         // The reader resolves every branch through resolveBranch; a null reads as
         // NOT_FOUND. Reads from the checkout bypass the resolver inside the reader.
-        const baseReader = createContentReader({
+        const baseReader = createContentReaderInternal({
             services,
             defaultBranch: activeBranch,
             getBranchContext: (branchName) => resolveBranch(otherBranch(branchName)),
@@ -139,7 +140,7 @@ export function createCanopyContext(options) {
         // function rather than an optional second parameter on the
         // `CanopyContext['read']`-typed closure, so the two call sites stay visible
         // and nobody widens the public API by accident.
-        const readWithOptions = async (input, extra) => {
+        const toReadInput = (input, extra) => {
             const entryPath = createLogicalPath(input.entryPath);
             let slug;
             if (input.slug) {
@@ -160,53 +161,55 @@ export function createCanopyContext(options) {
                 resolveReferences: input.resolveReferences ?? true,
                 ...extra,
             };
-            return baseReader.read(readInput);
+            return readInput;
         };
-        const read = (input) => readWithOptions(input);
+        const read = async (input) => baseReader.read(toReadInput(input));
         const readByUrlPath = async (urlPath, options) => {
             const contentRoot = services.config.contentRoot || 'content';
             const candidates = resolveUrlPathCandidates(urlPath, contentRoot);
             if (candidates.length === 0)
                 return null;
             const { branch, resolveReferences } = options ?? {};
-            for (const candidate of candidates) {
-                // Skip a candidate whose slug isn't valid (/favicon.ico, Next internals
-                // the [...slug] route catches). None can match an entry, so treat it as
-                // a miss rather than let read() throw "Invalid slug".
-                if (!parseSlug(candidate.slug).ok)
-                    continue;
-                try {
-                    return await readWithOptions({
-                        entryPath: candidate.entryPath,
-                        slug: candidate.slug,
-                        branch,
-                        resolveReferences,
-                    }, 
-                    // A read BY PUBLISHED URL accepts only what listEntries publishes.
-                    // See ReadContentInput.urlAddressableOnly for the two rules, and
-                    // why they live in the reader (which holds the branch-correct
-                    // schema) rather than the candidate builder (pure and schema-free).
-                    { urlAddressableOnly: true });
-                }
-                catch (err) {
-                    // Swallow a candidate path's "not found", and FORBIDDEN so a denied
-                    // or anonymous read renders as the adopter's 404 rather than an
-                    // unhandled 500. Real errors (validation, corruption, anything not a
-                    // ContentStoreError) rethrow.
-                    if (err instanceof ContentStoreError && isPageSwallowable(err)) {
-                        if (err.code === 'FORBIDDEN') {
-                            log.debug('readByUrlPath', 'Read denied, treating as not-found: ' + err.message, {
-                                urlPath,
-                                entryPath: candidate.entryPath,
-                                slug: candidate.slug,
-                            });
-                        }
-                        continue;
-                    }
-                    throw err;
+            // Swallow a candidate path's "not found", and FORBIDDEN so a denied or
+            // anonymous read renders as the adopter's 404 rather than an unhandled
+            // 500. Real errors (validation, corruption, anything not a
+            // ContentStoreError) rethrow.
+            const isMiss = (err, input) => {
+                if (!(err instanceof ContentStoreError && isPageSwallowable(err)))
+                    return false;
+                if (err.code === 'FORBIDDEN') {
+                    log.debug('readByUrlPath', 'Read denied, treating as not-found: ' + err.message, {
+                        urlPath,
+                        entryPath: input?.entryPath,
+                        slug: input?.slug,
+                    });
                 }
+                return true;
+            };
+            // Converting every candidate up front throws nothing a candidate-by-candidate
+            // loop would not: a valid slug holds no `..`, so the index candidate's path
+            // fails createLogicalPath only when the entry candidate's does.
+            let inputs;
+            try {
+                inputs = candidates
+                    // Skip a candidate whose slug isn't valid (/favicon.ico, Next internals
+                    // the [...slug] route catches). None can match an entry, so treat it as
+                    // a miss rather than let read() throw "Invalid slug".
+                    .filter((candidate) => parseSlug(candidate.slug).ok)
+                    .map((candidate) => toReadInput({ entryPath: candidate.entryPath, slug: candidate.slug, branch, resolveReferences }, 
+                // A read BY PUBLISHED URL accepts only what listEntries publishes.
+                // See ReadContentInput.urlAddressableOnly for the two rules, and
+                // why they live in the reader (which holds the branch-correct
+                // schema) rather than the candidate builder (pure and schema-free).
+                { urlAddressableOnly: true }));
             }
-            return null;
+            catch (err) {
+                if (isMiss(err))
+                    return null;
+                throw err;
+            }
+            // One branch and schema resolve for every candidate.
+            return baseReader.readFirst(inputs, isMiss);
         };
         /**
          * What a batch read (listEntries / buildContentTree) lists from: the branch's

package/dist/editor/BranchManager.d.ts

@@ -3,9 +3,12 @@ import type { OperatingMode } from '../operating-mode/index.js';
 import type { ConflictStatus, PullRequestState, SyncStatus } from '../types.js';
 import type { CommentThread } from '../comment-store.js';
 import type { UserSearchResult } from '../auth/types.js';
+import type { CreateRefusal } from './hooks/create-branch-request.js';
 /** @internal Exported for tests. */
 export interface BranchSummary {
     name: string;
+    /** What the card shows for the branch (`displayBranchName`); the full `name` keys it. */
+    shortName?: string;
     status: string;
     createdBy?: string;
     updatedAt?: string;
@@ -78,14 +81,15 @@ export interface BranchManagerProps {
     /** 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.
+     * Resolving `false` means the branch was not created, so the form stays open with the user's
+     * values; `{ refusal }` also shows why under the name field. Any other return (including none)
+     * closes it.
      */
     onCreate?: (branch: {
         name: string;
         title?: string;
         description?: string;
-    }) => Promise<boolean> | void;
+    }) => Promise<boolean | CreateRefusal> | void;
     onDelete?: (name: string) => void;
     onSubmit?: (name: string) => void;
     onWithdraw?: (name: string) => void;

package/dist/editor/BranchManager.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { useRef, useState } from 'react';
+import { useEffect, useRef, useState } from 'react';
 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';
@@ -9,10 +9,12 @@ import { BranchAccessList } from './components/BranchAccessList.js';
 // Import directly from helpers to avoid server-only code in authorization barrel
 import { isAdmin, isLockedOutOfBranch, isReviewer } from '../authorization/helpers.js';
 import { clientOperatingStrategy } from '../operating-mode/client.js';
+import { parseCreatedBranchName } from '../paths/validation.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 { branchAddress, displayBranchName } from './branch-names.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';
@@ -183,9 +185,9 @@ const BranchCard = ({ branch: b, isCurrent, workflowBlockedReason, user, onSelec
     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 menuLabel = `More actions for ${displayBranchName(b)}`;
     const [menuOpen, setMenuOpen] = useState(false);
-    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'
+    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: displayBranchName(b) }), 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'
@@ -206,10 +208,29 @@ export const BranchManager = ({ branches, mode, user, currentBranchName, current
     const [newBranchTitle, setNewBranchTitle] = useState('');
     const [newBranchDescription, setNewBranchDescription] = useState('');
     const [creating, setCreating] = useState(false);
+    // Why a create refused the name, shown while that name is still what is typed.
+    const [refused, setRefused] = useState(null);
+    const nameInputRef = useRef(null);
+    // Set by a refusal: the name field takes focus once it is enabled again, so its error is read.
+    const focusNameRef = useRef(false);
+    useEffect(() => {
+        if (creating || !focusNameRef.current)
+            return;
+        focusNameRef.current = false;
+        nameInputRef.current?.focus();
+    }, [creating, refused]);
     // Read synchronously: state would not yet show a first click to a second one in the same tick.
     const creatingRef = useRef(false);
+    // The server's own rules, so the field says what will be created, or why nothing can be.
+    const typedBranchName = newBranchName.trim();
+    const createdBranchName = typedBranchName ? parseCreatedBranchName(typedBranchName) : null;
+    const nameError = createdBranchName?.ok === false
+        ? createdBranchName.error
+        : refused?.typed === typedBranchName
+            ? refused.reason
+            : undefined;
     const handleCreate = async () => {
-        if (creatingRef.current || !newBranchName.trim())
+        if (creatingRef.current || !createdBranchName?.ok)
             return;
         creatingRef.current = true;
         try {
@@ -217,12 +238,18 @@ export const BranchManager = ({ branches, mode, user, currentBranchName, current
                 return;
             setCreating(true);
             const created = await onCreate?.({
-                name: newBranchName.trim(),
+                name: typedBranchName,
                 title: newBranchTitle.trim() || undefined,
                 description: newBranchDescription.trim() || undefined,
             });
             if (created === false)
                 return;
+            if (typeof created === 'object') {
+                focusNameRef.current = true;
+                setRefused({ typed: typedBranchName, reason: created.refusal });
+                return;
+            }
+            setRefused(null);
             setNewBranchName('');
             setNewBranchTitle('');
             setNewBranchDescription('');
@@ -240,5 +267,23 @@ 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, onApprove: onApprove, 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: () => {
+                            if (showCreateForm)
+                                setRefused(null);
+                            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: "spring-update", 
+                                        // Below the input, so a preview that wraps never moves the field being typed in.
+                                        inputWrapperOrder: ['label', 'input', 'description', 'error'], 
+                                        // Only when sanitizing changed what was typed, and never beside an error.
+                                        description: !nameError &&
+                                            createdBranchName?.ok &&
+                                            createdBranchName.shortName !== typedBranchName
+                                            ? `Will be named ${createdBranchName.shortName}`
+                                            : undefined, error: nameError, value: newBranchName, onChange: (e) => setNewBranchName(e.target.value), required: true, disabled: creating, ref: nameInputRef, "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: !createdBranchName?.ok, 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) => {
+                        // The editor resolves a shadowed outside branch's full name to the namespace branch
+                        // whose short name it is, so a card's actions name its branch by `branchAddress`.
+                        const address = branchAddress(branches, b);
+                        const act = (run) => run && (() => run(address));
+                        return (_jsx(BranchCard, { branch: b, isCurrent: b.name === currentBranchName, workflowBlockedReason: b.name === currentBranchName ? currentWorkflowBlockedReason : undefined, user: user, onSelect: act(onSelect), onSubmit: act(onSubmit), onWithdraw: act(onWithdraw), onApprove: act(onApprove), onRequestChanges: act(onRequestChanges), onDelete: act(onDelete), onGetUserMetadata: onGetUserMetadata, onGetOwnerMetadata: onGetOwnerMetadata }, b.name));
+                    }) })) })] }));
 };