@agent-native/core 0.123.0 → 0.123.2

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

@@ -29,7 +29,14 @@ import { TableRow } from "@tiptap/extension-table-row";
 import TaskItem from "@tiptap/extension-task-item";
 import TaskList from "@tiptap/extension-task-list";
 import { Fragment, type Node as ProseMirrorNode } from "@tiptap/pm/model";
-import { Plugin, PluginKey, AllSelection, Selection } from "@tiptap/pm/state";
+import {
+  Plugin,
+  PluginKey,
+  AllSelection,
+  NodeSelection,
+  Selection,
+  type Transaction,
+} from "@tiptap/pm/state";
 import { Decoration, DecorationSet, type EditorView } from "@tiptap/pm/view";
 import {
   useEditor,
@@ -925,6 +932,47 @@ export function shouldPersistLocalFileEditorUpdate({
   return Boolean(transactionUiEvent);
 }
 
+export function shouldPersistCollaborativeEditorUpdate({
+  collab,
+  editorFocused,
+  userInitiated,
+}: {
+  collab: boolean;
+  editorFocused: boolean;
+  userInitiated: boolean;
+}) {
+  // Collaborative mount/reconcile normalization can produce a local-looking
+  // transaction after the remote Y.Doc has loaded. If the editor is not
+  // focused and no human input event preceded the transaction, it has no
+  // authority to overwrite SQL. Focused commands and explicit user-intent
+  // transactions remain persistable; structural/media actions additionally
+  // use their immediate proof-of-save callbacks.
+  return !collab || editorFocused || userInitiated;
+}
+
+export function isUserInitiatedCollaborativeEditorUpdate({
+  editorFocused,
+  explicitUserEdit,
+  recentUserEditIntent,
+  transactionUiEvent,
+}: {
+  editorFocused: boolean;
+  explicitUserEdit: boolean;
+  recentUserEditIntent: boolean;
+  transactionUiEvent: unknown;
+}) {
+  // A recent input event is useful for grouping the follow-up transactions
+  // produced while the editor still owns focus. Once focus has left, however,
+  // only provenance on this exact transaction may authorize persistence;
+  // otherwise mount/Yjs normalization could borrow a stale two-second intent
+  // window and overwrite canonical SQL.
+  return (
+    explicitUserEdit ||
+    Boolean(transactionUiEvent) ||
+    (editorFocused && recentUserEditIntent)
+  );
+}
+
 function isEffectivelyEmptyEditorContent(value: string): boolean {
   const normalized = value.trim();
   return normalized === "" || normalized === "<empty-block/>";
@@ -975,19 +1023,21 @@ interface VisualEditorExtensionOptions {
   localFilePath?: string | null;
   referenceDepth?: number;
   emptyBlockPlaceholder?: string;
+  onMediaSourceCommitted?: (
+    editor: CoreEditor,
+    transaction: Transaction,
+  ) => void;
 }
 
-function hasAncestorType(
+export function hasAncestorType(
   editor: CoreEditor,
   pos: number,
   typeName: string,
 ): boolean {
   const doc = editor.state.doc;
-  const positions = [
-    Math.max(0, pos - 1),
-    pos,
-    Math.min(doc.content.size, pos + 1),
-  ];
+  const clampPosition = (candidate: number) =>
+    Math.min(doc.content.size, Math.max(0, candidate));
+  const positions = [...new Set([pos - 1, pos, pos + 1].map(clampPosition))];
 
   return positions.some((candidatePos) => {
     const resolvedPos = doc.resolve(candidatePos);
@@ -1002,6 +1052,88 @@ function hasAncestorType(
 
 type MediaNodeType = "image" | "video" | "audio";
 
+const MEDIA_NODE_TYPES = new Set<MediaNodeType>(["image", "video", "audio"]);
+
+function mediaSourceCounts(doc: ProseMirrorNode) {
+  const counts = new Map<string, number>();
+  doc.descendants((node) => {
+    if (!MEDIA_NODE_TYPES.has(node.type.name as MediaNodeType)) return true;
+    const src = typeof node.attrs.src === "string" ? node.attrs.src : "";
+    if (!src) return false;
+    const key = `${node.type.name}\u0000${src}`;
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+    return false;
+  });
+  return counts;
+}
+
+export function didCommitMediaSource(transaction: Transaction): boolean {
+  if (!transaction.docChanged) return false;
+  const before = mediaSourceCounts(transaction.before);
+  const after = mediaSourceCounts(transaction.doc);
+  return [...after].some(([key, count]) => count > (before.get(key) ?? 0));
+}
+
+const MediaSourceCommit = Extension.create<{
+  onMediaSourceCommitted?: (
+    editor: CoreEditor,
+    transaction: Transaction,
+  ) => void;
+}>({
+  name: "mediaSourceCommit",
+  addOptions() {
+    return { onMediaSourceCommitted: undefined };
+  },
+  onTransaction({ editor, transaction }) {
+    if (didCommitMediaSource(transaction)) {
+      this.options.onMediaSourceCommitted?.(editor, transaction);
+    }
+  },
+});
+
+/**
+ * Empty media nodes are transient editor UI, not durable document content.
+ *
+ * Persisting the placeholder before its async upload/link enrichment finishes
+ * lets the SQL echo reconcile the empty `src` back into the live Y.Doc. That
+ * can erase a successfully uploaded image or embedded video. Keep the local
+ * draft out of autosave until it has a source; uploads inserted by drop/paste
+ * are covered by their `uploadId` even when the selection is elsewhere.
+ */
+export function shouldSkipMediaDraftPersistence(editor: CoreEditor): boolean {
+  let hasPendingUpload = false;
+  editor.state.doc.descendants((node) => {
+    if (
+      MEDIA_NODE_TYPES.has(node.type.name as MediaNodeType) &&
+      Boolean(node.attrs.uploadId)
+    ) {
+      hasPendingUpload = true;
+      return false;
+    }
+    return !hasPendingUpload;
+  });
+  if (hasPendingUpload) return true;
+
+  const { selection } = editor.state;
+  if (!(selection instanceof NodeSelection)) return false;
+  return (
+    MEDIA_NODE_TYPES.has(selection.node.type.name as MediaNodeType) &&
+    !selection.node.attrs.src
+  );
+}
+
+/**
+ * Serialize only complete editor drafts. Structural slash commands explicitly
+ * ask to persist after their transaction, so this guard must live in the shared
+ * persistence path rather than only in `onUpdate`.
+ */
+export function serializeEditorDraftForPersistence(
+  editor: CoreEditor,
+): string | null {
+  if (shouldSkipMediaDraftPersistence(editor)) return null;
+  return docToNfm(editor.getJSON() as any);
+}
+
 function mediaNodeLabel(typeName: MediaNodeType) {
   if (typeName === "image") return "Image";
   if (typeName === "video") return "Video";
@@ -1305,6 +1437,7 @@ export function createVisualEditorExtensions({
   localFilePath,
   referenceDepth = 0,
   emptyBlockPlaceholder = DEFAULT_EMPTY_BLOCK_PLACEHOLDER,
+  onMediaSourceCommitted,
 }: VisualEditorExtensionOptions = {}): Extensions {
   // Build on the SHARED editor core (StarterKit base + the Collaboration /
   // CollaborationCaret wiring + collab undo/redo gating + ordering), then inject
@@ -1372,6 +1505,7 @@ export function createVisualEditorExtensions({
         documentId,
         onAudioComment: onImageComment,
       }),
+      MediaSourceCommit.configure({ onMediaSourceCommitted }),
       CustomTable.configure({
         resizable: false,
         HTMLAttributes: { class: "notion-table" },
@@ -1688,6 +1822,15 @@ export function VisualEditor({
   onSaveContentRef.current = onSaveContent;
   const notionPageLinksRef = useRef(notionPageLinks);
   notionPageLinksRef.current = notionPageLinks;
+  const onMediaSourceCommittedRef = useRef<
+    ((editor: CoreEditor, transaction: Transaction) => void) | null
+  >(null);
+  const onMediaSourceCommitted = useCallback(
+    (editor: CoreEditor, transaction: Transaction) => {
+      onMediaSourceCommittedRef.current?.(editor, transaction);
+    },
+    [],
+  );
   const resolveNotionPageLink = useCallback((notionPageId: string) => {
     const normalized = notionPageId.replace(/-/g, "").toLowerCase();
     return (
@@ -1745,6 +1888,7 @@ export function VisualEditor({
         localFilePath,
         referenceDepth,
         emptyBlockPlaceholder: t("editor.emptyBlockPlaceholder"),
+        onMediaSourceCommitted,
       }),
     [
       documentId,
@@ -1760,6 +1904,7 @@ export function VisualEditor({
       localFilePath,
       referenceDepth,
       t,
+      onMediaSourceCommitted,
     ],
   );
 
@@ -1784,8 +1929,9 @@ export function VisualEditor({
       const guards = guardsRef.current;
       if (!guards) return false;
       try {
-        const normalized =
-          options?.markdown ?? docToNfm(editorToPersist.getJSON() as any);
+        const serialized = serializeEditorDraftForPersistence(editorToPersist);
+        if (serialized === null) return true;
+        const normalized = options?.markdown ?? serialized;
         if (localFileMode && normalized === content) return true;
         // TipTap/Yjs can emit a local-looking empty-paragraph transaction while
         // an editor is mounting or reconciling. Content serializes that filler
@@ -1820,6 +1966,23 @@ export function VisualEditor({
     },
     [content, localFileMode, t],
   );
+  onMediaSourceCommittedRef.current = async (editorToPersist, transaction) => {
+    const guards = guardsRef.current;
+    if (!guards || guards.shouldIgnoreUpdate(transaction)) return;
+    try {
+      const persisted = await persistEditorContent(editorToPersist, {
+        immediate: true,
+        userInitiated: true,
+      });
+      if (!persisted) throw new Error(t("empty.genericError"));
+    } catch (error) {
+      // The ordinary onUpdate path still queues its debounced retry. Keep the
+      // immediate durability attempt from becoming an unhandled rejection,
+      // but fail visibly instead of treating a skipped save as success.
+      toast.error(t("empty.genericError"));
+      console.error("Media source persistence error:", error);
+    }
+  };
 
   const editor = useEditor({
     extensions,
@@ -1973,12 +2136,27 @@ export function VisualEditor({
       ) {
         return;
       }
+      const userInitiated = isUserInitiatedCollaborativeEditorUpdate({
+        editorFocused: editor.isFocused,
+        explicitUserEdit:
+          transaction.getMeta(LOCAL_FILE_USER_EDIT_META) === true,
+        recentUserEditIntent:
+          Date.now() - lastUserEditIntentAtRef.current < 2000,
+        transactionUiEvent: transaction.getMeta("uiEvent"),
+      });
+      if (
+        !shouldPersistCollaborativeEditorUpdate({
+          collab: !!ydoc,
+          editorFocused: editor.isFocused,
+          userInitiated,
+        })
+      ) {
+        return;
+      }
       if (isActiveSlashCommandDraft(editor)) return;
+      if (shouldSkipMediaDraftPersistence(editor)) return;
       persistEditorContent(editor, {
-        userInitiated:
-          transaction.getMeta(LOCAL_FILE_USER_EDIT_META) === true ||
-          Date.now() - lastUserEditIntentAtRef.current < 2000 ||
-          Boolean(transaction.getMeta("uiEvent")),
+        userInitiated,
       });
     },
   });
@@ -2294,9 +2472,9 @@ export function VisualEditor({
           editor={editor}
           documentId={documentId}
           notionPageId={notionPageId}
-          onDraftCommitted={() => {
-            void persistEditorContent(editor, { userInitiated: true });
-          }}
+          onDraftCommitted={() =>
+            persistEditorContent(editor, { userInitiated: true })
+          }
           onDraftPersisted={(markdown) =>
             persistEditorContent(editor, {
               markdown,

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

@@ -159,6 +159,8 @@ import {
   TooltipTrigger,
 } from "@/components/ui/tooltip";
 import {
+  applyOptimisticBuilderWriteMode,
+  contentDatabaseQueryFilter,
   isContentDatabaseUnavailable,
   useAddDatabaseItem,
   useAddContentDatabaseSourceFieldProperty,
@@ -910,6 +912,7 @@ function DatabaseTable({
   );
   const autoContinueBuilderSourceRef = useRef<Set<string>>(new Set());
   const builderContinuationWatchdogRef = useRef<Map<string, number>>(new Map());
+  const builderContinuationFailureRef = useRef<Map<string, number>>(new Map());
   const refreshSourceInFlightRef = useRef<string | null>(null);
   const hydrationSourceInFlightRef = useRef<string | null>(null);
   const workspaceSelectionQueueRef = useRef(createContentSpaceSelectionQueue());
@@ -1115,14 +1118,24 @@ function DatabaseTable({
     ),
   };
   const runSourceRefresh = useCallback(
-    (sourceId: string, onError?: () => void) => {
+    (
+      sourceId: string,
+      onError?: () => void,
+      expectedBuilderContinuationOffset?: number,
+      onSuccess?: () => void,
+    ) => {
       if (!acquireDatabaseSourceOperation(refreshSourceInFlightRef, sourceId)) {
         return false;
       }
       refreshSource.mutate(
-        { documentId: document.id, sourceId },
+        {
+          documentId: document.id,
+          sourceId,
+          expectedBuilderContinuationOffset,
+        },
         {
           onError,
+          onSuccess,
           onSettled: () => {
             releaseDatabaseSourceOperation(refreshSourceInFlightRef, sourceId);
           },
@@ -1132,6 +1145,25 @@ function DatabaseTable({
     },
     [document.id, refreshSource.mutate],
   );
+  const handleBuilderContinuationError = useCallback(
+    (continuationKey: string) => {
+      const failures =
+        (builderContinuationFailureRef.current.get(continuationKey) ?? 0) + 1;
+      builderContinuationFailureRef.current.set(continuationKey, failures);
+      if (builderSourceContinuationFailureDecision(failures) === "error") {
+        setBuilderContinuationClientErrorKeys((current) =>
+          addUniqueKey(current, continuationKey),
+        );
+      }
+    },
+    [],
+  );
+  const handleBuilderContinuationSuccess = useCallback(
+    (continuationKey: string) => {
+      builderContinuationFailureRef.current.delete(continuationKey);
+    },
+    [],
+  );
   const runBuilderHydration = useCallback(
     (
       sourceId: string,
@@ -1197,10 +1229,11 @@ function DatabaseTable({
       continuationKey,
     );
     if (
-      !runSourceRefresh(candidate.id, () =>
-        setBuilderContinuationClientErrorKeys((current) =>
-          addUniqueKey(current, continuationKey),
-        ),
+      !runSourceRefresh(
+        candidate.id,
+        () => handleBuilderContinuationError(continuationKey),
+        candidate.metadata.lastReadNextOffset,
+        () => handleBuilderContinuationSuccess(continuationKey),
       )
     ) {
       autoContinueBuilderSourceRef.current.delete(continuationKey);
@@ -1210,6 +1243,8 @@ function DatabaseTable({
     builderSources,
     canEdit,
     isActive,
+    handleBuilderContinuationError,
+    handleBuilderContinuationSuccess,
     refreshSource.isPending,
     runSourceRefresh,
   ]);
@@ -1273,10 +1308,11 @@ function DatabaseTable({
         return;
       }
       if (
-        runSourceRefresh(candidate.id, () =>
-          setBuilderContinuationClientErrorKeys((current) =>
-            addUniqueKey(current, continuationKey),
-          ),
+        runSourceRefresh(
+          candidate.id,
+          () => handleBuilderContinuationError(continuationKey),
+          candidate.metadata.lastReadNextOffset,
+          () => handleBuilderContinuationSuccess(continuationKey),
         )
       ) {
         builderContinuationWatchdogRef.current.set(
@@ -1295,6 +1331,8 @@ function DatabaseTable({
     builderSources,
     canEdit,
     isActive,
+    handleBuilderContinuationError,
+    handleBuilderContinuationSuccess,
     refreshSource.isPending,
     runSourceRefresh,
   ]);
@@ -2545,10 +2583,12 @@ function DatabaseTable({
                 continuationKey,
               );
               builderContinuationWatchdogRef.current.set(continuationKey, 0);
-              runSourceRefresh(builderSource.id, () =>
-                setBuilderContinuationClientErrorKeys((current) =>
-                  addUniqueKey(current, continuationKey),
-                ),
+              builderContinuationFailureRef.current.delete(continuationKey);
+              runSourceRefresh(
+                builderSource.id,
+                () => handleBuilderContinuationError(continuationKey),
+                builderSource.metadata.lastReadNextOffset,
+                () => handleBuilderContinuationSuccess(continuationKey),
               );
             }}
           />
@@ -2897,36 +2937,44 @@ function DatabaseTable({
         onReviewBuilderUpdate={(sourceId) => {
           openBuilderReview(sourceId);
         }}
-        onSetBuilderLiveWrites={(settings) =>
-          setSourceWriteMode.mutate(
-            {
-              documentId: document.id,
-              sourceId: settings.sourceId,
-              writeMode: settings.writeMode,
-              allowPublicationTransitions:
-                settings.writeMode === "publish_updates" &&
-                settings.allowPublicationTransitions === true,
+        onSetBuilderLiveWrites={(settings) => {
+          const request = {
+            documentId: document.id,
+            sourceId: settings.sourceId,
+            writeMode: settings.writeMode,
+            allowPublicationTransitions:
+              settings.writeMode === "publish_updates" &&
+              settings.allowPublicationTransitions === true,
+          };
+          const previous = queryClient.getQueriesData<ContentDatabaseResponse>(
+            contentDatabaseQueryFilter(document.id),
+          );
+          queryClient.setQueriesData<ContentDatabaseResponse>(
+            contentDatabaseQueryFilter(document.id),
+            (current) => applyOptimisticBuilderWriteMode(current, request),
+          );
+          setSourceWriteMode.mutate(request, {
+            onSuccess: () => {
+              toast.success(dbText("builderWriteModeUpdated"), {
+                description:
+                  settings.writeMode === "publish_updates"
+                    ? "Approved updates can write through to Builder while preserving publication state."
+                    : settings.writeMode === "stage_only"
+                      ? "Approved updates will stage Builder autosave revisions."
+                      : "Builder writes are disabled for this source.",
+              });
             },
-            {
-              onSuccess: () => {
-                toast.success(dbText("builderWriteModeUpdated"), {
-                  description:
-                    settings.writeMode === "publish_updates"
-                      ? "Approved updates can write through to Builder while preserving publication state."
-                      : settings.writeMode === "stage_only"
-                        ? "Approved updates will stage Builder autosave revisions."
-                        : "Builder writes are disabled for this source.",
-                });
-              },
-              onError: (error) => {
-                toast.error(dbText("builderWriteModeWasNotChanged"), {
-                  description:
-                    error instanceof Error ? error.message : dbText("tryAgain"),
-                });
-              },
+            onError: (error) => {
+              for (const [queryKey, data] of previous) {
+                queryClient.setQueryData(queryKey, data);
+              }
+              toast.error(dbText("builderWriteModeWasNotChanged"), {
+                description:
+                  error instanceof Error ? error.message : dbText("tryAgain"),
+              });
             },
-          )
-        }
+          });
+        }}
         sourceActionPending={
           attachSource.isPending ||
           changeSourceRole.isPending ||
@@ -2967,6 +3015,7 @@ function DatabaseTable({
           executeBuilderExecution.isPending ||
           cancelPreparedBuilderUpdate.isPending
         }
+        executionPending={executeBuilderExecution.isPending}
         error={
           builderReviewError ??
           (builderReviewPreviewQuery.error instanceof Error
@@ -10196,6 +10245,10 @@ export function builderSourceContinuationWatchdogDecision(refires: number) {
   return "refire";
 }
 
+export function builderSourceContinuationFailureDecision(failures: number) {
+  return failures <= 1 ? "retry" : "error";
+}
+
 export function builderSourceContinuationWatchdogDelay(refires: number) {
   return Math.min(
     BUILDER_SOURCE_CONTINUATION_MAX_BACKOFF_MS,

package/corpus/templates/content/app/components/editor/database-sources/BuilderSourceReviewDialog.tsx

@@ -291,6 +291,7 @@ export function BuilderSourceReviewDialog({
   source,
   canEdit,
   pending,
+  executionPending = false,
   batchResult = null,
   error = null,
   checkedAt,
@@ -307,6 +308,7 @@ export function BuilderSourceReviewDialog({
   source: ContentDatabaseSource | null;
   canEdit: boolean;
   pending: boolean;
+  executionPending?: boolean;
   // Optional so the inline-database caller (DatabaseView) that doesn't surface
   // batch results can still mount the dialog.
   batchResult?: ExecuteBuilderSourceBatchResponse | null;
@@ -485,7 +487,7 @@ export function BuilderSourceReviewDialog({
       : review?.result.status,
   );
   const footerHint = pending
-    ? preparedForExecution
+    ? executionPending
       ? "Sending to Builder…"
       : "Preparing full review…"
     : hasUnconfirmedUnpublish
@@ -517,7 +519,7 @@ export function BuilderSourceReviewDialog({
             ? `Push ${selectedReviewRows.length} updates`
             : "Push update";
   const buttonLabel = pending
-    ? preparedForExecution
+    ? executionPending
       ? "Sending…"
       : "Preparing…"
     : checked && review?.result.status === "running"