@agent-native/core 0.70.0 → 0.70.2

package/corpus/templates/clips/desktop/src/lib/bubble-webrtc.ts

@@ -73,6 +73,101 @@ import { emit, listen, type UnlistenFn } from "@tauri-apps/api/event";
 
 const CONNECT_TIMEOUT_MS = 3000;
 
+// ---- bitrate tuning for the loopback preview ----------------------------
+//
+// This is a SAME-MACHINE loopback (popover → bubble, both on 127.0.0.1),
+// so there is effectively no bandwidth limit. Left untuned, WebKit's
+// congestion controller still starts the encoder at libwebrtc's cautious
+// ~300 kbps default and ramps up over several seconds, and with the
+// default `balanced` degradation preference it downscales the picture
+// while the bitrate is low. That produced the "bubble is blurry for the
+// first ~10s, then sharpens" regression after the bubble stopped owning a
+// direct local camera stream. We pin a high start/max bitrate and forbid
+// resolution downscaling so the bubble is crisp from the first frame.
+//
+// 720p webcam is comfortable at a few Mbps; these are generous, not silly.
+const BUBBLE_START_BITRATE_KBPS = 2500;
+const BUBBLE_MIN_BITRATE_KBPS = 1200;
+const BUBBLE_MAX_BITRATE_KBPS = 5000;
+
+/**
+ * Pin the sender to a high, fixed bitrate and forbid resolution
+ * downscaling. Called after `setLocalDescription` so `encodings` is
+ * populated on every WebKit build. Best-effort — older WebViews may not
+ * support every field, so we swallow failures.
+ */
+async function configureBubbleSender(
+  sender: RTCRtpSender | null,
+): Promise<void> {
+  if (!sender) return;
+  try {
+    const params = sender.getParameters();
+    if (!params.encodings || params.encodings.length === 0) {
+      // Some WebKit builds report empty encodings until the first
+      // negotiation — seed one so our settings have somewhere to land.
+      params.encodings = [{}];
+    }
+    params.encodings[0].maxBitrate = BUBBLE_MAX_BITRATE_KBPS * 1000;
+    params.encodings[0].maxFramerate = 30;
+    // `minBitrate` is non-standard but honored by libwebrtc-based stacks
+    // (WebKit, Chromium); harmless where unsupported.
+    (params.encodings[0] as { minBitrate?: number }).minBitrate =
+      BUBBLE_MIN_BITRATE_KBPS * 1000;
+    // Never trade resolution for framerate — a soft bubble looks broken;
+    // a marginally lower fps does not.
+    params.degradationPreference = "maintain-resolution";
+    await sender.setParameters(params);
+  } catch (err) {
+    console.warn("[clips-bubble-webrtc] setParameters failed", err);
+  }
+}
+
+/**
+ * Raise the encoder's START bitrate via SDP so it doesn't begin at
+ * libwebrtc's cautious default and slowly climb (the visible quality
+ * ramp). WebKit reads these codec params from our own local description
+ * and applies them to our encoder. Also stamps a high `b=AS`/`b=TIAS`
+ * ceiling on the video m-section.
+ */
+function boostBubbleVideoBitrate(sdp: string | undefined): string {
+  if (!sdp) return sdp ?? "";
+  const eol = sdp.includes("\r\n") ? "\r\n" : "\n";
+  const lines = sdp.split(/\r\n|\n/);
+  const out: string[] = [];
+  let inVideo = false;
+  for (const line of lines) {
+    if (line.startsWith("m=")) {
+      inVideo = line.startsWith("m=video");
+      out.push(line);
+      continue;
+    }
+    if (inVideo && line.startsWith("c=")) {
+      out.push(line);
+      // b=AS is kbps; b=TIAS is bps. Both must follow the c= line.
+      out.push(`b=AS:${BUBBLE_MAX_BITRATE_KBPS}`);
+      out.push(`b=TIAS:${BUBBLE_MAX_BITRATE_KBPS * 1000}`);
+      continue;
+    }
+    if (
+      inVideo &&
+      line.startsWith("a=fmtp:") &&
+      // Skip RTX/FEC payloads (their fmtp carries `apt=`); only primary
+      // codecs honor the x-google-* hints.
+      !line.includes("apt=") &&
+      !line.includes("x-google-start-bitrate")
+    ) {
+      out.push(
+        `${line};x-google-start-bitrate=${BUBBLE_START_BITRATE_KBPS}` +
+          `;x-google-min-bitrate=${BUBBLE_MIN_BITRATE_KBPS}` +
+          `;x-google-max-bitrate=${BUBBLE_MAX_BITRATE_KBPS}`,
+      );
+      continue;
+    }
+    out.push(line);
+  }
+  return out.join(eol);
+}
+
 export interface BubbleWebrtcHandle {
   /** Tear down the peer connection and unsubscribe listeners. */
   stop(): void;
@@ -243,11 +338,23 @@ export function startBubbleWebrtc(
       }
     };
 
+    // Hint the encoder to PRESERVE RESOLUTION. A raw camera track defaults
+    // to "motion" semantics — under any bitrate pressure WebKit downscales
+    // the picture to protect the frame rate, which on this loopback shows
+    // up as a soft/blurry bubble. "detail" flips the default toward keeping
+    // pixels, complementing the explicit `maintain-resolution` set below.
+    try {
+      videoTrack.contentHint = "detail";
+    } catch {
+      // contentHint is a harmless no-op on older WebViews.
+    }
+
     // Add the camera video track. WebRTC will renegotiate if the track
     // id changes, but we only add once per handshake so this is a
-    // one-shot.
+    // one-shot. Capture the sender so we can pin its bitrate below.
+    let sender: RTCRtpSender | null = null;
     try {
-      localPc.addTrack(videoTrack, stream);
+      sender = localPc.addTrack(videoTrack, stream);
     } catch (err) {
       console.warn("[clips-bubble-webrtc] addTrack failed:", err);
       onFailure("add-track-failed");
@@ -258,6 +365,10 @@ export function startBubbleWebrtc(
     let offer: RTCSessionDescriptionInit;
     try {
       offer = await localPc.createOffer();
+      // Raise the encoder's start/max bitrate before we commit the local
+      // description so the bubble is sharp immediately instead of ramping
+      // up over ~10s. See `boostBubbleVideoBitrate`.
+      offer = { ...offer, sdp: boostBubbleVideoBitrate(offer.sdp) };
       await localPc.setLocalDescription(offer);
     } catch (err) {
       console.warn(
@@ -270,6 +381,12 @@ export function startBubbleWebrtc(
     }
     if (stopped || myId !== handshakeId) return;
 
+    // Now that the local description is set, `getParameters().encodings`
+    // is populated on every WebKit build — pin the bitrate floor/ceiling
+    // and forbid resolution downscaling.
+    await configureBubbleSender(sender);
+    if (stopped || myId !== handshakeId) return;
+
     try {
       await emit("clips:webrtc-offer", {
         handshakeId: myId,

package/corpus/templates/clips/desktop/src/overlays/countdown.tsx

@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useRef, useState } from "react";
 import { emit } from "@tauri-apps/api/event";
 import { getCurrentWindow } from "@tauri-apps/api/window";
+import { IconPlayerSkipForwardFilled, IconX } from "@tabler/icons-react";
 
 const COUNTDOWN_STEP_MS = 1000;
 
@@ -62,8 +63,26 @@ export function Countdown() {
 
   return (
     <div className="countdown-root">
-      <div className="countdown-number" key={n} aria-live="polite">
-        {n > 0 ? n : ""}
+      <div className="countdown-controls">
+        <button
+          type="button"
+          className="countdown-control countdown-control-cancel"
+          aria-label="Cancel recording"
+          onClick={() => closeWithEvent("clips:countdown-cancel")}
+        >
+          <IconX size={30} stroke={2.4} />
+        </button>
+        <div className="countdown-number" key={n} aria-live="polite">
+          {n > 0 ? n : ""}
+        </div>
+        <button
+          type="button"
+          className="countdown-control countdown-control-skip"
+          aria-label="Skip countdown and start recording now"
+          onClick={() => closeWithEvent("clips:countdown-done")}
+        >
+          <IconPlayerSkipForwardFilled size={28} />
+        </button>
       </div>
       <div className="countdown-hint" aria-label="Countdown shortcuts">
         <span>

package/corpus/templates/clips/desktop/src/styles.css

@@ -2037,6 +2037,70 @@ body[data-clips-route="recording-pill"] #root {
   pointer-events: none;
 }
 
+/*
+ * Horizontal row of [cancel] [number] [skip]. The two circular buttons are
+ * absolutely centered at exactly ±200px (logical) from the row center so the
+ * native cursor-poll hit-rects in clips/mod.rs (CONTROL_OFFSET_X = 200.0,
+ * CONTROL_DIAMETER = 64.0) line up with the rendered controls. Keep these
+ * numbers in sync with that Rust code.
+ */
+.countdown-controls {
+  position: relative;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.countdown-control {
+  position: absolute;
+  top: 50%;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 64px;
+  height: 64px;
+  margin: 0;
+  padding: 0;
+  border: 1px solid rgba(255, 255, 255, 0.22);
+  border-radius: 50%;
+  background: rgba(10, 12, 16, 0.42);
+  box-shadow: 0 10px 28px rgba(0, 0, 0, 0.28);
+  color: #ffffff;
+  cursor: pointer;
+  pointer-events: auto;
+  backdrop-filter: blur(8px);
+  transform: translateY(-50%);
+  transition:
+    background-color 0.15s ease,
+    border-color 0.15s ease,
+    transform 0.1s ease;
+}
+
+.countdown-control-cancel {
+  /* center at -200px from row center: -200 - (64 / 2) = -232px */
+  left: -232px;
+}
+
+.countdown-control-skip {
+  /* center at +200px from row center: 200 - (64 / 2) = 168px */
+  right: -232px;
+}
+
+.countdown-control:hover {
+  background: rgba(255, 255, 255, 0.92);
+  border-color: rgba(255, 255, 255, 0.95);
+  color: #0b0d12;
+}
+
+.countdown-control:active {
+  transform: translateY(-50%) scale(0.94);
+}
+
+.countdown-control:focus-visible {
+  outline: 2px solid rgba(255, 255, 255, 0.9);
+  outline-offset: 2px;
+}
+
 .countdown-number {
   font-size: 240px;
   font-weight: 800;
@@ -3848,11 +3912,15 @@ body[data-clips-route="recording-pill"] #root {
 }
 
 /* Collapsed (not expanded). Shrinks to dot + waveform; controls revealed via
-   CSS :hover which works at the WebKit level even when the app is unfocused. */
+   CSS :hover which works at the WebKit level even when the app is unfocused.
+   Top-anchored (not centered) inside the headroom-sized window so the hover
+   reveal of the drag grip grows the capsule strictly DOWNWARD — centering it
+   would split the growth and raise the top edge, sliding buttons up under the
+   cursor and causing misclicks. */
 .pill-inner-compact {
   width: fit-content;
   height: fit-content;
-  align-self: center;
+  align-self: flex-start;
   border-radius: 18px;
 }
 

package/corpus/templates/clips/desktop/src-tauri/src/clips/mod.rs

@@ -4,6 +4,7 @@ use std::path::PathBuf;
 use std::process::Command;
 #[cfg(target_os = "macos")]
 use std::process::Stdio;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::thread;
 use std::time::Duration;
 use tauri::{
@@ -26,6 +27,17 @@ use crate::util::{
 /// React bundle with a hash route that `main.tsx` uses to pick the component.
 const COUNTDOWN_LABEL: &str = "countdown";
 const TOOLBAR_LABEL: &str = "toolbar";
+// Geometry of the two circular cancel/skip buttons that flank the countdown
+// number. These MUST stay in sync with the CSS in
+// `templates/clips/desktop/src/styles.css` (`.countdown-control` is 64px and
+// its center sits ±200px logical from the window center). A few px of slop is
+// added to each hit-rect so edge clicks register.
+const COUNTDOWN_CONTROL_OFFSET_X: f64 = 200.0;
+const COUNTDOWN_CONTROL_DIAMETER: f64 = 64.0;
+const COUNTDOWN_CONTROL_HIT_PAD: f64 = 8.0;
+// Guards the single cursor-poll loop that toggles click-through on the
+// countdown overlay so only the button zones are interactive.
+static COUNTDOWN_CONTROL_TRACKING: AtomicBool = AtomicBool::new(false);
 const BUBBLE_LABEL: &str = "bubble";
 const FINALIZING_LABEL: &str = "finalizing";
 const FLOW_BAR_LABEL: &str = "flow-bar";
@@ -304,6 +316,7 @@ pub async fn show_countdown(app: AppHandle) -> Result<(), String> {
     dlog!("[clips-tray] show_countdown invoked");
     mark_popover_shown(&app);
     if let Some(existing) = app.get_webview_window(COUNTDOWN_LABEL) {
+        stop_countdown_control_tracking();
         let _ = app.emit("clips:countdown-shortcuts-active", false);
         let _ = existing.close();
     }
@@ -340,10 +353,68 @@ pub async fn show_countdown(app: AppHandle) -> Result<(), String> {
     configure_overlay_behavior(&win);
     let _ = win.show();
     let _ = app.emit("clips:countdown-shortcuts-active", true);
+    start_countdown_control_tracking(&app);
     dlog!("[clips-tray] countdown shown");
     Ok(())
 }
 
+/// True when the global cursor sits inside either circular cancel/skip button
+/// zone of the countdown overlay. The controls row is centered in the window;
+/// each button's center is `COUNTDOWN_CONTROL_OFFSET_X` logical px to the
+/// left/right of the window center, vertically at the window center. Cursor,
+/// window position, and window size all come from Tauri in physical px with a
+/// desktop top-left origin, so we convert the logical button geometry using the
+/// window's scale factor and do a plain point-in-rect test.
+fn cursor_over_countdown_control(window: &WebviewWindow) -> bool {
+    let (Ok(c), Ok(p), Ok(s), Ok(scale)) = (
+        window.cursor_position(),
+        window.outer_position(),
+        window.outer_size(),
+        window.scale_factor(),
+    ) else {
+        return false;
+    };
+    let center_x = p.x as f64 + s.width as f64 / 2.0;
+    let center_y = p.y as f64 + s.height as f64 / 2.0;
+    let half = (COUNTDOWN_CONTROL_DIAMETER / 2.0 + COUNTDOWN_CONTROL_HIT_PAD) * scale;
+    let offset = COUNTDOWN_CONTROL_OFFSET_X * scale;
+    let in_button = |bx: f64| -> bool {
+        c.x >= bx - half && c.x <= bx + half && c.y >= center_y - half && c.y <= center_y + half
+    };
+    in_button(center_x - offset) || in_button(center_x + offset)
+}
+
+/// Poll the cursor against the two button zones while the countdown overlay is
+/// alive, toggling `set_ignore_cursor_events` so the buttons are clickable only
+/// when the cursor is over them and the rest of the screen stays click-through.
+/// Idempotent; mirrors `start_pill_hover_tracking` in `recording_indicator.rs`.
+fn start_countdown_control_tracking(app: &AppHandle) {
+    if COUNTDOWN_CONTROL_TRACKING.swap(true, Ordering::SeqCst) {
+        return;
+    }
+    let app = app.clone();
+    tauri::async_runtime::spawn(async move {
+        let mut prev_interactive = false;
+        while COUNTDOWN_CONTROL_TRACKING.load(Ordering::Relaxed) {
+            let Some(win) = app.get_webview_window(COUNTDOWN_LABEL) else {
+                break;
+            };
+            let over = cursor_over_countdown_control(&win);
+            if over != prev_interactive {
+                prev_interactive = over;
+                // ignore_cursor_events(false) => clicks land on the buttons.
+                let _ = win.set_ignore_cursor_events(!over);
+            }
+            tokio::time::sleep(Duration::from_millis(70)).await;
+        }
+        COUNTDOWN_CONTROL_TRACKING.store(false, Ordering::SeqCst);
+    });
+}
+
+fn stop_countdown_control_tracking() {
+    COUNTDOWN_CONTROL_TRACKING.store(false, Ordering::SeqCst);
+}
+
 /// Full-screen transparent overlay that shows compact bottom-left progress
 /// while the recorder flushes its final chunks and awaits the server finalize.
 /// Rendered immediately after the user clicks Stop so they don't stare at a
@@ -800,6 +871,7 @@ pub async fn set_bubble_capture_excluded(app: AppHandle, excluded: bool) -> Resu
 
 #[tauri::command]
 pub async fn hide_overlays(app: AppHandle) -> Result<(), String> {
+    stop_countdown_control_tracking();
     let _ = app.emit("clips:countdown-shortcuts-active", false);
     for label in [
         COUNTDOWN_LABEL,
@@ -827,6 +899,7 @@ pub async fn hide_overlays(app: AppHandle) -> Result<(), String> {
 /// popover-close).
 #[tauri::command]
 pub async fn hide_recording_chrome(app: AppHandle) -> Result<(), String> {
+    stop_countdown_control_tracking();
     let _ = app.emit("clips:countdown-shortcuts-active", false);
     // The countdown + toolbar always tear down on recording stop. The region
     // guides only tear down when they aren't pinned on-screen via the always-on

package/corpus/templates/clips/server/routes/api/video/[recordingId].get.ts

@@ -41,6 +41,7 @@ import {
   setCookie,
   type H3Event,
 } from "h3";
+import { eq } from "drizzle-orm";
 import { readAppState } from "@agent-native/core/application-state";
 import {
   createSsrfSafeDispatcher,
@@ -62,6 +63,7 @@ import {
   loomEmbedUrlForRecording,
 } from "../../../../shared/loom.js";
 import { verifySharePassword } from "../../../lib/share-password.js";
+import { getDb, schema } from "../../../db/index.js";
 
 interface RecordingRow {
   expiresAt?: string | null;
@@ -301,12 +303,39 @@ export default defineEventHandler(async (event: H3Event) => {
   return runWithRequestContext(
     { userEmail: session?.email, orgId },
     async () => {
+      // Resolve via share grants first (owner / org / shared viewers). When
+      // there is no grant — e.g. an anonymous viewer on a public share/embed
+      // page — fall back to the public-visibility gate so public clips stay
+      // playable without signing in. This mirrors the visibility check in
+      // `/api/public-recording.get.ts` (which hands the player its videoUrl) so
+      // the metadata endpoint and this media endpoint never disagree about who
+      // can play a clip. Without this, anonymous viewers hit a 403 here and the
+      // player fails with "Could not start playback. Try again."
       const access = await resolveAccess("recording", recordingId);
-      if (!access) {
-        setResponseStatus(event, 403);
-        return { error: "Forbidden" };
+      let recRow: RecordingRow | null =
+        (access?.resource as RecordingRow | undefined) ?? null;
+      let role: string | null = access?.role ?? null;
+
+      if (!recRow) {
+        const db = getDb();
+        const [row] = await db
+          .select()
+          .from(schema.recordings)
+          .where(eq(schema.recordings.id, recordingId))
+          .limit(1);
+        if (!row) {
+          setResponseStatus(event, 404);
+          return { error: "Not found" };
+        }
+        if (row.visibility !== "public") {
+          setResponseStatus(event, 403);
+          return { error: "Forbidden" };
+        }
+        recRow = row as RecordingRow;
+        role = "viewer";
       }
-      const rec = access.resource as RecordingRow;
+
+      const rec = recRow;
 
       if (rec.expiresAt) {
         const expires = new Date(rec.expiresAt).getTime();
@@ -333,7 +362,7 @@ export default defineEventHandler(async (event: H3Event) => {
         password?: string;
         t?: string;
       };
-      if (rec.password && access.role !== "owner") {
+      if (rec.password && role !== "owner") {
         const token = typeof q.t === "string" ? q.t : "";
         const cookieToken =
           getCookie(event, protectedMediaCookieName(recordingId)) ?? "";

package/corpus/templates/content/AGENTS.md

@@ -122,7 +122,8 @@ cd templates/content && pnpm action <name> [args]
 | `configure-document-property`               | `--documentId <id> [--id <propertyId>] --name <name> --type <type> [--visibility always_show\|hide_when_empty\|always_hide]`             | Create or update a property definition                                                                                                  |
 | `duplicate-document-property`               | `--documentId <id> --propertyId <propertyId>`                                                                                            | Duplicate a property definition and its stored values                                                                                   |
 | `delete-document-property`                  | `--documentId <id> --propertyId <propertyId>`                                                                                            | Delete a property definition and its stored values                                                                                      |
-| `set-document-property`                     | `--documentId <id> --propertyId <propertyId> --value <json>`                                                                             | Set a document property value                                                                                                           |
+| `set-document-property`                     | `--documentId <id> --propertyId <propertyId> --value <json>`                                                                             | Set a document property value (for a `blocks` field, the value is its markdown content)                                                 |
+| `reorder-document-property`                 | `--documentId <id> --propertyId <propertyId> --targetPropertyId <id> [--position before\|after]`                                         | Reorder a property definition within its database (used to reorder Blocks fields on the page)                                           |
 | `set-document-discoverability`              | `--id <id> --hideFromSearch true\|false [--includeChildren true\|false]`                                                                 | Hide/show an org-accessible document in Organization/search while keeping link access                                                   |
 | `move-document`                             | `--id <id> [--parentId] [--position]`                                                                                                    | Move or reorder a document in the page tree                                                                                             |
 | `delete-document`                           | `--id <id>`                                                                                                                              | Delete with recursive children                                                                                                          |
@@ -413,10 +414,26 @@ Document properties are SQL-backed, Notion-style structured metadata rather
 than YAML embedded in the markdown body. Database property definitions support
 `text`, `number`, `select`, `multi_select`, `status`, `date`, `person`,
 `place`, `files_media` (`Files & media`), `checkbox`, `url`, `email`,
-`phone`, plus computed `formula`, `id`, `created_time`, `created_by`, and
+`phone`, `blocks` (Capacities-style rich-text body field), plus computed
+`formula`, `id`, `created_time`, `created_by`, and
 `last_edited_time`, `last_edited_by`, plus property visibility (`always_show`,
 `hide_when_empty`, `always_hide`). The value table stores per-row-document JSON
-values. Formula properties store their expression in property options and support
+values.
+
+**Blocks fields.** A `blocks` field is independent rich-text content per row —
+NOT YAML and NOT a pointer to the body. Every database is seeded with one
+primary "Content" Blocks field whose content is backed by `documents.content`
+(so it reuses the collaborative TipTap/Yjs body editor and existing data
+migrates for free). Each additional Blocks field stores its own content in
+`document_block_field_contents`, keyed by `(document_id, property_id)`, so no
+two Blocks fields ever share content — adding a second Blocks field creates a
+new, empty, independent field. On the page: one Blocks field renders chromeless
+(no header, just the body); two or more each show their name as a header and are
+collapsible and reorderable (the surviving lone field keeps its stored name).
+In table views a Blocks column shows a word count (e.g. "412 words"), not the
+body. A Blocks field can only be deleted from the database view's column menu
+(not from the page body); deleting the last Blocks field warns that it removes
+the body for every object of the type. Formula properties store their expression in property options and support
 `{Property name}` substitution plus simple numeric math such as `{MSV} * 2`.
 Database views support multiple named table, list, gallery, board, calendar, and timeline views saved in
 `content_databases.view_config_json`. Each view has its own stacked sorts,

package/corpus/templates/content/actions/_database-utils.ts

@@ -123,6 +123,10 @@ export async function getContentDatabaseResponse(
 
   if (!database) throw new Error(`Database "${databaseId}" not found`);
 
+  // PURE read: the primary "Content" Blocks field is seeded at create time and
+  // by the one-time startup repair — never here. Reading a database (including a
+  // shared one a viewer is opening) must not mutate schema.
+
   const { limit, offset } = normalizeContentDatabasePageOptions(options);
   const [itemCount] = await db
     .select({ count: sql<number>`COUNT(*)` })
@@ -261,6 +265,11 @@ export async function deleteDatabaseDataForDocument(
       await db
         .delete(schema.documentPropertyValues)
         .where(eq(schema.documentPropertyValues.propertyId, definition.id));
+      // Independent Blocks-field content is keyed by property id; drop it so
+      // deleting a database leaves no orphaned document_block_field_contents.
+      await db
+        .delete(schema.documentBlockFieldContents)
+        .where(eq(schema.documentBlockFieldContents.propertyId, definition.id));
     }
     const sources = await db
       .select({ id: schema.contentDatabaseSources.id })
@@ -309,6 +318,12 @@ export async function deleteDatabaseDataForDocument(
           eq(schema.documentPropertyValues.ownerEmail, ownerEmail),
         ),
       );
+    // A deleted row document's independent Blocks-field content is keyed by
+    // document id; drop it so no document_block_field_contents rows are
+    // orphaned when the row is removed.
+    await db
+      .delete(schema.documentBlockFieldContents)
+      .where(eq(schema.documentBlockFieldContents.documentId, documentId));
     await db
       .delete(schema.contentDatabaseItems)
       .where(eq(schema.contentDatabaseItems.documentId, documentId));