@agent-native/core 0.181.0 → 0.181.1-nightly-20260916144018

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

@@ -96,6 +96,7 @@ import {
   useDocument,
   useDeleteDocument,
   useDocuments,
+  useResolvePreviewDocumentDraft,
   useUpdatePreviewDocumentDraft,
   useUpdateDocument,
 } from "@/hooks/use-documents";
@@ -163,7 +164,9 @@ import { DocumentDatabase } from "./DocumentDatabase";
 import { DocumentEditorSkeleton } from "./DocumentEditorSkeleton";
 import { DocumentInfoPanel } from "./DocumentInfoPanel";
 import { DocumentProperties } from "./DocumentProperties";
+import { DocumentReconcileRecovery } from "./DocumentReconcileRecovery";
 import { DocumentToolbar, type ToolbarBreadcrumbItem } from "./DocumentToolbar";
+import type { EditorDraftSaveResult } from "./editor-draft-save";
 import { EmojiPicker } from "./EmojiPicker";
 import { LinkedLocalDocumentAgentBridge } from "./LinkedLocalDocumentAgentBridge";
 import {
@@ -200,6 +203,12 @@ import {
   normalizeTitleText,
   stripMarkdownHeadingPrefixFromTitlePaste,
 } from "./title-text";
+import {
+  useDocumentReconcileRecovery,
+  type DocumentReconcileRecoveryState,
+  type ReconcileRecoveryDraft,
+  type ReconcileSaveBase,
+} from "./useDocumentReconcileRecovery";
 import { VisualEditor } from "./VisualEditor";
 import type {
   NotionPageLink,
@@ -1043,8 +1052,8 @@ type DocumentSaveOptions = {
   historySessionId?: string;
   allowQueuedSave?: boolean;
   expectedLocalSourceRevision?: string | null;
-  adoptCurrentServerBase?: boolean;
   contentBase?: DocumentContentBase;
+  titleBase?: string;
   contentEditVersion?: number;
 };
 
@@ -1492,6 +1501,7 @@ function PageEditorSessionBody({
     });
   }, [documentId, host, t]);
   const updateDocument = useUpdateDocument();
+  const resolvePreviewDocumentDraft = useResolvePreviewDocumentDraft();
   const updatePreviewDocumentDraft = useUpdatePreviewDocumentDraft();
   const updatePreviewDocumentDraftRef = useRef(
     updatePreviewDocumentDraft.mutateAsync,
@@ -1701,9 +1711,20 @@ function PageEditorSessionBody({
     diskRevision?: DesktopContentFileRevision;
     unsavedText: string;
   } | null>(null);
-  const [documentReconcileConflict, setDocumentReconcileConflict] = useState<{
-    localDraft: string;
-  } | null>(null);
+  const reconcileRecoveryStateRef =
+    useRef<DocumentReconcileRecoveryState | null>(null);
+  const reconcileSaveRef = useRef<
+    (
+      draft: ReconcileRecoveryDraft,
+      base?: ReconcileSaveBase,
+    ) => Promise<boolean>
+  >(async () => false);
+  const reconcileRetainRef = useRef<
+    (draft: ReconcileRecoveryDraft) => Promise<void>
+  >(async () => undefined);
+  const reportReconcileRef = useRef<
+    (reason: "conflict" | "failed", localDraft: string) => void
+  >(() => undefined);
   const [localSourceMissing, setLocalSourceMissing] = useState(false);
   const [localSourceAccess, setLocalSourceAccess] = useState<
     "checking" | "available" | "unavailable"
@@ -1821,6 +1842,36 @@ function PageEditorSessionBody({
   const localContentRef = useRef(localContent);
   const contentEditVersionRef = useRef(0);
   localContentRef.current = localContent;
+  const reconcileRecovery = useDocumentReconcileRecovery({
+    save: (draft, base) => reconcileSaveRef.current(draft, base),
+    retain: (draft) => reconcileRetainRef.current(draft),
+    getDraft: () => localContentRef.current,
+    getTitle: () => localTitleRef.current,
+    getSaveIdentity: () =>
+      JSON.stringify([localTitleRef.current, localContentRef.current]),
+    stateRef: reconcileRecoveryStateRef,
+  });
+  const documentReconcileConflict = reconcileRecovery.state;
+  const {
+    report: reportReconcile,
+    resolve: resolveReconcile,
+    resolveChoice: resolveReconcileChoice,
+    updateDraft: updateReconcileDraft,
+    reportRetentionFailure,
+  } = reconcileRecovery;
+  const retainActiveRecoveryDraft = useCallback(
+    (draft: ReconcileRecoveryDraft) => {
+      void reconcileRetainRef.current(draft).catch(reportRetentionFailure);
+    },
+    [reportRetentionFailure],
+  );
+  const [acknowledgedLocalSnapshot, setAcknowledgedLocalSnapshot] = useState<{
+    value: string;
+    revision: string;
+    updatedAt: string;
+    sequence: number;
+  } | null>(null);
+  const acknowledgedLocalSnapshotSequenceRef = useRef(0);
   const getLinkedLocalEditorSnapshot = useCallback(
     () => ({
       title: localTitleRef.current,
@@ -1835,6 +1886,8 @@ function PageEditorSessionBody({
   documentUpdatedAtRef.current = document.updatedAt ?? null;
   const documentContentRef = useRef(document.content);
   documentContentRef.current = document.content;
+  const documentTitleRef = useRef(document.title);
+  documentTitleRef.current = document.title;
   const documentRevisionRef = useRef(document.revision);
   documentRevisionRef.current = document.revision;
   const handleBackgroundSaveError = useCallback(
@@ -2114,6 +2167,7 @@ function PageEditorSessionBody({
   useEffect(() => {
     if (!document || !isInitializedRef.current) return;
     if (isLinkedLocalSourceDocument) return;
+    if (reconcileRecoveryStateRef.current) return;
     const serverTitle = document.title;
     const lastSaved = lastSavedTitleRef.current;
     if (serverTitle === lastSaved.title) {
@@ -2405,6 +2459,23 @@ function PageEditorSessionBody({
               persistenceErrorsRef.current.set(field, error);
             }
           } else {
+            if (
+              updates.content !== undefined &&
+              result.revision &&
+              result.updatedAt
+            ) {
+              const snapshot = {
+                value: result.content,
+                revision: result.revision,
+                updatedAt: result.updatedAt,
+                sequence: ++acknowledgedLocalSnapshotSequenceRef.current,
+              };
+              setAcknowledgedLocalSnapshot((current) =>
+                !current || snapshot.sequence > current.sequence
+                  ? snapshot
+                  : current,
+              );
+            }
             if (
               result.updatedAt &&
               (!documentUpdatedAtRef.current ||
@@ -2591,13 +2662,6 @@ function PageEditorSessionBody({
     ): Promise<DocumentSaveResult> => {
       const contentEditVersion =
         options.contentEditVersion ?? contentEditVersionRef.current;
-      if (options.adoptCurrentServerBase) {
-        lastSavedContentRef.current = {
-          content: documentContentRef.current,
-          updatedAt: documentUpdatedAtRef.current,
-          revision: document.revision,
-        };
-      }
       lastSavedContentRef.current = refreshUnchangedContentSaveWatermark({
         serverContent: documentContentRef.current,
         serverUpdatedAt: documentUpdatedAtRef.current,
@@ -2608,19 +2672,35 @@ function PageEditorSessionBody({
       // stale — content. Guard per-field using the field's own watermark.
       const titleIsStale =
         !isLinkedLocalSourceDocument &&
+        options.titleBase === undefined &&
         documentUpdatedAtRef.current &&
         lastSavedTitleRef.current.updatedAt &&
         documentUpdatedAtRef.current > lastSavedTitleRef.current.updatedAt;
+      const contentBase = options.contentBase ?? lastSavedContentRef.current;
+      if (
+        options.titleBase !== undefined &&
+        documentTitleRef.current !== options.titleBase
+      ) {
+        return { contentPersisted: false };
+      }
+      if (
+        options.contentBase &&
+        (documentContentRef.current !== options.contentBase.content ||
+          documentUpdatedAtRef.current !== options.contentBase.updatedAt ||
+          documentRevisionRef.current !== options.contentBase.revision)
+      ) {
+        return { contentPersisted: false };
+      }
       const contentIsStale =
         !isLinkedLocalSourceDocument &&
         !!documentRevisionRef.current &&
-        !!lastSavedContentRef.current.revision &&
-        documentRevisionRef.current !== lastSavedContentRef.current.revision;
+        !!contentBase.revision &&
+        documentRevisionRef.current !== contentBase.revision;
 
       const updates: Record<string, string> = {};
       if (title !== lastSavedTitleRef.current.title && !titleIsStale)
         updates.title = title;
-      const contentChanged = content !== lastSavedContentRef.current.content;
+      const contentChanged = content !== contentBase.content;
       if (contentChanged && !contentIsStale) updates.content = content;
       if (Object.keys(updates).length === 0) {
         return { contentPersisted: !contentChanged };
@@ -2637,7 +2717,7 @@ function PageEditorSessionBody({
         let result;
         try {
           result = await saveDocumentWithRebase({
-            base: { ...lastSavedContentRef.current },
+            base: { ...contentBase },
             content,
             owner: {
               version: contentEditVersion,
@@ -2648,7 +2728,6 @@ function PageEditorSessionBody({
               confirm: (confirmedContent) => {
                 localContentRef.current = confirmedContent;
                 setLocalContent(confirmedContent);
-                setDocumentReconcileConflict(null);
               },
             },
             canRetry: (winner) =>
@@ -2667,9 +2746,7 @@ function PageEditorSessionBody({
           activeContentSavesRef.current -= 1;
         }
         if (result.status === "conflict") {
-          setDocumentReconcileConflict({
-            localDraft: result.localDraft,
-          });
+          reportReconcileRef.current("conflict", result.localDraft);
           return { contentPersisted: false };
         }
         saved = result.document;
@@ -2785,6 +2862,21 @@ function PageEditorSessionBody({
     },
     [documentId, t],
   );
+  const recoveryDraftRetentionQueueRef = useRef<Promise<void>>(
+    Promise.resolve(),
+  );
+  const queueRecoveryDraftRetention = useCallback(
+    (title: string, content: string, deferredReason: "conflict" | null) => {
+      const retain = () => retainRecoveryDraft(title, content, deferredReason);
+      const queued = recoveryDraftRetentionQueueRef.current.then(
+        retain,
+        retain,
+      );
+      recoveryDraftRetentionQueueRef.current = queued.catch(() => undefined);
+      return queued;
+    },
+    [retainRecoveryDraft],
+  );
   const clearRecoveryDraft = useCallback(
     async (persistedTitle: string, persistedContent: string) => {
       const current = recoveryDraftRef.current;
@@ -2846,14 +2938,11 @@ function PageEditorSessionBody({
       )
         .then((result) => {
           if (!result.contentPersisted) {
-            setDocumentReconcileConflict(
-              (current) =>
-                current ?? {
-                  localDraft:
-                    contentEditVersionRef.current === pending.contentEditVersion
-                      ? pending.content
-                      : localContentRef.current,
-                },
+            reportReconcileRef.current(
+              "conflict",
+              contentEditVersionRef.current === pending.contentEditVersion
+                ? pending.content
+                : localContentRef.current,
             );
           }
         })
@@ -2968,6 +3057,7 @@ function PageEditorSessionBody({
   const debouncedSave = useCallback(
     (title: string, content: string) => {
       if (!canEditRef.current) return;
+      if (reconcileRecoveryStateRef.current) return;
       const expectedLocalSourceRevision = isLinkedLocalSourceDocument
         ? localSourceRevisionForQueuedEdit(
             pendingDocumentSaveRef.current?.expectedLocalSourceRevision,
@@ -3310,6 +3400,13 @@ function PageEditorSessionBody({
         return;
       localTitleRef.current = newTitle;
       setLocalTitle(newTitle);
+      if (updateReconcileDraft(localContentRef.current, newTitle)) {
+        retainActiveRecoveryDraft({
+          localTitle: newTitle,
+          localDraft: localContentRef.current,
+        });
+        return;
+      }
       patchDocumentCaches(queryClient, documentId, { title: newTitle });
       // Renames must not leave a stale optimistic title for the next landing.
       refreshLandingTitleHintCache(queryClient, documentId, newTitle);
@@ -3319,22 +3416,15 @@ function PageEditorSessionBody({
       void rememberContentLandingDocument(documentId, newTitle).catch(() => {});
       debouncedSave(newTitle, localContentRef.current);
     },
-    [debouncedSave, documentId, editorCanEdit, isSuggesting, queryClient],
-  );
-
-  const handleContentChange = useCallback(
-    (newContent: string) => {
-      if (!editorCanEdit) return;
-      contentEditVersionRef.current += 1;
-      localContentRef.current = newContent;
-      setLocalContent(newContent);
-      if (documentReconcileConflict) {
-        setDocumentReconcileConflict({ localDraft: newContent });
-        return;
-      }
-      debouncedSave(localTitleRef.current, newContent);
-    },
-    [debouncedSave, documentReconcileConflict, editorCanEdit],
+    [
+      debouncedSave,
+      documentId,
+      editorCanEdit,
+      isSuggesting,
+      queryClient,
+      retainActiveRecoveryDraft,
+      updateReconcileDraft,
+    ],
   );
 
   const savedSuggestions = useMemo(() => {
@@ -3753,53 +3843,223 @@ function PageEditorSessionBody({
   ]);
 
   const handleContentSaveNow = useCallback(
-    async (newContent: string, adoptCurrentServerBase = false) => {
+    async (
+      recovery: ReconcileRecoveryDraft,
+      reconcileBase?: ReconcileSaveBase,
+    ) => {
       if (!editorCanEdit) return false;
       contentEditVersionRef.current += 1;
-      const contentEditVersion = contentEditVersionRef.current;
       if (saveTimeoutRef.current) {
         clearTimeout(saveTimeoutRef.current);
         saveTimeoutRef.current = null;
         pendingDocumentSaveRef.current = null;
       }
-      localContentRef.current = newContent;
-      setLocalContent(newContent);
+      localTitleRef.current = recovery.localTitle;
+      localContentRef.current = recovery.localDraft;
+      setLocalTitle(recovery.localTitle);
+      setLocalContent(recovery.localDraft);
       const result = await queueDocumentSave(
-        localTitleRef.current,
-        newContent,
+        recovery.localTitle,
+        recovery.localDraft,
         {
-          adoptCurrentServerBase,
+          contentBase: reconcileBase
+            ? {
+                content: reconcileBase.content,
+                updatedAt: reconcileBase.updatedAt,
+                revision: reconcileBase.revision,
+              }
+            : undefined,
+          titleBase: reconcileBase?.title,
         },
       );
-      if (!result.contentPersisted) {
-        setDocumentReconcileConflict(
-          (current) =>
-            current ?? {
-              localDraft:
-                contentEditVersionRef.current === contentEditVersion
-                  ? newContent
-                  : localContentRef.current,
-            },
-        );
-      } else if (contentEditVersionRef.current === contentEditVersion) {
-        setDocumentReconcileConflict(null);
-      }
       return result.contentPersisted;
     },
     [editorCanEdit, queueDocumentSave],
   );
+  reconcileSaveRef.current = handleContentSaveNow;
+  reconcileRetainRef.current = ({ localTitle, localDraft }) =>
+    queueRecoveryDraftRetention(
+      localTitle,
+      localDraft,
+      reconcileRecoveryStateRef.current?.reason === "conflict"
+        ? "conflict"
+        : null,
+    );
+  reportReconcileRef.current = reportReconcile;
+
+  const handleContentChange = useCallback(
+    (newContent: string) => {
+      if (!editorCanEdit) return;
+      contentEditVersionRef.current += 1;
+      localContentRef.current = newContent;
+      setLocalContent(newContent);
+      if (updateReconcileDraft(newContent)) {
+        retainActiveRecoveryDraft({
+          localTitle: localTitleRef.current,
+          localDraft: newContent,
+        });
+        return;
+      }
+      debouncedSave(localTitleRef.current, newContent);
+    },
+    [
+      debouncedSave,
+      editorCanEdit,
+      retainActiveRecoveryDraft,
+      updateReconcileDraft,
+    ],
+  );
+
+  const handleImmediateContentChange = useCallback(
+    async (newContent: string): Promise<EditorDraftSaveResult> => {
+      if (!editorCanEdit) return "failed";
+      if (reconcileRecoveryStateRef.current) {
+        handleContentChange(newContent);
+        return "retained";
+      }
+      return (await handleContentSaveNow({
+        localTitle: localTitleRef.current,
+        localDraft: newContent,
+      }))
+        ? "persisted"
+        : "failed";
+    },
+    [editorCanEdit, handleContentChange, handleContentSaveNow],
+  );
 
   const handleBaseAwareReconcile = useCallback(
-    (result: { status: "merged" | "conflict" | "failed"; content: string }) => {
+    (result: {
+      status: "merged" | "conflict" | "failed";
+      content: string;
+      serverContent: string;
+      serverRevision: string;
+    }) => {
+      if (saveTimeoutRef.current) {
+        clearTimeout(saveTimeoutRef.current);
+        saveTimeoutRef.current = null;
+        pendingDocumentSaveRef.current = null;
+      }
+      localContentRef.current = result.content;
+      setLocalContent(result.content);
+      reportReconcile(
+        result.status === "conflict" ? "conflict" : "failed",
+        result.content,
+      );
+      retainActiveRecoveryDraft({
+        localTitle: localTitleRef.current,
+        localDraft: result.content,
+      });
       if (result.status === "merged") {
-        void handleContentSaveNow(result.content, true);
-        return;
+        if (documentContentRef.current === result.serverContent) {
+          void resolveReconcile({
+            title: document.title,
+            content: result.serverContent,
+            updatedAt: documentUpdatedAtRef.current,
+            revision: result.serverRevision,
+          });
+        }
       }
-      setDocumentReconcileConflict({ localDraft: result.content });
     },
-    [handleContentSaveNow],
+    [reportReconcile, resolveReconcile, retainActiveRecoveryDraft],
+  );
+
+  const handleResolveReconcile = useCallback(
+    async (base: ReconcileSaveBase) => {
+      const saved = await resolveReconcile(base);
+      if (saved)
+        requestAnimationFrame(() => {
+          documentLayoutRef.current
+            ?.querySelector<HTMLElement>(".ProseMirror")
+            ?.focus({ preventScroll: true });
+        });
+      return saved;
+    },
+    [resolveReconcile],
+  );
+
+  const resolveLiveRecoveryDraft = useCallback(
+    async (
+      choice: "use_saved" | "save_separately",
+      base: ReconcileSaveBase,
+    ) => {
+      let resolvedUrlPath: string | undefined;
+      const resolved = await resolveReconcileChoice(
+        base,
+        async (recovery, reviewedBase) => {
+          await retainRecoveryDraft(
+            recovery.localTitle,
+            recovery.localDraft,
+            documentReconcileConflict?.reason === "conflict"
+              ? "conflict"
+              : null,
+          );
+          const draft = recoveryDraftRef.current;
+          if (!draft || !reviewedBase.updatedAt) return false;
+          const result = await resolvePreviewDocumentDraft.mutateAsync({
+            choice,
+            documentId,
+            expectedDraftVersion: draft.version,
+            expectedDraftTitle: draft.title,
+            expectedDraftContent: draft.content,
+            expectedDocumentUpdatedAt: reviewedBase.updatedAt,
+          });
+          if (result.status === "document_conflict") {
+            await queryClient.refetchQueries(documentQueryFilter(documentId));
+            return false;
+          }
+          if (
+            recoveryDraftRef.current?.version === draft.version &&
+            recoveryDraftRef.current.title === draft.title &&
+            recoveryDraftRef.current.content === draft.content
+          ) {
+            recoveryDraftRef.current = null;
+          }
+          resolvedUrlPath = result.urlPath;
+          return true;
+        },
+      );
+      if (!resolved) return false;
+      if (choice === "save_separately" && resolvedUrlPath) {
+        toast.success(t("editor.previewDraftSavedSeparately"));
+        void navigate(resolvedUrlPath);
+        return true;
+      }
+      if (choice === "use_saved") {
+        localTitleRef.current = base.title ?? document.title;
+        localContentRef.current = base.content;
+        setLocalTitle(base.title ?? document.title);
+        setLocalContent(base.content);
+        await queryClient.refetchQueries(documentQueryFilter(documentId));
+        toast.success(t("editor.previewDraftSavedToHistory"));
+      }
+      return true;
+    },
+    [
+      documentId,
+      documentReconcileConflict?.reason,
+      navigate,
+      queryClient,
+      resolveReconcileChoice,
+      resolvePreviewDocumentDraft,
+      retainRecoveryDraft,
+      t,
+    ],
   );
 
+  const copyLiveRecoveryDraft = useCallback(async () => {
+    const copied = await writeClipboardText(localContentRef.current);
+    if (copied) toast.success(t("editor.unsavedTextCopied"));
+    else toast.error(t("editor.toolbar.clipboardAccessUnavailable"));
+  }, [t]);
+
+  const focusEditorAfterRecoveryReview = useCallback(() => {
+    requestAnimationFrame(() => {
+      documentLayoutRef.current
+        ?.querySelector<HTMLElement>(".ProseMirror")
+        ?.focus({ preventScroll: true });
+    });
+  }, []);
+
   const useDiskVersion = useCallback(() => {
     if (!localSourceConflict) return;
     const next = localSourceConflict.diskDocument;
@@ -4868,41 +5128,23 @@ function PageEditorSessionBody({
           ) : null}
 
           {documentReconcileConflict ? (
-            <div
-              className="flex items-center gap-2 border-b bg-muted/40 px-4 py-2 text-sm"
-              role="alert"
-              data-document-reconcile-conflict
-            >
-              <span className="me-auto">{t("editor.toolbar.conflict")}</span>
-              <Button
-                type="button"
-                size="sm"
-                variant="ghost"
-                onClick={() => {
-                  void writeClipboardText(
-                    documentReconcileConflict.localDraft,
-                  ).then((copied) => {
-                    if (copied) toast.success(t("editor.unsavedTextCopied"));
-                    else
-                      toast.error(
-                        t("editor.toolbar.clipboardAccessUnavailable"),
-                      );
-                  });
-                }}
-              >
-                {t("editor.copyUnsavedText")}
-              </Button>
-              <Button
-                type="button"
-                size="sm"
-                onClick={() => {
-                  const localDraft = documentReconcileConflict.localDraft;
-                  void handleContentSaveNow(localDraft, true);
-                }}
-              >
-                {t("editor.keepLocalDraft")}
-              </Button>
-            </div>
+            <DocumentReconcileRecovery
+              state={documentReconcileConflict}
+              server={{
+                title: document.title,
+                content: document.content,
+                updatedAt: document.updatedAt ?? null,
+                revision: document.revision,
+              }}
+              canEdit={editorCanEdit}
+              onKeepMine={handleResolveReconcile}
+              onUseSaved={(base) => resolveLiveRecoveryDraft("use_saved", base)}
+              onSaveSeparately={(base) =>
+                resolveLiveRecoveryDraft("save_separately", base)
+              }
+              onCopy={copyLiveRecoveryDraft}
+              onClose={focusEditorAfterRecoveryReview}
+            />
           ) : null}
 
           {isSuggesting &&
@@ -5280,6 +5522,9 @@ function PageEditorSessionBody({
                                 ? null
                                 : (document.revision ?? null)
                             }
+                            acknowledgedLocalSnapshot={
+                              acknowledgedLocalSnapshot
+                            }
                             onBaseAwareReconcile={handleBaseAwareReconcile}
                             collabContentRevision={
                               isLocalFileDocument || isSuggesting
@@ -5294,7 +5539,7 @@ function PageEditorSessionBody({
                             }
                             onSaveContent={
                               suggestionEditorIsolation.persistCanonical
-                                ? handleContentSaveNow
+                                ? handleImmediateContentChange
                                 : undefined
                             }
                             ydoc={