@agent-native/core 0.123.0 → 0.123.2

package/corpus/templates/content/actions/change-content-database-source-role.ts

@@ -22,6 +22,7 @@ import {
   ensureDatabaseSourceProperty,
   importBuilderCmsEntriesAsDatabaseItems,
   mapBuilderCmsEntriesToLocalItems,
+  mutateContentDatabaseSourceMetadata,
   resolveDatabaseForSourceMutation,
   seedMockSourceFields,
   seedMockSourceRows,
@@ -134,26 +135,26 @@ function sourceRole(source: SourceRecord): "primary" | "secondary" | null {
 }
 
 async function clearSourceFederation(sourceId: string, now: string) {
-  const db = getDb();
-  const [current] = await db
-    .select({ metadataJson: schema.contentDatabaseSources.metadataJson })
-    .from(schema.contentDatabaseSources)
-    .where(eq(schema.contentDatabaseSources.id, sourceId));
-  let metadata: Record<string, unknown> = {};
-  try {
-    const parsed = JSON.parse(current?.metadataJson ?? "{}") as unknown;
-    metadata =
-      parsed && typeof parsed === "object" && !Array.isArray(parsed)
-        ? (parsed as Record<string, unknown>)
-        : {};
-  } catch {
-    metadata = {};
-  }
-  delete metadata.federation;
-  await db
-    .update(schema.contentDatabaseSources)
-    .set({ metadataJson: JSON.stringify(metadata), updatedAt: now })
-    .where(eq(schema.contentDatabaseSources.id, sourceId));
+  await mutateContentDatabaseSourceMetadata({
+    sourceId,
+    now,
+    buildPatch: (current) => {
+      let metadata: Record<string, unknown> = {};
+      try {
+        const parsed = JSON.parse(current.metadataJson ?? "{}") as unknown;
+        metadata =
+          parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? (parsed as Record<string, unknown>)
+            : {};
+      } catch {
+        metadata = {};
+      }
+      delete metadata.federation;
+      return { metadataJson: JSON.stringify(metadata) };
+    },
+    failureMessage:
+      "Source metadata changed repeatedly while clearing federation settings.",
+  });
 }
 
 async function removeRowsOwnedOnlyBySource(args: {

package/corpus/templates/content/actions/execute-builder-source-execution.ts

@@ -494,8 +494,12 @@ function livePreflightBlockMessage(args: {
   ) {
     return "Builder body changed since this diff was approved; refresh and re-review.";
   }
-  if (args.effect === "publish" && args.liveState.published !== "draft") {
-    return "Entry is already published.";
+  if (
+    args.effect === "publish" &&
+    args.liveState.published !== "draft" &&
+    args.liveState.published !== "published"
+  ) {
+    return "Builder publication state could not be verified; refresh and re-review.";
   }
   if (args.effect === "unpublish" && args.liveState.published !== "published") {
     return "Entry is not currently published.";
@@ -637,6 +641,7 @@ async function reconcileBuilderCmsWrite(args: {
 
 export function realExecutionDeps(
   sourceId?: string,
+  changeSetId?: string,
 ): ExecuteBuilderSourceExecutionDeps {
   return {
     now: () => new Date().toISOString(),
@@ -644,8 +649,39 @@ export function realExecutionDeps(
     assertEditor: async (database) => {
       await assertAccess("document", database.documentId, "editor");
     },
-    getSourceSnapshot: (database) =>
-      getContentDatabaseSourceSnapshotForWrite(database, sourceId),
+    getSourceSnapshot: async (database) => {
+      // Execution always targets one prepared change set. Loading every
+      // Builder-backed document (and every heavy body baseline) here can spend
+      // the hosted request budget before the provider write is dispatched.
+      // Resolve the durable prepared target first, then build the authoritative
+      // write snapshot for that document only. The unscoped fallback preserves
+      // compatibility for legacy/non-persisted callers.
+      const [target] = changeSetId
+        ? await getDb()
+            .select({
+              documentId: schema.contentDatabaseSourceChangeSets.documentId,
+              sourceId: schema.contentDatabaseSourceChangeSets.sourceId,
+            })
+            .from(schema.contentDatabaseSourceChangeSets)
+            .where(
+              sourceId
+                ? and(
+                    eq(schema.contentDatabaseSourceChangeSets.id, changeSetId),
+                    eq(
+                      schema.contentDatabaseSourceChangeSets.sourceId,
+                      sourceId,
+                    ),
+                  )
+                : eq(schema.contentDatabaseSourceChangeSets.id, changeSetId),
+            )
+            .limit(1)
+        : [];
+      return getContentDatabaseSourceSnapshotForWrite(
+        database,
+        sourceId ?? target?.sourceId,
+        target?.documentId ? [target.documentId] : undefined,
+      );
+    },
     getExecution: async (args) => {
       const [claim] = await getDb()
         .select({
@@ -1188,9 +1224,14 @@ export async function executeBuilderSourceExecutionWithDeps(
         now: deps.now(),
         attemptToken,
       });
-      throw writeResult.ambiguity
-        ? builderExecutionConflict(lastError)
-        : new Error(lastError);
+      if (writeResult.ambiguity) {
+        throw builderExecutionConflict(lastError);
+      }
+      const error = new Error(lastError) as Error & { statusCode?: number };
+      if (writeResult.status >= 400 && writeResult.status < 500) {
+        error.statusCode = writeResult.status;
+      }
+      throw error;
     }
 
     const reconciliationStartedAt = timing.start();
@@ -1297,7 +1338,7 @@ export default defineAction({
   ): Promise<ContentDatabaseResponse> => {
     return executeBuilderSourceExecutionWithDeps(
       args,
-      realExecutionDeps(args.sourceId),
+      realExecutionDeps(args.sourceId, args.changeSetId),
     );
   },
 });

package/corpus/templates/content/actions/materialize-builder-required-fields.ts

@@ -340,11 +340,6 @@ export default defineAction({
         ? { ...field, model: reference.model }
         : field;
     });
-    const enrichedMetadataJson = JSON.stringify({
-      ...parseMetadata(source.metadataJson),
-      builderModelFields: enrichedModelFields,
-    });
-
     await db.transaction(async (tx) => {
       const currentFields = await tx
         .select()
@@ -539,10 +534,48 @@ export default defineAction({
           );
         }
       }
-      await tx
-        .update(schema.contentDatabaseSources)
-        .set({ metadataJson: enrichedMetadataJson, updatedAt: now })
-        .where(eq(schema.contentDatabaseSources.id, source.id));
+      for (let attempt = 0; attempt < 5; attempt += 1) {
+        const [currentSource] = await tx
+          .select({
+            metadataJson: schema.contentDatabaseSources.metadataJson,
+          })
+          .from(schema.contentDatabaseSources)
+          .where(eq(schema.contentDatabaseSources.id, source.id))
+          .limit(1);
+        if (!currentSource) throw new Error("Builder source not found.");
+        const currentModelFields =
+          parseMetadata(currentSource.metadataJson).builderModelFields ?? [];
+        if (
+          JSON.stringify(currentModelFields) !== JSON.stringify(modelFields)
+        ) {
+          throw new Error(
+            "Builder model fields changed while required fields were being materialized. No fields were added.",
+          );
+        }
+        const nextMetadataJson = JSON.stringify({
+          ...parseMetadata(currentSource.metadataJson),
+          builderModelFields: enrichedModelFields,
+        });
+        const updated = await tx
+          .update(schema.contentDatabaseSources)
+          .set({ metadataJson: nextMetadataJson, updatedAt: now })
+          .where(
+            and(
+              eq(schema.contentDatabaseSources.id, source.id),
+              currentSource.metadataJson === null
+                ? isNull(schema.contentDatabaseSources.metadataJson)
+                : eq(
+                    schema.contentDatabaseSources.metadataJson,
+                    currentSource.metadataJson,
+                  ),
+            ),
+          )
+          .returning({ id: schema.contentDatabaseSources.id });
+        if (updated.length > 0) return;
+      }
+      throw new Error(
+        "Builder source metadata changed repeatedly while materializing required fields. No fields were added.",
+      );
     });
 
     return getContentDatabaseResponse(database.id, { limit: 100, offset: 0 });

package/corpus/templates/content/actions/prepare-builder-source-review.ts

@@ -1,5 +1,3 @@
-import { createHash } from "node:crypto";
-
 import { defineAction } from "@agent-native/core";
 import { getRequestUserEmail } from "@agent-native/core/server/request-context";
 import { assertAccess } from "@agent-native/core/sharing";
@@ -29,7 +27,9 @@ import { createBuilderSourceTiming } from "./_builder-source-timings.js";
 import {
   canRefreshLocallyBlockedBuilderReview,
   findOpenSourceChangeSet,
+  getContentDatabaseSourceSnapshotForReview,
   getContentDatabaseSourceSnapshotForWrite,
+  reviewedBuilderChangeSetRevisionId,
   resolveDatabaseForSourceMutation,
   serializeSourceRowRecord,
   sourceChangeSetKey,
@@ -125,10 +125,20 @@ function maxRisk(
 
 export function reviewPreparePriority(
   changeSet: ContentDatabaseSourceChangeSet,
+  source?: ContentDatabaseSource,
 ) {
-  if (changeSet.state === "pending_push") return 0;
-  if (changeSet.state === "staged_revision") return 1;
-  return 2;
+  const statePriority =
+    changeSet.state === "pending_push"
+      ? 0
+      : changeSet.state === "staged_revision"
+        ? 2
+        : 4;
+  const effectPriority =
+    source &&
+    resolveBuilderCmsWriteEffect({ source, changeSet }) === "create_draft"
+      ? 0
+      : 1;
+  return statePriority + effectPriority;
 }
 
 function parsePayload(value: string) {
@@ -142,40 +152,6 @@ function parsePayload(value: string) {
   }
 }
 
-function stableReviewValue(value: unknown): string {
-  if (value === null || typeof value !== "object") {
-    return JSON.stringify(value) ?? "undefined";
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map(stableReviewValue).join(",")}]`;
-  }
-  const record = value as Record<string, unknown>;
-  return `{${Object.keys(record)
-    .sort()
-    .map((key) => `${JSON.stringify(key)}:${stableReviewValue(record[key])}`)
-    .join(",")}}`;
-}
-
-function reviewedRevisionChangeSetId(
-  changeSet: ContentDatabaseSourceChangeSet,
-) {
-  const revision = createHash("sha256")
-    .update(
-      stableReviewValue({
-        databaseItemId: changeSet.databaseItemId,
-        documentId: changeSet.documentId,
-        kind: changeSet.kind,
-        direction: "outbound",
-        pushMode: changeSet.pushMode ?? "autosave",
-        fieldChanges: changeSet.fieldChanges,
-        bodyChange: changeSet.bodyChange,
-      }),
-    )
-    .digest("hex")
-    .slice(0, 16);
-  return `${changeSet.id}-revision-${revision}`;
-}
-
 function dryRunStatus(execution: ContentDatabaseSourceExecution | null) {
   const dryRun =
     execution?.payload.dryRun &&
@@ -360,6 +336,16 @@ async function approveChangeSetForReview(args: {
     updatedAt: args.now,
   });
 
+  const existingPayloadMatches = (row: {
+    fieldChangesJson: string;
+    bodyChangeJson: string | null;
+  }) =>
+    row.fieldChangesJson === JSON.stringify(args.changeSet.fieldChanges) &&
+    row.bodyChangeJson ===
+      (args.changeSet.bodyChange
+        ? JSON.stringify(args.changeSet.bodyChange)
+        : null);
+
   if (existing) {
     const existingExecutions = await db
       .select({
@@ -380,58 +366,64 @@ async function approveChangeSetForReview(args: {
     // Once dispatch may have happened, the approved payload is evidence. Keep
     // it byte-for-byte and let reconciliation decide what can happen next.
     if (existing.state === "approved" && !mayRefreshApprovedPayload) {
+      if (existingPayloadMatches(existing)) {
+        return {
+          id: existing.id,
+          state: "approved" as const,
+          changeSet: {
+            ...approvedChangeSet(existing.id),
+            summary: existing.summary,
+            fieldChanges: JSON.parse(
+              existing.fieldChangesJson,
+            ) as ContentDatabaseSourceChangeSet["fieldChanges"],
+            bodyChange: existing.bodyChangeJson
+              ? (JSON.parse(
+                  existing.bodyChangeJson,
+                ) as ContentDatabaseSourceChangeSet["bodyChange"])
+              : null,
+            updatedAt: existing.updatedAt,
+          },
+        };
+      }
+      // A failed, dispatched, or otherwise non-refreshable gate owns its exact
+      // approved payload forever. A materially different local edit must fall
+      // through to a new revision identity instead of aliasing that evidence.
+    } else {
+      await db
+        .update(schema.contentDatabaseSourceChangeSets)
+        .set({
+          direction: "outbound",
+          state: "approved",
+          pushMode: args.changeSet.pushMode ?? "autosave",
+          localOnly: 1,
+          summary,
+          fieldChangesJson: JSON.stringify(args.changeSet.fieldChanges),
+          bodyChangeJson: args.changeSet.bodyChange
+            ? JSON.stringify(args.changeSet.bodyChange)
+            : null,
+          updatedAt: args.now,
+        })
+        .where(eq(schema.contentDatabaseSourceChangeSets.id, existing.id));
+      if (existing.state !== "approved") {
+        await db.insert(schema.contentDatabaseSourceChangeReviews).values({
+          id: crypto.randomUUID(),
+          ownerEmail: args.ownerEmail,
+          sourceId: args.sourceId,
+          changeSetId: existing.id,
+          reviewerEmail: args.reviewerEmail,
+          decision: "approved",
+          stateFrom: existing.state,
+          stateTo: "approved",
+          note: "Approved by Builder update review.",
+          createdAt: args.now,
+        });
+      }
       return {
         id: existing.id,
         state: "approved" as const,
-        changeSet: {
-          ...approvedChangeSet(existing.id),
-          summary: existing.summary,
-          fieldChanges: JSON.parse(
-            existing.fieldChangesJson,
-          ) as ContentDatabaseSourceChangeSet["fieldChanges"],
-          bodyChange: existing.bodyChangeJson
-            ? (JSON.parse(
-                existing.bodyChangeJson,
-              ) as ContentDatabaseSourceChangeSet["bodyChange"])
-            : null,
-          updatedAt: existing.updatedAt,
-        },
+        changeSet: approvedChangeSet(existing.id),
       };
     }
-    await db
-      .update(schema.contentDatabaseSourceChangeSets)
-      .set({
-        direction: "outbound",
-        state: "approved",
-        pushMode: args.changeSet.pushMode ?? "autosave",
-        localOnly: 1,
-        summary,
-        fieldChangesJson: JSON.stringify(args.changeSet.fieldChanges),
-        bodyChangeJson: args.changeSet.bodyChange
-          ? JSON.stringify(args.changeSet.bodyChange)
-          : null,
-        updatedAt: args.now,
-      })
-      .where(eq(schema.contentDatabaseSourceChangeSets.id, existing.id));
-    if (existing.state !== "approved") {
-      await db.insert(schema.contentDatabaseSourceChangeReviews).values({
-        id: crypto.randomUUID(),
-        ownerEmail: args.ownerEmail,
-        sourceId: args.sourceId,
-        changeSetId: existing.id,
-        reviewerEmail: args.reviewerEmail,
-        decision: "approved",
-        stateFrom: existing.state,
-        stateTo: "approved",
-        note: "Approved by Builder update review.",
-        createdAt: args.now,
-      });
-    }
-    return {
-      id: existing.id,
-      state: "approved" as const,
-      changeSet: approvedChangeSet(existing.id),
-    };
   }
 
   // Local Builder diffs are materialized with deterministic IDs (for example,
@@ -442,7 +434,7 @@ async function approveChangeSetForReview(args: {
   // Bind a materially changed follow-up to a deterministic payload revision so
   // its review, execution, and idempotency evidence cannot alias the old row.
   const changeSetId = selectedExisting
-    ? reviewedRevisionChangeSetId(args.changeSet)
+    ? reviewedBuilderChangeSetRevisionId(args.changeSet)
     : args.changeSet.id;
   await db.insert(schema.contentDatabaseSourceChangeSets).values({
     id: changeSetId,
@@ -667,7 +659,7 @@ export default defineAction({
           const database = await resolveDatabaseForSourceMutation(args);
           if (!database) throw new Error("Database not found.");
           await assertAccess("document", database.documentId, "editor");
-          const snapshot = await getContentDatabaseSourceSnapshotForWrite(
+          const snapshot = await getContentDatabaseSourceSnapshotForReview(
             database,
             args.sourceId,
             args.documentIds,
@@ -716,7 +708,11 @@ export default defineAction({
         throw new Error("No pending local Builder changes to review.");
       }
       const reviewableChanges = [...allReviewableChanges]
-        .sort((a, b) => reviewPreparePriority(a) - reviewPreparePriority(b))
+        .sort(
+          (a, b) =>
+            reviewPreparePriority(a, snapshot) -
+            reviewPreparePriority(b, snapshot),
+        )
         .slice(0, BUILDER_SOURCE_REVIEW_PREPARE_LIMIT);
       const authoritativeSnapshot = await withAuthoritativeBuilderTargetRows({
         source: snapshot,
@@ -773,7 +769,9 @@ export default defineAction({
           reviewedSnapshot: await getContentDatabaseSourceSnapshotForWrite(
             database,
             args.sourceId,
-            args.documentIds,
+            reviewableChanges.every((changeSet) => changeSet.documentId)
+              ? reviewableChanges.map((changeSet) => changeSet.documentId!)
+              : args.documentIds,
           ),
           response: await getContentDatabaseResponse(database.id),
         }),

package/corpus/templates/content/actions/preview-builder-source-review.ts

@@ -7,7 +7,7 @@ import type {
   PreviewBuilderSourceReviewResponse,
 } from "../shared/api.js";
 import {
-  getContentDatabaseSourceSnapshotForWrite,
+  getContentDatabaseSourceSnapshotForReview,
   resolveDatabaseForSourceMutation,
 } from "./_database-source-utils.js";
 import {
@@ -45,7 +45,7 @@ export default defineAction({
       throw new Error("Select at least one Builder row before reviewing it.");
     }
 
-    const source = await getContentDatabaseSourceSnapshotForWrite(
+    const source = await getContentDatabaseSourceSnapshotForReview(
       database,
       args.sourceId,
       args.scope === "selected" ? args.documentIds : undefined,
@@ -72,7 +72,8 @@ export default defineAction({
     const changeSets = [...allReviewableChanges]
       .sort(
         (left, right) =>
-          reviewPreparePriority(left) - reviewPreparePriority(right),
+          reviewPreparePriority(left, source) -
+          reviewPreparePriority(right, source),
       )
       .slice(0, BUILDER_SOURCE_REVIEW_PREPARE_LIMIT);
     const authoritativeSource = await withAuthoritativeBuilderTargetRows({

package/corpus/templates/content/actions/refresh-content-database-source.ts

@@ -5,9 +5,11 @@ import { z } from "zod";
 import type { ContentDatabaseSourceStatusResponse } from "../shared/api.js";
 import { getContentDatabaseSourceAdapter } from "./_content-database-source-adapters.js";
 import {
+  claimBuilderCmsSourceRefresh,
   getContentDatabaseSourceSnapshot,
   getContentDatabaseSourceSnapshotById,
   getExistingSourceForWrite,
+  releaseBuilderCmsSourceRefreshClaim,
   resyncBuilderCmsSourceSnapshot,
   resyncMockSourceSnapshot,
   resolveDatabaseForSourceMutation,
@@ -33,6 +35,14 @@ export default defineAction({
       .describe(
         "For paginated Builder CMS or Notion sources, read a bounded multi-page snapshot in this refresh.",
       ),
+    expectedBuilderContinuationOffset: z
+      .number()
+      .int()
+      .nonnegative()
+      .optional()
+      .describe(
+        "Internal Builder pagination guard. Continue only when the persisted source still expects this offset.",
+      ),
   }),
   run: async (args): Promise<ContentDatabaseSourceStatusResponse> => {
     const database = await resolveDatabaseForSourceMutation(args);
@@ -50,15 +60,30 @@ export default defineAction({
     }
 
     const now = new Date().toISOString();
+    let skippedOverlappingBuilderRefresh = false;
     if (source.sourceType === "mock-local") {
       await resyncMockSourceSnapshot({ database, source, now });
     } else if (source.sourceType === "builder-cms") {
-      await resyncBuilderCmsSourceSnapshot({
-        database,
+      const claimedSource = await claimBuilderCmsSourceRefresh({
         source,
-        now,
-        runFullRefresh: args.fullRefresh === true,
+        expectedOffset: args.expectedBuilderContinuationOffset,
       });
+      skippedOverlappingBuilderRefresh = !claimedSource;
+      if (claimedSource) {
+        await resyncBuilderCmsSourceSnapshot({
+          database,
+          source: claimedSource.source,
+          now,
+          runFullRefresh: args.fullRefresh === true,
+          refreshClaimId: claimedSource.claimId,
+        }).catch(async (error: unknown) => {
+          await releaseBuilderCmsSourceRefreshClaim({
+            sourceId: source.id,
+            claimId: claimedSource.claimId,
+          });
+          throw error;
+        });
+      }
     } else if (source.sourceType === "local-table") {
       // Read-only federated secondary; its rows are re-read on demand, nothing
       // to resync against the primary's local snapshot here.
@@ -116,11 +141,13 @@ export default defineAction({
       database: serializeDatabase(database),
       mode: "source-backed",
       summary: snapshot
-        ? builderFetching
-          ? `${snapshot.sourceName} fetched ${builderFetched ?? "some"} rows. Run refresh again to continue loading the remaining Builder rows.`
-          : snapshot.sourceType === "notion-database"
-            ? `${snapshot.sourceName} refreshed read-only from Notion.`
-            : `${snapshot.sourceName} resynced locally; field mappings and row identity now reflect the current database snapshot.`
+        ? skippedOverlappingBuilderRefresh
+          ? `${snapshot.sourceName} already advanced or has another refresh in progress; the current snapshot was preserved.`
+          : builderFetching
+            ? `${snapshot.sourceName} fetched ${builderFetched ?? "some"} rows. Run refresh again to continue loading the remaining Builder rows.`
+            : snapshot.sourceType === "notion-database"
+              ? `${snapshot.sourceName} refreshed read-only from Notion.`
+              : `${snapshot.sourceName} resynced locally; field mappings and row identity now reflect the current database snapshot.`
         : "Source metadata refreshed.",
       source: snapshot,
     };

package/corpus/templates/content/actions/set-content-database-source-write-mode.ts

@@ -1,9 +1,7 @@
 import { defineAction } from "@agent-native/core";
 import { assertAccess } from "@agent-native/core/sharing";
-import { eq } from "drizzle-orm";
 import { z } from "zod";
 
-import { getDb, schema } from "../server/db/index.js";
 import {
   type ContentDatabaseResponse,
   type ContentDatabaseSourcePushMode,
@@ -16,6 +14,7 @@ import {
 } from "./_builder-cms-write-settings.js";
 import {
   getExistingSourceForWrite,
+  mutateContentDatabaseSourceMetadata,
   resolveDatabaseForSourceMutation,
 } from "./_database-source-utils.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
@@ -81,7 +80,6 @@ export default defineAction({
     if (!database) throw new Error("Database not found.");
     await assertAccess("document", database.documentId, "admin");
 
-    const db = getDb();
     const source = await getExistingSourceForWrite(database.id, args.sourceId);
     if (!source) {
       throw new Error(
@@ -94,28 +92,34 @@ export default defineAction({
       );
     }
 
-    const next = buildBuilderCmsWriteModeJson({
-      sourceType: source.sourceType,
-      sourceTable: source.sourceTable,
-      capabilitiesJson: source.capabilitiesJson,
-      metadataJson: source.metadataJson,
-      liveWritesEnabled: args.liveWritesEnabled,
-      writeMode: args.writeMode as ContentDatabaseSourceWriteMode | undefined,
-      allowPublicationTransitions: args.allowPublicationTransitions,
-      allowedWriteModes: executableWriteModes(args.allowedWriteModes),
-      allowDraftWrites: args.allowDraftWrites,
-      allowPublishWrites: args.allowPublishWrites,
-    });
     const now = new Date().toISOString();
-    await db
-      .update(schema.contentDatabaseSources)
-      .set({
-        capabilitiesJson: next.capabilitiesJson,
-        metadataJson: next.metadataJson,
-        lastError: null,
-        updatedAt: now,
-      })
-      .where(eq(schema.contentDatabaseSources.id, source.id));
+    await mutateContentDatabaseSourceMetadata({
+      sourceId: source.id,
+      now,
+      buildPatch: (current) => {
+        const next = buildBuilderCmsWriteModeJson({
+          sourceType: current.sourceType,
+          sourceTable: current.sourceTable,
+          capabilitiesJson: current.capabilitiesJson,
+          metadataJson: current.metadataJson,
+          liveWritesEnabled: args.liveWritesEnabled,
+          writeMode: args.writeMode as
+            | ContentDatabaseSourceWriteMode
+            | undefined,
+          allowPublicationTransitions: args.allowPublicationTransitions,
+          allowedWriteModes: executableWriteModes(args.allowedWriteModes),
+          allowDraftWrites: args.allowDraftWrites,
+          allowPublishWrites: args.allowPublishWrites,
+        });
+        return {
+          capabilitiesJson: next.capabilitiesJson,
+          metadataJson: next.metadataJson,
+          lastError: null,
+        };
+      },
+      failureMessage:
+        "Builder source settings changed repeatedly while saving write mode.",
+    });
 
     return getContentDatabaseResponse(database.id);
   },