@agent-native/core 0.70.0 → 0.70.2

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

@@ -1,12 +1,17 @@
-import { and, asc, eq, inArray, type InferSelectModel } from "drizzle-orm";
+import { accessFilter, assertAccess } from "@agent-native/core/sharing";
+import { and, asc, eq, inArray, sql, type InferSelectModel } from "drizzle-orm";
 import { getDb, schema } from "../server/db/index.js";
 import {
+  DEFAULT_BLOCKS_FIELD_NAME,
   defaultPropertyOptions,
   evaluatePropertyFormula,
   formulaValueText,
+  isBlocksPropertyType,
   isComputedPropertyType,
   isEmptyPropertyValue,
+  isPrimaryBlocksField,
   normalizePropertyValue,
+  resolveBlocksFieldValue,
   normalizePropertyVisibility,
   parsePropertyOptions,
   parsePropertyValue,
@@ -386,6 +391,10 @@ function normalizeStringList(value: unknown) {
 export async function listPropertiesForDocument(document: DocumentRow) {
   const database = await resolvePropertyDatabaseForDocument(document);
   if (!database) return [];
+  // Read path: PURE read. Seeding the primary Blocks field happens at create
+  // time and via the one-time startup repair (repairUnseededBlocksFields) —
+  // never here. A viewer opening a shared/legacy row must not trigger writes on
+  // another owner's database.
   return listPropertiesForDatabase(database.id, document);
 }
 
@@ -416,6 +425,13 @@ export async function listPropertiesForDatabase(
     ? await databaseRowNumbersByDocumentId(databaseId)
     : new Map<string, number>();
 
+  // Additional (non-primary) Blocks fields keep their content in their own
+  // store, keyed by (documentId, propertyId). Load this row's contents up front
+  // so each Blocks field resolves to its OWN independent content.
+  const blockContentByPropertyId = valueDocument
+    ? await blockFieldContentsForDocument(valueDocument.id)
+    : new Map<string, string>();
+
   const properties = definitions.map((definition) => {
     const type = definition.type as DocumentPropertyType;
     const storedValue = valueByPropertyId.get(definition.id);
@@ -437,7 +453,15 @@ export async function listPropertiesForDatabase(
           ? computedPropertyValue(type, valueDocument, {
               databaseRowNumber: rowNumberByDocumentId.get(valueDocument.id),
             })
-          : parsePropertyValue(storedValue?.valueJson),
+          : valueDocument && isBlocksPropertyType(type)
+            ? // Each Blocks field reads from exactly one place: the primary from
+              // the document body, additional fields from their own store.
+              resolveBlocksFieldValue({
+                options,
+                documentBody: valueDocument.content,
+                blockFieldContent: blockContentByPropertyId.get(definition.id),
+              })
+            : parsePropertyValue(storedValue?.valueJson),
       editable: !isComputedPropertyType(type),
     };
   });
@@ -544,8 +568,14 @@ async function propertyValuesForLinkedDocuments(
   const docs = await db
     .select()
     .from(schema.documents)
-    .where(inArray(schema.documents.id, documentIds));
+    .where(
+      and(
+        inArray(schema.documents.id, documentIds),
+        accessFilter(schema.documents, schema.documentShares),
+      ),
+    );
   const docById = new Map(docs.map((doc) => [doc.id, doc]));
+  const accessibleDocumentIds = docs.map((doc) => doc.id);
 
   if (isComputedPropertyType(property.definition.type)) {
     const rowNumberByDocumentId = property.definition.databaseId
@@ -561,12 +591,55 @@ async function propertyValuesForLinkedDocuments(
     });
   }
 
+  if (accessibleDocumentIds.length === 0) {
+    return documentIds.map(() => null);
+  }
+
+  if (isBlocksPropertyType(property.definition.type)) {
+    const blockFieldRows = isPrimaryBlocksField(property.definition.options)
+      ? []
+      : await db
+          .select({
+            documentId: schema.documentBlockFieldContents.documentId,
+            content: schema.documentBlockFieldContents.content,
+          })
+          .from(schema.documentBlockFieldContents)
+          .where(
+            and(
+              inArray(
+                schema.documentBlockFieldContents.documentId,
+                accessibleDocumentIds,
+              ),
+              eq(
+                schema.documentBlockFieldContents.propertyId,
+                property.definition.id,
+              ),
+            ),
+          );
+    const blockFieldContentByDocumentId = new Map(
+      blockFieldRows.map((row) => [row.documentId, row.content]),
+    );
+    return documentIds.map((documentId) => {
+      const doc = docById.get(documentId);
+      return doc
+        ? resolveBlocksFieldValue({
+            options: property.definition.options,
+            documentBody: doc.content,
+            blockFieldContent: blockFieldContentByDocumentId.get(documentId),
+          })
+        : null;
+    });
+  }
+
   const storedValues = await db
     .select()
     .from(schema.documentPropertyValues)
     .where(
       and(
-        inArray(schema.documentPropertyValues.documentId, documentIds),
+        inArray(
+          schema.documentPropertyValues.documentId,
+          accessibleDocumentIds,
+        ),
         eq(schema.documentPropertyValues.propertyId, property.definition.id),
       ),
     );
@@ -612,3 +685,297 @@ export function normalizedValueJson(
 ) {
   return serializePropertyValue(normalizePropertyValue(type, value));
 }
+
+// --- Blocks fields ---------------------------------------------------------
+//
+// Storage model: the default/primary "Content" Blocks field is backed by
+// `documents.content`. Every ADDITIONAL Blocks field stores its content in its
+// own row in `document_block_field_contents`, keyed by (documentId,
+// propertyId). This guarantees independence — no two Blocks fields ever share
+// content.
+
+// Load all additional-Blocks-field contents for a single document, keyed by
+// propertyId. The primary field is intentionally absent here (its content lives
+// on the document itself).
+export async function blockFieldContentsForDocument(
+  documentId: string,
+): Promise<Map<string, string>> {
+  const db = getDb();
+  const rows = await db
+    .select({
+      propertyId: schema.documentBlockFieldContents.propertyId,
+      content: schema.documentBlockFieldContents.content,
+    })
+    .from(schema.documentBlockFieldContents)
+    .where(eq(schema.documentBlockFieldContents.documentId, documentId));
+  return new Map(rows.map((row) => [row.propertyId, row.content ?? ""]));
+}
+
+export async function readBlockFieldContent(
+  documentId: string,
+  propertyId: string,
+): Promise<string> {
+  const db = getDb();
+  const [row] = await db
+    .select({ content: schema.documentBlockFieldContents.content })
+    .from(schema.documentBlockFieldContents)
+    .where(
+      and(
+        eq(schema.documentBlockFieldContents.documentId, documentId),
+        eq(schema.documentBlockFieldContents.propertyId, propertyId),
+      ),
+    );
+  return row?.content ?? "";
+}
+
+// Upsert the content for an additional (non-primary) Blocks field.
+//
+// Atomic insert-or-update on the UNIQUE (document_id, property_id) index — no
+// read-then-write window. Two concurrent first-saves can no longer race into a
+// duplicate-key throw: the loser falls through to the conflict UPDATE branch.
+export async function writeBlockFieldContent(args: {
+  documentId: string;
+  propertyId: string;
+  ownerEmail: string;
+  content: string;
+  now: string;
+}): Promise<void> {
+  const db = getDb();
+  await db
+    .insert(schema.documentBlockFieldContents)
+    .values({
+      id: nanoid(),
+      ownerEmail: args.ownerEmail,
+      documentId: args.documentId,
+      propertyId: args.propertyId,
+      content: args.content,
+      createdAt: args.now,
+      updatedAt: args.now,
+    })
+    .onConflictDoUpdate({
+      target: [
+        schema.documentBlockFieldContents.documentId,
+        schema.documentBlockFieldContents.propertyId,
+      ],
+      set: { content: args.content, updatedAt: args.now },
+    });
+}
+
+// Write the primary Blocks field's content — i.e. the document body.
+export async function writePrimaryBlocksContent(args: {
+  documentId: string;
+  content: string;
+  now: string;
+}): Promise<void> {
+  await assertAccess("document", args.documentId, "editor");
+  const db = getDb();
+  await db
+    .update(schema.documents)
+    .set({ content: args.content, updatedAt: args.now })
+    .where(eq(schema.documents.id, args.documentId));
+}
+
+// Fetch a single property definition scoped to a database (and owner).
+export async function getPropertyDefinitionForDatabase(args: {
+  propertyId: string;
+  databaseId: string;
+  ownerEmail: string;
+}) {
+  const db = getDb();
+  const [definition] = await db
+    .select()
+    .from(schema.documentPropertyDefinitions)
+    .where(
+      and(
+        eq(schema.documentPropertyDefinitions.id, args.propertyId),
+        eq(schema.documentPropertyDefinitions.ownerEmail, args.ownerEmail),
+        eq(schema.documentPropertyDefinitions.databaseId, args.databaseId),
+      ),
+    );
+  return definition ?? null;
+}
+
+// How many Blocks-type property definitions a database has. Used to drive the
+// solo (chromeless) vs. multi (headers + collapsible) rendering decision and
+// the "only Blocks field" delete warning.
+export async function countBlocksFieldsForDatabase(
+  databaseId: string,
+): Promise<number> {
+  const db = getDb();
+  const definitions = await db
+    .select({ type: schema.documentPropertyDefinitions.type })
+    .from(schema.documentPropertyDefinitions)
+    .where(eq(schema.documentPropertyDefinitions.databaseId, databaseId));
+  return definitions.filter((definition) =>
+    isBlocksPropertyType(definition.type as DocumentPropertyType),
+  ).length;
+}
+
+// The id of a database's existing primary Blocks definition, if any. Used to
+// adopt a legacy primary created by the old read-path seeder rather than
+// creating a duplicate.
+async function findExistingPrimaryBlocksDefinition(
+  databaseId: string,
+): Promise<string | null> {
+  const db = getDb();
+  const definitions = await db
+    .select({
+      id: schema.documentPropertyDefinitions.id,
+      type: schema.documentPropertyDefinitions.type,
+      optionsJson: schema.documentPropertyDefinitions.optionsJson,
+    })
+    .from(schema.documentPropertyDefinitions)
+    .where(eq(schema.documentPropertyDefinitions.databaseId, databaseId));
+  const primary = definitions.find(
+    (definition) =>
+      isBlocksPropertyType(definition.type as DocumentPropertyType) &&
+      isPrimaryBlocksField(parsePropertyOptions(definition.optionsJson)),
+  );
+  return primary?.id ?? null;
+}
+
+// Seed the primary "Content" Blocks field for a database exactly ONCE.
+//
+// `content_databases.primary_blocks_property_id` is the single source of truth
+// and the concurrency guard. The deterministic primary definition is inserted
+// before the database row is marked seeded, so we never publish blocks_seeded=1
+// before the definition row exists. Two concurrent calls converge on the same
+// property id and the loser returns the already-claimed id.
+//
+// Returns the primary property id (existing or newly created). Never reseeds a
+// database whose primary was intentionally deleted (blocks_seeded=1, id NULL).
+export async function seedDefaultBlocksField(args: {
+  databaseId: string;
+  ownerEmail: string;
+  orgId: string | null;
+  now: string;
+}): Promise<string | null> {
+  const db = getDb();
+
+  // Deterministic id keyed to the database so concurrent claimants converge on
+  // the same value; the UNIQUE primary-key on definitions also rejects a
+  // duplicate insert if two callers somehow both attempt it.
+  const id = `blocks_primary_${args.databaseId}`;
+
+  // Legacy adoption: a database seeded by the OLD read-path safety net already
+  // has a primary "Content" definition but a NULL column (if the v52 backfill
+  // somehow didn't run for it). Adopt that existing definition instead of
+  // creating a second primary — guarantees the invariant even off the migration
+  // path. The atomic UPDATE (column still NULL) makes this race-safe.
+  const existingPrimary = await findExistingPrimaryBlocksDefinition(
+    args.databaseId,
+  );
+  if (existingPrimary) {
+    await db
+      .update(schema.contentDatabases)
+      .set({
+        primaryBlocksPropertyId: existingPrimary,
+        blocksSeeded: 1,
+        updatedAt: args.now,
+      })
+      .where(
+        and(
+          eq(schema.contentDatabases.id, args.databaseId),
+          sql`primary_blocks_property_id IS NULL`,
+        ),
+      );
+    return existingPrimary;
+  }
+
+  const [database] = await db
+    .select({
+      primaryId: schema.contentDatabases.primaryBlocksPropertyId,
+      blocksSeeded: schema.contentDatabases.blocksSeeded,
+    })
+    .from(schema.contentDatabases)
+    .where(eq(schema.contentDatabases.id, args.databaseId));
+  if (!database) return null;
+  if (database.primaryId) return database.primaryId;
+  if (database.blocksSeeded === 1) return null;
+
+  const [maxPos] = await db
+    .select({ max: sql<number>`COALESCE(MAX(position), -1)` })
+    .from(schema.documentPropertyDefinitions)
+    .where(eq(schema.documentPropertyDefinitions.databaseId, args.databaseId));
+
+  await db
+    .insert(schema.documentPropertyDefinitions)
+    .values({
+      id,
+      ownerEmail: args.ownerEmail,
+      orgId: args.orgId,
+      databaseId: args.databaseId,
+      name: DEFAULT_BLOCKS_FIELD_NAME,
+      type: "blocks",
+      visibility: "always_show",
+      optionsJson: serializePropertyOptions({ blocks: { primary: true } }),
+      position: (maxPos?.max ?? -1) + 1,
+      createdAt: args.now,
+      updatedAt: args.now,
+    })
+    .onConflictDoNothing();
+
+  const claim = await db
+    .update(schema.contentDatabases)
+    .set({
+      primaryBlocksPropertyId: id,
+      blocksSeeded: 1,
+      updatedAt: args.now,
+    })
+    .where(
+      and(
+        eq(schema.contentDatabases.id, args.databaseId),
+        sql`primary_blocks_property_id IS NULL`,
+        sql`blocks_seeded = 0`,
+      ),
+    )
+    .returning({ id: schema.contentDatabases.primaryBlocksPropertyId });
+
+  if (claim[0]?.id === id) return id;
+
+  const [afterClaim] = await db
+    .select({ primaryId: schema.contentDatabases.primaryBlocksPropertyId })
+    .from(schema.contentDatabases)
+    .where(eq(schema.contentDatabases.id, args.databaseId));
+  if (afterClaim?.primaryId) return afterClaim.primaryId;
+
+  await db
+    .delete(schema.documentPropertyDefinitions)
+    .where(eq(schema.documentPropertyDefinitions.id, id));
+  return null;
+}
+
+// One-time startup repair for LEGACY databases that have never been seeded —
+// i.e. databases created before the Blocks type existed and which have NO
+// primary Blocks field yet (blocks_seeded = 0). Their `documents.content` body
+// still works; seeding the primary field exposes it as a first-class property.
+//
+// Runs at boot from the migration plugin, NOT from any read path, so opening a
+// shared/legacy row never triggers a write. Uses each database's own owner/org
+// (no request context). Idempotent: the atomic claim in seedDefaultBlocksField
+// makes re-runs no-ops, and databases whose primary was intentionally deleted
+// (blocks_seeded = 1) are skipped.
+export async function repairUnseededBlocksFields(): Promise<number> {
+  const db = getDb();
+  const databases = await db
+    .select({
+      id: schema.contentDatabases.id,
+      ownerEmail: schema.contentDatabases.ownerEmail,
+      orgId: schema.contentDatabases.orgId,
+    })
+    .from(schema.contentDatabases)
+    .where(eq(schema.contentDatabases.blocksSeeded, 0));
+
+  const now = new Date().toISOString();
+  let seeded = 0;
+  for (const database of databases) {
+    await seedDefaultBlocksField({
+      databaseId: database.id,
+      ownerEmail: database.ownerEmail,
+      orgId: database.orgId ?? null,
+      now,
+    });
+    seeded += 1;
+  }
+  return seeded;
+}

package/corpus/templates/content/actions/configure-document-property.ts

@@ -7,7 +7,11 @@ import { getDb, schema } from "../server/db/index.js";
 import {
   CREATABLE_DOCUMENT_PROPERTY_TYPES,
   DOCUMENT_PROPERTY_VISIBILITIES,
+  isBlocksPropertyType,
   isComputedPropertyType,
+  isPrimaryBlocksField,
+  parsePropertyOptions,
+  serializePropertyOptions,
   normalizePropertyVisibility,
   type DocumentPropertyType,
 } from "../shared/properties.js";
@@ -79,7 +83,7 @@ export default defineAction({
     const now = new Date().toISOString();
     const name = args.name.trim();
     const type = args.type as DocumentPropertyType;
-    const optionsJson = optionsForNewProperty(type, args.options as any);
+    let optionsJson = optionsForNewProperty(type, args.options as any);
     const database = await resolvePropertyDatabaseForDocument(document);
     if (!database) {
       throw new Error(
@@ -108,6 +112,27 @@ export default defineAction({
       ) {
         throw new Error("Computed property types cannot be changed.");
       }
+
+      const existingOptions = parsePropertyOptions(existing.optionsJson);
+      const existingIsPrimaryBlocks =
+        isBlocksPropertyType(existing.type as DocumentPropertyType) &&
+        isPrimaryBlocksField(existingOptions);
+
+      // The primary "Content" Blocks field backs the document body — it can be
+      // renamed/hidden but not retyped (delete it from the database view to
+      // remove the body). Block the type switch defensively.
+      if (existingIsPrimaryBlocks && existing.type !== type) {
+        throw new Error(
+          "The primary Content (Blocks) field cannot change type. Delete it from the database view to remove the body.",
+        );
+      }
+
+      // Preserve the primary flag when re-saving the primary Blocks field (a
+      // rename or visibility change must NOT demote it to a normal Blocks field).
+      if (existingIsPrimaryBlocks && isBlocksPropertyType(type)) {
+        optionsJson = serializePropertyOptions({ blocks: { primary: true } });
+      }
+
       if (existing.type !== type) {
         await db
           .delete(schema.documentPropertyValues)
@@ -117,6 +142,15 @@ export default defineAction({
               eq(schema.documentPropertyValues.ownerEmail, document.ownerEmail),
             ),
           );
+        // Switching a Blocks field to another type drops its independent content.
+        if (
+          isBlocksPropertyType(existing.type as DocumentPropertyType) &&
+          !isBlocksPropertyType(type)
+        ) {
+          await db
+            .delete(schema.documentBlockFieldContents)
+            .where(eq(schema.documentBlockFieldContents.propertyId, args.id));
+        }
       }
 
       await db

package/corpus/templates/content/actions/create-content-database.ts

@@ -10,7 +10,7 @@ import { and, eq, sql } from "drizzle-orm";
 import { z } from "zod";
 import { getDb, schema } from "../server/db/index.js";
 import { getContentDatabaseResponse } from "./_database-utils.js";
-import { nanoid } from "./_property-utils.js";
+import { nanoid, seedDefaultBlocksField } from "./_property-utils.js";
 
 export default defineAction({
   description:
@@ -151,6 +151,10 @@ export default defineAction({
       updatedAt: now,
     });
 
+    // Every database is seeded with one primary "Content" Blocks field, backed
+    // by `documents.content`, so each row's body is a first-class property.
+    await seedDefaultBlocksField({ databaseId, ownerEmail, orgId, now });
+
     await writeAppState("refresh-signal", { ts: Date.now() });
 
     return getContentDatabaseResponse(databaseId);

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

@@ -1,9 +1,15 @@
 import { defineAction } from "@agent-native/core";
 import { writeAppState } from "@agent-native/core/application-state";
 import { assertAccess } from "@agent-native/core/sharing";
-import { and, eq } from "drizzle-orm";
+import { and, eq, inArray } from "drizzle-orm";
 import { z } from "zod";
 import { getDb, schema } from "../server/db/index.js";
+import {
+  isBlocksPropertyType,
+  isPrimaryBlocksField,
+  parsePropertyOptions,
+  type DocumentPropertyType,
+} from "../shared/properties.js";
 import {
   listPropertiesForDocument,
   resolvePropertyDatabaseForDocument,
@@ -24,7 +30,7 @@ export default defineAction({
     if (!database) throw new Error("Document is not part of a database.");
 
     const [definition] = await db
-      .select({ id: schema.documentPropertyDefinitions.id })
+      .select()
       .from(schema.documentPropertyDefinitions)
       .where(
         and(
@@ -38,6 +44,13 @@ export default defineAction({
       );
     if (!definition) throw new Error(`Property "${propertyId}" not found`);
 
+    const isBlocks = isBlocksPropertyType(
+      definition.type as DocumentPropertyType,
+    );
+    const isPrimaryBlocks =
+      isBlocks &&
+      isPrimaryBlocksField(parsePropertyOptions(definition.optionsJson));
+
     await db
       .delete(schema.documentPropertyValues)
       .where(eq(schema.documentPropertyValues.propertyId, propertyId));
@@ -45,6 +58,43 @@ export default defineAction({
       .delete(schema.documentPropertyDefinitions)
       .where(eq(schema.documentPropertyDefinitions.id, propertyId));
 
+    if (isBlocks) {
+      // Drop the independent content for this Blocks field across every row.
+      await db
+        .delete(schema.documentBlockFieldContents)
+        .where(eq(schema.documentBlockFieldContents.propertyId, propertyId));
+
+      // Deleting the primary "Content" field removes the body (documents.content)
+      // for every object of this type, per the delete warning shown in the UI.
+      if (isPrimaryBlocks) {
+        // Record that the primary was intentionally removed: clear the single
+        // source of truth but LEAVE blocks_seeded = 1, so neither the read path
+        // nor the startup repair ever recreates it. Deleting the only Blocks
+        // field is an allowed product action that leaves the row metadata-only
+        // with ZERO Blocks fields.
+        await db
+          .update(schema.contentDatabases)
+          .set({
+            primaryBlocksPropertyId: null,
+            updatedAt: new Date().toISOString(),
+          })
+          .where(eq(schema.contentDatabases.id, database.id));
+
+        const items = await db
+          .select({ documentId: schema.contentDatabaseItems.documentId })
+          .from(schema.contentDatabaseItems)
+          .where(eq(schema.contentDatabaseItems.databaseId, database.id));
+        const documentIds = items.map((item) => item.documentId);
+        if (documentIds.length > 0) {
+          const now = new Date().toISOString();
+          await db
+            .update(schema.documents)
+            .set({ content: "", updatedAt: now })
+            .where(inArray(schema.documents.id, documentIds));
+        }
+      }
+    }
+
     // Free any source field that was mapped to this property so it returns to
     // the "From source" picker immediately, instead of staying orphaned until
     // the next source refresh reconciles it.

package/corpus/templates/content/actions/duplicate-document-property.ts

@@ -4,6 +4,11 @@ import { assertAccess } from "@agent-native/core/sharing";
 import { and, eq, sql } from "drizzle-orm";
 import { z } from "zod";
 import { getDb, schema } from "../server/db/index.js";
+import {
+  isBlocksPropertyType,
+  serializePropertyOptions,
+  type DocumentPropertyType,
+} from "../shared/properties.js";
 import {
   listPropertiesForDocument,
   nanoid,
@@ -56,6 +61,15 @@ export default defineAction({
 
     const now = new Date().toISOString();
     const newPropertyId = nanoid();
+    const isBlocks = isBlocksPropertyType(
+      definition.type as DocumentPropertyType,
+    );
+    // A duplicated Blocks field is a brand-new, independent, EMPTY field — never
+    // primary (only one field backs the body) and with no copied content.
+    const optionsJson = isBlocks
+      ? serializePropertyOptions({ blocks: { primary: false } })
+      : definition.optionsJson;
+
     await db.insert(schema.documentPropertyDefinitions).values({
       id: newPropertyId,
       ownerEmail: definition.ownerEmail,
@@ -64,28 +78,31 @@ export default defineAction({
       name: `${definition.name} copy`,
       type: definition.type,
       visibility: definition.visibility,
-      optionsJson: definition.optionsJson,
+      optionsJson,
       position: (maxPos?.max ?? -1) + 1,
       createdAt: now,
       updatedAt: now,
     });
 
-    const values = await db
-      .select()
-      .from(schema.documentPropertyValues)
-      .where(eq(schema.documentPropertyValues.propertyId, propertyId));
-    if (values.length > 0) {
-      await db.insert(schema.documentPropertyValues).values(
-        values.map((value) => ({
-          id: nanoid(),
-          ownerEmail: value.ownerEmail,
-          documentId: value.documentId,
-          propertyId: newPropertyId,
-          valueJson: value.valueJson,
-          createdAt: now,
-          updatedAt: now,
-        })),
-      );
+    // Blocks fields don't use document_property_values; a duplicate starts empty.
+    if (!isBlocks) {
+      const values = await db
+        .select()
+        .from(schema.documentPropertyValues)
+        .where(eq(schema.documentPropertyValues.propertyId, propertyId));
+      if (values.length > 0) {
+        await db.insert(schema.documentPropertyValues).values(
+          values.map((value) => ({
+            id: nanoid(),
+            ownerEmail: value.ownerEmail,
+            documentId: value.documentId,
+            propertyId: newPropertyId,
+            valueJson: value.valueJson,
+            createdAt: now,
+            updatedAt: now,
+          })),
+        );
+      }
     }
 
     await writeAppState("refresh-signal", { ts: Date.now() });