Skip to content

AI-native knowledge base & Evernote/Obsidian alternative with instant sync & native MCP. Free on Cloudflare or self-hosted via Docker.

50.6 KB
Raw Blame
import { useCallback, useEffect, useMemo, useRef, useState } from "react";
import { useMutation, useQueryClient, type UseMutationResult } from "@tanstack/react-query";
import { File as ExpoFile } from "expo-file-system";
import { ActivityIndicator, ChevronDown, ChevronLeft, RotateCcw } from "../components/icons";
import { BackHandler, KeyboardAvoidingView, Platform, View } from "react-native";
import { SafeAreaView } from "react-native-safe-area-context";
import { Alert, Pressable, Text, TextInput } from "../components/LocalizedText";
import {
  createExcerpt,
  DEFAULT_MEMO_TITLE,
  docToMarkdown,
  docToText,
  markdownToDoc,
  resolveMemoContentDoc,
  type MemoDetail,
  type Notebook,
  type TiptapDoc,
} from "@edgeever/shared";
import {
  clearMobileMemoDraft,
  clearMobileNewMemoDraft,
  writeMobileMemoDraft,
  type MobileMemoDraft,
} from "../lib/mobile-drafts";
import { localizeMissingNotebookName, useMobileLocale, getMobileCatalog, formatMobileCopy } from "../lib/mobile-locale";
import { useSession } from "../lib/session";
import { queueMobileMemoCreate, queueMobileMemoUpdate } from "../lib/sync-queue";
import { createMobileDataScope, upsertLocalMemo } from "../lib/local-mirror";
import { recordEditorStartup } from "../lib/startup-performance";
import { prepareUploadAsset, type MobileImageUploadAsset } from "../lib/mobile-image-upload";
import { uploadMobileResource } from "../lib/mobile-resource-upload";
import LocalTiptapEditor, { type LocalTiptapEditorRef } from "../components/LocalTiptapEditor";
import { SAFE_DOM_WEBVIEW_PROPS } from "../lib/mobile-dom";
import { safeDomCall } from "../lib/safe-dom-call";
import { applyMobileEditorUpload, cancelMobileEditorUpload, flushMobileEditor } from "../lib/mobile-editor-controller";
import {
  getMobileEditorSaveChrome,
  MOBILE_EDITOR_AUTOSAVE_DELAY_MS,
  shouldScheduleMobileEditorAutosave,
} from "../hooks/mobile-editor-save-chrome";
import { showEdgeEverKeyboard } from "../../modules/edgeever-keyboard";
import { MobileResourceActions } from "../components/MobileResourceActions";
import { MobileTemplatePickerModal } from "../components/MobileTemplatePicker";
import { useMobileTheme } from "../lib/mobile-theme";
import { createMemoSeedHasContent, type MobileCreateMemoSeed } from "../lib/mobile-templates";
import { createMobileDraftWriteBarrier } from "../lib/mobile-draft-write-barrier";
import {
  type MobileSharedImage,
  type MobileWebClipDraft,
} from "../lib/mobile-web-clip";
import { useMobileEditorResourceActions } from "../hooks/useMobileEditorResourceActions";
import { useMobileEditorUploadAsset } from "../hooks/useMobileEditorUploadAsset";
import { useMobileSelectionAi } from "../hooks/useMobileSelectionAi";
import { parseTags } from "./workspace-utils";
import { createOptimisticMemo, type MobileMemoUpdatePayload } from "./workspace-memo-cache";
import { styles } from "./workspace-styles";
import { NotebookPickerModal, SmartTagButton, TagPickerModal } from "./WorkspacePickers";
import {
  type MobileResourceTarget,
} from "../lib/mobile-attachments";
import {
  createOnceProtectedResourceFailureNotifier,
  type ProtectedResourceLoadFailure,
} from "../lib/mobile-protected-resources";

type MobileMemoUpdateMutation = UseMutationResult<MemoDetail, Error, { memo: MemoDetail; payload: MobileMemoUpdatePayload }>;

const MOBILE_EDITOR_STARTUP_TIMEOUT_MS = 10_000;

const useMobileEditorStartupGuard = ({ active, ready }: { active: boolean; ready: boolean }) => {
  const [attempt, setAttempt] = useState(0);
  const [timedOut, setTimedOut] = useState(false);

  useEffect(() => {
    if (!active || ready) {
      setTimedOut(false);
      return;
    }
    const timeout = setTimeout(() => setTimedOut(true), MOBILE_EDITOR_STARTUP_TIMEOUT_MS);
    return () => clearTimeout(timeout);
  }, [active, attempt, ready]);

  const restart = useCallback(() => {
    setTimedOut(false);
    setAttempt((current) => current + 1);
  }, []);

  return { attempt, restart, timedOut };
};

const MobileEditorStartupOverlay = ({
  onRetry,
  timedOut,
}: {
  onRetry: () => void;
  timedOut: boolean;
}) => {
  const { translate } = useMobileLocale();
  return (
    <View accessibilityLiveRegion="polite" style={styles.richEditorLoading}>
      {!timedOut ? <ActivityIndicator color="#16a06e" size="large" /> : null}
      <Text style={styles.richEditorLoadingTitle}>
        {translate(timedOut ? "编辑器启动时间过长" : "正在启动编辑器")}
      </Text>
      <Text style={styles.mutedText}>
        {translate(timedOut
          ? "本地编辑器未能及时启动,可以重试或返回,当前草稿不会丢失。"
          : "正在准备本地编辑器,笔记内容是安全的。")}
      </Text>
      {timedOut ? (
        <Pressable
          accessibilityLabel={translate("重试")}
          accessibilityRole="button"
          onPress={onRetry}
          style={styles.actionButton}
        >
          <RotateCcw color="#0f172a" size={16} />
          <Text style={styles.actionButtonText}>{translate("重试")}</Text>
        </Pressable>
      ) : null}
    </View>
  );
};

const resolveEditableMemoTitle = (title?: string | null) => {
  const trimmedTitle = title?.trim() ?? "";
  return trimmedTitle === DEFAULT_MEMO_TITLE ? "" : trimmedTitle;
};

const alertProtectedImageLoadFailure = (
  locale: "zh-CN" | "en-US" | "ja" | "pl" | "ru",
  failure: ProtectedResourceLoadFailure
) => {
  const statusLabel = failure.status != null
    ? String(failure.status)
    : getMobileCatalog(locale).mobile.common.networkError;
  Alert.alert(
    getMobileCatalog(locale).mobile.common.imageLoadFailed,
    formatMobileCopy(getMobileCatalog(locale).mobile.common.noteImageLoadFailed, { status: statusLabel })
  );
};

export const CreateMemoModal = ({
  baseUrl,
  client: clientProp,
  dataScope,
  defaultNotebookId,
  finishForIncomingShare = false,
  imageCompressionEnabled,
  initialDraft,
  initialSharedImages = [],
  notebooks,
  onCreated,
  onQueued,
  syncQueueScope,
}: {
  baseUrl: string;
  client?: ReturnType<typeof useSession>["client"];
  dataScope: string;
  defaultNotebookId: string;
  finishForIncomingShare?: boolean;
  imageCompressionEnabled: boolean;
  initialDraft?: MobileCreateMemoSeed | MobileWebClipDraft | null;
  initialSharedImages?: MobileSharedImage[];
  notebooks: Notebook[];
  onCreated: (memo: MemoDetail) => void;
  onDismiss: () => void;
  onQueued: () => void | Promise<void>;
  syncQueueScope: string;
}) => {
  const sessionState = useSession();
  const client = clientProp ?? sessionState.client;
  const session = sessionState.session;
  const queryClient = useQueryClient();
  const { resolvedLocale, translate } = useMobileLocale();
  const { resolvedTheme } = useMobileTheme();
  const fallbackNotebookId = defaultNotebookId;
  const editorRef = useRef<LocalTiptapEditorRef>(null);
  const resourceDataUrlCacheRef = useRef(new Map<string, Promise<string | null>>());
  const imageLoadFailureNotifier = useMemo(
    () =>
      createOnceProtectedResourceFailureNotifier((failure) => {
        alertProtectedImageLoadFailure(resolvedLocale, failure);
      }),
    [resolvedLocale]
  );
  const contentJsonRef = useRef<TiptapDoc>(markdownToDoc(""));
  const contentMarkdownRef = useRef("");
  const draftVersionRef = useRef(0);
  const draftWriteBarrier = useMemo(createMobileDraftWriteBarrier, []);
  const flushResolverRef = useRef<(() => void) | null>(null);
  const materializedMemoRef = useRef<MemoDetail | null>(null);
  const [notebookId, setNotebookId] = useState(fallbackNotebookId);
  const [title, setTitle] = useState("");
  const [tagsText, setTagsText] = useState("");
  const [contentMarkdown, setContentMarkdown] = useState("");
  const [notebookPickerOpen, setNotebookPickerOpen] = useState(false);
  const [tagPickerOpen, setTagPickerOpen] = useState(false);
  const [templatePickerOpen, setTemplatePickerOpen] = useState(false);
  const [draftLoaded, setDraftLoaded] = useState(false);
  const [dirty, setDirty] = useState(false);
  const [editorReady, setEditorReady] = useState(false);
  const [imageOperation, setImageOperation] = useState<"idle" | "creating" | "uploading">("idle");
  const imageOperationRef = useRef(imageOperation);
  const sharedImagesHandledRef = useRef(false);
  const [importingSharedImages, setImportingSharedImages] = useState(initialSharedImages.length > 0);
  const [sharedImageImportFailed, setSharedImageImportFailed] = useState(false);
  const failedSharedImageUrisRef = useRef(new Set<string>());
  const shareHandoffStartedRef = useRef(false);
  const createPendingRef = useRef(false);
  const submitStartedRef = useRef(false);
  const [submitStarted, setSubmitStarted] = useState(false);
  const [resourceTarget, setResourceTarget] = useState<MobileResourceTarget | null>(null);
  const editorStartup = useMobileEditorStartupGuard({ active: draftLoaded && Boolean(baseUrl), ready: editorReady });
  const { pickUploadAssets, uploadSourcePicker } = useMobileEditorUploadAsset();
  const targetNotebookId = notebookId || fallbackNotebookId;
  const selectedNotebookName = notebooks.find((notebook) => notebook.id === targetNotebookId)?.name ?? "选择笔记本";
  const titleRef = useRef(title);
  const tagsTextRef = useRef(tagsText);
  const targetNotebookIdRef = useRef(targetNotebookId);
  const userEditedSinceOpenRef = useRef(false);
  const notebooksRef = useRef(notebooks);
  notebooksRef.current = notebooks;
  titleRef.current = title;
  tagsTextRef.current = tagsText;
  targetNotebookIdRef.current = targetNotebookId;
  imageOperationRef.current = imageOperation;

  const { aiPromptsJson, cancelSelectionAi, requestSelectionAi } = useMobileSelectionAi({
    client,
    editorRef,
    resolvedLocale,
    titleRef,
  });

  const focusTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
  const keyboardTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);

  const pushBodyToEditor = useCallback((doc: TiptapDoc) => {
    safeDomCall(() => editorRef.current?.setContent(JSON.stringify(doc)));
  }, []);

  const clearFocusTimers = useCallback(() => {
    if (focusTimerRef.current !== null) {
      clearTimeout(focusTimerRef.current);
      focusTimerRef.current = null;
    }
    if (keyboardTimerRef.current !== null) {
      clearTimeout(keyboardTimerRef.current);
      keyboardTimerRef.current = null;
    }
  }, []);

  const scheduleBodyKeyboard = useCallback((delayMs = 160, focusEditor = true) => {
    clearFocusTimers();
    // Full-tree create only mounts the editor DomWebView, so native IME show is safe again.
    focusTimerRef.current = setTimeout(() => {
      focusTimerRef.current = null;
      if (focusEditor) {
        safeDomCall(() => editorRef.current?.focusEnd());
      }
      if (Platform.OS === "android") {
        keyboardTimerRef.current = setTimeout(() => {
          keyboardTimerRef.current = null;
          showEdgeEverKeyboard();
        }, focusEditor ? 120 : 0);
      }
    }, delayMs);
  }, [clearFocusTimers]);

  const retryEditorStartup = useCallback(() => {
    clearFocusTimers();
    setEditorReady(false);
    editorStartup.restart();
  }, [clearFocusTimers, editorStartup.restart]);

  // Component is only mounted while create is open — init once on mount.
  useEffect(() => {
    let active = true;
    setDraftLoaded(false);
    setEditorReady(false);
    setTemplatePickerOpen(false);
    userEditedSinceOpenRef.current = false;
    draftVersionRef.current = 0;

    if (initialDraft) {
      const markdown = initialDraft.contentMarkdown;
      contentMarkdownRef.current = markdown;
      contentJsonRef.current = markdownToDoc(markdown);
      setTitle(initialDraft.title);
      setTagsText(initialDraft.tagsText);
      setContentMarkdown(markdown);
      setNotebookId(fallbackNotebookId);
      setDirty(false);
      setDraftLoaded(true);
      return () => {
        active = false;
      };
    }

    contentMarkdownRef.current = "";
    contentJsonRef.current = markdownToDoc("");
    setTitle("");
    setTagsText("");
    setContentMarkdown("");
    setNotebookId(fallbackNotebookId);
    setDirty(false);

    // A regular create session must always start blank. Remove any legacy
    // auto-saved create draft instead of restoring content from the last one.
    void clearMobileNewMemoDraft(dataScope).catch(() => undefined).finally(() => {
      if (active) {
        setDraftLoaded(true);
      }
    });
    return () => {
      active = false;
    };
    // eslint-disable-next-line react-hooks/exhaustive-deps -- mount-only for create screen lifetime
  }, []);

  const isWebClipDraft = Boolean(
    initialDraft && "sourceUrl" in initialDraft && typeof initialDraft.sourceUrl === "string" && initialDraft.sourceUrl.length > 0
  );

  const persistCurrentDraft = useCallback(() => {
    const materializedMemo = materializedMemoRef.current;
    const currentTitle = titleRef.current;
    const currentContentMarkdown = contentMarkdownRef.current;
    const currentNotebookId = targetNotebookIdRef.current;
    const currentTagsText = tagsTextRef.current;
    const updatedAt = new Date().toISOString();

    return draftWriteBarrier.enqueue(() => materializedMemo
      ? writeMobileMemoDraft({
        memoId: materializedMemo.id,
        expectedRevision: materializedMemo.revision,
        title: currentTitle,
        contentMarkdown: currentContentMarkdown,
        notebookId: currentNotebookId,
        tagsText: currentTagsText,
        updatedAt,
      })
      : Promise.resolve());
  }, [draftWriteBarrier]);

  const applyTemplateSeed = useCallback((seed: MobileCreateMemoSeed) => {
    const markdown = seed.contentMarkdown;
    const doc = markdownToDoc(markdown);
    contentMarkdownRef.current = markdown;
    contentJsonRef.current = doc;
    setTitle(seed.title);
    setTagsText(seed.tagsText);
    setContentMarkdown(markdown);
    draftVersionRef.current += 1;
    userEditedSinceOpenRef.current = true;
    setDirty(true);
    // In-place body replace — never remount DomWebView (remount costs ~1s and breaks Android IME).
    pushBodyToEditor(doc);
    scheduleBodyKeyboard(80);
  }, [pushBodyToEditor, scheduleBodyKeyboard]);

  const requestApplyTemplateSeed = useCallback((seed: MobileCreateMemoSeed) => {
    const current = {
      title: titleRef.current,
      contentMarkdown: contentMarkdownRef.current,
      tagsText: tagsTextRef.current,
    };
    if (createMemoSeedHasContent(current)) {
      Alert.alert(translate("应用模板?"), translate("当前内容将被模板内容替换。"), [
        { text: translate("取消"), style: "cancel" },
        { text: translate("替换"), style: "destructive", onPress: () => applyTemplateSeed(seed) },
      ]);
      return;
    }
    applyTemplateSeed(seed);
  }, [applyTemplateSeed, translate]);

  useEffect(() => {
    if (!draftLoaded || !dirty || isWebClipDraft) {
      return;
    }
    const draftVersion = draftVersionRef.current;
    const timeout = setTimeout(() => {
      void persistCurrentDraft().then((written) => {
        if (written && !submitStartedRef.current && draftVersionRef.current === draftVersion) {
          setDirty(false);
        }
      }).catch(() => undefined);
    }, 350);
    return () => clearTimeout(timeout);
  }, [contentMarkdown, dirty, draftLoaded, isWebClipDraft, persistCurrentDraft, tagsText, targetNotebookId, title]);

  const createMutation = useMutation({
    mutationFn: async () => {
      if (!targetNotebookId) {
        throw new Error("请先创建一个笔记本");
      }
      const materializedMemo = materializedMemoRef.current;
      if (materializedMemo) {
        const optimisticMemo = createOptimisticMemo(materializedMemo, {
          title: titleRef.current.trim() || DEFAULT_MEMO_TITLE,
          contentJson: contentJsonRef.current,
          contentMarkdown: contentMarkdownRef.current.trim(),
          notebookId: targetNotebookIdRef.current,
          tags: parseTags(tagsTextRef.current),
        });
        await upsertLocalMemo(dataScope, optimisticMemo);
        await queueMobileMemoUpdate(syncQueueScope, {
          memoId: materializedMemo.id,
          expectedRevision: materializedMemo.revision,
          expectedContentHash: materializedMemo.contentHash,
          title: optimisticMemo.title ?? DEFAULT_MEMO_TITLE,
          contentMarkdown: optimisticMemo.contentMarkdown,
          notebookId: optimisticMemo.notebookId,
          tags: optimisticMemo.tags,
        });
        return optimisticMemo;
      }
      const now = new Date().toISOString();
      const temporaryId = `local:${Date.now().toString(36)}:${Math.random().toString(36).slice(2, 10)}`;
      const markdown = contentMarkdownRef.current.trim();
      const contentJson = contentJsonRef.current;
      const contentText = docToText(contentJson);
      const memo: MemoDetail = {
        id: temporaryId,
        notebookId: targetNotebookId,
        title: title.trim() || DEFAULT_MEMO_TITLE,
        excerpt: createExcerpt(contentText),
        tags: parseTags(tagsText),
        isPinned: false,
        isArchived: false,
        isDeleted: false,
        revision: 0,
        createdAt: now,
        updatedAt: now,
        deletedAt: null,
        contentJson,
        contentMarkdown: markdown,
        contentText,
        contentHash: `local:${temporaryId}`,
        sourceMemoIds: [],
        mergeSourceCount: 0,
        mergedIntoMemoId: null,
      };
      await upsertLocalMemo(dataScope, memo);
      await queueMobileMemoCreate(syncQueueScope, {
        memoId: temporaryId,
        notebookId: memo.notebookId,
        title: memo.title ?? DEFAULT_MEMO_TITLE,
        contentMarkdown: memo.contentMarkdown,
        tags: memo.tags,
        createdAt: now,
      });
      return memo;
    },
    onSuccess: async (memo) => {
      const materializedMemoId = materializedMemoRef.current?.id ?? null;
      // Wait for any already-running AsyncStorage write before removing the
      // draft. Nothing queued after submit began is allowed to recreate it.
      await draftWriteBarrier.blockAndDrain();
      if (!isWebClipDraft) {
        await clearMobileNewMemoDraft(dataScope);
      }
      if (materializedMemoId) {
        await clearMobileMemoDraft(materializedMemoId);
      }
      await Promise.all([
        queryClient.invalidateQueries({ queryKey: ["mobile", "notebooks"] }),
        queryClient.invalidateQueries({ queryKey: ["mobile", "memos"] }),
      ]);
      setTitle("");
      setTagsText("");
      setContentMarkdown("");
      contentMarkdownRef.current = "";
      contentJsonRef.current = markdownToDoc("");
      materializedMemoRef.current = null;
      draftVersionRef.current += 1;
      setDirty(false);
      void onQueued();
      onCreated(memo);
    },
    onError: () => {
      submitStartedRef.current = false;
      draftWriteBarrier.unblock();
      setSubmitStarted(false);
      draftVersionRef.current += 1;
      setDirty(true);
      if (!isWebClipDraft) {
        void persistCurrentDraft().catch(() => undefined);
      }
    },
  });
  createPendingRef.current = createMutation.isPending;
  const canSubmitCreateMemo = Boolean(targetNotebookId) && !submitStarted && !createMutation.isPending && imageOperation === "idle";
  const canUseTemplate = editorReady && imageOperation === "idle" && !submitStarted && !createMutation.isPending;

  const materializeMemoForImage = async () => {
    if (materializedMemoRef.current) {
      return materializedMemoRef.current;
    }
    if (!client || !targetNotebookIdRef.current) {
      throw new Error("当前无法连接实例,请稍后重试");
    }
    setImageOperation("creating");
    const response = await client.createMemo({
      notebookId: targetNotebookIdRef.current,
      title: titleRef.current.trim() || DEFAULT_MEMO_TITLE,
      contentMarkdown: contentMarkdownRef.current.trim(),
      tags: parseTags(tagsTextRef.current),
    });
    materializedMemoRef.current = response.memo;
    await upsertLocalMemo(dataScope, response.memo);
    if (!isWebClipDraft) {
      await clearMobileNewMemoDraft(dataScope);
    }
    await Promise.all([
      queryClient.invalidateQueries({ queryKey: ["mobile", "notebooks"] }),
      queryClient.invalidateQueries({ queryKey: ["mobile", "memos"] }),
    ]);
    return response.memo;
  };

  const uploadImageAsset = async (asset: MobileImageUploadAsset | null, keepBusy = false) => {
    let uploadId: string | null = null;
    try {
      if (!asset) {
        return;
      }
      const isImage = asset.mimeType?.startsWith("image/") ?? false;
      if (isImage) {
        uploadId = createMobileImageUploadId();
        const previewDataUrl = await createLocalImagePreviewDataUrl(asset);
        safeDomCall(() => editorRef.current?.beginImageUpload(uploadId, previewDataUrl));
      }
      const memo = await materializeMemoForImage();
      setImageOperation("uploading");
      const uploadAsset = await prepareUploadAsset(asset, imageCompressionEnabled);
      const { resource } = await uploadMobileResource(client!, memo.id, uploadAsset);
      applyMobileEditorUpload(editorRef, resource, uploadId, uploadAsset.name || (resource.kind === "image" ? "图片" : "附件"));
      if (resource.kind === "image" && !keepBusy) {
        safeDomCall(() => editorRef.current?.finishImageBatch([resource.url]));
      }
      failedSharedImageUrisRef.current.delete(asset.uri);
      setSharedImageImportFailed(failedSharedImageUrisRef.current.size > 0);
      return resource.kind === "image" ? resource.url : null;
    } catch (error) {
      cancelMobileEditorUpload(editorRef, uploadId);
      if (asset && initialSharedImages.some((image) => image.uri === asset.uri)) {
        failedSharedImageUrisRef.current.add(asset.uri);
        setSharedImageImportFailed(true);
      }
      Alert.alert("附件上传失败", error instanceof Error ? error.message : "请检查网络连接后重试", [
        { text: "取消", style: "cancel" },
        // Keep the source asset in this editor so retrying does not require
        // sharing again or creating another remote memo.
        { text: "重试", onPress: () => { void uploadImageAsset(asset); } },
      ]);
    } finally {
      if (!keepBusy) setImageOperation("idle");
    }
  };

  const pickAndUploadImage = async () => {
    const assets = await pickUploadAssets();
    if (!assets.length) return;
    const sources: string[] = [];
    setImageOperation("uploading");
    try {
      for (const asset of assets) {
        const source = await uploadImageAsset(asset, true);
        if (source === undefined) break;
        if (source) sources.push(source);
      }
      safeDomCall(() => editorRef.current?.finishImageBatch(sources));
    } finally {
      setImageOperation("idle");
    }
  };

  useEffect(() => {
    if (!editorReady || sharedImagesHandledRef.current || initialSharedImages.length === 0) {
      return;
    }
    sharedImagesHandledRef.current = true;
    void (async () => {
      try {
        for (const image of initialSharedImages) {
          if (await uploadImageAsset(image) === undefined) {
            setSharedImageImportFailed(true);
          }
        }
      } finally {
        setImportingSharedImages(false);
      }
    })();
  }, [editorReady, initialSharedImages]);

  const markDirty = () => {
    if (submitStartedRef.current) {
      return;
    }
    userEditedSinceOpenRef.current = true;
    draftVersionRef.current += 1;
    setDirty(true);
  };

  const flushEditor = () => flushMobileEditor(editorRef, flushResolverRef);

  const submitCreateMemo = async () => {
    if (submitStartedRef.current || createPendingRef.current || imageOperationRef.current !== "idle") {
      return;
    }
    submitStartedRef.current = true;
    setSubmitStarted(true);
    const draftsDrained = draftWriteBarrier.blockAndDrain();
    try {
      await flushEditor();
      await draftsDrained;
      createMutation.mutate();
    } catch {
      submitStartedRef.current = false;
      draftWriteBarrier.unblock();
      setSubmitStarted(false);
    }
  };

  const requestClose = () => submitCreateMemo();

  useEffect(() => {
    if (!finishForIncomingShare) {
      shareHandoffStartedRef.current = false;
      return;
    }
    if (!draftLoaded || !editorReady || importingSharedImages || sharedImageImportFailed || imageOperation !== "idle" || submitStarted || shareHandoffStartedRef.current) {
      return;
    }
    // Save through the normal close path, including editor flush and queued
    // writes. On failure keep both this editor and the next share intact;
    // the user can retry saving without an automatic retry loop.
    shareHandoffStartedRef.current = true;
    void submitCreateMemo();
  }, [finishForIncomingShare, draftLoaded, editorReady, importingSharedImages, sharedImageImportFailed, imageOperation, submitStarted, submitCreateMemo]);

  useEffect(() => {
    const subscription = BackHandler.addEventListener("hardwareBackPress", () => {
      void requestClose();
      return true;
    });
    return () => {
      subscription.remove();
      clearFocusTimers();
    };
  }, [clearFocusTimers]);

  const canMutateEditorResource = useCallback(() => Boolean(materializedMemoRef.current), []);
  const {
    deleteResource,
    downloadResource,
    loadEditorResource,
    renameResource,
    saveResourceAs,
    selectResource,
  } = useMobileEditorResourceActions({
    baseUrl,
    canMutate: canMutateEditorResource,
    client,
    editorRef,
    onLoadFailure: imageLoadFailureNotifier,
    onSelect: setResourceTarget,
    resolvedLocale,
    resourceCacheRef: resourceDataUrlCacheRef,
    sessionBaseUrl: session?.baseUrl,
    token: session?.token,
  });

  const editorElement = useMemo(() => draftLoaded && baseUrl ? (
    <LocalTiptapEditor
      autoFocus
      aiPromptsJson={aiPromptsJson}
      baseUrl={baseUrl}
      content={contentJsonRef.current}
      dom={{
        ...SAFE_DOM_WEBVIEW_PROPS,
        bounces: false,
        contentInsetAdjustmentBehavior: "never",
        overScrollMode: "never",
        scrollEnabled: false,
        style: styles.createMemoEditor,
      }}
      onChange={async (contentJson) => {
        contentJsonRef.current = contentJson;
        const markdown = docToMarkdown(contentJson);
        contentMarkdownRef.current = markdown;
        setContentMarkdown(markdown);
        markDirty();
        flushResolverRef.current?.();
        flushResolverRef.current = null;
      }}
      onAiCancel={cancelSelectionAi}
      onAiRequest={requestSelectionAi}
      onResourcePress={selectResource}
      onLoadResource={loadEditorResource}
      onPickImage={pickAndUploadImage}
      onReady={async (elapsedMs) => {
        setEditorReady(true);
        recordEditorStartup(elapsedMs);
        // LocalTiptapEditor owns caret placement; native only reveals the IME after
        // its final focus retry so the two layers cannot race each other.
        scheduleBodyKeyboard(180, false);
      }}
      key={editorStartup.attempt}
      ref={editorRef}
      locale={resolvedLocale}
      theme={resolvedTheme}
    />
  ) : null, [aiPromptsJson, baseUrl, cancelSelectionAi, draftLoaded, editorStartup.attempt, loadEditorResource, pushBodyToEditor, requestSelectionAi, resolvedLocale, resolvedTheme, scheduleBodyKeyboard, selectResource]);

  return (
    <SafeAreaView edges={["top", "left", "right", "bottom"]} style={styles.createMemoSafeArea}>
      <View style={styles.createMemoHeader}>
        <Pressable accessibilityLabel="返回" accessibilityRole="button" disabled={submitStarted || createMutation.isPending || imageOperation !== "idle"} onPress={() => void requestClose()} style={styles.createMemoBackButton}>
          <ChevronLeft color={submitStarted || createMutation.isPending || imageOperation !== "idle" ? "#cbd5e1" : "#0f172a"} size={30} />
        </Pressable>
        <View style={styles.createMemoHeaderActions}>
          <Text style={[styles.createMemoStatus, (submitStarted || createMutation.isPending) && styles.createMemoStatusActive]}>
            {imageOperation === "creating" ? "正在创建" : imageOperation === "uploading" ? "正在上传" : submitStarted || createMutation.isPending || dirty ? "保存中" : editorReady ? "已保存" : "准备中"}
          </Text>
          <Pressable
            accessibilityLabel={translate("模板")}
            accessibilityRole="button"
            disabled={!canUseTemplate}
            onPress={() => setTemplatePickerOpen(true)}
            style={[styles.createMemoTemplateButton, !canUseTemplate && styles.createMemoDoneButtonDisabled]}
          >
            <Text style={[styles.createMemoTemplateButtonText, !canUseTemplate && styles.createMemoDoneTextDisabled]}>{translate("模板")}</Text>
          </Pressable>
          <Pressable
            accessibilityLabel="完成新建笔记"
            disabled={!canSubmitCreateMemo}
            onPress={() => void submitCreateMemo()}
            style={[styles.createMemoDoneButton, !canSubmitCreateMemo && styles.createMemoDoneButtonDisabled]}
          >
            {submitStarted || createMutation.isPending ? <ActivityIndicator color="#64748b" size="small" /> : <Text style={[styles.createMemoDoneText, !canSubmitCreateMemo && styles.createMemoDoneTextDisabled]}>完成</Text>}
          </Pressable>
        </View>
      </View>

      <View style={styles.createMemoMain}>
        <TextInput
          autoCorrect
          accessibilityLabel="笔记标题"
          onChangeText={(value) => {
            setTitle(value);
            markDirty();
          }}
          placeholder={DEFAULT_MEMO_TITLE}
          placeholderTextColor="#94a3b8"
          style={styles.createMemoTitleInput}
          value={title}
        />

        <View style={styles.createMemoMetaRow}>
          <Pressable accessibilityLabel="所在笔记本" accessibilityRole="button" onPress={() => setNotebookPickerOpen(true)} style={styles.createMemoNotebookButton}>
            <Text numberOfLines={1} style={styles.createMemoNotebookText}>{selectedNotebookName}</Text>
            <ChevronDown color="#64748b" size={14} />
          </Pressable>
          <Pressable accessibilityLabel="选择笔记标签" accessibilityRole="button" onPress={() => setTagPickerOpen(true)} style={styles.createMemoTagsButton}>
            <Text numberOfLines={1} style={[styles.createMemoTagsInput, !tagsText && styles.createMemoTagsPlaceholder]}>
              {tagsText || "添加标签"}
            </Text>
            <ChevronDown color="#94a3b8" size={14} />
          </Pressable>
          <SmartTagButton
            client={client}
            contentMarkdown={contentMarkdown}
            onChange={(nextTags) => {
              setTagsText(nextTags.join(", "));
              markDirty();
            }}
            selectedTags={parseTags(tagsText)}
            title={title}
          />
        </View>

        <View style={styles.createMemoEditorFrame}>
          {editorElement}
          {!editorReady ? <MobileEditorStartupOverlay onRetry={retryEditorStartup} timedOut={editorStartup.timedOut} /> : null}
        </View>

        {createMutation.error ? (
          <Text style={styles.errorText}>{createMutation.error instanceof Error ? createMutation.error.message : "创建失败"}</Text>
        ) : null}
      </View>
      <NotebookPickerModal
        activeNotebookId={targetNotebookId}
        includeAllNotes={false}
        notebooks={notebooks}
        onClose={() => setNotebookPickerOpen(false)}
        onSelect={(nextNotebookId) => {
          if (!nextNotebookId || nextNotebookId === "all") {
            setNotebookPickerOpen(false);
            return;
          }
          setNotebookId(nextNotebookId);
          setNotebookPickerOpen(false);
          markDirty();
        }}
        visible={notebookPickerOpen}
      />
      <TagPickerModal
        dataScope={dataScope}
        onChange={(nextTags) => {
          setTagsText(nextTags.join(", "));
          markDirty();
        }}
        onClose={() => setTagPickerOpen(false)}
        selectedTags={parseTags(tagsText)}
        visible={tagPickerOpen}
      />
      <MobileResourceActions
        canMutate={Boolean(materializedMemoRef.current)}
        onClose={() => setResourceTarget(null)}
        onDelete={deleteResource}
        onDownload={downloadResource}
        onRename={renameResource}
        onSaveAs={saveResourceAs}
        target={resourceTarget}
      />
      <MobileTemplatePickerModal
        client={client}
        onClose={() => {
          setTemplatePickerOpen(false);
          scheduleBodyKeyboard(80);
        }}
        onSelect={requestApplyTemplateSeed}
        presentation="overlay"
        visible={templatePickerOpen}
      />
      {uploadSourcePicker}
    </SafeAreaView>
  );
};

/** Full-tree editor for paths that do not already have a mounted viewer WebView. Existing notes edit in place on the detail viewer. */
export const RichEditorModal = ({
  baseUrl,
  initialDraft,
  initialFocus = "body",
  imageCompressionEnabled,
  memo,
  notebooks,
  onClose,
  updateMutation,
}: {
  baseUrl: string;
  initialDraft: MobileMemoDraft | null;
  initialFocus?: "body" | "title";
  imageCompressionEnabled: boolean;
  memo: MemoDetail | null;
  notebooks: Notebook[];
  onClose: () => void;
  updateMutation: MobileMemoUpdateMutation;
}) => {
  const { client, session } = useSession();
  const { resolvedLocale } = useMobileLocale();
  const { resolvedTheme } = useMobileTheme();
  const restoredDraft = initialDraft?.expectedRevision === memo?.revision ? initialDraft : null;
  const initialContentJson = restoredDraft
    ? markdownToDoc(restoredDraft.contentMarkdown)
    : resolveMemoContentDoc(memo?.contentJson, memo?.contentMarkdown);
  const editorRef = useRef<LocalTiptapEditorRef>(null);
  const resourceDataUrlCacheRef = useRef(new Map<string, Promise<string | null>>());
  const imageLoadFailureNotifier = useMemo(
    () =>
      createOnceProtectedResourceFailureNotifier((failure) => {
        alertProtectedImageLoadFailure(resolvedLocale, failure);
      }),
    [memo?.id, resolvedLocale]
  );
  const initialFocusTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
  const contentJsonRef = useRef<TiptapDoc>(initialContentJson);
  const contentMarkdownRef = useRef(restoredDraft?.contentMarkdown ?? memo?.contentMarkdown ?? "");
  const contentSnapshotRef = useRef(JSON.stringify(contentJsonRef.current));
  const dirtyRef = useRef(Boolean(restoredDraft));
  const flushResolverRef = useRef<(() => void) | null>(null);
  const savingRef = useRef(false);
  const uploadingRef = useRef(false);
  const memoBaseRef = useRef(memo);
  const [title, setTitle] = useState(resolveEditableMemoTitle(restoredDraft?.title ?? memo?.title));
  const [tagsText, setTagsText] = useState(restoredDraft?.tagsText ?? memo?.tags.join(", ") ?? "");
  const [notebookId, setNotebookId] = useState(restoredDraft?.notebookId ?? memo?.notebookId ?? "");
  const [notebookPickerOpen, setNotebookPickerOpen] = useState(false);
  const [tagPickerOpen, setTagPickerOpen] = useState(false);
  const [draftRestored, setDraftRestored] = useState(Boolean(restoredDraft));
  const [ready, setReady] = useState(false);
  const [dirty, setDirty] = useState(Boolean(restoredDraft));
  const [autosaveGeneration, setAutosaveGeneration] = useState(0);
  const [saving, setSaving] = useState(false);
  const [uploading, setUploading] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const [startupMs, setStartupMs] = useState<number | null>(null);
  const [resourceTarget, setResourceTarget] = useState<MobileResourceTarget | null>(null);
  const editorStartup = useMobileEditorStartupGuard({ active: Boolean(memo && baseUrl), ready });
  const { pickUploadAssets, uploadSourcePicker } = useMobileEditorUploadAsset();
  const notebookLabel = notebooks.find((notebook) => notebook.id === notebookId)?.name ?? localizeMissingNotebookName(resolvedLocale);
  const saveChrome = getMobileEditorSaveChrome({
    dirty,
    draftRestored,
    error: Boolean(error),
    ready,
    saving,
    uploading,
  });
  const closingRef = useRef(false);
  const requestCloseRef = useRef<() => Promise<void>>(async () => undefined);
  const markAutosaveDirty = () => {
    dirtyRef.current = true;
    setDirty(true);
    setAutosaveGeneration((current) => current + 1);
  };
  const titleRef = useRef(title);
  const tagsTextRef = useRef(tagsText);
  const notebookIdRef = useRef(notebookId);
  titleRef.current = title;
  tagsTextRef.current = tagsText;
  notebookIdRef.current = notebookId;

  useEffect(() => () => {
    if (initialFocusTimerRef.current !== null) {
      clearTimeout(initialFocusTimerRef.current);
      initialFocusTimerRef.current = null;
    }
  }, []);

  const retryEditorStartup = useCallback(() => {
    if (initialFocusTimerRef.current !== null) {
      clearTimeout(initialFocusTimerRef.current);
      initialFocusTimerRef.current = null;
    }
    setReady(false);
    setStartupMs(null);
    setError(null);
    editorStartup.restart();
  }, [editorStartup.restart]);

  const persistDraft = async (contentJson: TiptapDoc) => {
    const currentMemo = memoBaseRef.current;
    if (!currentMemo) {
      return;
    }
    const contentSnapshot = JSON.stringify(contentJson);
    if (contentSnapshot === contentSnapshotRef.current) {
      flushResolverRef.current?.();
      flushResolverRef.current = null;
      return;
    }
    contentSnapshotRef.current = contentSnapshot;
    contentJsonRef.current = contentJson;
    contentMarkdownRef.current = docToMarkdown(contentJson);
    markAutosaveDirty();
    setError(null);
    flushResolverRef.current?.();
    flushResolverRef.current = null;
    await writeMobileMemoDraft({
      memoId: currentMemo.id,
      expectedRevision: currentMemo.revision,
      title: titleRef.current.trim(),
      contentMarkdown: contentMarkdownRef.current,
      notebookId: notebookIdRef.current,
      tagsText: tagsTextRef.current,
      updatedAt: new Date().toISOString(),
    });
  };

  const save = async () => {
    const currentMemo = memoBaseRef.current;
    if (!currentMemo || savingRef.current || !notebookIdRef.current) {
      return null;
    }
    if (!dirtyRef.current) {
      return currentMemo;
    }
    // Capture whether the user kept typing while this save is in flight so we
    // do not clear the dirty flag and drop their next autosave.
    const dirtyGenerationAtStart = contentSnapshotRef.current;
    savingRef.current = true;
    setSaving(true);
    setError(null);

    try {
      const savedMemo = await updateMutation.mutateAsync({
        memo: currentMemo,
        payload: {
          title: titleRef.current.trim() || DEFAULT_MEMO_TITLE,
          contentJson: contentJsonRef.current,
          contentMarkdown: contentMarkdownRef.current,
          notebookId: notebookIdRef.current,
          tags: parseTags(tagsTextRef.current),
        },
      });
      memoBaseRef.current = savedMemo;
      await clearMobileMemoDraft(currentMemo.id);
      if (contentSnapshotRef.current === dirtyGenerationAtStart) {
        dirtyRef.current = false;
        setDirty(false);
      } else {
        // Newer local edits arrived during the save. Restart the quiet period
        // so the follow-up save does not fire on the timer that already elapsed.
        markAutosaveDirty();
      }
      setDraftRestored(false);
      return savedMemo;
    } catch (saveError) {
      setError(saveError instanceof Error ? saveError.message : "保存失败");
      return null;
    } finally {
      savingRef.current = false;
      setSaving(false);
      if (closingRef.current) {
        closingRef.current = false;
        void requestCloseRef.current();
      }
    }
  };

  const flushEditor = () => flushMobileEditor(editorRef, flushResolverRef);
  const { aiPromptsJson, cancelSelectionAi, requestSelectionAi } = useMobileSelectionAi({
    client,
    editorRef,
    resolvedLocale,
    titleRef,
  });

  const requestClose = async () => {
    if (uploadingRef.current) {
      return;
    }
    if (savingRef.current) {
      closingRef.current = true;
      return;
    }
    closingRef.current = false;
    if (initialFocusTimerRef.current !== null) {
      clearTimeout(initialFocusTimerRef.current);
      initialFocusTimerRef.current = null;
    }
    await flushEditor();
    const savedMemo = await save();
    if (savedMemo) {
      onClose();
    }
  };
  requestCloseRef.current = requestClose;

  useEffect(() => {
    const subscription = BackHandler.addEventListener("hardwareBackPress", () => {
      void requestCloseRef.current();
      return true;
    });
    return () => subscription.remove();
  }, []);

  const pickAndUploadImage = async () => {
    if (!client || !memo || uploadingRef.current) {
      return;
    }
    if (memo.id.startsWith("local:")) {
      Alert.alert("正在同步新笔记", "首次同步完成后即可上传本地图片;图片链接现在就可以直接粘贴到正文。");
      return;
    }
    const assets = await pickUploadAssets();
    if (!assets.length) {
      return;
    }

    let uploadId: string | null = null;
    const sources: string[] = [];
    uploadingRef.current = true;
    setUploading(true);
    setError(null);
    try {
      for (const asset of assets) {
        const isImage = asset.mimeType?.startsWith("image/") ?? false;
        uploadId = isImage ? createMobileImageUploadId() : null;
        if (isImage && uploadId) {
          const previewDataUrl = await createLocalImagePreviewDataUrl(asset);
          safeDomCall(() => editorRef.current?.beginImageUpload(uploadId, previewDataUrl));
        }
        const uploadAsset = await prepareUploadAsset(asset, imageCompressionEnabled);
        const { resource } = await uploadMobileResource(client, memo.id, uploadAsset);
        applyMobileEditorUpload(editorRef, resource, uploadId, uploadAsset.name || (resource.kind === "image" ? "图片" : "附件"));
        if (resource.kind === "image") sources.push(resource.url);
        uploadId = null;
      }
    } catch (uploadError) {
      cancelMobileEditorUpload(editorRef, uploadId);
      setError(uploadError instanceof Error ? uploadError.message : "附件上传失败");
    } finally {
      safeDomCall(() => editorRef.current?.finishImageBatch(sources));
      uploadingRef.current = false;
      setUploading(false);
    }
  };

  const canMutateEditorResource = useCallback(() => Boolean(memo && !memo.id.startsWith("local:")), [memo]);
  const {
    deleteResource,
    downloadResource,
    loadEditorResource,
    renameResource,
    saveResourceAs,
    selectResource,
  } = useMobileEditorResourceActions({
    baseUrl,
    canMutate: canMutateEditorResource,
    client,
    editorRef,
    onLoadFailure: imageLoadFailureNotifier,
    onSelect: setResourceTarget,
    resolvedLocale,
    resourceCacheRef: resourceDataUrlCacheRef,
    sessionBaseUrl: session?.baseUrl,
    token: session?.token,
  });

  const editorElement = useMemo(
    () => memo && baseUrl ? (
      <LocalTiptapEditor
        autoFocus={initialFocus === "body"}
        aiPromptsJson={aiPromptsJson}
        baseUrl={baseUrl}
        content={contentJsonRef.current}
        dom={{
          ...SAFE_DOM_WEBVIEW_PROPS,
          bounces: false,
          contentInsetAdjustmentBehavior: "never",
          overScrollMode: "never",
          scrollEnabled: false,
          style: styles.richEditorWebView,
        }}
        onChange={persistDraft}
        onAiCancel={cancelSelectionAi}
        onAiRequest={requestSelectionAi}
        onResourcePress={selectResource}
        onLoadResource={loadEditorResource}
        onPickImage={pickAndUploadImage}
        onReady={async (elapsedMs) => {
          setStartupMs(elapsedMs);
          setReady(true);
          recordEditorStartup(elapsedMs);
          if (initialFocusTimerRef.current !== null) {
            clearTimeout(initialFocusTimerRef.current);
          }
          // The DOM editor performs its own bounded focus retry. Reveal the Android
          // keyboard only after that retry instead of issuing another competing focus.
          if (Platform.OS === "android" && initialFocus === "body") {
            initialFocusTimerRef.current = setTimeout(() => {
              initialFocusTimerRef.current = null;
              showEdgeEverKeyboard();
            }, 180);
          }
        }}
        key={editorStartup.attempt}
        ref={editorRef}
        locale={resolvedLocale}
        theme={resolvedTheme}
      />
    ) : null,
    [aiPromptsJson, baseUrl, cancelSelectionAi, editorStartup.attempt, initialFocus, loadEditorResource, memo?.id, requestSelectionAi, resolvedLocale, resolvedTheme, selectResource]
  );

  useEffect(() => {
    const currentMemo = memoBaseRef.current;
    if (!currentMemo || !dirty) {
      return;
    }
    const timeout = setTimeout(() => {
      void writeMobileMemoDraft({
        memoId: currentMemo.id,
        expectedRevision: currentMemo.revision,
        title: titleRef.current.trim(),
        contentMarkdown: contentMarkdownRef.current,
        notebookId: notebookIdRef.current,
        tagsText: tagsTextRef.current,
        updatedAt: new Date().toISOString(),
      });
    }, 350);
    return () => clearTimeout(timeout);
  }, [dirty, memo, notebookId, tagsText, title]);

  useEffect(() => {
    if (!memoBaseRef.current || !shouldScheduleMobileEditorAutosave({
      active: true,
      closing: closingRef.current,
      dirty,
      ready,
      saving: savingRef.current,
      uploading: uploadingRef.current,
    })) {
      return;
    }
    const timeout = setTimeout(() => {
      void flushEditor().then(save);
    }, MOBILE_EDITOR_AUTOSAVE_DELAY_MS);
    return () => clearTimeout(timeout);
  }, [autosaveGeneration, dirty, memo, notebookId, ready, tagsText, title]);

  return (
    <SafeAreaView style={styles.richEditorSafeArea}>
      <KeyboardAvoidingView
        behavior="height"
        enabled={Platform.OS === "android"}
        style={styles.richEditorKeyboardAvoiding}
      >
        <View style={styles.createMemoHeader}>
          <Pressable accessibilityLabel="返回" accessibilityRole="button" disabled={uploading} onPress={() => void requestClose()} style={styles.createMemoBackButton}>
            <ChevronLeft color={uploading ? "#cbd5e1" : "#0f172a"} size={30} />
          </Pressable>
          <View style={styles.createMemoHeaderActions}>
            <Text numberOfLines={1} style={[styles.createMemoStatus, styles.richEditorHeaderStatus, saveChrome.emphasized && styles.createMemoStatusActive, error && styles.richEditorStatusError]}>{saveChrome.label}</Text>
            <Pressable
              accessibilityLabel="完成编辑"
              accessibilityRole="button"
              disabled={uploading || !ready}
              onPress={() => void requestClose()}
              style={[styles.createMemoDoneButton, (uploading || !ready) && styles.createMemoDoneButtonDisabled]}
            >
              <Text style={[styles.createMemoDoneText, (uploading || !ready) && styles.createMemoDoneTextDisabled]}>完成</Text>
            </Pressable>
          </View>
        </View>

        {memo && baseUrl ? (
          <View style={styles.richEditorContainer}>
            <TextInput
              autoFocus={initialFocus === "title"}
              onChangeText={(value) => {
                setTitle(value);
                markAutosaveDirty();
              }}
              placeholder={DEFAULT_MEMO_TITLE}
              placeholderTextColor="#94a3b8"
              selectTextOnFocus={initialFocus === "title"}
              style={styles.createMemoTitleInput}
              value={title}
            />
            <View style={[styles.createMemoMetaRow, styles.richStandaloneMetaRow]}>
              <Pressable accessibilityLabel="所在笔记本" accessibilityRole="button" onPress={() => setNotebookPickerOpen(true)} style={styles.createMemoNotebookButton}>
                <Text numberOfLines={1} style={styles.createMemoNotebookText}>{notebookLabel}</Text>
                <ChevronDown color="#64748b" size={14} />
              </Pressable>
              <Pressable accessibilityLabel="选择笔记标签" accessibilityRole="button" onPress={() => setTagPickerOpen(true)} style={[styles.createMemoTagsButton, styles.richStandaloneTagsInput]}>
                <Text numberOfLines={1} style={[styles.createMemoTagsInput, !tagsText && styles.createMemoTagsPlaceholder]}>
                  {tagsText || "添加标签"}
                </Text>
                <ChevronDown color="#94a3b8" size={14} />
              </Pressable>
              <SmartTagButton
                client={client}
                contentMarkdown={contentMarkdownRef.current}
                disabled={saving || uploading}
                onChange={(nextTags) => {
                  setTagsText(nextTags.join(", "));
                  markAutosaveDirty();
                }}
                selectedTags={parseTags(tagsText)}
                title={title}
              />
            </View>
            {draftRestored ? <Text style={styles.richEditorDraftNotice}>已恢复上次未完成的本地草稿</Text> : null}
            <View style={styles.richEditorFrame}>
              {editorElement}
              {!ready ? <MobileEditorStartupOverlay onRetry={retryEditorStartup} timedOut={editorStartup.timedOut} /> : null}
            </View>
            {error ? <Text style={styles.richEditorInlineError}>{error}</Text> : null}
            {startupMs !== null && __DEV__ ? <Text style={styles.richEditorPerf}>本地编辑器启动:{startupMs}ms</Text> : null}
          </View>
        ) : (
          <View style={styles.centerState}>
            <Text style={styles.errorText}>缺少笔记数据,无法打开富文本编辑器</Text>
          </View>
        )}
        <NotebookPickerModal
          activeNotebookId={notebookId}
          includeAllNotes={false}
          notebooks={notebooks}
          onClose={() => setNotebookPickerOpen(false)}
          onSelect={(nextNotebookId) => {
            if (!nextNotebookId || nextNotebookId === "all") {
              setNotebookPickerOpen(false);
              return;
            }
            setNotebookId(nextNotebookId);
            setNotebookPickerOpen(false);
            markAutosaveDirty();
          }}
          visible={notebookPickerOpen}
        />
        <TagPickerModal
          dataScope={createMobileDataScope(session?.baseUrl ?? baseUrl, session?.user?.id)}
          onChange={(nextTags) => {
            setTagsText(nextTags.join(", "));
            markAutosaveDirty();
          }}
          onClose={() => setTagPickerOpen(false)}
          selectedTags={parseTags(tagsText)}
          visible={tagPickerOpen}
        />
        <MobileResourceActions
          canMutate={Boolean(memo && !memo.id.startsWith("local:"))}
          onClose={() => setResourceTarget(null)}
          onDelete={deleteResource}
          onDownload={downloadResource}
          onRename={renameResource}
          onSaveAs={saveResourceAs}
          target={resourceTarget}
        />
        {uploadSourcePicker}
      </KeyboardAvoidingView>
    </SafeAreaView>
  );
};

const createMobileImageUploadId = () =>
  `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;

const createLocalImagePreviewDataUrl = async (asset: { mimeType?: string | null; uri: string }) => {
  const file = new ExpoFile(asset.uri);
  const mimeType = asset.mimeType || file.type || "application/octet-stream";
  return `data:${mimeType};base64,${await file.base64()}`;
};