@agent-native/core 0.91.2 → 0.92.0

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

@@ -16,6 +16,7 @@ import {
   federateSources,
 } from "./_federation-join.js";
 import {
+  listPropertiesForDatabaseDocuments,
   listPropertiesForDatabase,
   serializeDatabase,
 } from "./_property-utils.js";
@@ -197,6 +198,10 @@ export async function getContentDatabaseResponse(
           )
       : [];
   const documentById = new Map(documents.map((doc) => [doc.id, doc]));
+  const propertiesByDocumentId = await listPropertiesForDatabaseDocuments(
+    databaseId,
+    documents,
+  );
   const queuedBodyHydrationItemIds =
     items.length > 0
       ? new Set(
@@ -234,7 +239,7 @@ export async function getContentDatabaseResponse(
       bodyHydration: serializeBodyHydration(item, {
         queued: bodyHydrationQueued,
       }),
-      properties: await listPropertiesForDatabase(databaseId, document),
+      properties: propertiesByDocumentId.get(document.id) ?? [],
     });
   }
 

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

@@ -41,6 +41,7 @@ import {
   type DocumentPropertyType,
   type DocumentPropertyValue,
 } from "../shared/properties.js";
+import { chunks } from "./_batch-utils.js";
 
 type DocumentRow = InferSelectModel<typeof schema.documents>;
 type ContentDatabaseRow = InferSelectModel<typeof schema.contentDatabases>;
@@ -526,6 +527,173 @@ export async function listPropertiesForDatabase(
   return nextProperties;
 }
 
+function serializePropertyDefinition(
+  definition: typeof schema.documentPropertyDefinitions.$inferSelect,
+) {
+  const type = definition.type as DocumentPropertyType;
+  return {
+    id: definition.id,
+    databaseId: definition.databaseId,
+    name: definition.name,
+    type,
+    visibility: normalizePropertyVisibility(definition.visibility),
+    options: parsePropertyOptions(definition.optionsJson),
+    position: definition.position,
+    createdAt: definition.createdAt,
+    updatedAt: definition.updatedAt,
+  };
+}
+
+function propertyValueKey(documentId: string, propertyId: string) {
+  return `${documentId}\0${propertyId}`;
+}
+
+export async function listPropertiesForDatabaseDocuments(
+  databaseId: string,
+  valueDocuments: DocumentRow[],
+): Promise<Map<string, DocumentProperty[]>> {
+  const db = getDb();
+  const definitions = await db
+    .select()
+    .from(schema.documentPropertyDefinitions)
+    .where(eq(schema.documentPropertyDefinitions.databaseId, databaseId))
+    .orderBy(asc(schema.documentPropertyDefinitions.position));
+  const result = new Map<string, DocumentProperty[]>();
+  if (valueDocuments.length === 0) return result;
+  if (definitions.length === 0) {
+    for (const document of valueDocuments) result.set(document.id, []);
+    return result;
+  }
+
+  const documentIds = valueDocuments.map((document) => document.id);
+  const propertyIds = definitions.map((definition) => definition.id);
+  const values: Array<typeof schema.documentPropertyValues.$inferSelect> = [];
+  for (const documentIdChunk of chunks(documentIds, 200)) {
+    for (const propertyIdChunk of chunks(propertyIds, 200)) {
+      values.push(
+        ...(await db
+          .select()
+          .from(schema.documentPropertyValues)
+          .where(
+            and(
+              inArray(
+                schema.documentPropertyValues.documentId,
+                documentIdChunk,
+              ),
+              inArray(
+                schema.documentPropertyValues.propertyId,
+                propertyIdChunk,
+              ),
+            ),
+          )),
+      );
+    }
+  }
+  const valueByDocumentAndProperty = new Map(
+    values.map((value) => [
+      propertyValueKey(value.documentId, value.propertyId),
+      value,
+    ]),
+  );
+
+  const rowNumberByDocumentId = definitions.some((definition) =>
+    isComputedPropertyType(definition.type as DocumentPropertyType),
+  )
+    ? await databaseRowNumbersByDocumentId(databaseId)
+    : new Map<string, number>();
+
+  const blockContentByDocumentAndProperty = new Map<string, string>();
+  const hasAdditionalBlocksFields = definitions.some((definition) => {
+    const type = definition.type as DocumentPropertyType;
+    return (
+      isBlocksPropertyType(type) &&
+      !isPrimaryBlocksField(parsePropertyOptions(definition.optionsJson))
+    );
+  });
+  if (hasAdditionalBlocksFields) {
+    for (const documentIdChunk of chunks(documentIds, 200)) {
+      const rows = await db
+        .select({
+          documentId: schema.documentBlockFieldContents.documentId,
+          propertyId: schema.documentBlockFieldContents.propertyId,
+          content: schema.documentBlockFieldContents.content,
+        })
+        .from(schema.documentBlockFieldContents)
+        .where(
+          inArray(
+            schema.documentBlockFieldContents.documentId,
+            documentIdChunk,
+          ),
+        );
+      for (const row of rows) {
+        blockContentByDocumentAndProperty.set(
+          propertyValueKey(row.documentId, row.propertyId),
+          row.content ?? "",
+        );
+      }
+    }
+  }
+
+  for (const document of valueDocuments) {
+    const properties = definitions.map((definition) => {
+      const propertyDefinition = serializePropertyDefinition(definition);
+      const storedValue = valueByDocumentAndProperty.get(
+        propertyValueKey(document.id, definition.id),
+      );
+      return {
+        definition: propertyDefinition,
+        value:
+          isComputedPropertyType(propertyDefinition.type) &&
+          propertyDefinition.type !== "formula"
+            ? computedPropertyValue(propertyDefinition.type, document, {
+                databaseRowNumber: rowNumberByDocumentId.get(document.id),
+              })
+            : isBlocksPropertyType(propertyDefinition.type)
+              ? resolveBlocksFieldValue({
+                  options: propertyDefinition.options,
+                  documentBody: document.content,
+                  blockFieldContent: blockContentByDocumentAndProperty.get(
+                    propertyValueKey(document.id, definition.id),
+                  ),
+                })
+              : parsePropertyValue(storedValue?.valueJson),
+        editable: !isComputedPropertyType(propertyDefinition.type),
+      };
+    });
+
+    const valuesByName = Object.fromEntries(
+      properties
+        .filter((property) => property.definition.type !== "formula")
+        .map((property) => [property.definition.name, property.value]),
+    );
+    const evaluatedProperties = properties.map((property) =>
+      property.definition.type === "formula"
+        ? {
+            ...property,
+            value: evaluatePropertyFormula(
+              property.definition.options.formula,
+              valuesByName,
+            ),
+          }
+        : property,
+    );
+    const nextProperties = [];
+    for (const property of evaluatedProperties) {
+      if (property.definition.type === "rollup") {
+        nextProperties.push({
+          ...property,
+          value: await evaluatePropertyRollup(property, evaluatedProperties),
+        });
+      } else {
+        nextProperties.push(property);
+      }
+    }
+    result.set(document.id, nextProperties);
+  }
+
+  return result;
+}
+
 async function evaluatePropertyRollup(
   property: DocumentProperty,
   properties: DocumentProperty[],

package/corpus/templates/content/actions/add-content-database-source-field-property.ts

@@ -21,6 +21,7 @@ import {
   type DocumentPropertyOptions,
   type DocumentPropertyType,
 } from "../shared/properties.js";
+import { chunks } from "./_batch-utils.js";
 import {
   resolveDatabaseForSourceMutation,
   serializeSourceField,
@@ -343,7 +344,11 @@ export default defineAction({
     const sourceRows = isSecondary
       ? []
       : await db
-          .select()
+          .select({
+            databaseItemId: schema.contentDatabaseSourceRows.databaseItemId,
+            documentId: schema.contentDatabaseSourceRows.documentId,
+            sourceValuesJson: schema.contentDatabaseSourceRows.sourceValuesJson,
+          })
           .from(schema.contentDatabaseSourceRows)
           .where(eq(schema.contentDatabaseSourceRows.sourceId, source.id));
     const builderMetadata = builderMetadataForSourceField({
@@ -397,17 +402,19 @@ export default defineAction({
       options,
     );
     if (itemValues.length > 0) {
-      await db.insert(schema.documentPropertyValues).values(
-        itemValues.map((row) => ({
-          id: nanoid(),
-          ownerEmail: database.ownerEmail,
-          documentId: row.documentId,
-          propertyId,
-          valueJson: serializePropertyValue(row.value),
-          createdAt: now,
-          updatedAt: now,
-        })),
-      );
+      for (const chunk of chunks(itemValues, 200)) {
+        await db.insert(schema.documentPropertyValues).values(
+          chunk.map((row) => ({
+            id: nanoid(),
+            ownerEmail: database.ownerEmail,
+            documentId: row.documentId,
+            propertyId,
+            valueJson: serializePropertyValue(row.value),
+            createdAt: now,
+            updatedAt: now,
+          })),
+        );
+      }
     }
 
     const sourceField = serializeSourceField(

package/corpus/templates/content/actions/bind-content-database-source-field.ts

@@ -9,6 +9,7 @@ import type {
   ContentDatabaseResponse,
 } from "../shared/api.js";
 import { serializePropertyValue } from "../shared/properties.js";
+import { chunks } from "./_batch-utils.js";
 import { resolveDatabaseForSourceMutation } from "./_database-source-utils.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
 import { nanoid } from "./_property-utils.js";
@@ -207,7 +208,11 @@ export default defineAction({
     }
     if (federationRole !== "secondary") {
       const sourceRows = await db
-        .select()
+        .select({
+          databaseItemId: schema.contentDatabaseSourceRows.databaseItemId,
+          documentId: schema.contentDatabaseSourceRows.documentId,
+          sourceValuesJson: schema.contentDatabaseSourceRows.sourceValuesJson,
+        })
         .from(schema.contentDatabaseSourceRows)
         .where(eq(schema.contentDatabaseSourceRows.sourceId, source.id));
       const itemValues = sourceFieldPropertyValuesFromRows(
@@ -237,17 +242,19 @@ export default defineAction({
           );
       }
       if (itemValues.length > 0) {
-        await db.insert(schema.documentPropertyValues).values(
-          itemValues.map((row) => ({
-            id: nanoid(),
-            ownerEmail: database.ownerEmail,
-            documentId: row.documentId,
-            propertyId: property.id,
-            valueJson: serializePropertyValue(row.value),
-            createdAt: now,
-            updatedAt: now,
-          })),
-        );
+        for (const chunk of chunks(itemValues, 200)) {
+          await db.insert(schema.documentPropertyValues).values(
+            chunk.map((row) => ({
+              id: nanoid(),
+              ownerEmail: database.ownerEmail,
+              documentId: row.documentId,
+              propertyId: property.id,
+              valueJson: serializePropertyValue(row.value),
+              createdAt: now,
+              updatedAt: now,
+            })),
+          );
+        }
       }
     }
 

package/corpus/templates/content/actions/delete-document.ts

@@ -5,6 +5,7 @@ import { and, eq, inArray } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
+import { chunks } from "./_batch-utils.js";
 import {
   deleteLocalFileDocument,
   isLocalDocumentId,
@@ -13,21 +14,13 @@ import {
 
 const DELETE_BATCH_SIZE = 90;
 
-function chunks<T>(items: T[], size = DELETE_BATCH_SIZE): T[][] {
-  const out: T[][] = [];
-  for (let index = 0; index < items.length; index += size) {
-    out.push(items.slice(index, index + size));
-  }
-  return out;
-}
-
 async function selectDocumentChildren(
   db: ReturnType<typeof getDb>,
   parentIds: string[],
   ownerEmail: string,
 ) {
   const rows: Array<{ id: string }> = [];
-  for (const batch of chunks(parentIds)) {
+  for (const batch of chunks(parentIds, DELETE_BATCH_SIZE)) {
     rows.push(
       ...(await db
         .select({ id: schema.documents.id })
@@ -49,7 +42,7 @@ async function selectOwnedDatabaseIds(
   ownerEmail: string,
 ) {
   const rows: Array<{ id: string }> = [];
-  for (const batch of chunks(documentIds)) {
+  for (const batch of chunks(documentIds, DELETE_BATCH_SIZE)) {
     rows.push(
       ...(await db
         .select({ id: schema.contentDatabases.id })
@@ -71,7 +64,7 @@ async function selectDatabaseItemDocuments(
   ownerEmail: string,
 ) {
   const rows: Array<{ documentId: string }> = [];
-  for (const batch of chunks(databaseIds)) {
+  for (const batch of chunks(databaseIds, DELETE_BATCH_SIZE)) {
     rows.push(
       ...(await db
         .select({ documentId: schema.contentDatabaseItems.documentId })
@@ -87,7 +80,10 @@ async function selectDatabaseItemDocuments(
   if (rows.length === 0) return rows;
 
   const ownedRows: Array<{ id: string }> = [];
-  for (const batch of chunks(rows.map((row) => row.documentId))) {
+  for (const batch of chunks(
+    rows.map((row) => row.documentId),
+    DELETE_BATCH_SIZE,
+  )) {
     ownedRows.push(
       ...(await db
         .select({ id: schema.documents.id })
@@ -167,7 +163,7 @@ async function deleteWhereIn<T>(
   items: T[],
   run: (batch: T[]) => Promise<unknown>,
 ) {
-  for (const batch of chunks(items)) {
+  for (const batch of chunks(items, DELETE_BATCH_SIZE)) {
     if (batch.length > 0) await run(batch);
   }
 }

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

@@ -4,7 +4,8 @@ import { z } from "zod";
 
 import type { ContentDatabaseSourceStatusResponse } from "../shared/api.js";
 import {
-  getContentDatabaseSourceSnapshotForWrite,
+  getContentDatabaseSourceSnapshot,
+  getContentDatabaseSourceSnapshotById,
   getExistingSourceForWrite,
   resyncBuilderCmsSourceSnapshot,
   resyncMockSourceSnapshot,
@@ -60,10 +61,9 @@ export default defineAction({
     } else {
       throw new Error(`Unsupported source type "${source.sourceType}".`);
     }
-    const snapshot = await getContentDatabaseSourceSnapshotForWrite(
-      database,
-      args.sourceId,
-    );
+    const snapshot = args.sourceId
+      ? await getContentDatabaseSourceSnapshotById(database, args.sourceId)
+      : await getContentDatabaseSourceSnapshot(database);
 
     const builderProgress =
       snapshot?.sourceType === "builder-cms" ? snapshot.metadata : null;

package/corpus/templates/content/app/components/editor/body-hydration.ts

@@ -39,29 +39,39 @@ export function builderBodyHydrationDisplayHydratedCount(args: {
 export function databaseItemBodyHydrationIsPending(
   item: Pick<ContentDatabaseItem, "bodyHydration" | "document">,
 ) {
+  const hydration =
+    item.bodyHydration ?? item.document.databaseMembership?.bodyHydration;
   if (
-    item.document.databaseMembership?.sourceId &&
-    !item.bodyHydration &&
-    !item.document.databaseMembership.bodyHydration
+    sourceBackedEmptyBodyNeedsHydration({
+      sourceId: item.document.databaseMembership?.sourceId,
+      content: item.document.content,
+      hydration,
+    })
   ) {
     return true;
   }
-  return builderBodyHydrationIsPending(
-    item.bodyHydration ?? item.document.databaseMembership?.bodyHydration,
-  );
+  return builderBodyHydrationIsPending(hydration);
 }
 
 export function documentBodyHydrationIsPending(
-  document: Pick<Document, "databaseMembership">,
+  document: Pick<Document, "content" | "databaseMembership">,
 ) {
-  return builderBodyHydrationIsPending(
-    document.databaseMembership?.bodyHydration,
-  );
+  const hydration = document.databaseMembership?.bodyHydration;
+  if (
+    sourceBackedEmptyBodyNeedsHydration({
+      sourceId: document.databaseMembership?.sourceId,
+      content: document.content,
+      hydration,
+    })
+  ) {
+    return true;
+  }
+  return builderBodyHydrationIsPending(hydration);
 }
 
 export function previewBodyHydrationIsPending(args: {
   item: Pick<ContentDatabaseItem, "bodyHydration" | "document">;
-  document: Pick<Document, "databaseMembership"> | null | undefined;
+  document: Pick<Document, "content" | "databaseMembership"> | null | undefined;
 }) {
   const membership =
     args.document?.databaseMembership ?? args.item.document.databaseMembership;
@@ -101,6 +111,20 @@ export function isEffectivelyEmptyDocumentContent(
   return normalized === "" || normalized === "<empty-block/>";
 }
 
+function sourceBackedEmptyBodyNeedsHydration(args: {
+  sourceId: string | null | undefined;
+  content: string | null | undefined;
+  hydration: ContentDatabaseBodyHydration | null | undefined;
+}) {
+  if (!args.sourceId || !isEffectivelyEmptyDocumentContent(args.content)) {
+    return false;
+  }
+  if (!args.hydration) return true;
+  if (builderBodyHydrationIsPending(args.hydration)) return true;
+  if (args.hydration.status === "error") return false;
+  return args.hydration.status === "hydrated" && !args.hydration.version;
+}
+
 export function shouldIgnorePreviewEmptyNormalization(args: {
   currentContent: string | null | undefined;
   nextContent: string | null | undefined;

package/corpus/templates/content/app/components/editor/database/DatabaseView.tsx

@@ -7159,6 +7159,11 @@ function BuilderSourceContinuationBar({
         )
       : rawFetchedCount;
   const hasMore = source.metadata.lastReadHasMore === true && !rowsComplete;
+  const fetchedCountDetail = builderSourceContinuationFetchedCountDetail(
+    source,
+    fetchedCount,
+    rowsComplete,
+  );
   const bodyHydrationActive =
     !hasMore &&
     !!bodyHydration &&
@@ -7212,7 +7217,9 @@ function BuilderSourceContinuationBar({
               failed: bodyHydration.error,
             },
           )
-        : dbText("builderRowsFetchedSoFar", { count: fetchedCount });
+        : dbText("builderRowsFetchedSoFar", {
+            count: fetchedCountDetail ?? fetchedCount,
+          });
 
   return (
     <div
@@ -8030,6 +8037,24 @@ export function builderSourceContinuationProgressPercent(
     : rawPercent;
 }
 
+export function builderSourceContinuationFetchedCountDetail(
+  source: Pick<ContentDatabaseSource, "metadata">,
+  fetchedCount: number | null,
+  rowsComplete = false,
+) {
+  const knownFetchTotal =
+    !rowsComplete &&
+    source.metadata.lastReadHasMore === true &&
+    typeof source.metadata.lastReadLimit === "number"
+      ? source.metadata.lastReadLimit
+      : null;
+  return fetchedCount !== null &&
+    knownFetchTotal !== null &&
+    knownFetchTotal > fetchedCount
+    ? `${fetchedCount} of ${knownFetchTotal}`
+    : fetchedCount;
+}
+
 export function builderSourceContinuationWatchdogDecision(refires: number) {
   return "refire";
 }
@@ -12427,12 +12452,24 @@ function isTablePropertyVisible(
   });
 }
 
-function databaseTableCellDisplayValue(property: DocumentProperty) {
+function databaseTableCellDisplayValue(
+  property: DocumentProperty,
+  item?: Pick<ContentDatabaseItem, "bodyHydration" | "document">,
+) {
   // Blocks columns show a word count, never the dumped body content.
   if (property.definition.type === "blocks") {
     const content = typeof property.value === "string" ? property.value : "";
     const words = countWords(content);
-    if (words === 0) return <span aria-hidden="true">&nbsp;</span>;
+    if (words === 0) {
+      if (item && databaseItemBodyHydrationIsPending(item)) {
+        return (
+          <span className="text-muted-foreground">
+            {dbText("builderBodySyncing")}
+          </span>
+        );
+      }
+      return <span aria-hidden="true">&nbsp;</span>;
+    }
     return (
       <span className="text-muted-foreground">{formatWordCount(content)}</span>
     );
@@ -16865,6 +16902,9 @@ function DatabaseTableRow({
           item.properties.find(
             (candidate) => candidate.definition.id === property.definition.id,
           ) ?? property;
+        const bodyCellHydrationPending =
+          itemProperty.definition.type === "blocks" &&
+          databaseItemBodyHydrationIsPending(item);
 
         const value = (
           <div
@@ -16873,10 +16913,12 @@ function DatabaseTableRow({
               wrapCells
                 ? "whitespace-normal break-words"
                 : "truncate whitespace-nowrap",
-              isEmptyPropertyValue(itemProperty.value) && "text-transparent",
+              isEmptyPropertyValue(itemProperty.value) &&
+                !bodyCellHydrationPending &&
+                "text-transparent",
             )}
           >
-            {databaseTableCellDisplayValue(itemProperty)}
+            {databaseTableCellDisplayValue(itemProperty, item)}
           </div>
         );
         const isEditableCheckbox =

package/corpus/templates/content/app/hooks/use-documents.ts

@@ -14,6 +14,7 @@ import { useQueryClient } from "@tanstack/react-query";
 import { toast } from "sonner";
 
 import { databaseItemBodyHydrationIsPending } from "@/components/editor/body-hydration";
+import { isEffectivelyEmptyDocumentContent } from "@/components/editor/body-hydration";
 
 import type { DocumentUpdateConflictResponse } from "../../actions/update-document";
 import { useRestoreContentDatabase } from "./use-content-database";
@@ -85,14 +86,19 @@ export function seedDatabaseItemDocumentCaches(
   queryClient: Pick<QueryClient, "getQueryData" | "setQueryData">,
   item: ContentDatabaseItem,
 ) {
+  const sourceBackedEmptyBody =
+    (!!item.bodyHydration || !!item.document.databaseMembership?.sourceId) &&
+    isEffectivelyEmptyDocumentContent(item.document.content);
   // Seed only cold caches. Overwriting an existing entry would bump its
   // freshness with possibly older table-snapshot data (a background database
   // refetch can lag a just-saved document edit) and suppress the correcting
   // refetch for the whole staleTime window. Rows whose Builder body has not
-  // hydrated yet are never seeded: their empty table-snapshot `content` would
-  // render as an authoritative empty document.
+  // hydrated yet, or whose source-backed list snapshot intentionally omits the
+  // body, are never seeded: their empty table-snapshot `content` would render as
+  // an authoritative empty document.
   if (
     !databaseItemBodyHydrationIsPending(item) &&
+    !sourceBackedEmptyBody &&
     queryClient.getQueryData(documentQueryKey(item.document.id)) === undefined
   ) {
     queryClient.setQueryData<Document>(documentQueryKey(item.document.id), {

package/corpus/templates/content/changelog/2026-07-08-builder-source-sync-now-completes-reliably-on-hosted-databases.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-08
+---
+
+Builder source sync now completes reliably on hosted databases with hundreds of entries.

package/corpus/templates/content/changelog/2026-07-08-fixed-builder-database-sync-so-large-sources-continue-past-t.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-08
+---
+
+Fixed Builder database sync so large sources continue past the first batch without leaving the table stuck mid-refresh.

package/corpus/templates/content/server/plugins/db.ts

@@ -616,6 +616,25 @@ const runContentMigrations = runMigrations(
       // becoming unrelated top-level comments. See actions/sync-notion-comments.ts.
       sql: `ALTER TABLE document_comments ADD COLUMN IF NOT EXISTS notion_discussion_id TEXT`,
     },
+    {
+      version: 63,
+      name: "builder-source-refresh-hot-path-indexes",
+      sql: `CREATE INDEX IF NOT EXISTS content_database_items_database_position_idx ON content_database_items (database_id, position);
+        CREATE INDEX IF NOT EXISTS content_database_items_document_idx ON content_database_items (document_id);
+        CREATE INDEX IF NOT EXISTS content_database_source_rows_source_created_idx ON content_database_source_rows (source_id, created_at);
+        CREATE INDEX IF NOT EXISTS content_database_source_rows_source_document_idx ON content_database_source_rows (source_id, document_id);
+        CREATE INDEX IF NOT EXISTS content_database_source_rows_source_item_idx ON content_database_source_rows (source_id, database_item_id);
+        CREATE INDEX IF NOT EXISTS content_database_source_rows_source_row_idx ON content_database_source_rows (source_id, source_row_id);
+        CREATE INDEX IF NOT EXISTS content_database_source_fields_source_key_idx ON content_database_source_fields (source_id, source_field_key);
+        CREATE INDEX IF NOT EXISTS content_database_source_fields_source_property_idx ON content_database_source_fields (source_id, property_id);
+        CREATE INDEX IF NOT EXISTS content_database_body_hydration_queue_source_document_idx ON content_database_body_hydration_queue (source_id, document_id, priority, created_at)`,
+    },
+    {
+      version: 64,
+      name: "document-property-value-hot-path-indexes",
+      sql: `CREATE INDEX IF NOT EXISTS document_property_values_document_property_idx ON document_property_values (document_id, property_id);
+        CREATE INDEX IF NOT EXISTS document_property_values_property_document_idx ON document_property_values (property_id, document_id)`,
+    },
   ],
   { table: "content_migrations" },
 );