@agent-native/core 0.84.0 → 0.84.2

package/corpus/templates/content/actions/disconnect-notion.ts

@@ -0,0 +1,16 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import { disconnectNotionForOwner } from "../server/lib/notion.js";
+import { getCurrentNotionOwner } from "./_notion-action-utils.js";
+
+export default defineAction({
+  description: "Disconnect the current user's Notion workspace.",
+  schema: z.object({}),
+  http: { method: "POST" },
+  run: async () => {
+    const owner = getCurrentNotionOwner();
+    const deleted = await disconnectNotionForOwner(owner);
+    return { success: true, deleted };
+  },
+});

package/corpus/templates/content/actions/duplicate-database-item.ts

@@ -11,7 +11,7 @@ import { nanoid } from "./_property-utils.js";
 
 export default defineAction({
   description:
-    "Duplicate a page row in a content database, including stored property values.",
+    "Duplicate exactly one page row in a content database, including stored property values. For two or more rows, use duplicate-database-items once instead of looping this action.",
   schema: z.object({
     itemId: z.string().optional().describe("Database item ID"),
     documentId: z.string().optional().describe("Database row document ID"),

package/corpus/templates/content/actions/duplicate-database-items.ts

@@ -0,0 +1,191 @@
+import { defineAction } from "@agent-native/core";
+import { writeAppState } from "@agent-native/core/application-state";
+import { getRequestUserEmail } from "@agent-native/core/server/request-context";
+import { assertAccess } from "@agent-native/core/sharing";
+import { and, eq, gte, inArray, sql } from "drizzle-orm";
+
+import { getDb, schema } from "../server/db/index.js";
+import {
+  databaseRowBatchSchema,
+  resolveDatabaseRowsForBatch,
+} from "./_database-row-batch.js";
+import { getContentDatabaseResponse } from "./_database-utils.js";
+import { nanoid } from "./_property-utils.js";
+
+export default defineAction({
+  description:
+    "Duplicate multiple page rows in a content database in one atomic batch. Use this for two or more selected/named rows instead of looping duplicate-database-item.",
+  schema: databaseRowBatchSchema,
+  run: async (args) => {
+    const db = getDb();
+    const { database, rows } = await resolveDatabaseRowsForBatch(args);
+
+    await assertAccess("document", database.documentId, "editor");
+    for (const row of rows) {
+      await assertAccess("document", row.document.id, "viewer");
+    }
+
+    const sourceDocumentIds = rows.map((row) => row.document.id);
+    const sourceItemIds = rows.map((row) => row.item.id);
+    const now = new Date().toISOString();
+    const insertionPosition =
+      Math.max(...rows.map((row) => row.item.position)) + 1;
+    const currentUserEmail = getRequestUserEmail() ?? database.ownerEmail;
+
+    const values =
+      sourceDocumentIds.length > 0
+        ? await db
+            .select()
+            .from(schema.documentPropertyValues)
+            .where(
+              inArray(
+                schema.documentPropertyValues.documentId,
+                sourceDocumentIds,
+              ),
+            )
+        : [];
+    const valuesByDocumentId = new Map<
+      string,
+      Array<typeof schema.documentPropertyValues.$inferSelect>
+    >();
+    for (const value of values) {
+      const list = valuesByDocumentId.get(value.documentId) ?? [];
+      list.push(value);
+      valuesByDocumentId.set(value.documentId, list);
+    }
+
+    const inheritedShares = await db
+      .select({
+        principalType: schema.documentShares.principalType,
+        principalId: schema.documentShares.principalId,
+        role: schema.documentShares.role,
+      })
+      .from(schema.documentShares)
+      .where(eq(schema.documentShares.resourceId, database.documentId));
+
+    const duplicates = rows.map((row, index) => ({
+      sourceItemId: row.item.id,
+      sourceDocumentId: row.document.id,
+      duplicatedItemId: nanoid(),
+      duplicatedDocumentId: nanoid(),
+      position: insertionPosition + index,
+      row,
+    }));
+
+    await db.transaction(async (tx) => {
+      await tx
+        .update(schema.contentDatabaseItems)
+        .set({
+          position: sql`${schema.contentDatabaseItems.position} + ${duplicates.length}`,
+          updatedAt: now,
+        })
+        .where(
+          and(
+            eq(schema.contentDatabaseItems.databaseId, database.id),
+            gte(schema.contentDatabaseItems.position, insertionPosition),
+          ),
+        );
+
+      await tx
+        .update(schema.documents)
+        .set({
+          position: sql`${schema.documents.position} + ${duplicates.length}`,
+          updatedAt: now,
+        })
+        .where(
+          and(
+            eq(schema.documents.ownerEmail, database.ownerEmail),
+            eq(schema.documents.parentId, database.documentId),
+            gte(schema.documents.position, insertionPosition),
+          ),
+        );
+
+      await tx.insert(schema.documents).values(
+        duplicates.map((duplicate) => ({
+          id: duplicate.duplicatedDocumentId,
+          ownerEmail: duplicate.row.document.ownerEmail,
+          orgId: duplicate.row.document.orgId,
+          parentId: database.documentId,
+          title: `Copy of ${duplicate.row.document.title.trim() || "Untitled"}`,
+          content: duplicate.row.document.content,
+          icon: duplicate.row.document.icon,
+          position: duplicate.position,
+          isFavorite: 0,
+          hideFromSearch: duplicate.row.document.hideFromSearch,
+          visibility: duplicate.row.document.visibility,
+          createdAt: now,
+          updatedAt: now,
+        })),
+      );
+
+      await tx.insert(schema.contentDatabaseItems).values(
+        duplicates.map((duplicate) => ({
+          id: duplicate.duplicatedItemId,
+          ownerEmail: duplicate.row.item.ownerEmail,
+          orgId: duplicate.row.item.orgId,
+          databaseId: database.id,
+          documentId: duplicate.duplicatedDocumentId,
+          position: duplicate.position,
+          createdAt: now,
+          updatedAt: now,
+        })),
+      );
+
+      const duplicatedValues = duplicates.flatMap((duplicate) =>
+        (valuesByDocumentId.get(duplicate.sourceDocumentId) ?? []).map(
+          (value) => ({
+            id: nanoid(),
+            ownerEmail: duplicate.row.document.ownerEmail,
+            documentId: duplicate.duplicatedDocumentId,
+            propertyId: value.propertyId,
+            valueJson: value.valueJson,
+            createdAt: now,
+            updatedAt: now,
+          }),
+        ),
+      );
+      if (duplicatedValues.length > 0) {
+        await tx.insert(schema.documentPropertyValues).values(duplicatedValues);
+      }
+
+      if (inheritedShares.length > 0) {
+        await tx.insert(schema.documentShares).values(
+          duplicates.flatMap((duplicate) =>
+            inheritedShares.map((share) => ({
+              id: nanoid(),
+              resourceId: duplicate.duplicatedDocumentId,
+              principalType: share.principalType,
+              principalId: share.principalId,
+              role: share.role,
+              createdBy: currentUserEmail,
+              createdAt: now,
+            })),
+          ),
+        );
+      }
+    });
+
+    await writeAppState("refresh-signal", { ts: Date.now() });
+
+    return {
+      ...(await getContentDatabaseResponse(database.id)),
+      duplicatedItemId: duplicates[0]?.duplicatedItemId,
+      duplicatedDocumentId: duplicates[0]?.duplicatedDocumentId,
+      duplicatedItemIds: duplicates.map(
+        (duplicate) => duplicate.duplicatedItemId,
+      ),
+      duplicatedDocumentIds: duplicates.map(
+        (duplicate) => duplicate.duplicatedDocumentId,
+      ),
+      sourceItemIds,
+      sourceDocumentIds,
+      sourceToDuplicate: duplicates.map((duplicate) => ({
+        sourceItemId: duplicate.sourceItemId,
+        sourceDocumentId: duplicate.sourceDocumentId,
+        duplicatedItemId: duplicate.duplicatedItemId,
+        duplicatedDocumentId: duplicate.duplicatedDocumentId,
+      })),
+      duplicatedCount: duplicates.length,
+    };
+  },
+});

package/corpus/templates/content/actions/link-notion-page.ts

@@ -1,8 +1,11 @@
 import { defineAction } from "@agent-native/core";
-import { getRequestUserEmail } from "@agent-native/core/server";
 import { z } from "zod";
 
 import { linkDocumentToNotionPage } from "../server/lib/notion-sync.js";
+import {
+  getNotionDocumentOwner,
+  resolveDocumentId,
+} from "./_notion-action-utils.js";
 
 export default defineAction({
   description: "Link a document to a Notion page for syncing.",
@@ -10,19 +13,19 @@ export default defineAction({
     documentId: z.string().optional().describe("Document ID (required)"),
     id: z.string().optional().describe("Alias for --documentId"),
     pageId: z.string().optional().describe("Notion page ID or URL (required)"),
+    pageIdOrUrl: z.string().optional().describe("Alias for --pageId"),
     url: z.string().optional().describe("Alias for --pageId"),
   }),
-  http: false,
+  http: { method: "POST" },
   run: async (args) => {
-    const owner = getRequestUserEmail();
-    if (!owner) throw new Error("no authenticated user");
-    const documentId = args.documentId || args.id;
-    const pageIdOrUrl = args.pageId || args.url;
+    const documentId = resolveDocumentId(args);
+    const pageIdOrUrl = args.pageId || args.pageIdOrUrl || args.url;
 
-    if (!documentId || !pageIdOrUrl) {
+    if (!pageIdOrUrl) {
       throw new Error("documentId and pageId are required");
     }
 
+    const owner = await getNotionDocumentOwner(documentId);
     return linkDocumentToNotionPage(owner, documentId, pageIdOrUrl);
   },
 });

package/corpus/templates/content/actions/list-notion-links.ts

@@ -1,16 +1,15 @@
 import { defineAction } from "@agent-native/core";
-import { getRequestUserEmail } from "@agent-native/core/server";
 import { z } from "zod";
 
 import { listNotionLinks } from "../server/lib/notion-sync.js";
+import { getCurrentNotionOwner } from "./_notion-action-utils.js";
 
 export default defineAction({
   description: "List all documents linked to Notion pages.",
   schema: z.object({}),
-  http: false,
+  http: { method: "GET" },
   run: async () => {
-    const owner = getRequestUserEmail();
-    if (!owner) throw new Error("no authenticated user");
+    const owner = getCurrentNotionOwner();
     return listNotionLinks(owner);
   },
 });

package/corpus/templates/content/actions/pull-notion-page.ts

@@ -1,8 +1,11 @@
 import { defineAction } from "@agent-native/core";
-import { getRequestUserEmail } from "@agent-native/core/server";
 import { z } from "zod";
 
 import { pullDocumentFromNotion } from "../server/lib/notion-sync.js";
+import {
+  getNotionDocumentOwner,
+  resolveDocumentId,
+} from "./_notion-action-utils.js";
 
 export default defineAction({
   description: "Pull content from a linked Notion page into a local document.",
@@ -10,15 +13,10 @@ export default defineAction({
     documentId: z.string().optional().describe("Document ID (required)"),
     id: z.string().optional().describe("Alias for --documentId"),
   }),
-  http: false,
+  http: { method: "POST" },
   run: async (args) => {
-    const documentId = args.documentId || args.id;
-    if (!documentId) {
-      throw new Error("documentId is required");
-    }
-
-    const owner = getRequestUserEmail();
-    if (!owner) throw new Error("no authenticated user");
+    const documentId = resolveDocumentId(args);
+    const owner = await getNotionDocumentOwner(documentId);
     return pullDocumentFromNotion(owner, documentId, true);
   },
 });

package/corpus/templates/content/actions/push-notion-page.ts

@@ -1,8 +1,11 @@
 import { defineAction } from "@agent-native/core";
-import { getRequestUserEmail } from "@agent-native/core/server";
 import { z } from "zod";
 
 import { pushDocumentToNotion } from "../server/lib/notion-sync.js";
+import {
+  getNotionDocumentOwner,
+  resolveDocumentId,
+} from "./_notion-action-utils.js";
 
 export default defineAction({
   description: "Push local document content to a linked Notion page.",
@@ -10,15 +13,10 @@ export default defineAction({
     documentId: z.string().optional().describe("Document ID (required)"),
     id: z.string().optional().describe("Alias for --documentId"),
   }),
-  http: false,
+  http: { method: "POST" },
   run: async (args) => {
-    const documentId = args.documentId || args.id;
-    if (!documentId) {
-      throw new Error("documentId is required");
-    }
-
-    const owner = getRequestUserEmail();
-    if (!owner) throw new Error("no authenticated user");
+    const documentId = resolveDocumentId(args);
+    const owner = await getNotionDocumentOwner(documentId);
     return pushDocumentToNotion(owner, documentId);
   },
 });

package/corpus/templates/content/actions/refresh-notion-sync-status.ts

@@ -0,0 +1,24 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import { refreshDocumentSyncStatus } from "../server/lib/notion-sync.js";
+import {
+  getNotionDocumentOwner,
+  resolveDocumentId,
+} from "./_notion-action-utils.js";
+
+export default defineAction({
+  description: "Refresh Notion sync status for a linked Content document.",
+  schema: z.object({
+    documentId: z.string().optional().describe("Document ID (required)"),
+    id: z.string().optional().describe("Alias for --documentId"),
+    autoSync: z.boolean().optional(),
+  }),
+  run: async (args) => {
+    const documentId = resolveDocumentId(args);
+    const owner = await getNotionDocumentOwner(documentId);
+    return refreshDocumentSyncStatus(owner, documentId, {
+      autoSync: !!args.autoSync,
+    });
+  },
+});

package/corpus/templates/content/actions/resolve-notion-sync-conflict.ts

@@ -0,0 +1,23 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import { resolveDocumentSyncConflict } from "../server/lib/notion-sync.js";
+import {
+  getNotionDocumentOwner,
+  resolveDocumentId,
+} from "./_notion-action-utils.js";
+
+export default defineAction({
+  description: "Resolve a Notion sync conflict by pulling or pushing.",
+  schema: z.object({
+    documentId: z.string().optional().describe("Document ID (required)"),
+    id: z.string().optional().describe("Alias for --documentId"),
+    direction: z.enum(["pull", "push"]),
+  }),
+  http: { method: "POST" },
+  run: async (args) => {
+    const documentId = resolveDocumentId(args);
+    const owner = await getNotionDocumentOwner(documentId);
+    return resolveDocumentSyncConflict(owner, documentId, args.direction);
+  },
+});

package/corpus/templates/content/actions/search-notion-pages.ts

@@ -0,0 +1,67 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import {
+  getNotionConnectionForOwner,
+  notionFetch,
+} from "../server/lib/notion.js";
+import type {
+  NotionSearchResponse,
+  NotionSearchResult,
+} from "../shared/api.js";
+import { getCurrentNotionOwner } from "./_notion-action-utils.js";
+
+export default defineAction({
+  description: "Search connected Notion pages visible to the current user.",
+  schema: z.object({
+    query: z.string().default(""),
+  }),
+  http: { method: "GET" },
+  run: async ({ query }): Promise<NotionSearchResponse> => {
+    const owner = getCurrentNotionOwner();
+    const conn = await getNotionConnectionForOwner(owner);
+    if (!conn) {
+      throw new Error("Notion not connected");
+    }
+
+    const result = await notionFetch<{
+      results: Array<{
+        id: string;
+        object: string;
+        icon?: { type: string; emoji?: string } | null;
+        url?: string;
+        last_edited_time?: string;
+        properties?: Record<string, any>;
+      }>;
+      has_more: boolean;
+    }>("/search", conn.accessToken, {
+      method: "POST",
+      body: JSON.stringify({
+        query: query.trim(),
+        filter: { value: "page", property: "object" },
+        sort: { direction: "descending", timestamp: "last_edited_time" },
+        page_size: 20,
+      }),
+    });
+
+    const results: NotionSearchResult[] = result.results.map((page) => {
+      const titleProp = Object.values(page.properties || {}).find(
+        (value: any) => value?.type === "title",
+      ) as any;
+      const title =
+        (titleProp?.title || [])
+          .map((part: any) => part.plain_text || "")
+          .join("") || "Untitled";
+
+      return {
+        id: page.id,
+        title,
+        icon: page.icon?.type === "emoji" ? page.icon.emoji || null : null,
+        url: page.url || `https://notion.so/${page.id.replace(/-/g, "")}`,
+        lastEditedTime: page.last_edited_time || null,
+      };
+    });
+
+    return { results, hasMore: result.has_more };
+  },
+});

package/corpus/templates/content/actions/unlink-notion-page.ts

@@ -0,0 +1,23 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import { unlinkDocumentFromNotion } from "../server/lib/notion-sync.js";
+import {
+  getNotionDocumentOwner,
+  resolveDocumentId,
+} from "./_notion-action-utils.js";
+
+export default defineAction({
+  description: "Unlink a Content document from its Notion page.",
+  schema: z.object({
+    documentId: z.string().optional().describe("Document ID (required)"),
+    id: z.string().optional().describe("Alias for --documentId"),
+  }),
+  http: { method: "DELETE" },
+  run: async (args) => {
+    const documentId = resolveDocumentId(args);
+    const owner = await getNotionDocumentOwner(documentId);
+    await unlinkDocumentFromNotion(owner, documentId);
+    return { success: true };
+  },
+});

package/corpus/templates/content/app/components/editor/DocumentDatabase.tsx

@@ -143,8 +143,10 @@ import {
   useChangeContentDatabaseSourceRole,
   useContentDatabase,
   useContentDatabases,
+  useDeleteDatabaseItems,
   useDisconnectContentDatabaseSource,
   useDuplicateDatabaseItem,
+  useDuplicateDatabaseItems,
   useExecuteBuilderSourceBatch,
   useMoveDatabaseItem,
   usePrepareBuilderSourceReview,
@@ -2862,9 +2864,9 @@ function DatabaseTableView({
   const db = useDatabaseT();
   const queryClient = useQueryClient();
   const moveItem = useMoveDatabaseItem(databaseDocumentId);
-  const duplicateItem = useDuplicateDatabaseItem(databaseDocumentId);
+  const duplicateItems = useDuplicateDatabaseItems(databaseDocumentId);
   const setProperty = useSetDocumentProperty(databaseDocumentId);
-  const deleteDocument = useDeleteDocument();
+  const deleteItems = useDeleteDatabaseItems(databaseDocumentId);
   const [draggedItemId, setDraggedItemId] = useState<string | null>(null);
   const [dropTargetItemId, setDropTargetItemId] = useState<string | null>(null);
   const [draggedPropertyId, setDraggedPropertyId] = useState<string | null>(
@@ -3113,14 +3115,15 @@ function DatabaseTableView({
   async function deleteSelectedRows() {
     if (selectedItems.length === 0) return;
     const selectedSnapshot = selectedItems;
-    onClearSelection();
     setConfirmDeleteSelectedOpen(false);
 
     try {
+      await deleteItems.mutateAsync({
+        documentId: databaseDocumentId,
+        itemIds: selectedSnapshot.map((item) => item.id),
+      });
+      onClearSelection();
       onDeletedPreviewItems(selectedSnapshot);
-      for (const item of selectedSnapshot) {
-        await deleteDocument.mutateAsync({ id: item.document.id });
-      }
       await queryClient.invalidateQueries({
         queryKey: [
           "action",
@@ -3144,22 +3147,11 @@ function DatabaseTableView({
     const selectedSnapshot = selectedItems;
     setIsDuplicatingSelected(true);
 
-    let duplicatedPreviewItem: ContentDatabaseItem | null = null;
-    let duplicatedCount = 0;
-    let failedCount = 0;
-
     try {
-      for (const item of selectedSnapshot) {
-        try {
-          const response = await duplicateItem.mutateAsync({ itemId: item.id });
-          duplicatedCount += 1;
-          duplicatedPreviewItem =
-            databaseDuplicatedItemFromResponse(response) ??
-            duplicatedPreviewItem;
-        } catch {
-          failedCount += 1;
-        }
-      }
+      const response = await duplicateItems.mutateAsync({
+        documentId: databaseDocumentId,
+        itemIds: selectedSnapshot.map((item) => item.id),
+      });
 
       await queryClient.invalidateQueries({
         queryKey: [
@@ -3172,16 +3164,15 @@ function DatabaseTableView({
         queryKey: ["action", "list-documents"],
       });
 
+      const duplicatedPreviewItem =
+        databaseDuplicatedItemFromResponse(response);
       if (duplicatedPreviewItem) onPreview(duplicatedPreviewItem);
-      if (duplicatedCount > 0) onClearSelection();
-      if (failedCount > 0) {
-        toast.error(db("failedToDuplicateEverySelectedRow"), {
-          description:
-            duplicatedCount > 0
-              ? `${duplicatedCount} duplicated, ${failedCount} failed.`
-              : "No rows were duplicated.",
-        });
-      }
+      onClearSelection();
+    } catch (err) {
+      toast.error(db("failedToDuplicateEverySelectedRow"), {
+        description:
+          err instanceof Error ? err.message : db("somethingWentWrong"),
+      });
     } finally {
       setIsDuplicatingSelected(false);
     }
@@ -3240,9 +3231,11 @@ function DatabaseTableView({
             canEdit={canEdit}
             properties={bulkEditableProperties}
             duplicateDisabled={
-              isDuplicatingSelected || deleteDocument.isPending
+              isDuplicatingSelected ||
+              duplicateItems.isPending ||
+              deleteItems.isPending
             }
-            deleteDisabled={deleteDocument.isPending}
+            deleteDisabled={deleteItems.isPending}
             updateDisabled={setProperty.isPending}
             onClearSelection={onClearSelection}
             onSetPropertyValue={setSelectedPropertyValue}
@@ -3466,10 +3459,10 @@ function DatabaseTableView({
             </AlertDialogCancel>
             <AlertDialogAction
               className="bg-destructive text-destructive-foreground hover:bg-destructive/90"
-              disabled={deleteDocument.isPending}
+              disabled={deleteItems.isPending}
               onClick={() => void deleteSelectedRows()}
             >
-              {deleteDocument.isPending ? "Deleting..." : "Delete"}
+              {deleteItems.isPending ? "Deleting..." : "Delete"}
             </AlertDialogAction>
           </AlertDialogFooter>
         </AlertDialogContent>

package/corpus/templates/content/app/components/editor/DocumentEditor.tsx

@@ -6,7 +6,6 @@ import {
   emailToName,
   useSession,
   useT,
-  appApiPath,
   agentNativePath,
   type CollabUser,
 } from "@agent-native/core/client";
@@ -41,7 +40,11 @@ import {
   useUpdateDocument,
 } from "@/hooks/use-documents";
 import { useLocalStorage } from "@/hooks/use-local-storage";
-import { useDocumentSyncStatus } from "@/hooks/use-notion";
+import {
+  documentSyncStatusQueryKey,
+  useDocumentSyncStatus,
+  usePushDocumentToNotion,
+} from "@/hooks/use-notion";
 import {
   canWriteLinkedLocalSource,
   readDocumentFromLinkedLocalSource,
@@ -360,6 +363,7 @@ function DocumentEditorBody({ documentId, document }: DocumentEditorBodyProps) {
   useDocumentSyncStatus(canEdit && !isLocalFileDocument ? documentId : null, {
     autoSync,
   });
+  const pushDocumentToNotion = usePushDocumentToNotion(documentId);
   const [localTitle, setLocalTitle] = useState("");
   const [localContent, setLocalContent] = useState("");
   const [localContentUpdatedAt, setLocalContentUpdatedAt] = useState<
@@ -775,20 +779,18 @@ function DocumentEditorBody({ documentId, document }: DocumentEditorBodyProps) {
       // the debounce and the next save, reading the previous content.
       // Pulls remain driven by the polling refetch in useDocumentSyncStatus.
       if (autoSync) {
-        const status = queryClient.getQueryData<DocumentSyncStatus>([
-          "document-sync",
-          documentId,
-        ]);
+        const status = queryClient.getQueryData<DocumentSyncStatus>(
+          documentSyncStatusQueryKey(documentId, { autoSync }),
+        );
         if (status?.pageId && !status.hasConflict) {
           try {
-            const res = await fetch(
-              appApiPath(`/api/documents/${documentId}/notion/push`),
-              { method: "POST" },
+            const next = await pushDocumentToNotion.mutateAsync({
+              documentId,
+            });
+            queryClient.setQueryData(
+              documentSyncStatusQueryKey(documentId, { autoSync }),
+              next,
             );
-            if (res.ok) {
-              const next = (await res.json()) as DocumentSyncStatus;
-              queryClient.setQueryData(["document-sync", documentId], next);
-            }
           } catch {
             // Non-fatal — next polling refetch will surface any error.
           }
@@ -803,6 +805,7 @@ function DocumentEditorBody({ documentId, document }: DocumentEditorBodyProps) {
       autoSync,
       isLinkedLocalSourceDocument,
       persistDocumentUpdates,
+      pushDocumentToNotion,
       queryClient,
     ],
   );