Skip to content

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

63.4 KB
Raw Blame
import { prepareNoteImageAssets } from "@edgeever/shared/note-image-fonts";
import { noteImageAssetUrls } from "@edgeever/shared/note-image-assets";
import "./styles.css";
import "katex/dist/katex.min.css";
import { Graph } from "@antv/x6";
import { Editor } from "@tiptap/core";
import Image from "@tiptap/extension-image";
import Placeholder from "@tiptap/extension-placeholder";
import CodeBlock from "@tiptap/extension-code-block";
import type { Node as ProseMirrorNode } from "@tiptap/pm/model";
import { NodeSelection } from "@tiptap/pm/state";
import mermaid from "mermaid";
import { toCanvas } from "html-to-image";
import {
  createEdgeEverDocumentExtensions,
  applyImageAlignment,
  createNativeUnsupportedContentExtensions,
  DETAILS_EDITOR_CSS,
  diagramDocumentToX6Cells,
  attachDiagramReader,
  MIND_MAP_CONNECTOR_NAME,
  mindMapConnector,
  docToMarkdown,
  NativeAttachmentMetadata,
  prepareNativeEditorContent,
  parseDiagramDocument,
  stripDiagramDocumentMarker,
  resolveAttachmentKind,
  resolveNativeAttachmentContent,
  restoreNativeEditorContent,
  wrapDetailsContentHtml,
  type TiptapDoc,
  type DiagramDocument,
} from "@edgeever/shared";
import { clearMobileEditorUndoHistory, type MobileEditorLocale } from "@edgeever/shared/mobile-editor";
import {
  type NoteImageTheme,
  type NoteImageFontStyle,
  type NoteImageFontSize,
  type NoteImageCardWidth,
  NOTE_IMAGE_CARD_WIDTH_PIXELS,
  NOTE_IMAGE_BACKGROUND_COLORS,
  NOTE_IMAGE_THEMES,
  resolveTheme,
  buildImageExportBasename,
  buildNoteImageCardMarkup,
  generateCardCss,
  prepareNoteImageContent,
  planNativeNoteImageRender,
} from "@edgeever/shared/note-image-card";
import { createEdgeEverMathematics } from "@edgeever/shared/mathematics";
import { createIosImageGallery } from "./document-nodes";
import { createImageInsertTransaction, groupUploadedImages, NATIVE_IMAGE_GALLERY_CSS } from "@edgeever/shared/native-image-gallery";
import { installPhoneImageFillStyle, NEW_IMAGE_WIDTH_PERCENT } from "@edgeever/shared/image-display";

const galleryStyle = document.createElement("style");
galleryStyle.textContent = NATIVE_IMAGE_GALLERY_CSS;
document.head.append(galleryStyle);
installPhoneImageFillStyle();

const detailsStyle = document.createElement("style");
detailsStyle.textContent = DETAILS_EDITOR_CSS;
document.head.append(detailsStyle);

Graph.registerConnector(MIND_MAP_CONNECTOR_NAME, mindMapConnector, true);

type BridgeMessage =
  | { type: "ready"; startupMs: number }
  | { type: "change"; contentMarkdown: string; contentJson: string }
  | { type: "loadResource"; requestId: string; source: string }
  | { type: "resourcePress"; targetJson: string }
  | { type: "imagePreview"; source: string; alt: string }
  | { type: "doubleTap" }
  | { type: "pickImage" }
  | { type: "searchResult"; count: number; index: number }
  | { type: "readerScroll"; collapsed: boolean }
  | { type: "imageExportFontStatus"; requestId: string; status: "loading" | "fallback" | "ready" }
  | { type: "imageExportFontsReady"; requestId: string }
  | { type: "imageExportChunk"; requestId: string; chunk: string }
  | {
      type: "imageExportComplete";
      fontFallback: boolean;
      requestId: string;
      filename: string;
      mimeType: string;
      width: number;
      height: number;
      totalImages: number;
      failedImages: number;
    }
  | { type: "imageExportError"; requestId: string; message: string }
  | { type: "activeFlags"; flags: number }
  | { type: "log"; message: string }
  | { type: "error"; message: string };

/** Match shared `getResourceIdFromUrl` — never return bare `blob`. */
function getResourceIdFromHref(href: string): string | null {
  try {
    const parsed = new URL(href, "http://edgeever.local");
    const match = parsed.pathname.match(/^\/api\/v1\/resources\/([^/]+)(?:\/blob)?\/?$/);
    if (match?.[1]) return decodeURIComponent(match[1]);
  } catch {
    /* ignore */
  }
  const loose = href.match(/\/api\/v1\/resources\/([^/?#]+)/);
  if (loose?.[1] && loose[1] !== "blob") return decodeURIComponent(loose[1]);
  return null;
}

function normalizeResourceHref(href: string, resourceId: string): string {
  if (/\/blob(?:$|[?#])/.test(href) || href.includes(`/resources/${resourceId}/blob`)) return href;
  if (href.startsWith("/api/v1/resources/") || href.includes("/api/v1/resources/")) {
    return `/api/v1/resources/${encodeURIComponent(resourceId)}/blob`;
  }
  return href;
}

function buildImageTargetJson(src: string, filename: string): string | null {
  const resourceId = getResourceIdFromHref(src);
  if (!resourceId) return null;
  return JSON.stringify({
    kind: "image",
    href: normalizeResourceHref(src, resourceId),
    filename: filename.trim() || `image-${resourceId}`,
    resourceId,
  });
}

function buildAttachmentTargetJson(href: string, label: string): string | null {
  const resourceId = getResourceIdFromHref(href);
  if (!resourceId) return null;
  const filename =
    label.replace(/^\s*(?:附件[::]|Attachment:)\s*/i, "").trim() || resourceId;
  return JSON.stringify({
    kind: "attachment",
    href: normalizeResourceHref(href, resourceId),
    filename,
    resourceId,
  });
}

const ATTACHMENT_KIND_CLASS_PREFIX = "edgeever-attachment-kind-";

function normalizeAttachmentFilename(label: string): string {
  return label.replace(/^\s*(?:附件[::]|Attachment:)\s*/i, "").trim();
}

function decorateAttachmentLinks(root: ParentNode): void {
  root.querySelectorAll<HTMLAnchorElement>(
    'a.edgeever-attachment-link, a[href*="/api/v1/resources/"]'
  ).forEach((link) => {
    Array.from(link.classList).forEach((className) => {
      if (className.startsWith(ATTACHMENT_KIND_CLASS_PREFIX)) link.classList.remove(className);
    });
    const filename = normalizeAttachmentFilename(link.textContent || "");
    link.classList.add(
      "edgeever-attachment-link",
      `${ATTACHMENT_KIND_CLASS_PREFIX}${resolveAttachmentKind(null, filename)}`,
    );
  });
}

type ConfigureOptions = {
  mode?: "viewer" | "editor";
  locale?: string;
  theme?: "light" | "dark";
  placeholder?: string;
};

const startedAt = performance.now();
const IMAGE_EXPORT_WIDTH = 768;
const IMAGE_EXPORT_PIXEL_RATIO = 1.5;
const IMAGE_EXPORT_CHUNK_SIZE = 256 * 1024;

type ImageExportRequest = {
  requestId: string;
  format: "jpeg" | "png";
  title: string;
  fallbackTitle: string;
  notebook?: string;
  tags?: string[];
  updatedAt?: string;
  background?: "mint" | "slate" | "warm" | NoteImageTheme;
  theme?: NoteImageTheme;
  fontStyle?: NoteImageFontStyle;
  fontSize?: NoteImageFontSize;
  cardWidth?: NoteImageCardWidth;
  showTitle?: boolean;
  showNotebook?: boolean;
  showTags?: boolean;
  showUpdatedAt?: boolean;
  branding?: boolean;
};
let mode: "viewer" | "editor" = "viewer";
let locale: MobileEditorLocale = "zh-CN";
let currentPlaceholder = "开始输入…";
let suppressChange = false;
const resourceResolvers = new Map<string, (dataUrl: string | null) => void>();
let resourceSeq = 0;

function post(msg: BridgeMessage) {
  try {
    (window as unknown as { webkit?: { messageHandlers?: { edgeever?: { postMessage: (m: unknown) => void } } } })
      .webkit?.messageHandlers?.edgeever?.postMessage(msg);
  } catch {
    // native host unavailable (browser preview)
  }
}

function sanitizeImageExportBasename(title: string, fallback: string) {
  return title.replace(/[\u0000-\u001f<>:"/\\|?*]/g, "-").replace(/\s+/g, " ").replace(/[. ]+$/g, "").trim().slice(0, 100) || fallback;
}

async function blobToBytes(blob: Blob) {
  return new Uint8Array(await blob.arrayBuffer());
}

function bytesToBase64(bytes: Uint8Array) {
  let binary = "";
  for (let offset = 0; offset < bytes.length; offset += 0x8000) {
    binary += String.fromCharCode(...bytes.subarray(offset, offset + 0x8000));
  }
  return btoa(binary);
}

function isProtectedResource(src: string): boolean {
  return src.startsWith("/api/") || src.includes("/api/v1/resources/");
}

/** file:// editor pages often cannot load remote/protected img srcs; native must rewrite them. */
function needsNativeHydration(src: string): boolean {
  if (!src || src.startsWith("data:") || src.startsWith("blob:") || src.startsWith("edgeever-res:")) {
    return false;
  }
  // Protected API paths always need auth + rewrite.
  if (isProtectedResource(src)) return true;
  // Absolute remote images also need rewrite under file:// packaging.
  if (src.startsWith("http://") || src.startsWith("https://")) return true;
  // Root-relative non-api assets resolved via native base URL.
  if (src.startsWith("/")) return true;
  return false;
}

function requestResource(source: string): Promise<string | null> {
  return new Promise((resolve) => {
    const requestId = `r${++resourceSeq}`;
    resourceResolvers.set(requestId, resolve);
    post({ type: "loadResource", requestId, source });
    // Timeout so broken resources don't hang forever.
    setTimeout(() => {
      if (resourceResolvers.delete(requestId)) resolve(null);
    }, 30_000);
  });
}

async function hydrateProtectedImages(root: HTMLElement) {
  const images = Array.from(root.querySelectorAll<HTMLImageElement>("img[src]"));
  await Promise.all(
    images.map(async (img) => {
      const src = img.getAttribute("src") || "";
      if (!needsNativeHydration(src)) return;
      if (!img.dataset.originalSrc) img.dataset.originalSrc = src;
      // Avoid re-requesting while a previous hydrate is in flight for the same original.
      if (img.dataset.hydrating === "1") return;
      img.dataset.hydrating = "1";
      try {
        const dataUrl = await requestResource(src);
        if (dataUrl) img.setAttribute("src", dataUrl);
      } finally {
        delete img.dataset.hydrating;
      }
    })
  );
}

async function renderMermaidBlocks(root: HTMLElement, theme: "light" | "dark") {
  const codeBlocks = Array.from(root.querySelectorAll("pre code.language-mermaid, pre code[class*='mermaid']"));
  // Also treat fenced mermaid paragraphs produced as codeBlock with language attr via data
  const preBlocks = Array.from(root.querySelectorAll("pre")).filter((pre) => {
    const text = pre.textContent || "";
    return pre.querySelector("code") && /^(graph|sequenceDiagram|classDiagram|stateDiagram|erDiagram|journey|gantt|pie|mindmap|flowchart)/m.test(text.trim());
  });

  const targets = new Set([...codeBlocks.map((c) => c.parentElement!).filter(Boolean), ...preBlocks]);
  mermaid.initialize({
    startOnLoad: false,
    securityLevel: "strict",
    theme: theme === "dark" ? "dark" : "default",
    flowchart: { nodeSpacing: 25, rankSpacing: 30 },
  });

  let i = 0;
  for (const pre of targets) {
    const source = (pre.textContent || "").trim();
    if (!source) continue;
    try {
      const id = `mmd-${Date.now()}-${i++}`;
      const { svg } = await mermaid.render(id, source);
      const wrap = document.createElement("div");
      wrap.className = "edgeever-mermaid";
      wrap.innerHTML = svg;
      const renderedSvg = wrap.querySelector("svg");
      const viewBox = renderedSvg?.viewBox.baseVal;
      if (renderedSvg && viewBox && viewBox.width > 0 && viewBox.height > 0) {
        renderedSvg.style.width = `${Math.ceil(viewBox.width)}px`;
        renderedSvg.style.height = `${Math.ceil(viewBox.height)}px`;
        renderedSvg.style.maxWidth = "none";
      }
      pre.replaceWith(wrap);
    } catch {
      // leave code block as-is
    }
  }
}

let viewerDiagramReader: ReturnType<typeof attachDiagramReader> | null = null;
let viewerDiagramFrame: number | null = null;
let viewerDiagram: DiagramDocument | null = null;
let viewerDiagramGraph: Graph | null = null;
let viewerDiagramObserver: ResizeObserver | null = null;
let viewerDiagramContainer: HTMLElement | null = null;

function clearViewerDiagramGraph() {
  if (viewerDiagramFrame !== null) cancelAnimationFrame(viewerDiagramFrame);
  viewerDiagramFrame = null;
  viewerDiagramReader?.dispose();
  viewerDiagramReader = null;
  viewerDiagramObserver?.disconnect();
  viewerDiagramObserver = null;
  viewerDiagramGraph?.dispose();
  viewerDiagramGraph = null;
  viewerDiagramContainer?.remove();
  viewerDiagramContainer = null;
  editorEl.querySelector<HTMLElement>(".ProseMirror")?.removeAttribute("hidden");
}

function renderViewerDiagram(root: HTMLElement, diagram: DiagramDocument, theme: "light" | "dark") {
  clearViewerDiagramGraph();
  const proseMirror = root.querySelector<HTMLElement>(".ProseMirror");
  if (!proseMirror) return false;
  const cells = diagramDocumentToX6Cells(diagram, theme);
  const container = document.createElement("div");
  container.className = "edgeever-x6-diagram";
  container.setAttribute("role", "img");
  container.setAttribute("aria-label", diagram.kind === "mind-map" ? "思维导图" : diagram.kind === "architecture" ? "架构图" : "流程图");
  // Keep TipTap's managed DOM intact. Replacing a node inside ProseMirror makes
  // the next setContent call unreliable when SwiftUI reuses this WKWebView.
  proseMirror.hidden = true;
  root.append(container);
  const parent = container.parentElement;
  const measureWidth = () => {
    if (!parent) return Math.max(1, container.clientWidth);
    const style = getComputedStyle(parent);
    const containerStyle = getComputedStyle(container);
    const horizontalPadding = Number.parseFloat(style.paddingLeft || "0")
      + Number.parseFloat(style.paddingRight || "0");
    const horizontalMargin = Number.parseFloat(containerStyle.marginLeft || "0")
      + Number.parseFloat(containerStyle.marginRight || "0");
    return Math.max(1, parent.clientWidth - horizontalPadding - horizontalMargin);
  };
  const graph = new Graph({
    container,
    // The replacement node is empty at mount time and can briefly report 0.
    // Anchor sizing to its stable parent so X6 cannot persist a 1px canvas.
    width: measureWidth(),
    height: Math.max(1, container.clientHeight),
    background: { color: cells.canvas },
    grid: false,
    interacting: false,
    panning: { enabled: true },
    mousewheel: { enabled: true, minScale: 0.1, maxScale: 2.5 },
  });
  graph.addNodes(cells.nodes);
  graph.addEdges(cells.edges);
  const reader = attachDiagramReader(graph, container, { ...diagram, nodes: diagram.nodes.map((node, index) => ({ ...node, width: cells.nodes[index].width, height: cells.nodes[index].height })) }, locale, theme === "dark");
  viewerDiagramReader = reader;
  const fit = () => reader.resize(measureWidth(), Math.max(1, container.clientHeight));
  viewerDiagramFrame = requestAnimationFrame(fit);
  const observer = new ResizeObserver(fit);
  observer.observe(parent ?? container);
  viewerDiagramGraph = graph;
  viewerDiagramObserver = observer;
  viewerDiagramContainer = container;
  return true;
}

const IMAGE_WIDTH_PRESETS = [
  { label: "25%", width: 25 },
  { label: "50%", width: 50 },
  { label: "75%", width: 75 },
  { label: "100%", width: 100 },
] as const;

function parseImageWidth(raw: unknown): number | null {
  if (raw == null || raw === "") return null;
  const n = typeof raw === "number" ? raw : Number.parseFloat(String(raw).replace("%", ""));
  if (!Number.isFinite(n)) return null;
  return Math.min(100, Math.max(10, Math.round(n)));
}

function clampImageWidth(n: number): number {
  return Math.min(100, Math.max(10, Math.round(n)));
}

/**
 * Image width is a % of the editor content column.
 * Apply to the figure itself (not only the <img>) so the layout box shrinks
 * with the picture — otherwise WKWebView keeps a full-width slot and paints
 * a pale selection wash in the empty half.
 */
function applyFigureWidth(el: HTMLElement, width: number | null, alignment?: unknown) {
  const w = width == null ? null : clampImageWidth(width);
  if (w == null) {
    el.style.removeProperty("width");
    el.style.removeProperty("max-width");
    el.style.removeProperty("--ee-image-width");
    delete el.dataset.width;
    el.classList.remove("has-width");
    applyImageAlignment(el, alignment);
    return;
  }
  const pct = `${w}%`;
  el.dataset.width = String(w);
  el.classList.add("has-width");
  el.style.setProperty("--ee-image-width", pct);
  // Inline styles beat any generic img/figure rules; max-width keeps us inside the column.
  el.style.setProperty("width", pct);
  el.style.setProperty("max-width", pct);
  el.style.setProperty("margin-left", "auto");
  el.style.setProperty("margin-right", "auto");
  el.style.setProperty("box-sizing", "border-box");
  el.style.setProperty("display", "block");
  applyImageAlignment(el, alignment);
}

/**
 * iOS WKWebView + ProseMirror: control taps must:
 * 1) preventDefault on pointerdown so PM does not steal NodeSelection
 * 2) run the action on pointerup (click is suppressed after preventDefault)
 * Desktop still gets a debounced click fallback.
 */
function bindImageControlTap(el: HTMLElement, action: () => void) {
  let lastRun = 0;
  const block = (event: Event) => {
    event.preventDefault();
    event.stopPropagation();
    if (typeof event.stopImmediatePropagation === "function") {
      event.stopImmediatePropagation();
    }
  };
  const run = (event: Event) => {
    block(event);
    const now = Date.now();
    if (now - lastRun < 350) return;
    lastRun = now;
    action();
  };
  el.addEventListener("pointerdown", block);
  el.addEventListener("mousedown", block);
  el.addEventListener("touchstart", block, { passive: false });
  el.addEventListener("pointerup", run);
  el.addEventListener("click", run);
}

/**
 * Android LocalTiptapEditor image node parity:
 * - figure wrapper + ⋯ action button
 * - viewer: tap image → fullscreen preview; ⋯ → resource sheet
 * - editor: tap image → select + show width bar (25/50/75/100%); ⋯ → resource sheet
 */
function createEdgeEverImageExtension() {
  return Image.extend({
    addAttributes() {
      return {
        ...this.parent?.(),
        width: {
          default: null,
          parseHTML: (element) =>
            parseImageWidth(
              element.getAttribute("data-width") ?? element.getAttribute("width") ?? (element as HTMLElement).style.width
            ),
          renderHTML: (attributes) => {
            const width = parseImageWidth(attributes.width);
            return width ? { "data-width": String(width), style: `width: ${width}%` } : {};
          },
        },
      };
    },
    addNodeView() {
      return ({ editor: ed, getPos, node }) => {
        let currentNode = node;
        const wrapper = document.createElement("figure");
        wrapper.className = "edgeever-image-node is-loading";
        wrapper.contentEditable = "false";
        wrapper.setAttribute("role", "img");

        const loading = document.createElement("div");
        loading.className = "edgeever-image-loading";
        const spinner = document.createElement("span");
        spinner.className = "edgeever-image-upload-spinner";
        loading.append(spinner);

        const image = document.createElement("img");
        image.draggable = false;
        image.hidden = true;

        const actionButton = document.createElement("button");
        actionButton.type = "button";
        actionButton.className = "edgeever-image-actions";
        actionButton.contentEditable = "false";
        actionButton.hidden = true;
        actionButton.setAttribute("aria-label", "图片操作");
        actionButton.textContent = "⋯";

        const sizeControls = document.createElement("div");
        sizeControls.className = "edgeever-image-size-controls";
        sizeControls.contentEditable = "false";
        sizeControls.hidden = true;
        sizeControls.setAttribute("role", "group");
        sizeControls.setAttribute("aria-label", "图片宽度");

        const applyWidthAtPos = (width: number) => {
          const pos = getPos();
          if (typeof pos !== "number") return;
          const n = ed.state.doc.nodeAt(pos);
          if (!n || n.type.name !== "image") return;
          const nextWidth = clampImageWidth(width);
          // Avoid chain().focus() — iOS WKWebView often drops NodeSelection mid-gesture.
          let tr = ed.state.tr.setNodeMarkup(pos, undefined, {
            ...n.attrs,
            width: nextWidth,
          });
          try {
            tr = tr.setSelection(NodeSelection.create(tr.doc, pos));
          } catch {
            /* keep markup update even if selection fails */
          }
          ed.view.dispatch(tr);
          applyFigureWidth(wrapper, nextWidth, currentNode.attrs.alignment);
          setActiveWidth(nextWidth);
        };

        const sizeButtons: Array<{ button: HTMLButtonElement; width: number }> = [];
        for (const preset of IMAGE_WIDTH_PRESETS) {
          const btn = document.createElement("button");
          btn.type = "button";
          btn.className = "edgeever-image-size-button";
          btn.textContent = preset.label;
          btn.setAttribute("aria-label", preset.label);
          btn.setAttribute("aria-pressed", "false");
          bindImageControlTap(btn, () => applyWidthAtPos(preset.width));
          sizeButtons.push({ button: btn, width: preset.width });
          sizeControls.append(btn);
        }

        const setActiveWidth = (width: number | null) => {
          for (const item of sizeButtons) {
            const active = width != null && item.width === width;
            item.button.classList.toggle("is-active", active);
            item.button.setAttribute("aria-pressed", String(active));
          }
        };

        const setPhase = (phase: "loading" | "ready" | "failed") => {
          wrapper.classList.toggle("is-loading", phase === "loading");
          wrapper.classList.toggle("is-failed", phase === "failed");
          loading.hidden = phase === "ready";
          image.hidden = phase !== "ready";
          actionButton.hidden = phase !== "ready";
          if (phase === "failed") {
            loading.replaceChildren();
            const label = document.createElement("span");
            label.className = "edgeever-image-loading-label";
            label.textContent = "图片加载失败";
            loading.append(label);
            loading.hidden = false;
          } else if (phase === "loading") {
            loading.replaceChildren(spinner);
          }
        };

        const resourceHrefFromAttrs = (attrs: Record<string, unknown>) => {
          const src = String(attrs.src ?? "");
          // Prefer protected API path over display data:/edgeever-res:
          if (isProtectedResource(src) || getResourceIdFromHref(src)) return src;
          return wrapper.dataset.resourceHref || src;
        };

        const emitActions = () => {
          const href =
            wrapper.dataset.resourceHref ||
            image.dataset.originalSrc ||
            resourceHrefFromAttrs(currentNode.attrs as Record<string, unknown>);
          const json = buildImageTargetJson(href, String(currentNode.attrs.alt ?? "image"));
          if (json) {
            post({ type: "resourcePress", targetJson: json });
            return;
          }
          // Still notify native with best-effort payload when id parse fails.
          post({
            type: "log",
            message: `image actions: no resource id for href=${href.slice(0, 120)}`,
          });
        };

        const emitPreview = () => {
          const href =
            wrapper.dataset.resourceHref ||
            image.dataset.originalSrc ||
            resourceHrefFromAttrs(currentNode.attrs as Record<string, unknown>) ||
            image.getAttribute("src") ||
            "";
          if (!href) return;
          post({
            type: "imagePreview",
            source: href,
            alt: String(currentNode.attrs.alt ?? ""),
          });
        };

        bindImageControlTap(actionButton, emitActions);

        // Android parity:
        // - viewer: tap image → fullscreen preview
        // - editor: tap image → select node (shows 25/50/75/100% width bar); ⋯ → action sheet
        // Image body: only stopPropagation on pointerdown (keeps scroll working).
        let lastImageActivate = 0;
        const onImageActivate = (event: Event) => {
          if (event.target instanceof Element && event.target.closest(".edgeever-image-actions")) {
            return;
          }
          const now = Date.now();
          if (now - lastImageActivate < 350) return;
          lastImageActivate = now;
          event.stopPropagation();
          if (mode === "viewer" || !ed.isEditable) {
            event.preventDefault();
            emitPreview();
            return;
          }
          event.preventDefault();
          const pos = getPos();
          if (typeof pos === "number") {
            ed.chain().setNodeSelection(pos).run();
          }
        };
        image.addEventListener("pointerdown", (event) => event.stopPropagation());
        image.addEventListener("click", onImageActivate);
        image.addEventListener("pointerup", (event) => {
          // iOS sometimes skips click after PM handles pointer; activate on short taps.
          if (event.pointerType === "touch" || event.pointerType === "pen") {
            onImageActivate(event);
          }
        });

        wrapper.append(loading, image, actionButton, sizeControls);

        let requestId = 0;
        let renderedSource = "";
        let selected = false;

        const applyMeta = (attrs: Record<string, unknown>) => {
          const alt = String(attrs.alt ?? "");
          image.alt = alt;
          const width = parseImageWidth(attrs.width);
          applyFigureWidth(wrapper, width, attrs.alignment);
          setActiveWidth(width);
          const src = String(attrs.src ?? "");
          const rid = getResourceIdFromHref(src);
          if (rid) {
            wrapper.dataset.resourceHref = normalizeResourceHref(src, rid);
            image.dataset.originalSrc = wrapper.dataset.resourceHref;
          }
        };

        const loadImage = (attrs: Record<string, unknown>) => {
          requestId += 1;
          const active = requestId;
          const src = String(attrs.src ?? "");
          renderedSource = src;
          applyMeta(attrs);
          setPhase("loading");
          sizeControls.hidden = true;

          const finish = (display: string) => {
            if (active !== requestId) return;
            image.onload = () => {
              if (active !== requestId) return;
              setPhase("ready");
              image.style.cursor = mode === "viewer" || !ed.isEditable ? "zoom-in" : "pointer";
              if (selected && ed.isEditable && mode === "editor") {
                sizeControls.hidden = false;
              }
            };
            image.onerror = () => {
              if (active !== requestId) return;
              setPhase("failed");
            };
            image.src = display;
          };

          if (!src) {
            setPhase("failed");
            return;
          }
          if (src.startsWith("data:") || src.startsWith("edgeever-res:") || src.startsWith("blob:")) {
            finish(src);
            return;
          }
          if (needsNativeHydration(src)) {
            void requestResource(src).then((dataUrl) => {
              if (active !== requestId) return;
              if (dataUrl) finish(dataUrl);
              else setPhase("failed");
            });
            return;
          }
          finish(src);
        };

        loadImage(node.attrs as Record<string, unknown>);

        return {
          dom: wrapper,
          update: (updated) => {
            if (updated.type.name !== "image") return false;
            currentNode = updated;
            const nextSrc = String(updated.attrs.src ?? "");
            applyMeta(updated.attrs as Record<string, unknown>);
            if (nextSrc !== renderedSource) {
              loadImage(updated.attrs as Record<string, unknown>);
            } else {
              setActiveWidth(parseImageWidth(updated.attrs.width));
              applyFigureWidth(wrapper, parseImageWidth(updated.attrs.width), updated.attrs.alignment);
            }
            return true;
          },
          selectNode: () => {
            selected = true;
            wrapper.classList.add("is-selected");
            // Re-assert layout width so selection never leaves a full-width empty slot.
            const selWidth =
              parseImageWidth(
                (ed.state.selection as { node?: { attrs?: { width?: unknown } } }).node?.attrs?.width
              ) ?? parseImageWidth(wrapper.dataset.width) ?? parseImageWidth(currentNode.attrs.width);
            applyFigureWidth(wrapper, selWidth, currentNode.attrs.alignment);
            // Width bar only in editor when the image is the active node selection.
            if (ed.isEditable && mode === "editor" && !image.hidden) {
              sizeControls.hidden = false;
              setActiveWidth(selWidth);
            }
          },
          deselectNode: () => {
            selected = false;
            wrapper.classList.remove("is-selected");
            sizeControls.hidden = true;
          },
          destroy: () => {
            requestId += 1;
          },
        };
      };
    },
  }).configure({
    inline: false,
    allowBase64: true,
  });
}

function buildExtensions(placeholder: string) {
  return [
    ...createEdgeEverDocumentExtensions({
      mathematics: createEdgeEverMathematics(),
      starterKit: { codeBlock: false, link: false },
      image: createEdgeEverImageExtension(),
      gallery: createIosImageGallery(() => locale),
      pdf: false,
      file: false,
      pluginEmbed: false,
      table: { table: { resizable: false } },
      markdown: true,
    }),
    NativeAttachmentMetadata,
    CodeBlock.configure({
      languageClassPrefix: "language-",
    }),
    ...createNativeUnsupportedContentExtensions(),
    Placeholder.configure({
      placeholder,
    }),
  ];
}

const editorEl = document.getElementById("editor")!;
const toolbarEl = document.getElementById("toolbar")!;
let readerCollapsed = false;

editorEl.addEventListener("scroll", () => {
  if (mode !== "viewer") return;
  const collapsed = editorEl.scrollTop > (readerCollapsed ? 4 : 24);
  if (collapsed === readerCollapsed) return;
  readerCollapsed = collapsed;
  post({ type: "readerScroll", collapsed });
}, { passive: true });

function resetReaderScroll() {
  if (mode !== "viewer") return;
  editorEl.scrollTop = 0;
  readerCollapsed = false;
  post({ type: "readerScroll", collapsed: false });
}

const editor = new Editor({
  element: editorEl,
  extensions: buildExtensions("开始书写…"),
  editable: false,
  content: { type: "doc", content: [{ type: "paragraph" }] },
  onUpdate: ({ editor: ed }) => {
    refreshToolbarState();
    requestAnimationFrame(() => decorateAttachmentLinks(editorEl));
    if (suppressChange || mode !== "editor") return;
    emitChange(ed);
  },
  onSelectionUpdate: () => refreshToolbarState(),
  editorProps: {
    attributes: {
      class: "edgeever-prose",
      spellcheck: "true",
    },
    transformPastedHTML(html) {
      return wrapDetailsContentHtml(html);
    },
    handleClick(_view, _pos, event) {
      return handleResourcePointer(event as MouseEvent, "click");
    },
    handleDOMEvents: {
      contextmenu(_view, event) {
        return handleResourcePointer(event, "contextmenu");
      },
    },
  },
});

// Evernote-style viewer shortcut: a deliberate double tap on ordinary note
// content enters edit mode. Resource controls keep their existing gestures.
editorEl.addEventListener("dblclick", (event) => {
  if (mode !== "viewer") return;
  const target = event.target as HTMLElement | null;
  if (!target || target.closest("a, button, img, input, textarea, select, .edgeever-image-node")) return;
  event.preventDefault();
  event.stopPropagation();
  post({ type: "doubleTap" });
});

/**
 * Android parity:
 * - attachment link → always resource action sheet
 * - viewer image click → fullscreen preview
 * - viewer image long-press / contextmenu → resource action sheet
 * - editor image click inside nodeView → select + width bar (owned by nodeView)
 * - editor image ⋯ → resource action sheet (owned by nodeView)
 */
function handleResourcePointer(event: Event, kind: "click" | "contextmenu"): boolean {
  const target = event.target as HTMLElement | null;
  if (!target) return false;

  // Size / ⋯ controls own their gestures — never intercept from PM handleClick.
  if (
    target.closest(".edgeever-image-size-controls") ||
    target.closest(".edgeever-image-actions") ||
    target.closest(".edgeever-image-size-button")
  ) {
    return true;
  }

  const link = target.closest("a");
  if (link instanceof HTMLAnchorElement) {
    const href = link.getAttribute("href") || "";
    if (isProtectedResource(href) || getResourceIdFromHref(href)) {
      const json = buildAttachmentTargetJson(href, link.textContent || "");
      if (json) {
        event.preventDefault();
        event.stopPropagation();
        post({ type: "resourcePress", targetJson: json });
        return true;
      }
    }
  }

  const img = target.closest("img");
  if (img instanceof HTMLImageElement) {
    // Custom image nodeView owns image taps (select/preview/⋯).
    if (img.closest("figure.edgeever-image-node") && kind === "click") {
      return false;
    }

    const src = img.dataset.originalSrc || img.getAttribute("src") || "";
    const protectedSrc =
      img.dataset.originalSrc ||
      (isProtectedResource(src) || getResourceIdFromHref(src) ? src : "");
    if (!protectedSrc && !getResourceIdFromHref(src)) {
      // Non-protected image — still allow preview of data: display src in viewer.
      if (mode === "viewer" && kind === "click" && src) {
        event.preventDefault();
        post({
          type: "imagePreview",
          source: src,
          alt: img.getAttribute("alt") || "",
        });
        return true;
      }
      return false;
    }
    const hrefForMenu = protectedSrc || src;
    const filename = img.getAttribute("alt") || "image";

    // Long-press / context menu → resource actions (editor + viewer).
    if (kind === "contextmenu") {
      const json = buildImageTargetJson(hrefForMenu, filename);
      if (json) {
        event.preventDefault();
        event.stopPropagation();
        post({ type: "resourcePress", targetJson: json });
        return true;
      }
    }

    // Viewer plain tap on bare <img> (no nodeView) → preview.
    if (mode === "viewer" && kind === "click") {
      event.preventDefault();
      event.stopPropagation();
      post({
        type: "imagePreview",
        source: hrefForMenu,
        alt: filename,
      });
      return true;
    }
  }

  return false;
}

// Long-press on images (mobile WebView often does not fire contextmenu reliably).
(() => {
  let timer: ReturnType<typeof setTimeout> | null = null;
  let startImg: HTMLImageElement | null = null;
  const clear = () => {
    if (timer) clearTimeout(timer);
    timer = null;
    startImg = null;
  };
  editorEl.addEventListener(
    "touchstart",
    (event) => {
      const img = (event.target as HTMLElement | null)?.closest("img");
      if (!(img instanceof HTMLImageElement)) return;
      startImg = img;
      timer = setTimeout(() => {
        if (!startImg) return;
        const src = startImg.dataset.originalSrc || startImg.getAttribute("src") || "";
        const json = buildImageTargetJson(src, startImg.getAttribute("alt") || "image");
        if (json) {
          post({ type: "resourcePress", targetJson: json });
        }
        clear();
      }, 480);
    },
    { passive: true }
  );
  editorEl.addEventListener("touchend", clear, { passive: true });
  editorEl.addEventListener("touchmove", clear, { passive: true });
  editorEl.addEventListener("touchcancel", clear, { passive: true });
})();

const LITERAL_DOLLAR_PLACEHOLDER = "\uE000edgeever-dollar\uE001";

const protectLiteralDollarPairs = (value: unknown): unknown => {
  if (!value || typeof value !== "object") return value;
  const node = value as { type?: unknown; text?: unknown; content?: unknown };
  if (node.type === "text" && typeof node.text === "string") {
    const dollarCount = Array.from(node.text).filter((character) => character === "$").length;
    return dollarCount >= 2
      ? { ...node, text: node.text.replaceAll("$", LITERAL_DOLLAR_PLACEHOLDER) }
      : value;
  }
  return Array.isArray(node.content)
    ? { ...node, content: node.content.map(protectLiteralDollarPairs) }
    : value;
};

const serializeEditorMarkdown = (ed: Editor) => {
  return docToMarkdown(restoreNativeEditorContent(ed.getJSON() as TiptapDoc));
};

let pendingAiSelection: { from: number; to: number; isInline: boolean; documentFingerprint: string } | null = null;

const serializeSelectionMarkdown = (ed: Editor, from: number, to: number) => {
  const manager = (ed.storage as { markdown?: { manager?: { serialize?: (doc: unknown) => string } } })
    .markdown?.manager;
  const content = ed.state.doc.slice(from, to).content.toJSON();
  if (manager?.serialize) {
    return manager
      .serialize(protectLiteralDollarPairs({ type: "doc", content }))
      .replaceAll(LITERAL_DOLLAR_PLACEHOLDER, "\\$");
  }
  return ed.state.doc.textBetween(from, to, "\n\n");
};

type AiSelectionContext = {
  from: number;
  to: number;
  isInline: boolean;
  markdown: string;
  text: string;
};

type ParsedMarkdownNode = {
  type?: string;
  text?: string;
  content?: ParsedMarkdownNode[];
  [key: string]: unknown;
};

const AI_INLINE_SENTINEL = "edgeever-inline-sentinel";

const serializeInlineSelectionMarkdown = (ed: Editor, content: unknown[], fallback: string) => {
  const manager = (ed.storage as { markdown?: { manager?: { serialize?: (doc: unknown) => string } } })
    .markdown?.manager;
  if (!manager?.serialize) return fallback;
  return manager
    .serialize(protectLiteralDollarPairs({ type: "doc", content: [{ type: "paragraph", content }] }))
    .replaceAll(LITERAL_DOLLAR_PLACEHOLDER, "\\$");
};

const getAiSelectionContext = (ed: Editor): AiSelectionContext | null => {
  const selection = ed.state.selection;
  if (selection.empty || selection.from >= selection.to) return null;

  const selectedTextblocks: Array<{
    node: ProseMirrorNode;
    contentFrom: number;
    contentTo: number;
    from: number;
    to: number;
  }> = [];
  ed.state.doc.nodesBetween(selection.from, selection.to, (node, pos) => {
    if (!node.isTextblock) return true;
    const contentFrom = pos + 1;
    const contentTo = contentFrom + node.content.size;
    const from = Math.max(selection.from, contentFrom);
    const to = Math.min(selection.to, contentTo);
    if (to > from) selectedTextblocks.push({ node, contentFrom, contentTo, from, to });
    return false;
  });

  if (selectedTextblocks.length === 1) {
    const block = selectedTextblocks[0];
    const selectedBlock = block.node.cut(
      block.from - block.contentFrom,
      block.to - block.contentFrom,
    ).toJSON() as { content?: unknown[] };
    const text = ed.state.doc.textBetween(block.from, block.to, "\n");
    const markdown = serializeInlineSelectionMarkdown(ed, selectedBlock.content ?? [], text).trim();
    return markdown
      ? { from: block.from, to: block.to, isInline: true, markdown, text }
      : null;
  }

  const markdown = serializeSelectionMarkdown(ed, selection.from, selection.to).trim();
  return markdown
    ? {
        from: selection.from,
        to: selection.to,
        isInline: false,
        markdown,
        text: ed.state.doc.textBetween(selection.from, selection.to, "\n\n"),
      }
    : null;
};

const parseAiSelectionReplacement = (ed: Editor, draft: string, isInline: boolean): unknown[] => {
  const manager = (ed.storage as { markdown?: { manager?: { parse?: (value: string) => { content?: unknown[] } } } })
    .markdown?.manager;
  const normalizedDraft = draft.trim();
  const blockContent = manager?.parse?.(normalizedDraft).content ?? [{ type: "text", text: normalizedDraft }];
  if (!isInline) return blockContent;

  const inlineDraft = normalizedDraft.replace(/\s*\n+\s*/g, " ");
  const inlineContent = manager?.parse?.(`${AI_INLINE_SENTINEL}${inlineDraft}`).content;
  const paragraph = inlineContent?.length === 1 ? inlineContent[0] as ParsedMarkdownNode : null;
  const paragraphContent = paragraph?.type === "paragraph" ? paragraph.content ?? [] : [];
  const firstNode = paragraphContent[0];
  if (firstNode?.type !== "text" || typeof firstNode.text !== "string" || !firstNode.text.startsWith(AI_INLINE_SENTINEL)) {
    return [{ type: "text", text: inlineDraft }];
  }

  const firstText = firstNode.text.slice(AI_INLINE_SENTINEL.length);
  return [
    ...(firstText ? [{ ...firstNode, text: firstText }] : []),
    ...paragraphContent.slice(1),
  ];
};

function emitChange(ed: Editor) {
  try {
    const contentJson = JSON.stringify(restoreNativeEditorContent(ed.getJSON() as TiptapDoc));
    const contentMarkdown = serializeEditorMarkdown(ed);
    post({ type: "change", contentMarkdown, contentJson });
  } catch (error) {
    post({ type: "error", message: error instanceof Error ? error.message : String(error) });
  }
}

type EditorSearchMatch = { from: number; to: number };

function getEditorSearchMatches(ed: Editor, query: string): EditorSearchMatch[] {
  const needle = query.trim().toLocaleLowerCase();
  if (needle.length === 0) return [];

  const characters: Array<{ char: string; pos: number }> = [];
  let previousTextEnd: number | null = null;
  ed.state.doc.descendants((node, pos) => {
    if (!node.isText || !node.text) return;
    if (previousTextEnd !== null && pos > previousTextEnd) {
      characters.push({ char: "\u0000", pos: -1 });
    }
    for (let index = 0; index < node.text.length; index += 1) {
      characters.push({ char: node.text[index] ?? "", pos: pos + index });
    }
    previousTextEnd = pos + node.text.length;
  });

  const haystack = characters.map((item) => item.char).join("").toLocaleLowerCase();
  const matches: EditorSearchMatch[] = [];
  let index = haystack.indexOf(needle);
  while (index !== -1) {
    const start = characters[index];
    const end = characters[index + needle.length - 1];
    if (start && end && start.pos >= 0 && end.pos >= 0) {
      matches.push({ from: start.pos, to: end.pos + 1 });
    }
    index = haystack.indexOf(needle, index + needle.length);
  }
  return matches;
}

const activeListItemType = () => editor.isActive("taskItem") ? "taskItem" : "listItem";

function setToolbarVisible(visible: boolean) {
  toolbarEl.classList.toggle("editor-mode", visible);
  toolbarEl.innerHTML = "";
  if (!visible) return;
  const actions: Array<{ id: string; label: string; run: () => void }> = [
    { id: "undo", label: "↩", run: () => editor.chain().focus().undo().run() },
    { id: "redo", label: "↪", run: () => editor.chain().focus().redo().run() },
    {
      id: "image",
      label: "▧+",
      run: () => post({ type: "pickImage" }),
    },
    { id: "bold", label: "B", run: () => editor.chain().focus().toggleBold().run() },
    {
      id: "bullet",
      label: "•",
      run: () => editor.chain().focus().toggleBulletList().run(),
    },
    {
      id: "task",
      label: "☑",
      run: () => editor.chain().focus().toggleTaskList().run(),
    },
    {
      id: "indent",
      label: "⇥",
      run: () => editor.chain().focus().sinkListItem(activeListItemType()).run(),
    },
    {
      id: "outdent",
      label: "⇤",
      run: () => editor.chain().focus().liftListItem(activeListItemType()).run(),
    },
    {
      id: "quote",
      label: "❝",
      run: () => editor.chain().focus().toggleBlockquote().run(),
    },
    {
      id: "hr",
      label: "—",
      run: () => editor.chain().focus().setHorizontalRule().run(),
    },
  ];
  for (const action of actions) {
    const btn = document.createElement("button");
    btn.type = "button";
    btn.textContent = action.label;
    btn.dataset.action = action.id;
    const labels: Record<string, Record<MobileEditorLocale, string>> = {
      undo: { "zh-CN": "撤销", "en-US": "Undo", ja: "元に戻す", pl: "Cofnij", ru: "Отменить" },
      redo: { "zh-CN": "重做", "en-US": "Redo", ja: "やり直す", pl: "Ponów", ru: "Повторить" },
      image: { "zh-CN": "插入图片", "en-US": "Insert image", ja: "画像を挿入", pl: "Wstaw obraz", ru: "Вставить изображение" },
      bold: { "zh-CN": "粗体", "en-US": "Bold", ja: "太字", pl: "Pogrubienie", ru: "Полужирный" },
      bullet: { "zh-CN": "项目符号列表", "en-US": "Bullet list", ja: "箇条書き", pl: "Lista punktowana", ru: "Маркированный список" },
      task: { "zh-CN": "任务清单", "en-US": "Task list", ja: "タスクリスト", pl: "Lista zadań", ru: "Список задач" },
      indent: { "zh-CN": "增加列表缩进", "en-US": "Increase list indent", ja: "リストのインデントを増やす", pl: "Zwiększ wcięcie listy", ru: "Увеличить отступ списка" },
      outdent: { "zh-CN": "减少列表缩进", "en-US": "Decrease list indent", ja: "リストのインデントを減らす", pl: "Zmniejsz wcięcie listy", ru: "Уменьшить отступ списка" },
      quote: { "zh-CN": "引用", "en-US": "Block quote", ja: "引用", pl: "Cytat", ru: "Цитата" },
      hr: { "zh-CN": "分隔线", "en-US": "Horizontal rule", ja: "区切り線", pl: "Linia pozioma", ru: "Горизонтальная линия" },
    };
    btn.setAttribute("aria-label", labels[action.id]?.[locale] ?? action.id);
    btn.addEventListener("click", () => {
      action.run();
      if (action.id !== "image") emitChange(editor);
      refreshToolbarState();
    });
    toolbarEl.appendChild(btn);
  }
  refreshToolbarState();
}

function refreshToolbarState() {
  const active: Record<string, boolean> = {
    bold: editor.isActive("bold"),
    bullet: editor.isActive("bulletList"),
    task: editor.isActive("taskList"),
    quote: editor.isActive("blockquote"),
  };
  const historyEnabled = (command: "undo" | "redo") => {
    try {
      return editor.can().chain().focus()[command]().run();
    } catch {
      return false;
    }
  };
  const enabled: Record<string, boolean> = {
    undo: historyEnabled("undo"),
    redo: historyEnabled("redo"),
  };
  toolbarEl.querySelectorAll<HTMLButtonElement>("button[data-action]").forEach((button) => {
    const actionId = button.dataset.action ?? "";
    button.classList.toggle("is-active", active[actionId] ?? false);
    if (actionId in enabled) button.disabled = !enabled[actionId];
  });
}

async function afterContentSet(theme: "light" | "dark" = "light") {
  editorEl.querySelectorAll<HTMLElement>("[data-placeholder]").forEach((element) => {
    element.dataset.placeholder = currentPlaceholder;
  });
  decorateAttachmentLinks(editorEl);
  await hydrateProtectedImages(editorEl);
  if (mode === "viewer") {
    if (!viewerDiagram || !renderViewerDiagram(editorEl, viewerDiagram, theme)) {
      clearViewerDiagramGraph();
      await renderMermaidBlocks(editorEl, theme);
    }
  }
}

async function exportNoteImage(request: ImageExportRequest) {
  if (!request.requestId || (request.format !== "png" && request.format !== "jpeg")) return;
  const resolvedTheme = resolveTheme(request.background, request.theme);
  const fontStyle = request.fontStyle ?? "auto";
  const fontSize = request.fontSize ?? "lg";
  const cardWidth = request.cardWidth ?? "wide";
  const targetWidth = NOTE_IMAGE_CARD_WIDTH_PIXELS[cardWidth] || NOTE_IMAGE_CARD_WIDTH_PIXELS.wide;
  const themeCfg = NOTE_IMAGE_THEMES[resolvedTheme] || NOTE_IMAGE_THEMES.aurora;

  const editorClone = editor.view.dom.cloneNode(true) as HTMLElement;
  editorClone.removeAttribute("contenteditable");
  editorClone.querySelectorAll("button, [contenteditable='true']").forEach((element) => {
    element.removeAttribute("contenteditable");
    if (element instanceof HTMLButtonElement) element.remove();
  });

  prepareNoteImageContent(editorClone);
  const bodyHtml = editorClone.innerHTML;

  const host = document.createElement("div");
  host.style.cssText = `position:fixed;left:-100000px;top:0;width:${targetWidth}px;pointer-events:none;`;
  const style = document.createElement("style");
  style.textContent = generateCardCss({ theme: resolvedTheme, fontStyle, fontSize, cardWidth });

  const cardMarkup = buildNoteImageCardMarkup({
    title: request.title || request.fallbackTitle,
    notebook: request.notebook,
    tags: request.tags,
    updatedAt: request.updatedAt,
    bodyHtml,
    theme: resolvedTheme,
    fontStyle,
    showTitle: request.showTitle ?? false,
    showNotebook: request.showNotebook ?? false,
    showTags: request.showTags ?? false,
    showUpdatedAt: request.showUpdatedAt ?? true,
    showBranding: request.branding ?? true,
  });

  host.appendChild(style);
  host.insertAdjacentHTML("beforeend", cardMarkup);
  const documentRoot = host.lastElementChild as HTMLElement;
  documentRoot.style.width = `${targetWidth}px`;
  documentRoot.style.maxWidth = "none";
  documentRoot.style.margin = "0";

  document.body.appendChild(host);

  try {
    post({ type: "imageExportFontStatus", requestId: request.requestId, status: "loading" });
    const assets = await prepareNoteImageAssets({ theme: resolvedTheme, fontStyle, text: [request.title, request.notebook, ...(request.tags || []), request.updatedAt, bodyHtml].join(" "), urls: noteImageAssetUrls });
    post({ type: "imageExportFontStatus", requestId: request.requestId, status: assets.fontFallback ? "fallback" : "ready" });
    void assets.fontsReady?.then(() => post({ type: "imageExportFontsReady", requestId: request.requestId }), () => {});
    style.textContent = assets.css + generateCardCss({ theme: resolvedTheme, fontStyle, fontSize, cardWidth });
    const images = Array.from(documentRoot.querySelectorAll<HTMLImageElement>("img"));
    await Promise.race([
      Promise.all([
        document.fonts?.ready,
        ...images.map(async (image) => {
          if (image.complete) return;
          try { await image.decode(); } catch { /* Export the readable remainder. */ }
        }),
      ]),
      new Promise<void>((resolve) => window.setTimeout(resolve, 8_000)),
    ]);
    const exportedImages = Array.from(
      documentRoot.querySelectorAll<HTMLImageElement>(".edgeever-card-body img"),
    );
    const failedImages = exportedImages.filter((image) => !image.complete || image.naturalWidth === 0).length;
    const totalHeight = Math.max(1, Math.ceil(documentRoot.getBoundingClientRect().height));
    const renderPlan = planNativeNoteImageRender(targetWidth, totalHeight);
    let embedFailedImages = 0;
    let captureRoot = documentRoot;
    let captureWrapper: HTMLDivElement | null = null;
    if (renderPlan.sourceScale < 1) {
      captureWrapper = document.createElement("div");
      captureWrapper.style.cssText = `position:relative;width:${renderPlan.sourceWidth}px;height:${renderPlan.sourceHeight}px;overflow:hidden;`;
      documentRoot.replaceWith(captureWrapper);
      captureWrapper.appendChild(documentRoot);
      documentRoot.style.transform = `scale(${renderPlan.sourceScale})`;
      documentRoot.style.transformOrigin = "top left";
      captureRoot = captureWrapper;
    }
    const backgroundColor = NOTE_IMAGE_BACKGROUND_COLORS[resolvedTheme] || themeCfg.canvasBg;

    const missingImagePlaceholder = "data:image/gif;base64,R0lGODlhAQABAAD/ACwAAAAAAQABAAACADs=";
    const renderCanvas = (root: HTMLElement, width: number, height: number) => toCanvas(root, {
      backgroundColor,
      cacheBust: false,
      height,
      imagePlaceholder: missingImagePlaceholder,
      onImageErrorHandler: (event) => {
        embedFailedImages += 1;
        if (event instanceof Event && event.target instanceof HTMLImageElement) {
          event.target.src = missingImagePlaceholder;
        }
      },
      pixelRatio: renderPlan.pixelRatio,
      fontEmbedCSS: assets.fontCss,
      width,
    });
    let canvas: HTMLCanvasElement;
    try {
      canvas = await renderCanvas(captureRoot, renderPlan.sourceWidth, renderPlan.sourceHeight);
    } catch {
      const retryScale = renderPlan.sourceScale * 0.75;
      if (retryScale < 0.5) throw new Error("NOTE_IMAGE_RENDER_FAILED");
      const retryWidth = Math.max(1, Math.floor(targetWidth * retryScale));
      const retryHeight = Math.max(1, Math.floor(totalHeight * retryScale));
      if (!captureWrapper) {
        captureWrapper = document.createElement("div");
        documentRoot.replaceWith(captureWrapper);
        captureWrapper.appendChild(documentRoot);
      }
      captureWrapper.style.cssText = `position:relative;width:${retryWidth}px;height:${retryHeight}px;overflow:hidden;`;
      documentRoot.style.transform = `scale(${retryScale})`;
      documentRoot.style.transformOrigin = "top left";
      try {
        canvas = await renderCanvas(captureWrapper, retryWidth, retryHeight);
      } catch {
        throw new Error("NOTE_IMAGE_RENDER_FAILED");
      }
    }
    const blob = await new Promise<Blob>((resolve, reject) => {
      canvas.toBlob(
        (result) => result ? resolve(result) : reject(new Error("Image renderer returned an empty file")),
        request.format === "jpeg" ? "image/jpeg" : "image/png",
        request.format === "jpeg" ? 0.92 : 1,
      );
    });

    const extension = request.format === "jpeg" ? "jpg" : "png";
    const basename = buildImageExportBasename(request.title, request.fallbackTitle);
    const bytes = await blobToBytes(blob);
    const filename = `${basename}.${extension}`;
    const mimeType = request.format === "jpeg" ? "image/jpeg" : "image/png";
    const base64 = bytesToBase64(bytes);
    for (let offset = 0; offset < base64.length; offset += IMAGE_EXPORT_CHUNK_SIZE) {
      post({ type: "imageExportChunk", requestId: request.requestId, chunk: base64.slice(offset, offset + IMAGE_EXPORT_CHUNK_SIZE) });
      await new Promise((resolve) => setTimeout(resolve, 0));
    }
    post({
      type: "imageExportComplete",
      fontFallback: assets.fontFallback,
      requestId: request.requestId,
      filename,
      mimeType,
      width: canvas.width,
      height: canvas.height,
      totalImages: exportedImages.length,
      failedImages: Math.min(exportedImages.length, failedImages + embedFailedImages),
    });
  } catch (error) {
    post({ type: "imageExportError", requestId: request.requestId, message: error instanceof Error ? error.message : "Image export failed" });
  } finally {
    host.remove();
  }
}

export type EdgeEverEditorAPI = {
  configure: (opts: ConfigureOptions) => void;
  setMarkdown: (md: string) => void;
  setDocumentFromJSON: (json: string) => void;
  resetReaderScroll: () => void;
  resolveResource: (requestId: string, dataUrl: string | null) => void;
  getMarkdown: () => string;
  getDocument: () => string;
  captureSelection: () => string | null;
  applySelectionDraft: (markdown: string, mode: "append" | "replace") => boolean;
  undo: () => boolean;
  focusEnd: () => void;
  flush: () => void;
  exec: (actionId: string) => void;
  beginImageUpload: (uploadId: string, previewDataUrl: string) => void;
  completeImageUpload: (uploadId: string, imageUrl: string, alt: string) => void;
  groupImages: (sources: string[]) => boolean;
  cancelImageUpload: (uploadId: string) => void;
  search: (query: string, requestedIndex: number) => void;
  exportImage: (request: ImageExportRequest) => void;
};

const api: EdgeEverEditorAPI = {
  resetReaderScroll,
  exportImage(request) {
    void exportNoteImage(request);
  },
  configure(opts) {
    const nextMode = opts.mode === "editor" ? "editor" : "viewer";
    const modeChanged = nextMode !== mode;
    mode = nextMode;
    locale = opts.locale === "en-US" || opts.locale === "ja" || opts.locale === "pl" ? opts.locale : "zh-CN";
    // Configuring a reused WebView is not a document edit. TipTap otherwise emits
    // an update for its old (often empty) body before native pushes the share seed.
    editor.setEditable(mode === "editor", false);
    if (modeChanged) {
      // Without that update event, node views that hide editing controls (the image
      // gallery toolbar) keep their old state. A no-op transaction refreshes them
      // without recording history or triggering a save.
      editor.view.dispatch(editor.state.tr.setMeta("addToHistory", false).setMeta("preventUpdate", true));
    }
    setToolbarVisible(mode === "editor");
    document.documentElement.dataset.theme = opts.theme || "light";
    document.body.classList.toggle("viewer-mode", mode === "viewer");
    document.body.classList.toggle("editor-mode", mode === "editor");
    if (opts.placeholder) {
      currentPlaceholder = opts.placeholder;
      editorEl.querySelectorAll<HTMLElement>("[data-placeholder]").forEach((element) => {
        element.dataset.placeholder = currentPlaceholder;
      });
    }
    // Match Evernote-style edit entry: focus the surface when entering editor mode.
    // Combined with setContent's default end selection, caret lands at document end.
    if (mode === "editor" && modeChanged) {
      requestAnimationFrame(() => {
        try {
          editor.commands.focus("end");
        } catch {
          /* ignore */
        }
      });
    }
    void afterContentSet(opts.theme || "light");
  },

  setMarkdown(md) {
    suppressChange = true;
    const diagram = mode === "viewer" ? parseDiagramDocument(md) : null;
    viewerDiagram = diagram;
    // Valid IR is drawn by read-only X6. Do not inject a hidden Mermaid
    // document into TipTap; invalid envelopes keep the stripped fence.
    const displayMarkdown = mode === "viewer"
      ? (diagram ? "" : stripDiagramDocumentMarker(md))
      : md;
    try {
      editor.commands.setContent(displayMarkdown || "", { contentType: "markdown" } as never);
    } catch {
      try {
        const manager = (editor.storage as { markdown?: { manager?: { parse: (s: string) => unknown } } }).markdown
          ?.manager;
        if (manager) {
          editor.commands.setContent(manager.parse(displayMarkdown || "") as never);
        } else {
          throw new Error("no markdown manager");
        }
      } catch {
        editor.commands.setContent({
          type: "doc",
          content: [{ type: "paragraph", content: displayMarkdown ? [{ type: "text", text: displayMarkdown }] : [] }],
        });
      }
    }
    // Keep editability. Do NOT focus("end") here — native re-pushes content on SwiftUI
    // updates while typing; focusing would yank the caret to the document bottom mid-edit.
    editor.setEditable(mode === "editor");
    clearMobileEditorUndoHistory(editor);
    refreshToolbarState();
    suppressChange = false;
    void afterContentSet((document.documentElement.dataset.theme as "light" | "dark") || "light");
  },

  setDocumentFromJSON(json) {
    suppressChange = true;
    viewerDiagram = null;
    clearViewerDiagramGraph();
    try {
      const doc = JSON.parse(json) as TiptapDoc;
      editor.commands.setContent(prepareNativeEditorContent(
        resolveNativeAttachmentContent(doc),
        locale,
      ));
    } catch {
      editor.commands.setContent({ type: "doc", content: [{ type: "paragraph" }] });
    }
    editor.setEditable(mode === "editor");
    clearMobileEditorUndoHistory(editor);
    refreshToolbarState();
    suppressChange = false;
    void afterContentSet((document.documentElement.dataset.theme as "light" | "dark") || "light");
  },

  resolveResource(requestId, dataUrl) {
    const resolver = resourceResolvers.get(requestId);
    if (resolver) {
      resourceResolvers.delete(requestId);
      resolver(dataUrl);
    }
  },

  getMarkdown() {
    return serializeEditorMarkdown(editor);
  },

  getDocument() {
    return JSON.stringify(restoreNativeEditorContent(editor.getJSON() as TiptapDoc));
  },

  captureSelection() {
    const context = getAiSelectionContext(editor);
    if (!context) {
      pendingAiSelection = null;
      return null;
    }
    pendingAiSelection = {
      from: context.from,
      to: context.to,
      isInline: context.isInline,
      documentFingerprint: JSON.stringify(editor.getJSON()),
    };
    return JSON.stringify({
      from: context.from,
      to: context.to,
      markdown: context.markdown,
      text: context.text,
    });
  },

  applySelectionDraft(markdown, applyMode) {
    const range = pendingAiSelection;
    if (!range || !markdown.trim()) return false;
    if (JSON.stringify(editor.getJSON()) !== range.documentFingerprint) {
      pendingAiSelection = null;
      return false;
    }
    const docSize = editor.state.doc.content.size;
    const from = Math.min(Math.max(range.from, 0), docSize);
    const to = Math.min(Math.max(range.to, from), docSize);
    try {
      const manager = (editor.storage as { markdown?: { manager?: { parse?: (value: string) => { content?: unknown[] } } } })
        .markdown?.manager;
      const parsed = manager?.parse?.(markdown);
      const content = applyMode === "replace"
        ? parseAiSelectionReplacement(editor, markdown, range.isInline)
        : parsed?.content ?? markdown;
      const insertRange = applyMode === "append" ? { from: to, to } : { from, to };
      editor.chain().focus().insertContentAt(insertRange, content as never).run();
      pendingAiSelection = null;
      emitChange(editor);
      return true;
    } catch {
      return false;
    }
  },

  undo() {
    if (!editor.can().undo()) return false;
    const changed = editor.commands.undo();
    if (changed) emitChange(editor);
    return changed;
  },

  focusEnd() {
    try {
      editor.commands.focus("end");
    } catch {
      /* ignore */
    }
    // iOS WKWebView: TipTap selection alone may not move DOM focus to the contenteditable.
    // Explicitly focus ProseMirror so the software keyboard can attach after native first-responder.
    try {
      const dom = editor.view?.dom as HTMLElement | undefined;
      if (dom && typeof dom.focus === "function") {
        dom.focus({ preventScroll: true });
      }
    } catch {
      /* ignore */
    }
  },

  flush() {
    emitChange(editor);
  },

  exec(actionId) {
    const map: Record<string, () => void> = {
      bold: () => editor.chain().focus().toggleBold().run(),
      bulletList: () => editor.chain().focus().toggleBulletList().run(),
      taskList: () => editor.chain().focus().toggleTaskList().run(),
      blockquote: () => editor.chain().focus().toggleBlockquote().run(),
      horizontalRule: () => editor.chain().focus().setHorizontalRule().run(),
      heading2: () => editor.chain().focus().toggleHeading({ level: 2 }).run(),
      codeBlock: () => editor.chain().focus().toggleCodeBlock().run(),
    };
    map[actionId]?.();
    emitChange(editor);
  },

  beginImageUpload(uploadId, previewDataUrl) {
    editor
      .chain()
      .focus()
      .setImage({ src: previewDataUrl, alt: uploadId, width: NEW_IMAGE_WIDTH_PERCENT })
      .run();
    // mark last image
    const imgs = editorEl.querySelectorAll("img");
    const last = imgs[imgs.length - 1] as HTMLImageElement | undefined;
    if (last) last.dataset.uploadId = uploadId;
    emitChange(editor);
  },

  completeImageUpload(uploadId, imageUrl, alt) {
    if (!editor.isEditable) return;
    editor.view.dispatch(createImageInsertTransaction(editor.state, {
      src: imageUrl, alt: alt || uploadId || "",
      width: NEW_IMAGE_WIDTH_PERCENT,
    }));
    emitChange(editor);
  },

  groupImages(sources) {
    const grouped = groupUploadedImages(editor, sources);
    if (grouped) emitChange(editor);
    return grouped;
  },

  cancelImageUpload(uploadId) {
    const img = editorEl.querySelector(`img[data-upload-id="${uploadId}"]`);
    img?.remove();
    emitChange(editor);
  },

  search(query, requestedIndex) {
    const matches = getEditorSearchMatches(editor, query);
    const index = matches.length > 0
      ? Math.min(Math.max(Number.isFinite(requestedIndex) ? requestedIndex : 0, 0), matches.length - 1)
      : 0;
    const match = matches[index];
    if (match) {
      editor.commands.setTextSelection({ from: match.from, to: match.to });
      try {
        const dom = editor.view.domAtPos(match.from).node;
        const element = dom instanceof Element ? dom : dom.parentElement;
        element?.scrollIntoView({ block: "center", behavior: "smooth" });
      } catch {
        /* ignore */
      }
    }
    post({ type: "searchResult", count: matches.length, index });
  },
};

(window as unknown as { EdgeEverEditor: EdgeEverEditorAPI }).EdgeEverEditor = api;
setToolbarVisible(false);
post({ type: "ready", startupMs: Math.round(performance.now() - startedAt) });