canopycms 0.12.1 → 0.13.0

package/dist/api/branch-review.d.ts

@@ -1,9 +1,17 @@
 import { z } from 'zod';
 import { type BranchListItemResponse } from './branch.js';
-export interface RequestChangesBody {
+/** What a verdict carries besides the branch: the commit the reviewer's page showed. */
+interface ReviewedHead {
+    /** The listing's `headSha` (api/branch.ts) the page was showing. */
+    headSha?: string;
+}
+export interface RequestChangesBody extends ReviewedHead {
     /** Saved as a branch comment; trimmed before its length is checked, and ignored when empty. */
     note?: string;
 }
+export type ApproveBody = ReviewedHead;
+/** @internal Exported for tests. */
+export declare const BRANCH_MOVED_ERROR = "This branch changed since you opened it. Review the latest changes.";
 export declare const requestChanges: import("./route-builder.js").RouteDefinition<z.ZodObject<{
     branch: z.ZodType<import("../paths/index.js").BranchName, z.ZodTypeDef, import("../paths/index.js").BranchName>;
 }, "strip", z.ZodTypeAny, {
@@ -16,9 +24,12 @@ export declare const requestChanges: import("./route-builder.js").RouteDefinitio
     };
 }>, z.ZodOptional<z.ZodObject<{
     note: z.ZodOptional<z.ZodString>;
+    headSha: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
+    headSha?: string | undefined;
     note?: string | undefined;
 }, {
+    headSha?: string | undefined;
     note?: string | undefined;
 }>>, BranchListItemResponse>;
 export declare const approveBranch: import("./route-builder.js").RouteDefinition<z.ZodObject<{
@@ -31,4 +42,11 @@ export declare const approveBranch: import("./route-builder.js").RouteDefinition
     branch: string & {
         readonly __brand: "BranchName";
     };
-}>, undefined, BranchListItemResponse>;
+}>, z.ZodOptional<z.ZodObject<{
+    headSha: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    headSha?: string | undefined;
+}, {
+    headSha?: string | undefined;
+}>>, BranchListItemResponse>;
+export {};

package/dist/api/branch-review.js

@@ -12,10 +12,67 @@ import { getErrorMessage } from '../utils/error.js';
 import { REQUEST_CHANGES_NOTE_MAX_LENGTH } from '../authorization/review-role.js';
 import { getBranchProtection, isAdmin } from '../authorization/index.js';
 import { sanitizeDisplayName } from '../submission-attribution.js';
-/** Optional on the wire: a bodiless request means no note. */
+const FULL_SHA = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
+/** Optional on the wire, so a request without one gets {@link BRANCH_MOVED_ERROR}, not a 400. */
+const headShaSchema = z.string().regex(FULL_SHA).optional();
 const requestChangesBodySchema = z
-    .object({ note: z.string().trim().max(REQUEST_CHANGES_NOTE_MAX_LENGTH).optional() })
+    .object({
+    note: z.string().trim().max(REQUEST_CHANGES_NOTE_MAX_LENGTH).optional(),
+    headSha: headShaSchema,
+})
     .optional();
+const approveBodySchema = z.object({ headSha: headShaSchema }).optional();
+/** @internal Exported for tests. */
+export const BRANCH_MOVED_ERROR = 'This branch changed since you opened it. Review the latest changes.';
+const branchMoved = {
+    ok: false,
+    status: 409,
+    code: 'BRANCH_MOVED',
+    error: BRANCH_MOVED_ERROR,
+};
+class BranchMovedError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'BranchMovedError';
+    }
+}
+class HeadUnreadableError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'HeadUnreadableError';
+    }
+}
+const headUnreadable = {
+    ok: false,
+    status: 503,
+    error: "Couldn't read this branch right now. Try again in a moment.",
+};
+/**
+ * Throws unless the clone's HEAD is `sent`, the commit the reviewer saw, and returns it. A request
+ * naming none, from a page loaded before the editor sent one, is refused: what it showed is
+ * unknown. Called under the content-write lock: a submit and the worker move HEAD only while
+ * holding it (docs/concurrency.md, "Who takes it"), so the head checked is the one the verdict is
+ * written against.
+ */
+const assertReviewedHead = async (ctx, { branch, branchRoot }, sent) => {
+    if (!sent)
+        throw new BranchMovedError();
+    let head;
+    try {
+        const git = ctx.services.createGitManagerFor(branchRoot, { baseBranch: branch.baseBranch });
+        head = await git.headSha();
+        // A git that exits quietly answers nothing, which is no head at all.
+        if (!FULL_SHA.test(head))
+            throw new Error(`no commit in its answer (${head.length} chars)`);
+    }
+    catch (err) {
+        console.error(`CanopyCMS: Could not read the head of ${branch.name}:`, getErrorMessage(err));
+        throw new HeadUnreadableError();
+    }
+    if (head !== sent)
+        throw new BranchMovedError();
+    return sent;
+};
 const NOTE_NOT_SAVED_WARNING = "Changes were requested, but your note couldn't be saved.";
 /**
  * The 409 for a branch that left review before this request arrived, because the reviewer's page
@@ -43,38 +100,62 @@ const approveConflict = (status) => ({
  * The verdict `user` gives. The reviewer guard admits only authenticated users, and the record is
  * always written, so a new verdict replaces whatever the last one left.
  */
-const reviewBy = (user, state) => ({
+const reviewBy = (user, state, commit) => ({
     state,
     by: {
         userId: user.userId,
         name: user.type === 'authenticated' ? sanitizeDisplayName(user.name) : undefined,
     },
     at: new Date().toISOString(),
+    commit,
 });
 const requestChangesHandler = async (gc, ctx, req, _params, body) => {
     const { branchContext } = gc;
     if (!canRequestChangesFrom(branchContext.branch.status)) {
         return requestChangesConflict(branchContext.branch.status);
     }
-    await syncConvertToDraft(ctx, branchContext);
+    const headSha = body?.headSha;
     const meta = getBranchMetadataFileManager(branchContext.branchRoot, branchContext.baseRoot);
     // The status the guard read can be stale by now, so the save checks the status on disk, in the
-    // same step that writes. A branch that left review meanwhile is refused, and the draft
-    // conversion above is left as it is: withdraw converts the pull request to a draft too, and a
-    // merged one cannot be converted.
+    // same step that writes, and the head under the lock with it. A branch that left review or moved
+    // meanwhile is refused before the pull request is touched.
     let found;
-    const updated = await meta.saveIf({
-        branch: {
-            name: branchContext.branch.name,
-            status: 'editing',
-            review: reviewBy(req.user, 'changes-requested'),
-        },
-    }, (existing) => {
-        found = existing?.branch.status;
-        return canRequestChangesFrom(found);
-    });
+    let updated;
+    try {
+        updated = await withContentWriteLock(branchContext.branchRoot, async () => {
+            const commit = await assertReviewedHead(ctx, branchContext, headSha);
+            return meta.saveIf({
+                branch: {
+                    name: branchContext.branch.name,
+                    status: 'editing',
+                    review: reviewBy(req.user, 'changes-requested', commit),
+                },
+            }, (existing) => {
+                found = existing?.branch.status;
+                return canRequestChangesFrom(found);
+            });
+        });
+    }
+    catch (err) {
+        if (err instanceof BranchMovedError)
+            return branchMoved;
+        if (err instanceof HeadUnreadableError)
+            return headUnreadable;
+        if (err instanceof ContentWriteLockBusyError) {
+            return {
+                ok: false,
+                status: 409,
+                error: err.outcome === 'not-run'
+                    ? "This branch is being synced, so changes weren't requested. Try again in a moment."
+                    : 'This branch was being synced while changes were requested, so the request may not have been recorded. Refresh to check.',
+            };
+        }
+        throw err;
+    }
     if (!updated)
         return requestChangesConflict(found);
+    // Best-effort: syncConvertToDraft only logs a failure.
+    await syncConvertToDraft(ctx, { ...branchContext, branch: updated.branch });
     // The note is written after the status change so a failed write never blocks the branch from
     // returning to editing; the caller is warned instead.
     const note = body?.note;
@@ -106,8 +187,9 @@ const requestChangesHandler = async (gc, ctx, req, _params, body) => {
         },
     };
 };
-const approveBranchHandler = async (gc, ctx, req, _params) => {
+const approveBranchHandler = async (gc, ctx, req, _params, body) => {
     const { branchContext } = gc;
+    const headSha = body?.headSha;
     // Approve is a CanopyCMS status only. The CMS authors its pull requests and GitHub refuses
     // an author's approval review, so nothing is sent to GitHub.
     if (branchContext.branch.createdBy === req.user.userId) {
@@ -132,22 +214,23 @@ const approveBranchHandler = async (gc, ctx, req, _params) => {
         };
     }
     const meta = getBranchMetadataFileManager(branchContext.branchRoot, branchContext.baseRoot);
-    // As for request changes, the status on disk decides, in the step that writes. So does an
-    // unfinished submit: what's approved may not be what the pull request holds. So do conflicts: a
-    // merge of GitHub's commits can record some on a branch in review, under the content-write lock
-    // held here, so none lands between the check and the write.
+    // As for request changes, the status on disk and the head decide, in the step that writes. So
+    // does an unfinished submit: what's approved may not be what the pull request holds. So do
+    // conflicts: a merge of GitHub's commits can record some on a branch in review, under the
+    // content-write lock held here, so none lands between the check and the write.
     let found;
     let unfinished = false;
     let notQueued = false;
     let updated;
     try {
         updated = await withContentWriteLock(branchContext.branchRoot, async () => {
+            const commit = await assertReviewedHead(ctx, branchContext, headSha);
             await assertNoOpenConflicts(branchContext.branchRoot);
             return meta.saveIf({
                 branch: {
                     name: branchContext.branch.name,
                     status: 'approved',
-                    review: reviewBy(req.user, 'approved'),
+                    review: reviewBy(req.user, 'approved', commit),
                 },
             }, (existing) => {
                 found = existing?.branch.status;
@@ -158,6 +241,10 @@ const approveBranchHandler = async (gc, ctx, req, _params) => {
         });
     }
     catch (err) {
+        if (err instanceof BranchMovedError)
+            return branchMoved;
+        if (err instanceof HeadUnreadableError)
+            return headUnreadable;
         if (err instanceof OpenMergeConflictsError) {
             return {
                 ok: false,
@@ -231,6 +318,8 @@ export const approveBranch = defineEndpoint({
     method: 'POST',
     path: '/:branch/approve',
     params: branchParamSchema,
+    body: approveBodySchema,
+    bodyType: 'ApproveBody',
     responseType: 'BranchListItemResponse',
     response: {},
     defaultMockData: {

package/dist/api/branch-status.d.ts

@@ -3,7 +3,7 @@ import type { ApiResponse } from './types.js';
 import { type BranchListItem, type BranchListItemResponse } from './branch.js';
 import type { StampedEntry } from '../stamp-on-publish.js';
 export type { BranchMergeResponse } from './branch-merge.js';
-export type { RequestChangesBody } from './branch-review.js';
+export type { ApproveBody, RequestChangesBody } from './branch-review.js';
 export type { UpdateFromBaseResponse } from './branch-update-from-base.js';
 /**
  * A submit's answer: the branch, plus the entries the submit stamped (stamp-on-publish.ts) when
@@ -98,9 +98,12 @@ export declare const WORKFLOW_ROUTES: {
         };
     }>, z.ZodOptional<z.ZodObject<{
         note: z.ZodOptional<z.ZodString>;
+        headSha: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
+        headSha?: string | undefined;
         note?: string | undefined;
     }, {
+        headSha?: string | undefined;
         note?: string | undefined;
     }>>, BranchListItemResponse>;
     readonly approve: import("./route-builder.js").RouteDefinition<z.ZodObject<{
@@ -113,7 +116,13 @@ export declare const WORKFLOW_ROUTES: {
         branch: string & {
             readonly __brand: "BranchName";
         };
-    }>, undefined, BranchListItemResponse>;
+    }>, z.ZodOptional<z.ZodObject<{
+        headSha: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        headSha?: string | undefined;
+    }, {
+        headSha?: string | undefined;
+    }>>, BranchListItemResponse>;
     readonly markMerged: import("./route-builder.js").RouteDefinition<z.ZodObject<{
         branch: z.ZodType<import("../paths/index.js").BranchName, z.ZodTypeDef, import("../paths/index.js").BranchName>;
     }, "strip", z.ZodTypeAny, {

package/dist/api/branch-status.js

@@ -208,8 +208,9 @@ const submitBranchForMergeHandler = async (gc, ctx, req, _params, body) => {
             status: 'submitted',
             submittedAt,
             ...pushed,
-            // Only a request-derived URL: config.editorUrl is read live by every later re-render.
-            ...(editorUrl && !ctx.services.config.editorUrl ? { editorUrl } : {}),
+            // config.editorUrl, when set, still wins in every later re-render here; the worker, which
+            // has no config, links the conflicts status with this.
+            ...(editorUrl ? { editorUrl } : {}),
             syncFailureReason: prResult.syncFailureReason,
             pullRequestUrl: prResult.prUrl ?? branchContext.branch.pullRequestUrl,
             pullRequestNumber: prResult.prNumber ?? branchContext.branch.pullRequestNumber,

package/dist/api/branch-update-from-base.js

@@ -3,7 +3,7 @@ import { toBranchListItem } from './branch.js';
 import { defineEndpoint } from './route-builder.js';
 import { canPerformWorkflowAction, getBranchProtection } from '../authorization/index.js';
 import { BranchMetadataFileManager, getBranchMetadataFileManager } from '../branch-metadata.js';
-import { clientOperatingStrategy } from '../operating-mode/index.js';
+import { clientOperatingStrategy, operatingStrategy } from '../operating-mode/index.js';
 import { enqueueTask, listTasks } from '../task-queue/cms-task-queue.js';
 import { getTaskQueueDir } from '../task-queue/task-queue-config.js';
 import { BASE_UPDATE_GIVE_UP_MS, BASE_UPDATE_REQUEST_INTERVAL_MS, SYNC_BRANCH_ACTION, isBaseUpdatePending, } from '../base-update.js';
@@ -17,6 +17,9 @@ import { baseBranchOf } from '../utils/base-branch.js';
  *
  * The request is recorded on branch.json, which is what the worker answers, so a lost task or a
  * worker restart costs only the wait for its next regular cycle. The task only wakes it early.
+ * Where the mode runs no worker loop (operating-mode `baseUpdateRunsInRequest`), a new request runs
+ * the worker's merge itself and is answered before the response; one it joins is answered by the
+ * run that made it.
  * A request joins the last one, answering with its time: while that is unanswered, under
  * BASE_UPDATE_GIVE_UP_MS old and either under BASE_UPDATE_REQUEST_INTERVAL_MS old or still queued;
  * or once it was answered under BASE_UPDATE_REQUEST_INTERVAL_MS ago without failing. Anything
@@ -26,6 +29,7 @@ const updateFromBaseHandler = async (gc, ctx, req, _params) => {
     const { branchContext } = gc;
     const { config } = ctx.services;
     const { branch } = branchContext;
+    const runsInRequest = operatingStrategy(config.mode).baseUpdateRunsInRequest();
     if (!clientOperatingStrategy(config.mode).syncsBranchesWithBase()) {
         return {
             ok: false,
@@ -86,7 +90,8 @@ const updateFromBaseHandler = async (gc, ctx, req, _params) => {
         };
     }
     const taskDir = getTaskQueueDir(config);
-    const queued = (await listTasks(taskDir, 'pending', Number.MAX_SAFE_INTEGER)).some((t) => t.action === SYNC_BRANCH_ACTION && t.payload.branch === branch.name);
+    const queued = !runsInRequest &&
+        (await listTasks(taskDir, 'pending', Number.MAX_SAFE_INTEGER)).some((t) => t.action === SYNC_BRANCH_ACTION && t.payload.branch === branch.name);
     const now = Date.now();
     let requestedAt = new Date(now).toISOString();
     let joined = false;
@@ -105,9 +110,11 @@ const updateFromBaseHandler = async (gc, ctx, req, _params) => {
         const answer = existing.branch.lastBaseUpdate;
         const pending = isBaseUpdatePending(existing.branch);
         // An unanswered request is joined until the editor stops waiting on it. An answer under the
-        // interval old stands for a new click too, except a failure, whose Retry must ask again.
+        // interval old stands for a new click too, except a failure, whose Retry must ask again, and
+        // except where the request runs the merge itself, which costs no worker cycle.
         const joinsPending = pending && age < BASE_UPDATE_GIVE_UP_MS && (queued || age < BASE_UPDATE_REQUEST_INTERVAL_MS);
-        const answeredRecently = !pending &&
+        const answeredRecently = !runsInRequest &&
+            !pending &&
             answer !== undefined &&
             answer.outcome !== 'failed' &&
             now - Date.parse(answer.at) < BASE_UPDATE_REQUEST_INTERVAL_MS;
@@ -127,12 +134,56 @@ const updateFromBaseHandler = async (gc, ctx, req, _params) => {
                 : "This branch can't be edited, so it can't get the latest changes.",
         };
     }
-    const current = saved ?? (await BranchMetadataFileManager.loadOnly(branchContext.branchRoot));
+    let current = saved ?? (await BranchMetadataFileManager.loadOnly(branchContext.branchRoot));
     if (current?.branch.name !== branch.name) {
         return { ok: false, status: 404, error: 'This branch no longer exists.' };
     }
+    // A joined request is answered by the run that made it.
+    if (runsInRequest && !joined) {
+        // Answered here where the run couldn't, as nothing else would: an open request holds the form
+        // read-only.
+        const answerFailed = () => meta
+            .update((existing) => existing?.branch.name === branch.name &&
+            existing.branch.baseUpdateRequestedAt === requestedAt &&
+            isBaseUpdatePending(existing.branch)
+            ? { branch: { lastBaseUpdate: { at: requestedAt, outcome: 'failed' } } }
+            : null, { keepUpdatedAt: true })
+            .catch(() => undefined);
+        let run;
+        try {
+            run = await ctx.services.runBaseUpdateNow(branchContext);
+        }
+        catch (err) {
+            console.error(`CanopyCMS: Could not bring the latest changes into ${branch.name}:`, redactCredentials(getErrorMessage(err)));
+            await answerFailed();
+            return {
+                ok: false,
+                status: 500,
+                error: "The latest changes couldn't be added. Your work is safe.",
+            };
+        }
+        if (run === 'other-remote') {
+            await answerFailed();
+            return {
+                ok: false,
+                status: 409,
+                error: "This branch uses a git remote other than the local one, so its latest changes can't be brought in here.",
+            };
+        }
+        if (run === 'busy') {
+            return {
+                ok: false,
+                status: 409,
+                error: "This branch is busy with a save or another update, so the latest changes weren't added. Try again in a moment.",
+            };
+        }
+        current = await BranchMetadataFileManager.loadOnly(branchContext.branchRoot);
+        if (current?.branch.name !== branch.name) {
+            return { ok: false, status: 404, error: 'This branch no longer exists.' };
+        }
+    }
     // A wake-up already queued serves the new request too.
-    if (!joined && !queued) {
+    if (!runsInRequest && !joined && !queued) {
         try {
             await enqueueTask(taskDir, { action: SYNC_BRANCH_ACTION, payload: { branch: branch.name } });
         }

package/dist/api/branch.d.ts

@@ -60,6 +60,11 @@ export interface BranchListItem extends Omit<BranchMetadata, 'review' | 'keptOve
         users: number;
         groups: number;
     };
+    /**
+     * The commit a branch in review held when it was listed, which Approve and Request changes send
+     * back to say what the reviewer saw (api/branch-review.ts). Only on a listing.
+     */
+    headSha?: string;
 }
 /**
  * Response type for branch creation and the workflow transitions. Carries the

package/dist/api/branch.js

@@ -11,7 +11,7 @@ import { clientOperatingStrategy } from '../operating-mode/index.js';
 import { DELETE_NEEDS_ADMIN_REASON } from '../editor/copy.js';
 import { getErrorMessage } from '../utils/error.js';
 import { filePathExists } from '../utils/fs.js';
-import { isNetworkRemoteUrl } from '../utils/git.js';
+import { isNetworkRemoteUrl, readHeadCommitFromFiles } from '../utils/git.js';
 import { parseCreatedBranchName, sanitizeBranchName, isSettingsBranchName } from '../paths/index.js';
 import { GitManager } from '../git-manager.js';
 import { syncDeleteRemoteBranch } from './github-sync.js';
@@ -521,17 +521,42 @@ const branchListResponse = async (ctx, req, branches, defaultBranch) => {
             console.error('CanopyCMS: Failed to look up branch owners:', getErrorMessage(error));
         }
     }
+    const heads = await Promise.all(branches.map((context) => reviewedHead(ctx, context)));
     return {
         ok: true,
         status: 200,
         data: {
-            branches: branches.map((context) => toBranchListItem(ctx.services.config, context.branch, req.user)),
+            branches: branches.map((context, i) => {
+                const item = toBranchListItem(ctx.services.config, context.branch, req.user);
+                const headSha = heads[i];
+                return headSha ? { ...item, headSha } : item;
+            }),
             defaultBranch,
             users,
             serverTime: Date.now(),
         },
     };
 };
+/**
+ * A branch in review's head commit, from the clone's files, so a listing of many spawns no git;
+ * git reads only a layout the files can't answer. Undefined when unreadable: the editor then has
+ * nothing to send, and the review is refused until a listing reads it.
+ */
+const reviewedHead = async (ctx, { branch, branchRoot }) => {
+    if (branch.status !== 'submitted' && branch.status !== 'approved')
+        return undefined;
+    try {
+        const fromFiles = await readHeadCommitFromFiles(branchRoot);
+        if (fromFiles)
+            return fromFiles;
+        const git = ctx.services.createGitManagerFor(branchRoot, { baseBranch: branch.baseBranch });
+        return await git.headSha();
+    }
+    catch (err) {
+        console.error(`CanopyCMS: Could not read the head of ${branch.name}:`, getErrorMessage(err));
+        return undefined;
+    }
+};
 /** A person's delete, as deletion by age never does, can take commits only the branch still has. */
 const mayHoldLostCommits = (branch) => branch.unpublishedAtMerge === true ||
     (branch.status === 'archived' && branch.rewrittenOnGitHub !== undefined);

package/dist/api/client.d.ts

@@ -12,7 +12,7 @@ import type { BranchDeleteResponse, BranchListItemResponse, BranchListResponse,
 import type { BranchChangesResponse } from './branch-changes.js';
 import type { BranchEntryChangeResponse, RestoreEntryBody, RestoreEntryResponse } from './branch-entry-changes.js';
 import type { EntryConflictResponse, MergeConflictsResponse, ReleaseConflictsHoldResponse, ResolveEntryConflictBody, ResolveEntryConflictResponse } from './merge-conflicts.js';
-import type { BranchMergeResponse, RequestChangesBody, SubmitBranchBody, SubmitBranchResponse, UpdateFromBaseResponse } from './branch-status.js';
+import type { ApproveBody, BranchMergeResponse, RequestChangesBody, SubmitBranchBody, SubmitBranchResponse, UpdateFromBaseResponse } from './branch-status.js';
 import type { AdminDeleteTaskResponse, AdminRetryTaskResponse, AdminStatusResponse, AdminTasksResponse, BranchHealthResponse, DeleteArchivedBranchesBody, DeleteArchivedBranchesResponse, DismissUnpublishedResponse, PurgeBranchDirResponse, RepairBranchDirResponse, RepairContentDuplicatesResponse } from './admin.js';
 import type { AddCommentBody, AddCommentResponse, CommentsResponse, ResolveCommentResponse } from './comments.js';
 import type { ContentReadResponse, ContentWriteResponse, ReferenceValidationResponse, RenameEntryBody, RenameEntryResponse, ValidateReferencesBody, WriteContentBody } from './content.js';
@@ -114,7 +114,7 @@ export declare class CanopyApiClient {
         /** POST /:branch/request-changes */
         requestChanges: (params: Record<string, string>, body: RequestChangesBody, options?: RequestOptions) => Promise<BranchListItemResponse>;
         /** POST /:branch/approve */
-        approve: (params: Record<string, string>, options?: RequestOptions) => Promise<BranchListItemResponse>;
+        approve: (params: Record<string, string>, body: ApproveBody, options?: RequestOptions) => Promise<BranchListItemResponse>;
         /** POST /:branch/mark-merged */
         markMerged: (params: Record<string, string>, options?: RequestOptions) => Promise<BranchMergeResponse>;
         /** POST /:branch/archive */

package/dist/api/client.js

@@ -87,8 +87,8 @@ export class CanopyApiClient {
                 return this.request('POST', this.buildPath('/:branch/request-changes', params), body, 'standard', options);
             },
             /** POST /:branch/approve */
-            approve: (params, options) => {
-                return this.request('POST', this.buildPath('/:branch/approve', params), undefined, 'standard', options);
+            approve: (params, body, options) => {
+                return this.request('POST', this.buildPath('/:branch/approve', params), body, 'standard', options);
             },
             /** POST /:branch/mark-merged */
             markMerged: (params, options) => {

package/dist/api/content.js

@@ -493,7 +493,7 @@ const writeContentHandler = async (gc, ctx, req, params, body) => {
             if (!id || resolving.length === 0)
                 return;
             try {
-                resolvedConflicts = await clearFieldConflicts(branchContext, id, resolving);
+                resolvedConflicts = await clearFieldConflicts(ctx.services.config, branchContext, id, resolving);
             }
             catch (err) {
                 canopyLogWarn(`CanopyCMS: saved ${logicalPathSegments.join('/')} but couldn't mark its conflicts resolved:`, getErrorMessage(err));

package/dist/api/merge-conflicts.d.ts

@@ -7,6 +7,7 @@
 import { z } from 'zod';
 import type { BranchContext } from '../types.js';
 import type { ApiResponse } from './types.js';
+import type { CanopyConfig } from '../config/index.js';
 import type { DataPathSegment } from '../editor/entry-diff.js';
 import type { FieldConflictKind, SidePaths } from '../merge/entry-merge.js';
 import { type MergeConflictKind, type MergeSides, type ResolvedFieldConflict } from '../merge-conflicts.js';
@@ -105,7 +106,7 @@ export declare const resolvedConflictsSchema: z.ZodArray<z.ZodObject<{
  * call once the entry is written, inside its locks: the record's own locks come after them in
  * the one lock order (docs/concurrency.md).
  */
-export declare function clearFieldConflicts(branchContext: BranchContext, contentId: string, resolved: readonly ResolvedFieldConflict[]): Promise<ResolvedFieldConflict[]>;
+export declare function clearFieldConflicts(config: Pick<CanopyConfig, 'mode'>, branchContext: BranchContext, contentId: string, resolved: readonly ResolvedFieldConflict[]): Promise<ResolvedFieldConflict[]>;
 declare const resolveBodySchema: z.ZodObject<{
     /** The content id the record names the entry by. */
     id: z.ZodType<ContentId, z.ZodTypeDef, ContentId>;
@@ -118,18 +119,22 @@ declare const resolveBodySchema: z.ZodObject<{
      * field by field with the latest version (`unreadable`).
      */
     choice: z.ZodEnum<["keep", "delete", "restore", "use-latest"]>;
+    /** The card promised the entry stays deleted: a `keep` is refused if it is in the tree now. */
+    entryGone: z.ZodOptional<z.ZodLiteral<true>>;
 }, "strip", z.ZodTypeAny, {
     id: string & {
         readonly __brand: "ContentId";
     };
     mergeSha: string;
     choice: "delete" | "restore" | "keep" | "use-latest";
+    entryGone?: true | undefined;
 }, {
     id: string & {
         readonly __brand: "ContentId";
     };
     mergeSha: string;
     choice: "delete" | "restore" | "keep" | "use-latest";
+    entryGone?: true | undefined;
 }>;
 export type ResolveEntryConflictBody = z.infer<typeof resolveBodySchema>;
 export type ReleaseConflictsHoldResponse = ApiResponse<{
@@ -209,18 +214,22 @@ export declare const MERGE_CONFLICT_ROUTES: {
          * field by field with the latest version (`unreadable`).
          */
         choice: z.ZodEnum<["keep", "delete", "restore", "use-latest"]>;
+        /** The card promised the entry stays deleted: a `keep` is refused if it is in the tree now. */
+        entryGone: z.ZodOptional<z.ZodLiteral<true>>;
     }, "strip", z.ZodTypeAny, {
         id: string & {
             readonly __brand: "ContentId";
         };
         mergeSha: string;
         choice: "delete" | "restore" | "keep" | "use-latest";
+        entryGone?: true | undefined;
     }, {
         id: string & {
             readonly __brand: "ContentId";
         };
         mergeSha: string;
         choice: "delete" | "restore" | "keep" | "use-latest";
+        entryGone?: true | undefined;
     }>, ResolveEntryConflictResponse>;
 };
 export {};