@agent-native/core 0.81.3 → 0.83.0

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/chunk.post.ts

@@ -17,6 +17,7 @@ import {
   readAppState,
   writeAppState,
 } from "@agent-native/core/application-state";
+import { getActiveFileUploadProvider } from "@agent-native/core/file-upload";
 import { runWithRequestContext } from "@agent-native/core/server";
 import { normalizeChunkUploadNumber } from "@shared/recording-core.js";
 import { MAX_UPLOAD_BYTES as MAX_RECORDING_UPLOAD_BYTES } from "@shared/upload-limits.js";
@@ -40,12 +41,23 @@ import {
   getEventOwnerContext,
   ownerEmailMatches,
 } from "../../../../lib/recordings.js";
+import {
+  getResumableSession,
+  setResumableSession,
+  type StoredResumableSession,
+} from "../../../../lib/resumable-session.js";
 import {
   shouldRejectVideoUploadWithoutStorage,
   STORAGE_SETUP_REQUIRED_REASON,
 } from "../../../../lib/video-storage.js";
+
 const RECORDING_TOO_LARGE_REASON = `Recording exceeds the ${Math.round(MAX_RECORDING_UPLOAD_BYTES / (1024 * 1024))} MB size limit. Please record a shorter clip.`;
 
+// Netlify functions have a 6 MB buffered request cap, but binary requests
+// are base64 encoded by the gateway and effectively cap out around 4.5 MB.
+// Keep our own cap lower so dev/local failures match production.
+const MAX_CHUNK_BYTES = 4 * 1024 * 1024;
+
 const ALLOWED_RECORDING_MIME_TYPES = new Set([
   "video/webm",
   "video/mp4",
@@ -115,10 +127,6 @@ export default defineEventHandler(async (event: H3Event) => {
     throw createError({ statusCode: 400, message: "Invalid chunk index" });
   }
 
-  // Netlify functions have a 6 MB buffered request cap, but binary requests
-  // are base64 encoded by the gateway and effectively cap out around 4.5 MB.
-  // Keep our own cap lower so dev/local failures match production.
-  const MAX_CHUNK_BYTES = 4 * 1024 * 1024;
   const contentLength = Number(getHeader(event, "content-length") || 0);
   if (contentLength > MAX_CHUNK_BYTES) {
     setResponseStatus(event, 413);
@@ -164,6 +172,20 @@ export default defineEventHandler(async (event: H3Event) => {
       throw createError({ statusCode: 404, message: "Recording not found" });
     }
 
+    // Resumable streaming path — forward chunks directly to the provider.
+    const resumableSession = await getResumableSession(recordingId);
+    if (resumableSession) {
+      return handleResumableChunk(
+        event,
+        resumableSession,
+        recordingId,
+        index,
+        isFinal,
+        mimeType,
+        query,
+      );
+    }
+
     const failedUploadResponse = (reason: string, bytes?: number) => {
       setResponseStatus(
         event,
@@ -183,6 +205,13 @@ export default defineEventHandler(async (event: H3Event) => {
       );
     }
 
+    // Already finalized — retried final chunk after session was deleted. Skip
+    // buffered path writes so recording-upload-* state stays correct.
+    if (existing.status === "ready") {
+      return { ok: true, finalized: true };
+    }
+
+    // Store chunks in application_state, assemble on finalize.
     if (await shouldRejectVideoUploadWithoutStorage()) {
       const now = new Date().toISOString();
       await db
@@ -362,10 +391,7 @@ export default defineEventHandler(async (event: H3Event) => {
 
       await db
         .update(schema.recordings)
-        .set({
-          uploadProgress: progress,
-          updatedAt: new Date().toISOString(),
-        })
+        .set({ uploadProgress: progress, updatedAt: new Date().toISOString() })
         .where(
           and(
             eq(schema.recordings.id, recordingId),
@@ -399,21 +425,9 @@ export default defineEventHandler(async (event: H3Event) => {
       if (failedResponse) return failedResponse;
       debugLog("[chunk] isFinal — invoking finalize", { recordingId });
       try {
-        const result = await finalizeRecording.run({
-          id: recordingId,
-          durationMs: normalizeChunkUploadNumber(query.durationMs),
-          width: normalizeChunkUploadNumber(query.width),
-          height: normalizeChunkUploadNumber(query.height),
-          hasAudio:
-            query.hasAudio === undefined
-              ? undefined
-              : query.hasAudio === "1" || query.hasAudio === "true",
-          hasCamera:
-            query.hasCamera === undefined
-              ? undefined
-              : query.hasCamera === "1" || query.hasCamera === "true",
-          mimeType,
-        });
+        const result = await finalizeRecording.run(
+          buildFinalizeArgs(recordingId, mimeType, query),
+        );
         debugLog("[chunk] finalize ok", {
           recordingId,
           videoUrl: (result as any)?.videoUrl,
@@ -510,11 +524,154 @@ export default defineEventHandler(async (event: H3Event) => {
       }
     }
 
-    return {
-      ok: true,
-      finalized: false,
-      index,
-      bytes: bytes.byteLength,
-    };
+    return { ok: true, finalized: false, index, bytes: bytes.byteLength };
   });
 });
+
+function buildFinalizeArgs(
+  recordingId: string,
+  mimeType: string,
+  query: Record<string, unknown>,
+) {
+  return {
+    id: recordingId,
+    durationMs: normalizeChunkUploadNumber(query.durationMs),
+    width: normalizeChunkUploadNumber(query.width),
+    height: normalizeChunkUploadNumber(query.height),
+    hasAudio:
+      query.hasAudio === undefined
+        ? undefined
+        : query.hasAudio === "1" || query.hasAudio === "true",
+    hasCamera:
+      query.hasCamera === undefined
+        ? undefined
+        : query.hasCamera === "1" || query.hasCamera === "true",
+    mimeType,
+  };
+}
+
+// Resumable streaming path: each chunk is forwarded directly to the upload
+// provider. Always returns a response — never falls through to the buffered path.
+async function handleResumableChunk(
+  event: H3Event,
+  session: StoredResumableSession,
+  recordingId: string,
+  index: number,
+  isFinal: boolean,
+  mimeType: string,
+  query: Record<string, unknown>,
+) {
+  const uploadProvider = getActiveFileUploadProvider();
+  console.log(
+    `[resumable-chunk-${recordingId}] resumable session exists - bytesUploaded=${session.bytesUploaded} index=${index} isFinal=${isFinal}`,
+  );
+
+  const raw = await readRawBody(event, false);
+  const bytes: Uint8Array = raw ?? new Uint8Array(0);
+
+  if (!isFinal && bytes.byteLength === 0) {
+    throw createError({ statusCode: 400, message: "Empty chunk body" });
+  }
+
+  if (isFinal && bytes.byteLength === 0) {
+    // 0-byte sentinel from the recorder after stop(). All data chunks have
+    // already been PUT to the provider; send Content-Range: bytes */<total>
+    // to close the session before handing off to finalize-recording.
+    const closeRes = await uploadProvider!.resumable!.relayChunk(
+      { sessionId: session.sessionId, meta: session.meta },
+      `bytes */${session.bytesUploaded}`,
+      new Uint8Array(0),
+    );
+    if (!closeRes.ok) {
+      console.error(
+        `[resumable-chunk-${recordingId}] session close failed (${closeRes.status})`,
+      );
+      setResponseStatus(event, 502);
+      return {
+        ok: false,
+        error: `Resumable session close failed (${closeRes.status})`,
+      };
+    }
+  } else {
+    // Idempotent replay guard: a client retry (after a lost response) can
+    // re-send a chunk we already committed. Re-PUTing it at the new offset
+    // would corrupt the file — detect the duplicate by index and skip the PUT.
+    // Chunks are strictly sequential, so any index <= last committed is a replay.
+    // A replayed non-final is acked here; a replayed final falls through to
+    // finalize, which is idempotent.
+    const isReplay = index <= (session.lastCommittedIndex ?? -1);
+    if (isReplay) {
+      console.warn(
+        `[resumable-chunk-${recordingId}] duplicate chunk ${index}, acking without re-upload`,
+      );
+      if (!isFinal) {
+        return {
+          ok: true,
+          finalized: false,
+          index,
+          bytes: bytes.byteLength,
+          duplicate: true,
+        };
+      }
+    } else {
+      // Forward the data chunk to the provider and advance offsets only after
+      // the provider confirms receipt (308 Resume Incomplete for non-final, 2xx for final).
+      const start = session.bytesUploaded;
+      const end = start + bytes.byteLength - 1;
+      const contentRange = isFinal
+        ? `bytes ${start}-${end}/${start + bytes.byteLength}`
+        : `bytes ${start}-${end}/*`;
+
+      const putT0 = Date.now();
+      const putResult = await uploadProvider!.resumable!.relayChunk(
+        { sessionId: session.sessionId, meta: session.meta },
+        contentRange,
+        bytes,
+        { mimeType: mimeType.split(";")[0].trim() },
+      );
+      console.log(
+        `[resumable-chunk-${recordingId}] PUT ${Date.now() - putT0}ms status=${putResult.status} range="${contentRange}"`,
+      );
+
+      const resultOk = isFinal
+        ? putResult.ok && putResult.status !== 308
+        : putResult.ok;
+      if (!resultOk) {
+        setResponseStatus(event, 502);
+        return {
+          ok: false,
+          error: `Chunk upload failed (${putResult.status})`,
+        };
+      }
+
+      await setResumableSession(recordingId, {
+        ...session,
+        ...(putResult.updatedMeta
+          ? { meta: { ...session.meta, ...putResult.updatedMeta } }
+          : {}),
+        bytesUploaded: start + bytes.byteLength,
+        lastCommittedIndex: index,
+      });
+
+      if (!isFinal) {
+        return { ok: true, finalized: false, index, bytes: bytes.byteLength };
+      }
+    }
+  }
+
+  // isFinal — delegate to finalize-recording, which reads the resumable
+  // session and calls provider.resumable.completeSession.
+  try {
+    const result = await finalizeRecording.run(
+      buildFinalizeArgs(recordingId, mimeType, query),
+    );
+    return { ok: true, finalized: true, ...result };
+  } catch (err) {
+    console.error(`[resumable-chunk-${recordingId}] finalize failed:`, err);
+    setResponseStatus(event, 500);
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : "Finalize failed",
+    };
+  }
+}

package/corpus/templates/clips/server/routes/api/uploads/[recordingId]/reset-chunks.post.ts

@@ -44,6 +44,7 @@ import {
   getEventOwnerContext,
   ownerEmailMatches,
 } from "../../../../lib/recordings.js";
+import { deleteResumableSession } from "../../../../lib/resumable-session.js";
 
 interface CompressionMeta {
   originalBytes?: number;
@@ -112,6 +113,9 @@ export default defineEventHandler(async (event: H3Event) => {
     const cleared = await deleteAppStateByPrefix(
       `recording-chunks-${recordingId}-`,
     );
+    // Clear any stale resumable session so a buffered retry does not
+    // accidentally route through handleResumableChunk with stale offsets.
+    await deleteResumableSession(recordingId).catch(() => {});
 
     // Reset the per-recording upload progress so the UI poller sees the
     // re-upload restart from 0 and doesn't briefly show "100% then

package/corpus/templates/clips/shared/recording-core.ts

@@ -46,6 +46,11 @@ export function pickMimeType(): string {
   return "";
 }
 
+/** How the client delivers recorded data to the server.
+ *  - `"streaming"` — chunks are flushed to GCS during recording via a resumable session
+ *  - `"buffered"`  — full blob assembled after stop() and uploaded in slices */
+export type UploadMode = "streaming" | "buffered";
+
 /** Query params understood by the chunk-upload route
  * (`/api/uploads/:id/chunk`). This is the on-the-wire contract — the route in
  * `server/routes/api/uploads/[recordingId]/chunk.post.ts` reads exactly these. */

package/corpus/templates/content/.env.local.example

@@ -0,0 +1,6 @@
+# Local database-mode development for Builder/source testing.
+# Copy to .env.local or run `pnpm dev:database` to generate one.
+# These values are local-only. Do not use them for production deploys.
+
+AGENT_NATIVE_MODE=database
+BETTER_AUTH_SECRET=<generated-local-development-secret>

package/corpus/templates/content/AGENTS.md

@@ -113,10 +113,11 @@ cd templates/content && pnpm action <name> [args]
 | `attach-content-database-source`            | `--databaseId <id>` or `--documentId <id> [--sourceType mock\|builder-cms] [--sourceName] [--sourceTable] [--relationshipMode items\|details] [--join <json>]` | Attach a source binding; use `items` to add more rows and `details` to match a source onto existing rows                                |
 | `change-content-database-source-role`       | `--databaseId <id>` or `--documentId <id> --sourceId <id> --relationshipMode items\|details [--join <json>]`                                                   | Change an attached source between adding rows and adding matched detail columns without removing the source                             |
 | `refresh-content-database-source`           | `--databaseId <id>` or `--documentId <id>`                                                                                                                     | Refresh the read-only source status envelope; Builder CMS reads live entries only when configured                                       |
+| `process-builder-body-hydration`            | `--sourceId <id> [--documentId <id>] [--limit <n>]`                                                                                                            | Hydrate queued Builder article bodies into readable Content markdown with preserved source-component markers                            |
 | `set-content-database-source-write-mode`    | `--databaseId <id>` or `--documentId <id> --liveWritesEnabled true\|false [--allowedWriteModes <json>]`                                                        | Enable/disable per-source Builder live writes; enabling is allowed only for `agent-native-blog-article-test` with explicit modes        |
 | `stage-builder-revision`                    | `--databaseId <id>` or `--documentId <id>`                                                                                                                     | Stage pending local Builder CMS changes as a local-only save-revision record; never calls Builder                                       |
 | `review-content-database-source-change-set` | `--databaseId <id>` or `--documentId <id> --changeSetId <id> --decision approve\|reject [--note]`                                                              | Approve or reject a local source change-set review record without provider writes                                                       |
-| `prepare-builder-source-execution`          | `--databaseId <id>` or `--documentId <id> --changeSetId <id> [--pushModeConfirmation autosave\|draft\|publish]`                                                | Prepare a dry-run Builder execution gate with request semantics/idempotency key; never calls Builder                                    |
+| `prepare-builder-source-execution`          | `--databaseId <id>` or `--documentId <id> --changeSetId <id> [--pushModeConfirmation autosave\|draft\|publish]`                                                | Prepare a dry-run Builder execution gate for approved field/body changes with request semantics/idempotency key; never calls Builder    |
 | `validate-builder-source-execution`         | `--databaseId <id>` or `--documentId <id> --changeSetId <id> [--idempotencyKey <key>]`                                                                         | Validate/replay a prepared Builder execution gate locally as a dry run; never calls Builder                                             |
 | `execute-builder-source-execution`          | `--databaseId <id>` or `--documentId <id> --changeSetId <id> [--idempotencyKey <key>] [--pushModeConfirmation autosave\|draft\|publish]`                       | Execute a guarded live Builder write only when approved, validated, enabled, idempotent, and targeting `agent-native-blog-article-test` |
 | `add-database-item`                         | `--databaseId <id> [--title <text>] [--propertyValues <json>]`                                                                                                 | Add a page row to a database, optionally seeding property values                                                                        |
@@ -208,6 +209,14 @@ Content has two file workflows:
   Edit reusable symbol content in that emitted source file; do not retarget
   `entry`, `model`, or `source` in the parent MDX unless a dedicated Builder
   retargeting workflow is added.
+- **Builder source components:** Builder CMS database body hydration renders
+  unsupported provider-native body blocks as `<SourceComponent ... />` markers.
+  Treat these as read-only preservation anchors, not editable local blocks.
+  Agents may edit surrounding prose, but must not delete, duplicate, move, or
+  rewrite `rawRef`, `rawHash`, or marker ids unless a dedicated provider
+  conversion workflow exists. Guarded Builder write-back refuses missing,
+  tampered, or structurally moved markers so source-native components are not
+  lost.
 - **Picked folders and components:** browser-picked folders can be the
   source of truth for `.md`/`.mdx` files, but the browser does not expose an
   absolute path that Vite can compile. Component previews from a picked

package/corpus/templates/content/actions/_builder-cms-read-client.ts

@@ -5,6 +5,11 @@ import type {
   BuilderCmsModelSummary,
   BuilderCmsModelsResponse,
 } from "../shared/api.js";
+import {
+  builderBlocksHash,
+  builderEntryBlocks,
+  type BuilderContentEntry,
+} from "../shared/builder-mdx.js";
 import {
   normalizeBuilderCmsApiEntry,
   type BuilderCmsSourceEntry,
@@ -23,6 +28,7 @@ export interface BuilderCmsEntryLiveState {
   exists: boolean;
   published: "published" | "draft" | string | null;
   lastUpdated: number | string | null;
+  blocksHash: string | null;
   id: string | null;
 }
 
@@ -42,7 +48,7 @@ const BUILDER_CMS_MAX_READ_LIMIT = 1000;
 const BUILDER_CMS_PAGE_SIZE = 100;
 const BUILDER_CMS_READ_RETRIES = 2;
 const BUILDER_CMS_ENTRY_FIELDS =
-  "id,name,published,lastUpdated,createdDate,data.title,data.handle,data.url,data.slug,data.date,data.description,data.status,data.author,data.image";
+  "id,name,published,lastUpdated,createdDate,data.title,data.handle,data.url,data.slug,data.date,data.description,data.status,data.author,data.image,data.blocks,data.blocksString";
 
 function builderContentApiHost() {
   return (
@@ -76,6 +82,7 @@ function liveStateFromBuilderEntry(value: unknown): BuilderCmsEntryLiveState {
           exists: false,
           published: null,
           lastUpdated: null,
+          blocksHash: null,
           id: null,
         };
   }
@@ -84,6 +91,7 @@ function liveStateFromBuilderEntry(value: unknown): BuilderCmsEntryLiveState {
       exists: false,
       published: null,
       lastUpdated: null,
+      blocksHash: null,
       id: null,
     };
   }
@@ -97,6 +105,7 @@ function liveStateFromBuilderEntry(value: unknown): BuilderCmsEntryLiveState {
       exists: false,
       published: null,
       lastUpdated: null,
+      blocksHash: null,
       id: null,
     };
   }
@@ -116,10 +125,12 @@ function liveStateFromBuilderEntry(value: unknown): BuilderCmsEntryLiveState {
       exists: false,
       published: null,
       lastUpdated: null,
+      blocksHash: null,
       id: null,
     };
   }
 
+  const blocks = builderEntryBlocks(record as BuilderContentEntry);
   return {
     exists: true,
     published:
@@ -129,6 +140,7 @@ function liveStateFromBuilderEntry(value: unknown): BuilderCmsEntryLiveState {
       stringOrNumberFromUnknown(record.updatedDate) ??
       stringOrNumberFromUnknown(record.updatedAt) ??
       stringOrNumberFromUnknown(data.updatedAt),
+    blocksHash: blocks.length > 0 ? builderBlocksHash(blocks) : null,
     id,
   };
 }
@@ -618,6 +630,7 @@ export async function readBuilderCmsEntryLiveState(args: {
       exists: false,
       published: null,
       lastUpdated: null,
+      blocksHash: null,
       id: null,
     };
   }

package/corpus/templates/content/actions/_builder-cms-source-adapter.ts

@@ -3,6 +3,21 @@ import type {
   ContentDatabaseSourceFieldMapping,
   DocumentPropertyValue,
 } from "../shared/api.js";
+import {
+  builderBlocksHash,
+  builderEntryBlocks,
+  normalizeRemoteUpdatedAt,
+  type BuilderContentEntry,
+} from "../shared/builder-mdx.js";
+
+export const BUILDER_CMS_BODY_CONTENT_KEY = "__builder.body.content";
+export const BUILDER_CMS_BODY_BLOCKS_HASH_KEY = "__builder.body.blocksHash";
+export const BUILDER_CMS_BODY_SIDECARS_KEY = "__builder.body.sidecarsJson";
+export const BUILDER_CMS_BODY_LOSSLESS_CONTENT_KEY =
+  "__builder.body.losslessContent";
+export const BUILDER_CMS_BODY_READABLE_MAP_KEY =
+  "__builder.body.readableMapJson";
+export const BUILDER_CMS_BODY_BLOCK_COUNT_KEY = "__builder.body.blockCount";
 
 export interface BuilderCmsSourceEntry {
   id: string;
@@ -11,6 +26,7 @@ export interface BuilderCmsSourceEntry {
   urlPath: string;
   updatedAt: string;
   sourceValues: Record<string, DocumentPropertyValue>;
+  rawEntry?: BuilderContentEntry;
 }
 
 export interface ExistingBuilderSourceRowIdentity {
@@ -291,6 +307,7 @@ function builderSourceValuesFromRecord(args: {
   title: string;
   urlPath: string;
   updatedAt: string;
+  rawEntry: BuilderContentEntry;
 }) {
   const values: Record<string, DocumentPropertyValue> = {
     "data.title": args.title,
@@ -298,6 +315,7 @@ function builderSourceValuesFromRecord(args: {
     lastUpdated: args.updatedAt,
   };
   for (const [key, value] of Object.entries(args.data)) {
+    if (key === "blocks" || key === "blocksString") continue;
     values[`data.${key}`] = sourceValueFromUnknown(value);
   }
   for (const key of ["published", "createdDate", "updatedDate", "updatedAt"]) {
@@ -305,6 +323,11 @@ function builderSourceValuesFromRecord(args: {
       values[key] = sourceValueFromUnknown(args.record[key]);
     }
   }
+  const blocks = builderEntryBlocks(args.rawEntry);
+  if (blocks.length > 0) {
+    values[BUILDER_CMS_BODY_BLOCKS_HASH_KEY] = builderBlocksHash(blocks);
+    values[BUILDER_CMS_BODY_BLOCK_COUNT_KEY] = blocks.length;
+  }
   return values;
 }
 
@@ -342,6 +365,24 @@ export function normalizeBuilderCmsApiEntry(
     ]) ??
     timestampStringFromRecord(data, ["updatedAt"]) ??
     new Date().toISOString();
+  const rawEntry: BuilderContentEntry = {
+    ...record,
+    id,
+    model,
+    name:
+      typeof record.name === "string" && record.name.trim()
+        ? record.name.trim()
+        : title,
+    published:
+      typeof record.published === "string" ? record.published : undefined,
+    lastUpdated: normalizeRemoteUpdatedAt({
+      ...record,
+      id,
+      model,
+      data,
+    } as BuilderContentEntry),
+    data,
+  };
 
   return {
     id,
@@ -355,6 +396,8 @@ export function normalizeBuilderCmsApiEntry(
       title,
       urlPath,
       updatedAt,
+      rawEntry,
     }),
+    rawEntry,
   };
 }

package/corpus/templates/content/actions/_builder-cms-write-adapter.ts

@@ -194,6 +194,70 @@ function nestedBuilderPatch(
   return body;
 }
 
+function mergeBuilderPatch(
+  base: Record<string, unknown>,
+  patch: Record<string, unknown>,
+) {
+  const merged = { ...base };
+  for (const [key, value] of Object.entries(patch)) {
+    if (
+      key === "data" &&
+      value &&
+      typeof value === "object" &&
+      !Array.isArray(value)
+    ) {
+      merged.data = {
+        ...((merged.data && typeof merged.data === "object"
+          ? merged.data
+          : {}) as Record<string, unknown>),
+        ...(value as Record<string, unknown>),
+      };
+      continue;
+    }
+    merged[key] = value;
+  }
+  return merged;
+}
+
+function builderBodyPatch(changeSet: ContentDatabaseSourceChangeSet) {
+  const bodyChange = changeSet.bodyChange;
+  const checks: string[] = [];
+  const blockers: string[] = [];
+  if (!bodyChange) {
+    return { patch: {}, checks, blockers, hasBodyOperation: false };
+  }
+  if (!bodyChange.proposedBlocksJson) {
+    blockers.push(
+      "Builder body diff could not be converted to Builder blocks.",
+    );
+    return { patch: {}, checks, blockers, hasBodyOperation: false };
+  }
+  try {
+    const blocks = JSON.parse(bodyChange.proposedBlocksJson) as unknown;
+    if (!Array.isArray(blocks)) {
+      blockers.push("Builder body diff did not produce a blocks array.");
+      return { patch: {}, checks, blockers, hasBodyOperation: false };
+    }
+    checks.push("Includes converted Builder body blocks.");
+    for (const warning of bodyChange.warnings ?? []) {
+      checks.push(`Body conversion warning: ${warning}`);
+    }
+    return {
+      patch: {
+        data: {
+          blocks,
+        },
+      },
+      checks,
+      blockers,
+      hasBodyOperation: true,
+    };
+  } catch {
+    blockers.push("Builder body diff contains invalid converted blocks JSON.");
+    return { patch: {}, checks, blockers, hasBodyOperation: false };
+  }
+}
+
 function builderRequestForEffect(args: {
   effect: BuilderCmsWriteEffect;
   model: string;
@@ -272,18 +336,19 @@ function builderSafetyChecks(args: {
   entryId: string | null;
   syntheticFixtureTarget: boolean;
   operations: BuilderCmsExecutionOperation[];
+  hasBodyOperation: boolean;
+  bodyChecks: string[];
+  bodyBlockers: string[];
 }) {
   const checks = [
     "Requires explicit approval before execution.",
     "Uses the stored execution idempotency key.",
+    ...args.bodyChecks,
   ];
-  const blockers: string[] = [];
+  const blockers: string[] = [...args.bodyBlockers];
 
-  if (args.operations.length === 0) {
-    blockers.push("No field operations are available for this Builder change.");
-  }
-  if (args.changeSet.bodyChange) {
-    blockers.push("Builder body diffs are not executable in this slice.");
+  if (args.operations.length === 0 && !args.hasBodyOperation) {
+    blockers.push("No Builder operations are available for this change.");
   }
   if (args.effect === "autosave" || args.effect === "update_in_place") {
     const label = args.effect === "autosave" ? "Autosave" : "Update in place";
@@ -418,7 +483,11 @@ export function buildBuilderCmsExecutionPlan(args: {
     localFieldKey: field.localFieldKey,
     value: field.proposedValue,
   }));
-  const bodyPatch = nestedBuilderPatch(operations);
+  const bodyDiffPatch = builderBodyPatch(args.changeSet);
+  const bodyPatch = mergeBuilderPatch(
+    nestedBuilderPatch(operations),
+    bodyDiffPatch.patch,
+  );
   // State-preserving effects must not include `published` in the body. Builder
   // PATCH preserves omitted publication state, so only transition/create effects
   // are allowed to set it.
@@ -441,6 +510,9 @@ export function buildBuilderCmsExecutionPlan(args: {
       args.source.sourceTable === SAFE_WRITE_MODEL &&
       target?.isSyntheticFixture === true,
     operations,
+    hasBodyOperation: bodyDiffPatch.hasBodyOperation,
+    bodyChecks: bodyDiffPatch.checks,
+    bodyBlockers: bodyDiffPatch.blockers,
   });
   const state: ContentDatabaseSourceExecutionState =
     safety.blockers.length > 0