canopycms 0.11.1 → 0.12.1

package/dist/cli/init.js

@@ -1558,6 +1558,9 @@ var ProdClientSafeStrategy = class {
   supportsPullRequests() {
     return true;
   }
+  syncsBranchesWithBase() {
+    return true;
+  }
   getPermissionsFileName() {
     return "permissions.json";
   }
@@ -1584,6 +1587,9 @@ var DevClientSafeStrategy = class {
   supportsPullRequests() {
     return false;
   }
+  syncsBranchesWithBase() {
+    return false;
+  }
   getPermissionsFileName() {
     return "permissions.json";
   }

package/dist/cli/site-config.d.ts

@@ -1,9 +1,21 @@
 /**
- * Imports a site's `canopycms.config.ts` for CLI commands that need it (`sync`, and
- * `configured-asset-store.ts`). Importing runs the site's config and loads its own dependencies.
+ * Imports a site's own TypeScript modules for CLI commands that need them: `canopycms.config.ts`
+ * (`sync`, `generate-ai-content`, `backfill-item-keys`, `configured-asset-store.ts`) and the
+ * entry schema registry (`generate-ai-content`, `backfill-item-keys`). jiti lets plain node
+ * import them without tsx. Importing runs the module and loads its own dependencies.
  */
+/** A site module's exports, by name. */
+export declare function importSiteModule(filePath: string): Promise<Record<string, unknown>>;
 /** The site's server config export (`server` of a split config, else the export itself). */
 export declare function importSiteServerConfig(projectDir: string): Promise<{
     configPath: string;
     server: unknown;
 }>;
+/**
+ * The site's entry schema registry: `{appDir}/schemas.ts`'s `entrySchemaRegistry` export, else
+ * the module's exports. Throws when the file is missing or fails to import.
+ */
+export declare function importSiteEntrySchemaRegistry(projectDir: string, appDir: string): Promise<{
+    schemasPath: string;
+    registry: Record<string, unknown>;
+}>;

package/dist/cli/site-config.js

@@ -1,17 +1,33 @@
 /**
- * Imports a site's `canopycms.config.ts` for CLI commands that need it (`sync`, and
- * `configured-asset-store.ts`). Importing runs the site's config and loads its own dependencies.
+ * Imports a site's own TypeScript modules for CLI commands that need them: `canopycms.config.ts`
+ * (`sync`, `generate-ai-content`, `backfill-item-keys`, `configured-asset-store.ts`) and the
+ * entry schema registry (`generate-ai-content`, `backfill-item-keys`). jiti lets plain node
+ * import them without tsx. Importing runs the module and loads its own dependencies.
  */
 import path from 'node:path';
 import { createJiti } from 'jiti';
+const jiti = createJiti(import.meta.url);
+/** A site module's exports, by name. */
+export async function importSiteModule(filePath) {
+    return (await jiti.import(filePath));
+}
 /** The site's server config export (`server` of a split config, else the export itself). */
 export async function importSiteServerConfig(projectDir) {
     const configPath = path.join(projectDir, 'canopycms.config.ts');
-    const jiti = createJiti(import.meta.url);
-    const mod = (await jiti.import(configPath));
+    const mod = await importSiteModule(configPath);
     const configExport = mod.default ?? mod.config ?? mod;
     const server = typeof configExport === 'object' && configExport !== null && 'server' in configExport
         ? configExport.server
         : configExport;
     return { configPath, server };
 }
+/**
+ * The site's entry schema registry: `{appDir}/schemas.ts`'s `entrySchemaRegistry` export, else
+ * the module's exports. Throws when the file is missing or fails to import.
+ */
+export async function importSiteEntrySchemaRegistry(projectDir, appDir) {
+    const schemasPath = path.join(projectDir, appDir, 'schemas.ts');
+    const mod = await importSiteModule(schemasPath);
+    const registry = mod.entrySchemaRegistry ?? mod;
+    return { schemasPath, registry };
+}

package/dist/comment-store.d.ts

@@ -1,3 +1,4 @@
+import type { KeyRemap } from './merge/entry-merge.js';
 export type CommentType = 'field' | 'entry' | 'branch';
 interface Comment {
     id: string;
@@ -94,6 +95,13 @@ export declare class CommentStore {
      * `CommentStoreConflictError`.
      */
     private withMutation;
+    /**
+     * Point the threads on `entryPath` at the item keys a merge gave their items. A remap names its
+     * item by the keys of the items holding it, outermost first, as the threads held them before the
+     * merge, so every remap is matched against a thread's keys before any of them is applied.
+     * Resolves how many threads moved.
+     */
+    remapItemKeys(entryPath: string, remaps: readonly KeyRemap[]): Promise<number>;
     addComment(options: {
         userId: string;
         text: string;

package/dist/comment-store.js

@@ -138,6 +138,34 @@ export class CommentStore {
             throw err;
         }
     }
+    /**
+     * Point the threads on `entryPath` at the item keys a merge gave their items. A remap names its
+     * item by the keys of the items holding it, outermost first, as the threads held them before the
+     * merge, so every remap is matched against a thread's keys before any of them is applied.
+     * Resolves how many threads moved.
+     */
+    async remapItemKeys(entryPath, remaps) {
+        if (remaps.length === 0)
+            return 0;
+        return this.withMutation(async (data, version) => {
+            let moved = 0;
+            for (const thread of Object.values(data.threads)) {
+                const keys = thread.itemKeys;
+                if (thread.entryPath !== entryPath || !keys)
+                    continue;
+                const remapped = keys.map((key, depth) => remaps.find((r) => r.from === key &&
+                    r.within.length === depth &&
+                    r.within.every((outer, i) => outer === keys[i]))?.to ?? key);
+                if (remapped.every((key, i) => key === keys[i]))
+                    continue;
+                thread.itemKeys = remapped;
+                moved++;
+            }
+            if (moved > 0)
+                await this.writeData(data, version);
+            return moved;
+        });
+    }
     async addComment(options) {
         // Generate IDs outside the mutation so they stay stable across retries
         const threadId = options.threadId || randomUUID();

package/dist/content-index-generation.d.ts

@@ -1,7 +1,4 @@
-/**
- * Absolute path of the generation marker for a branch-clone root.
- * @internal No importer; deletion candidate in safeinsights/canopycms#725.
- */
+/** Absolute path of the generation marker under `root`. */
 export declare function contentIndexGenerationPath(root: string): string;
 /**
  * Record on disk that indexed files under `root` changed, so ContentStores in

package/dist/content-index-generation.js

@@ -18,10 +18,7 @@ import { SCHEMA_GENERATION_RESOURCE } from './branch-schema-cache.js';
  * before recreating a missing expected file.
  */
 const RESOURCE = 'content-index';
-/**
- * Absolute path of the generation marker for a branch-clone root.
- * @internal No importer; deletion candidate in safeinsights/canopycms#725.
- */
+/** Absolute path of the generation marker under `root`. */
 export function contentIndexGenerationPath(root) {
     return resourceGenerationPath(root, RESOURCE);
 }

package/dist/content-store.d.ts

@@ -43,6 +43,10 @@ export declare class ContentStoreError extends Error {
     code: ContentStoreErrorCode;
     constructor(message: string, code: ContentStoreErrorCode);
 }
+/** Why a restore refuses: another entry took the slug after this one was deleted. */
+export declare const RESTORE_SLUG_TAKEN_MESSAGE = "Another entry now has this entry's URL. Change that entry's URL, then restore this one.";
+/** Why a restore refuses: the entry, by its content ID, is on the branch already. */
+export declare const RESTORE_ID_TAKEN_MESSAGE = "This entry is already on the branch, so there is nothing to restore. Refresh to see where it is.";
 /**
  * Thrown when `expectedVersion` on a write doesn't match the file's current mtime.
  * Indicates a cross-process concurrent write — the caller should reload and retry.
@@ -415,7 +419,17 @@ export declare class ContentStore {
      * `referenceAccess` denies resolves to a `RestrictedReference` rather than its data.
      */
     read(collectionPath: LogicalPath, slug?: Slug | '', options?: ReadOptions): Promise<ContentDocument>;
-    write(collectionPath: LogicalPath, slug: (Slug | "") | undefined, input: WriteInput, entryTypeName?: string, existingId?: ContentId): Promise<ContentDocument>;
+    write(collectionPath: LogicalPath, slug: (Slug | "") | undefined, input: WriteInput, entryTypeName?: string, existingId?: ContentId, options?: {
+        /**
+         * Runs once the file is written, under both of the write's locks, so what it changes about
+         * the entry no other writer or rebase sees before it does. A throw rejects the write, though
+         * the file is already written.
+         */
+        afterWrite?: (written: {
+            id?: string;
+            relativePath: PhysicalPath;
+        }) => Promise<void>;
+    }): Promise<ContentDocument>;
     /**
      * Set top-level `field` of the entry file at `physicalPath` to the string `value` when the
      * file holds it empty (absent, null or ''), keeping every other byte. Resolves to the file's
@@ -478,8 +492,56 @@ export declare class ContentStore {
      * pattern in docs/concurrency.md and branch-registry.test.ts's `BlockingRegistry`.
      */
     protected afterPrePassForTesting(): Promise<void>;
-    /** Delete an entry and remove it from the index. */
-    delete(collectionPath: LogicalPath, slug: Slug): Promise<void>;
+    /**
+     * Delete an entry and remove it from the index. With `expectId`, only the entry of that content
+     * ID: another at the slug, or none, is `EntryGoneError`. `beforeDelete` runs under both of the
+     * delete's locks before anything changes, and throwing refuses; `afterDelete` runs once it is
+     * gone, under them too.
+     */
+    delete(collectionPath: LogicalPath, slug: Slug, options?: {
+        expectId?: string;
+        beforeDelete?: () => Promise<void>;
+        afterDelete?: (deleted: {
+            id?: string;
+        }) => Promise<void>;
+    }): Promise<void>;
+    /**
+     * Puts back an entry deleted on this branch: `raw`, its file as the base holds it, verbatim,
+     * under its old slug, entry type and content ID, so references and comment threads find it
+     * again and the branch no longer differs from the base there.
+     *
+     * A create under write()'s locks and create-only guards that never replaces or relocates
+     * anything. It refuses with `ContentConflictError` while a file holds the slug, or the index
+     * or the target directory holds the ID: unlike write(), it has no index repair, so an ID
+     * found elsewhere is a moved entry, not a deleted one, and is left alone. The index is
+     * warmed outside the lock, as write() warms it, and rescanned under the lock only when the
+     * generation marker says another host changed the tree.
+     */
+    restore(collectionPath: LogicalPath, slug: Slug, entry: {
+        id: ContentId;
+        entryTypeName: string;
+        raw: string;
+    }, options?: {
+        /** Runs under the content-write lock before anything is written; throwing refuses. */
+        beforeWrite?: () => Promise<void>;
+        /** Runs once the entry is back, under the restore's locks. */
+        afterWrite?: () => Promise<void>;
+    }): Promise<{
+        relativePath: PhysicalPath;
+    }>;
+    /**
+     * Replace the file of entry `id`, at `slug` in `collectionPath`, with `raw`, verbatim, under
+     * write()'s locks; `beforeWrite` runs under them first, and throwing refuses, and `afterWrite`
+     * after. For a file no parse can be trusted with, so nothing is re-serialised. `EntryGoneError`
+     * when no file of that id is there.
+     */
+    replaceRaw(collectionPath: LogicalPath, slug: Slug, entry: {
+        id: ContentId;
+        raw: string;
+    }, options?: {
+        beforeWrite?: () => Promise<void>;
+        afterWrite?: () => Promise<void>;
+    }): Promise<void>;
     /**
      * Rename an entry by changing its slug (middle segment of filename).
      * Entry filename pattern: {entryTypeName}.{slug}.{id}.{ext}

package/dist/content-store.js

@@ -16,7 +16,7 @@ import path from 'node:path';
 import matter from 'gray-matter';
 import { parse as yamlParse } from 'yaml';
 import { atomicWriteFile } from './utils/atomic-write.js';
-import { serializeFrontmatter, serializeYaml } from './utils/content-serialize.js';
+import { serializeEntry, serializeFrontmatter, serializeYaml } from './utils/content-serialize.js';
 import { serializeJson } from './utils/json-source-splice.js';
 import { withLock } from './utils/async-mutex.js';
 import { assertContentWriteLockHeld, ContentWriteLockBusyError, DEFAULT_CONTENT_WRITE_LOCK_WAIT_MS, withContentWriteLock, } from './utils/content-write-lock.js';
@@ -56,6 +56,10 @@ export class ContentStoreError extends Error {
         this.code = code;
     }
 }
+/** Why a restore refuses: another entry took the slug after this one was deleted. */
+export const RESTORE_SLUG_TAKEN_MESSAGE = "Another entry now has this entry's URL. Change that entry's URL, then restore this one.";
+/** Why a restore refuses: the entry, by its content ID, is on the branch already. */
+export const RESTORE_ID_TAKEN_MESSAGE = 'This entry is already on the branch, so there is nothing to restore. Refresh to see where it is.';
 /**
  * Thrown when `expectedVersion` on a write doesn't match the file's current mtime.
  * Indicates a cross-process concurrent write — the caller should reload and retry.
@@ -798,7 +802,7 @@ export class ContentStore {
         doc.version = stat.mtimeMs;
         return doc;
     }
-    async write(collectionPath, slug = '', input, entryTypeName, existingId) {
+    async write(collectionPath, slug = '', input, entryTypeName, existingId, options = {}) {
         // Warm the index outside the lock (a full scan must not hold the entry lock)
         await this.idIndex();
         const schemaItem = this.assertSchemaItem(collectionPath);
@@ -1023,16 +1027,7 @@ export class ContentStore {
                     // intact, and no caller passes `existingId`. If a relocating write becomes
                     // reachable, read the ID's current path instead of `absolutePath`.
                     const existingRaw = current?.content;
-                    let content;
-                    if (input.format === 'json') {
-                        content = serializeJson(input.data ?? {}, existingRaw);
-                    }
-                    else if (input.format === 'yaml') {
-                        content = serializeYaml(input.data ?? {}, existingRaw);
-                    }
-                    else {
-                        content = serializeFrontmatter(input.body, input.data ?? {}, existingRaw, input.format, fields);
-                    }
+                    const content = serializeEntry(input, existingRaw, fields);
                     await atomicWriteFile(absolutePath, content);
                     // Update the ID index after a successful write. Look up and mutate the LIVE index
                     // in one synchronous window (no awaits in between): a concurrent rebuild may have
@@ -1069,6 +1064,7 @@ export class ContentStore {
                         });
                     }
                     await this.recordOwnMutation(liveIndex);
+                    await options.afterWrite?.({ id, relativePath });
                     const afterStat = await fs.stat(absolutePath);
                     const base = {
                         collection: schemaItem.logicalPath,
@@ -1228,8 +1224,13 @@ export class ContentStore {
      * pattern in docs/concurrency.md and branch-registry.test.ts's `BlockingRegistry`.
      */
     async afterPrePassForTesting() { }
-    /** Delete an entry and remove it from the index. */
-    async delete(collectionPath, slug) {
+    /**
+     * Delete an entry and remove it from the index. With `expectId`, only the entry of that content
+     * ID: another at the slug, or none, is `EntryGoneError`. `beforeDelete` runs under both of the
+     * delete's locks before anything changes, and throwing refuses; `afterDelete` runs once it is
+     * gone, under them too.
+     */
+    async delete(collectionPath, slug, options = {}) {
         // Warm the index outside the lock (a full scan must not hold the entry lock)
         await this.idIndex();
         const collection = this.assertCollection(collectionPath);
@@ -1238,7 +1239,9 @@ export class ContentStore {
         const prePass = await this.buildPaths(collection, slug);
         if (prePass.existed)
             this.assertEntryTypeAvailable(collection, prePass.entryTypeName);
-        if (!prePass.existed) {
+        if (!prePass.existed || (options.expectId !== undefined && prePass.id !== options.expectId)) {
+            if (options.expectId !== undefined)
+                throw new EntryGoneError();
             // Nothing on disk for this slug -- no shared resource to lock on, and fs.unlink on the
             // freshly generated (necessarily nonexistent) path throws ENOENT, as callers expect.
             await fs.unlink(prePass.absolutePath);
@@ -1264,6 +1267,11 @@ export class ContentStore {
                         return RETRY_KEY;
                     }
                     const { absolutePath, relativePath } = inLock;
+                    if (options.expectId !== undefined &&
+                        (!inLock.existed || inLock.id !== options.expectId)) {
+                        throw new EntryGoneError();
+                    }
+                    await options.beforeDelete?.();
                     await fs.unlink(absolutePath);
                     // Remove from the LIVE index — lookup and mutation in one synchronous
                     // window, since a concurrent rebuild may swap instances across awaits.
@@ -1273,6 +1281,7 @@ export class ContentStore {
                         liveIndex.remove(id);
                     }
                     await this.recordOwnMutation(liveIndex);
+                    await options.afterDelete?.({ id: id ?? inLock.id });
                     return undefined;
                 });
                 if (outcome !== RETRY_KEY)
@@ -1283,6 +1292,103 @@ export class ContentStore {
             throw new ContentConflictError();
         });
     }
+    /**
+     * Puts back an entry deleted on this branch: `raw`, its file as the base holds it, verbatim,
+     * under its old slug, entry type and content ID, so references and comment threads find it
+     * again and the branch no longer differs from the base there.
+     *
+     * A create under write()'s locks and create-only guards that never replaces or relocates
+     * anything. It refuses with `ContentConflictError` while a file holds the slug, or the index
+     * or the target directory holds the ID: unlike write(), it has no index repair, so an ID
+     * found elsewhere is a moved entry, not a deleted one, and is left alone. The index is
+     * warmed outside the lock, as write() warms it, and rescanned under the lock only when the
+     * generation marker says another host changed the tree.
+     */
+    async restore(collectionPath, slug, entry, options = {}) {
+        await this.idIndex();
+        const collection = this.assertCollection(collectionPath);
+        if (!collection.entries?.some((e) => e.name === entry.entryTypeName)) {
+            throw new ContentStoreError(`Entry type '${entry.entryTypeName}' not found in collection`, 'NO_SCHEMA_ITEM');
+        }
+        this.assertEntryTypeAvailable(collection, entry.entryTypeName);
+        return this.withContentWriteExclusion(async () => {
+            await options.beforeWrite?.();
+            // Every content write and every git or sync change to the tree bumps the marker
+            // (content-index-generation.ts), so a marker that still matches the index's means the
+            // index is current. Read here unthrottled, unlike idIndex()'s own probe; a rescan holds no
+            // entry lock, which it must not.
+            if ((await readContentIndexGeneration(this.root)) !== this.loadedDiskGeneration) {
+                this.invalidateIndex();
+            }
+            await this.idIndex();
+            return withLock(this.createLockKey(collection, slug), async () => {
+                // The ID first: an entry already back at its own slug is this one, not another.
+                const target = await this.buildPaths(collection, slug, {
+                    existingId: entry.id,
+                    entryTypeName: entry.entryTypeName,
+                });
+                const dir = path.dirname(target.absolutePath);
+                const liveIndex = this._idIndex;
+                if (liveIndex.findById(entry.id) ||
+                    liveIndex.getDuplicateFor(entry.id) ||
+                    (await this.findEntryPathsById(dir, entry.id)).length > 0) {
+                    throw new ContentConflictError(RESTORE_ID_TAKEN_MESSAGE);
+                }
+                if ((await this.buildPaths(collection, slug)).existed) {
+                    throw new ContentConflictError(RESTORE_SLUG_TAKEN_MESSAGE);
+                }
+                // [SLUG] and [URL], as write() checks a create.
+                const routable = parseSlug(target.slug);
+                if (!routable.ok) {
+                    throw new ContentStoreError(`Cannot restore entry "${target.slug}": ${routable.error}.`, 'VALIDATION');
+                }
+                await this.assertUrlPathAvailable(dir, target.slug);
+                await fs.mkdir(dir, { recursive: true });
+                await atomicWriteFile(target.absolutePath, entry.raw);
+                // The live index, looked up and changed with no await between: a rebuild since the check
+                // above may have swapped in one that already scanned the restored file.
+                const index = this._idIndex;
+                if (!index.findById(entry.id)) {
+                    index.add({
+                        type: 'entry',
+                        relativePath: target.relativePath,
+                        collection: collectionPath,
+                        slug,
+                    });
+                }
+                await this.recordOwnMutation(index);
+                await options.afterWrite?.();
+                return { relativePath: target.relativePath };
+            });
+        });
+    }
+    /**
+     * Replace the file of entry `id`, at `slug` in `collectionPath`, with `raw`, verbatim, under
+     * write()'s locks; `beforeWrite` runs under them first, and throwing refuses, and `afterWrite`
+     * after. For a file no parse can be trusted with, so nothing is re-serialised. `EntryGoneError`
+     * when no file of that id is there.
+     */
+    async replaceRaw(collectionPath, slug, entry, options = {}) {
+        await this.idIndex();
+        const collection = this.assertCollection(collectionPath);
+        const prePass = await this.buildPaths(collection, slug);
+        if (!prePass.existed || prePass.id !== entry.id)
+            throw new EntryGoneError();
+        this.assertEntryTypeAvailable(collection, prePass.entryTypeName);
+        const lockKey = this.entryLockKey(collection, slug, prePass);
+        return this.withContentWriteExclusion(() => withLock(lockKey, async () => {
+            const inLock = await this.buildPaths(collection, slug);
+            if (!inLock.existed || inLock.id !== entry.id)
+                throw new EntryGoneError();
+            if (this.entryLockKey(collection, slug, inLock) !== lockKey) {
+                throw new ContentConflictError();
+            }
+            await options.beforeWrite?.();
+            await atomicWriteFile(inLock.absolutePath, entry.raw);
+            await this.recordOwnMutation(this._idIndex);
+            await options.afterWrite?.();
+        }));
+    }
     /**
      * Rename an entry by changing its slug (middle segment of filename).
      * Entry filename pattern: {entryTypeName}.{slug}.{id}.{ext}

package/dist/editor/BranchManager.d.ts

@@ -4,6 +4,7 @@ import type { BranchHold, ConflictStatus, PullRequestState, SyncStatus } from '.
 import type { CommentThread } from '../comment-store.js';
 import type { UserSearchResult } from '../auth/types.js';
 import type { CreateRefusal } from './hooks/create-branch-request.js';
+import type { BaseUpdateControl } from './base-update-wait.js';
 /** @internal Exported for tests. */
 export interface BranchSummary {
     name: string;
@@ -33,7 +34,7 @@ export interface BranchSummary {
     syncFailureReason?: string;
     /** Whether this branch has unresolved merge conflicts with the base branch */
     conflictStatus?: ConflictStatus;
-    /** ContentIds of entries where --theirs was applied during rebase; cleared on clean rebase */
+    /** ContentIds of entries with a merge conflict a person has yet to resolve */
     conflictFiles?: string[];
     /** What is stuck and needs a person (api/branch.ts). */
     hold?: BranchHold;
@@ -82,6 +83,8 @@ export interface BranchManagerProps {
     currentBranchName?: string;
     /** Why the open branch's Submit or Withdraw must wait, such as a Save all still writing it. */
     currentWorkflowBlockedReason?: string;
+    /** "Get latest changes" for the open branch, when it applies (hooks/useBaseUpdate.tsx). */
+    currentBaseUpdate?: BaseUpdateControl;
     /** Opens on the new-branch form, its name field focused, as New branch… in the branch bar asks. */
     startCreating?: boolean;
     onSelect?: (name: string) => void;

package/dist/editor/BranchManager.js

@@ -17,6 +17,7 @@ import { HOLD_BADGE, SYNC_FAILED_IN_REVIEW_NOTE, branchHoldMessage, endSentence,
 import { TooltipDetail } from './components/TooltipDetail.js';
 import { branchAddress, displayBranchName } from './branch-names.js';
 import { CLOSED_PULL_REQUEST_REASON, DELETE_NEEDS_ADMIN_REASON, EDITOR_ACTIONS, rewrittenSubmitReason, UNFINISHED_SUBMIT_APPROVE_REASON, } from './copy.js';
+import { GetLatestChangesButton } from './components/GetLatestChangesButton.js';
 import { isReviewerOfOthersReview } from '../authorization/review-role.js';
 import { SYSTEM_USER_ID } from '../system-users.js';
 /**
@@ -149,7 +150,7 @@ const WRAP_ANYWHERE = { overflowWrap: 'anywhere' };
  * 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, onApprove, onRequestChanges, onArchive, onDelete, onGetUserMetadata, onGetOwnerMetadata = onGetUserMetadata, }) => {
+const BranchCard = ({ branch: b, isCurrent, workflowBlockedReason, baseUpdate, user, onSelect, onSubmit, onWithdraw, onApprove, onRequestChanges, onArchive, onDelete, onGetUserMetadata, onGetOwnerMetadata = onGetUserMetadata, }) => {
     const statusBadge = branchStatusPresentation(b.status, b.isProtected);
     const perms = getBranchPermissions(b, user);
     const userIsAdmin = isAdmin(user?.groups);
@@ -194,7 +195,10 @@ const BranchCard = ({ branch: b, isCurrent, workflowBlockedReason, user, onSelec
     // Two visible actions, the long "Withdraw from review", or any action beside a hold's line would
     // crowd the details at the drawer's width, so they take a row below. Open and Review stay beside
     // the title.
-    const actionRow = !!secondary || primary?.label === EDITOR_ACTIONS.withdrawFromReview || (!!primary && !!b.hold);
+    const actionRow = !!secondary ||
+        !!baseUpdate ||
+        primary?.label === EDITOR_ACTIONS.withdrawFromReview ||
+        (!!primary && !!b.hold);
     const archive = heldBack(userIsAdmin && b.status !== 'archived' && b.pullRequestState === 'closed'
         ? {
             label: EDITOR_ACTIONS.archiveBranch,
@@ -227,7 +231,7 @@ const BranchCard = ({ branch: b, isCurrent, workflowBlockedReason, user, onSelec
                                                                 b.hold?.kind === 'rewritten-at-merge') &&
                                                                 !userIsAdmin
                                                                 ? DELETE_NEEDS_ADMIN_REASON
-                                                                : 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 })] }))] }));
+                                                                : 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: [baseUpdate && (_jsx(GetLatestChangesButton, { control: baseUpdate, testId: `get-latest-changes-button-${b.name}` })), secondary && _jsx(CardActionButton, { action: secondary }), primary && _jsx(CardActionButton, { action: primary })] }))] }));
 };
 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)
@@ -281,7 +285,7 @@ const ArchivedSection = ({ count, open, onToggle, forcedOpen, children }) => {
                 // Inset and content-width, or the ScrollArea clips the focus ring.
                 style: { alignSelf: 'flex-start', outlineOffset: -2 }, "data-testid": "archived-branches-toggle", children: _jsxs(Group, { gap: 4, wrap: "nowrap", children: [_jsx(Chevron, { size: 16, "aria-hidden": true }), _jsxs(Text, { size: "sm", fw: 600, children: ["Archived (", count, ")"] })] }) })), open && children] }));
 };
-export const BranchManager = ({ branches, mode, user, currentBranchName, currentWorkflowBlockedReason, startCreating = false, onSelect, onBeforeCreate, onCreate, onDelete, onSubmit, onWithdraw, onApprove, onRequestChanges, onArchive, onClose: _, comments = [], currentUserId, canResolve = false, onAddComment, onResolveThread, highlightThreadId, onGetUserMetadata, onGetOwnerMetadata, onGetCommentUserMetadata, }) => {
+export const BranchManager = ({ branches, mode, user, currentBranchName, currentWorkflowBlockedReason, currentBaseUpdate, startCreating = false, onSelect, onBeforeCreate, onCreate, onDelete, onSubmit, onWithdraw, onApprove, onRequestChanges, onArchive, 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('');
@@ -359,7 +363,7 @@ export const BranchManager = ({ branches, mode, user, currentBranchName, current
         // 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), onArchive: act(onArchive), onDelete: act(onDelete), onGetUserMetadata: onGetUserMetadata, onGetOwnerMetadata: onGetOwnerMetadata }, b.name));
+        return (_jsx(BranchCard, { branch: b, isCurrent: b.name === currentBranchName, workflowBlockedReason: b.name === currentBranchName ? currentWorkflowBlockedReason : undefined, baseUpdate: b.name === currentBranchName ? currentBaseUpdate : undefined, user: user, onSelect: act(onSelect), onSubmit: act(onSubmit), onWithdraw: act(onWithdraw), onApprove: act(onApprove), onRequestChanges: act(onRequestChanges), onArchive: act(onArchive), onDelete: act(onDelete), onGetUserMetadata: onGetUserMetadata, onGetOwnerMetadata: onGetOwnerMetadata }, b.name));
     };
     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: () => {