@heycys/gallery 0.1.0 → 0.1.2

package/browser/editor/page/todo-writes.mjs

@@ -0,0 +1,75 @@
+import { TODO_EVENT, TODO_MOST, TODO_ROUTE } from "../../shared/workspace-query.mjs";
+import { postAnswer } from "./post.mjs";
+
+// To-dos of documents checked from this page (workspace.setTodo, the plan's 5.1; docs/editor.md "To-dos
+// checked from another page"): the kit's ask (TODO_EVENT, cancelable on the window: { ask: { slug, ref,
+// done }, answer(promise) }) taken by whoever holds the page's token (a custom page's board, a document's
+// editor) and written by the workspace's service (POST TODO_ROUTE, one document a request: the edit
+// service's setTodos, one commit of the reader's). The checks of one document wait in a line of their own:
+// those asked while one write of it is out go together in the next (its items in the order asked, the
+// last of an item winning), so that a reader ticking five boxes quickly makes two commits, not five.
+// Each ask is answered { ok: true, changed, block } (`block` the item's id now, which the commit gives
+// one that had none) or { ok: false, reason, message? }, never rejected.
+
+/**
+ * `token`: the page map's. `done(ask, answer)`: an ask answered (the board keeps an undo step of one that
+ * changed its document). Returns { write(ask) (a promise of its answer), idle() (once every write asked so
+ * far is answered), listen() (takes the kit's asks; returns the function that stops it) }.
+ */
+export function createTodoWrites({ token, done = () => {} }) {
+  const lines = new Map(); // slug -> { waiting: [{ ask, resolve }], out: Promise | null }
+
+  async function send(slug, line) {
+    const batch = line.waiting.splice(0, TODO_MOST);
+    const answer = await postAnswer(TODO_ROUTE, token, { slug, items: batch.map(({ ask }) => ({ ref: ask.ref, done: ask.done })) });
+    batch.forEach(({ ask, resolve }, index) => {
+      const result = answer?.ok ? answer.results?.[index] ?? { ok: false, reason: "failed" } : { ok: false, reason: answer?.reason === "offline" ? "offline" : answer?.reason ?? "failed", ...(typeof answer?.message === "string" ? { message: answer.message } : {}) };
+      try {
+        done(ask, result);
+      } finally {
+        resolve(result);
+      }
+    });
+  }
+
+  // The line of a document: written once nothing of it is out, what waits then going together.
+  function run(slug) {
+    const line = lines.get(slug);
+    if (line.out || line.waiting.length === 0) return;
+    // A microtask's wait, so that the asks of one gesture (a block checking several at once) go together.
+    line.out = Promise.resolve().then(() => send(slug, line)).catch(() => {}).finally(() => {
+      line.out = null;
+      if (line.waiting.length > 0) run(slug);
+      else lines.delete(slug);
+    });
+  }
+
+  function write(ask) {
+    return new Promise((resolve) => {
+      if (!lines.has(ask.slug)) lines.set(ask.slug, { waiting: [], out: null });
+      lines.get(ask.slug).waiting.push({ ask, resolve });
+      run(ask.slug);
+    });
+  }
+
+  return {
+    write,
+    async idle() {
+      for (;;) {
+        const out = [...lines.values()].map((line) => line.out).filter(Boolean);
+        if (out.length === 0) return;
+        await Promise.all(out);
+      }
+    },
+    listen() {
+      const take = (event) => {
+        const { ask, answer } = event.detail ?? {};
+        if (event.defaultPrevented || !ask || typeof answer !== "function") return;
+        event.preventDefault();
+        answer(write(ask));
+      };
+      addEventListener(TODO_EVENT, take);
+      return () => removeEventListener(TODO_EVENT, take);
+    },
+  };
+}

package/browser/editor/page/tooltip.mjs

@@ -22,7 +22,7 @@ const STYLE = `
 const DELAY = 150;
 const GAP = 6;
 const MAC = /Mac|iPhone|iPad/.test(globalThis.navigator?.platform ?? "");
-const KEYS = MAC ? { mod: "⌘", shift: "⇧", alt: "⌥" } : { mod: "Ctrl", shift: "⇧", alt: "Alt" };
+const KEYS = MAC ? { mod: "⌘", shift: "⇧", alt: "⌥", enter: "↩" } : { mod: "Ctrl", shift: "⇧", alt: "Alt", enter: "Enter" };
 let shown = null; // { node, tip }
 let timer = 0;
 

package/browser/editor/page/type-grid.mjs

@@ -6,8 +6,9 @@ import { t } from "../../shared/i18n/index.mjs";
 
 // The types a block can be turned into, as icons side by side (as Feishu's block menu), the block's
 // own type marked: the top of the block menu (block-menu/) and the format bar's "turn into"
-// (format-bar/). The buttons are the format bar's (32×28px, 4px apart, its blue for the current
-// one), so both read alike. Each icon names its type, and its Markdown shortcut, in a tooltip.
+// (format-bar/). The buttons are the format bar's (32×28px, 4px apart; the current one marked as
+// a pressed tool of the bar is, its icon's lines in the bar's blue, --ge-accent, and no fill of its
+// own, so the pointer's gray fills it as any other), so both read alike. Each icon names its type, and its Markdown shortcut, in a tooltip.
 // A type that says `corner` has no cell of its own but the gray corner of that type's (a split
 // button): 小字's of 文本's, so 文本 and the headings fill one line. The corner shows only with the
 // pointer (or the keys) on the cell, or, blue, when the block is of that type. It is a click target
@@ -26,7 +27,7 @@ const STYLE = `
   .ge-type { display: flex; align-items: center; justify-content: center; width: ${CELL}px; height: 28px; padding: 0; border: 0; border-radius: 6px; background: transparent; color: var(--ge-ico); cursor: pointer; transition: background 20ms ease-in; }
   .ge-type:hover, .ge-type[data-active] { background: var(--ge-hover); }
   .ge-type:active { background: var(--ge-press); }
-  .ge-type[aria-current="true"] { background: var(--ge-fill); color: var(--ge-accent); }
+  .ge-type[aria-current="true"] { color: var(--ge-accent); }
   .ge-type-pair { position: relative; border-radius: 6px; overflow: hidden; }
   .ge-type-corner { position: absolute; right: 0; bottom: 0; width: ${CORNER}px; height: ${CORNER}px; padding: 0; border: 0; background: transparent; cursor: pointer; }
   .ge-type-corner::before { content: ""; position: absolute; inset: 0; background: light-dark(rgb(55 53 47 / 12%), rgb(255 255 255 / 13%)); clip-path: path("${TRIANGLE}"); opacity: 0; transition: background 20ms ease-in, opacity 120ms ease-out; }

package/browser/editor/page/typing/code-edges.mjs

@@ -12,7 +12,11 @@ import { ENTRIES } from "../../components/registry.mjs";
 // the caret in a pad (pads.mjs). Code blocks are text blocks of their own (components/code/) and
 // have none of this. A component's entry in the text (`entry`: a chip as padded as code) has the
 // same stops, and Backspace at the stop after it (Delete at the one before it) takes the whole
-// entry away (beforeDelete says what the page says of that; editor.mjs records the step).
+// entry away (takeEntry, on the key's keydown through beforeDelete and on its beforeinput where an
+// input method's keydown says 229; it says what the page says of that, editor.mjs records the step).
+// A Backspace that takes the last character between inline code or an entry and the caret after it
+// leaves the caret outside it, at the stop after it (deletingBack, deletedBack): the browser puts it
+// in at the end (an entry's: left of its icon), its end and the text after it one place to it.
 
 const EDGED = ["code", ...ENTRIES.map(({ at }) => at)].join(", ");
 const isEdged = (node) => node?.nodeType === 1 && node.matches(EDGED);
@@ -187,28 +191,48 @@ export function codePress(host, x, y) {
 }
 
 /**
- * Backspace or Delete with the caret in a pad at an edge: the pad goes first, the caret where the
- * key then takes the character beside it, as it would without the pad (keydown, before the browser
- * deletes or the editor merges blocks). At the stop beside a component's entry the whole entry goes,
- * and what the page says of that is returned; nothing otherwise.
+ * Backspace (`back`) at the stop after a component's entry, or Delete at the one before it: the whole
+ * entry goes, as a chip of the text does, the caret where it stood, and what the page says of that is
+ * returned; nothing otherwise. The keydown's (beforeDelete) and the beforeinput's, for a key whose
+ * keydown the editor passed by (an input method's, keyCode 229: editor.mjs). The pads beside it go
+ * with it, before the text either side of it is joined, so that no zero-width space is left in that
+ * text (a pad an undo step put back is part of the text beside it by then).
  */
-export function beforeDelete(host, key) {
+export function takeEntry(host, back) {
   const selection = getSelection();
   if (!selection.rangeCount || !selection.isCollapsed) return;
-  const back = key === "Backspace";
-  // At the stop after an entry (or before it, for Delete): the whole entry goes.
   const outside = caretAtEdge(host);
   const entry = outside && !outside.inside ? entryOf(outside.code) : undefined;
-  if (entry && (back ? outside.side === "end" : outside.side === "start")) {
-    const caret = host.ownerDocument.createRange();
-    if (isPad(selection.anchorNode)) selection.anchorNode.remove();
-    caret.setStartBefore(outside.code);
-    caret.collapse(true);
-    outside.code.remove();
-    host.normalize();
-    select(caret);
-    return entry.removed;
+  if (!entry || (back ? outside.side !== "end" : outside.side !== "start")) return;
+  const { code } = outside;
+  for (const [next, trim] of [["previousSibling", new RegExp(`${ZWSP}+$`)], ["nextSibling", new RegExp(`^${ZWSP}+`)]]) {
+    for (let node = code[next]; node?.nodeType === 3; node = code[next]) {
+      node.data = node.data.replace(trim, "");
+      if (node.data !== "") break;
+      node.remove();
+    }
   }
+  const caret = host.ownerDocument.createRange();
+  caret.setStartBefore(code);
+  caret.collapse(true);
+  code.remove();
+  host.normalize();
+  select(caret);
+  return entry.removed;
+}
+
+/**
+ * Backspace or Delete with the caret in a pad at an edge: the pad goes first, the caret where the
+ * key then takes the character beside it, as it would without the pad (keydown, before the browser
+ * deletes or the editor merges blocks). At the stop beside a component's entry the whole entry goes
+ * (takeEntry), and what the page says of that is returned; nothing otherwise.
+ */
+export function beforeDelete(host, key) {
+  const back = key === "Backspace";
+  const removed = takeEntry(host, back);
+  if (removed) return removed;
+  const selection = getSelection();
+  if (!selection.rangeCount || !selection.isCollapsed) return;
   const pad = selection.anchorNode;
   if (!isPad(pad) || !host.contains(pad)) return;
   const edge = caretAtEdge(host);
@@ -226,3 +250,25 @@ export function beforeDelete(host, key) {
   caret.collapse(true);
   select(caret);
 }
+
+// The host whose caret a deletion backward found in text outside any inline code or entry (no pad),
+// for the input after it (deletedBack).
+let backFrom = null;
+
+/** A deletion backward about to happen (its beforeinput): where the caret stands, for deletedBack. */
+export function deletingBack(host) {
+  const selection = getSelection();
+  const node = selection.rangeCount && selection.isCollapsed ? selection.anchorNode : null;
+  backFrom = node?.nodeType === 3 && !isPad(node) && !node.parentElement.closest(EDGED) ? host : null;
+}
+
+/**
+ * The deletion done (its input): a caret it took from the text after inline code or an entry into
+ * it, at its end, goes back out to the stop after it, where the reader deleting back stays.
+ */
+export function deletedBack(host) {
+  const was = backFrom === host;
+  backFrom = null;
+  const edge = was && caretAtEdge(host);
+  if (edge && edge.inside && edge.side === "end") padCaret(edge.code, "after");
+}

package/browser/editor/page/typing/index.mjs

@@ -1,12 +1,12 @@
 import {
-  boxKind, can, emptyContainer, isEmpty, isFirstLine, isHost, limitText, mergeWithPrevious, nestedBlocks, nestedLists, nextLine, parentItem, previousLine, removalTarget, splitBlock, takeOut, textEnd, unitElement,
+  UNIT, boxKind, can, emptyContainer, isEmpty, isFirstLine, isHost, limitText, mergeWithPrevious, nestedBlocks, nestedLists, nextLine, parentItem, previousLine, removalTarget, splitBlock, takeOut, textEnd, unitElement, newParagraphHost, withLeads,
 } from "../core.mjs";
 import { atEdge, caretAt, hosts, select, textNear } from "../caret.mjs";
 import { convertible } from "../convert.mjs";
 import { joinCode } from "../marks.mjs";
 import { numberWithUnit, sideOf, WORD } from "../../../shared/inline-spacing.mjs";
 import { pageOf, pagesAround } from "../page-objects.mjs";
-import { BLOCK_TYPES, HOSTS, firstSaysOf, placeholderOf, textFilters, textTypeOf } from "../../components/registry.mjs";
+import { BLOCK_TYPES, HOSTS, accepts, firstSaysOf, placeholderOf, textFilters, textTypeOf } from "../../components/registry.mjs";
 import { t } from "../../../shared/i18n/index.mjs";
 
 // Typing in a block (docs/editor.md, "Browser side"): every key goes first to the component the block
@@ -25,6 +25,8 @@ import { t } from "../../../shared/i18n/index.mjs";
 // 3万5千), and a block written without such spaces is typed in its own way (none added).
 const HAN = /[\u2e80-\u2eff\u2f00-\u2fdf\u3040-\u309f\u30a0-\u30fa\u30fc-\u30ff\u3100-\u312f\u3200-\u32ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]/;
 const LATIN = /[A-Za-z0-9]/;
+// The text blocks that say their placeholder whenever they are empty (HOSTS' `untitled`: the page's title).
+const UNTITLED = Object.keys(HOSTS).filter((kind) => HOSTS[kind].untitled).map((kind) => `main [data-ge-kind="${kind}"]`).join(", ");
 const needsSpace = (a, b, before) => ((HAN.test(a) && LATIN.test(b)) || (LATIN.test(a) && HAN.test(b))) && !numberWithUnit(a, b, before);
 // The block's own way with Chinese beside Latin letters and digits, from its text but what was just
 // typed: true when it writes them together more often than apart (a number's unit is no sign either way).
@@ -47,13 +49,12 @@ function writtenTogether(host, node, start, end) {
 /**
  * struct(parents, touched, mutate): the editor's undoable structural change (history.mjs). say: the
  * status line. keepText(unit): why a block may not go (block-info.mjs). paragraphBefore(host): an
- * empty paragraph before the block, the caret staying (insert/). paragraphAfter(unit): one after a
- * block, the caret in it, where its box takes one (insert/). removeBlocks(units): the blocks
+ * empty paragraph before the block, the caret staying (insert/). removeBlocks(units): the blocks
  * deleted as the selected ones are (selection/delete.mjs). adding(): the block the "/" menu the
  * handle's "+" opened is open in (slash-menu/), or null. leave: where Enter and Backspace leave a
- * container (leave.mjs).
+ * container (leave.mjs). showHidden(node): the folds hiding a block opened (fold/ showAround).
  */
-export function createTyping({ struct, say, keepText, paragraphBefore, paragraphAfter, removeBlocks, selectBlock = () => {}, adding = () => null, leave }) {
+export function createTyping({ struct, say, keepText, paragraphBefore, removeBlocks, selectBlock = () => {}, adding = () => null, leave, showHidden = () => {} }) {
   // A key, asked of the component of the text block `host` and then of what stands around it, nearest
   // first (docs/editor.md, "The order of keys"): whether it was theirs. `ctx` is notion-lite's, as
   // much of it as a key reads, the block being an element here.
@@ -62,8 +63,43 @@ export function createTyping({ struct, say, keepText, paragraphBefore, paragraph
     return Boolean(key(pageOf(host)?.keys ?? {})?.(ctx, ...rest) || pagesAround(host).some((page) => key(page.keys?.around ?? {})?.(ctx, ...rest)));
   }
 
+  // Enter in the page's title (HOSTS' `opensBody`): notion-lite's splitBlock for the page (enter.js, its
+  // first rule): what is selected goes, what follows the caret leaves the title for a new paragraph right
+  // below it, the first block of the page (an empty one at its end, a new untitled document's too), and
+  // the caret goes to its start; the title keeps what stands before the caret, never a line break. One
+  // undo step, the caret back in the title where it was. Below the title is the header's first line when it has one
+  // (the paragraph goes before it, in the header), else the first block after the header.
+  function enterBody(title) {
+    const selection = getSelection();
+    if (!selection.rangeCount || !title.contains(selection.getRangeAt(0).startContainer) || !title.contains(selection.getRangeAt(0).endContainer)) return;
+    const range = selection.getRangeAt(0);
+    const header = title.parentElement;
+    let line = title.nextElementSibling;
+    while (line && !line.matches(UNIT)) line = line.nextElementSibling;
+    const [box, before] = line ? [header, withLeads(line)[0]] : [header.parentElement, header.nextSibling];
+    const paragraph = newParagraphHost(document);
+    if (!box?.hasAttribute("data-ge-box") || !accepts(box.getAttribute("data-ge-box-kind"), paragraph.getAttribute("data-ge-type"))) {
+      say(limitText(title, "split"));
+      return;
+    }
+    struct([...new Set([header, box])], [title], () => {
+      range.deleteContents();
+      const tail = document.createRange();
+      tail.setStart(range.startContainer, range.startOffset);
+      tail.setEnd(title, title.childNodes.length);
+      const moved = tail.extractContents();
+      if (moved.textContent.length > 0) paragraph.append(document.createTextNode(moved.textContent)); // the title's words, plain
+      title.normalize();
+      if (isEmpty(title)) title.replaceChildren();
+      box.insertBefore(paragraph, before);
+      return { touched: [title, paragraph], focus: paragraph };
+    }, { caret: true });
+    caretAt(paragraph, "start");
+  }
+
   // Enter.
   function split(host) {
+    if (HOSTS[host.getAttribute("data-ge-kind")]?.opensBody) return enterBody(host);
     // The caret at the very start of a block with text: an empty paragraph goes before the block and
     // the caret stays (a block that splits does this itself, splitBlock). This comes first: in a code
     // block too, whose own Enter breaks the line.
@@ -75,8 +111,7 @@ export function createTyping({ struct, say, keepText, paragraphBefore, paragraph
     // in any editor, and so does the empty last paragraph of a panel), the rule of every block.
     if (asked((keys) => keys.enter, host) || leave.enter(host)) return;
     if (!can(host, "split")) {
-      // At the very end of a block that says so, a paragraph follows it, as one that splits would.
-      if (!HOSTS[host.getAttribute("data-ge-kind")]?.opensAfter || !atEdge(host, true) || !paragraphAfter(host)) say(limitText(host, "split"));
+      say(limitText(host, "split"));
       return;
     }
     const selection = getSelection();
@@ -159,8 +194,15 @@ export function createTyping({ struct, say, keepText, paragraphBefore, paragraph
     return true;
   }
 
+  // A block on the line above or below that a folded heading hides (fold/: data-ge-folded on it or
+  // around it): its fold opens first, so a join never takes in words out of sight.
+  const opened = (line) => {
+    if (line?.closest?.("[data-ge-folded]")) showHidden(line);
+  };
+
   // Backspace at the start of a block. Returns whether it was handled.
   function backspace(host) {
+    opened(previousLine(host));
     // The block's component (a list item's: a nested item moves out a level, the first or last item of
     // a top-level list leaves it as body text, an emptied item holding lists stays), then what stands
     // around it (the item a block stands under; a node, at the start of its first line, holding
@@ -192,6 +234,7 @@ export function createTyping({ struct, say, keepText, paragraphBefore, paragraph
 
   // Delete at the end of a block. Returns whether it was handled.
   function forwardDelete(host) {
+    opened(nextLine(host));
     // Its component (an empty item holding blocks stays), then what stands around it (at the end of a
     // node's last block nothing is taken in).
     if (asked((keys) => keys.delete, host)) return true;
@@ -260,10 +303,23 @@ export function createTyping({ struct, say, keepText, paragraphBefore, paragraph
     if (hint) host.setAttribute("data-ge-placeholder", hint);
     else host?.removeAttribute("data-ge-placeholder");
     host?.toggleAttribute("data-ge-adding", add);
+    untitled();
+  }
+
+  // The page's title says 未命名文档 whenever it is empty, the caret in it or not (HOSTS' `untitled`:
+  // notion-lite's page title, data-ph 新页面); asked again on every move of the caret and every input,
+  // so an undo, a deletion across blocks and the workbench's renaming are followed too.
+  function untitled() {
+    if (!UNTITLED) return;
+    for (const host of document.querySelectorAll(UNTITLED)) {
+      if (!isHost(host)) continue;
+      if (isEmpty(host)) host.setAttribute("data-ge-placeholder", placeholderOf(host));
+      else if (host !== placeholder) host.removeAttribute("data-ge-placeholder");
+    }
   }
 
   return {
-    split, backspace, forwardDelete, autoSpace, updatePlaceholder,
+    split, backspace, forwardDelete, autoSpace, updatePlaceholder, untitled,
     /** Tab (`back`: Shift+Tab). Whether the key was taken. */
     tab: (host, back) => asked((keys) => keys.tab, host, back),
     /** Ctrl+Enter. Whether the key was taken. */

package/browser/editor/page/typing/leave.mjs

@@ -15,7 +15,7 @@ import { BLOCK_TYPES, LEAVES_BY_ENTER, accepts } from "../../components/registry
 //   - A block of a type that says `resettable` (a quote's paragraph, a list item) turns into a
 //     paragraph where it stands, its container splitting around it (convert.mjs).
 // Enter in a title that goes into its content (a disclosure, a card, a code block) is another rule
-// (their components'), and so is Enter at the end of a block that says `opensAfter` (typing/).
+// (their components').
 
 /**
  * The empty last block of a box that says `leaveByEnter`, moved out after the box (the box goes if

package/browser/editor/page/ui.mjs

@@ -55,6 +55,19 @@ export function button(label, action, { primary = false, ...props } = {}) {
   return node;
 }
 
+/**
+ * A text button in the editor's one button look (look.mjs BUTTONS, `.ge-btn`): no line, no fill, a gray
+ * under the pointer. `primary` the pale blue one (add, confirm, save; `data-primary`), `danger` with it the
+ * pale red (a delete), `quiet` a small one for looking, not deciding (`data-quiet`). A press on it leaves
+ * the selection where it is (button()).
+ */
+export function textButton(label, action, { primary = false, danger = false, quiet = false, class: own = "", ...props } = {}) {
+  const node = button(label, action, { primary, class: `ge-btn${own ? ` ${own}` : ""}`, ...props });
+  if (danger) node.dataset.danger = "";
+  if (quiet) node.dataset.quiet = "";
+  return node;
+}
+
 // Editor UI lives in the top layer with an open modal dialog, otherwise it would be inert.
 export function layer() {
   return document.querySelector(DIALOG.open) ?? document.body;

package/browser/shared/annotations.mjs

@@ -2,8 +2,8 @@ import { attr, hasClass } from "./html-tree.mjs";
 import { BLOCK_ID, randomId } from "./ids.mjs";
 
 // 批注 (docs/workbench.md "Annotations", docs/editor.md "Annotations"): the reader's suggestions for a
-// local Agent, each about a piece of a report: words of its text, or blocks taken whole. One with no
-// text is a plain mark of that place. Kept in reports/<slug>/annotations.json, never in report.html:
+// local Agent, each about a piece of a report: words of its text, or blocks taken whole. One has
+// words: an item with none is none (cleanItem). Kept in reports/<slug>/annotations.json, never in report.html:
 //
 //   { v: 1, items: [{ id, created, updated, text, anchor }] }
 //   anchor: { kind: "text", blocks: [data-block-id…], quote, prefix, suffix }
@@ -389,12 +389,13 @@ export function cleanAnchor(anchor) {
 export const sameWords = (a, b) => Boolean(a && b) && a.kind === b.kind && (a.blocks ?? []).join() === (b.blocks ?? []).join() && squash(a.quote) === squash(b.quote)
   && squash(a.prefix).slice(-CONTEXT_KEPT) === squash(b.prefix).slice(-CONTEXT_KEPT) && squash(a.suffix).slice(0, CONTEXT_KEPT) === squash(b.suffix).slice(0, CONTEXT_KEPT);
 
-/** An annotation as the file keeps it, from what was sent (`now`: when it is saved), or null when it is none. */
+/** An annotation as the file keeps it, from what was sent (`now`: when it is saved), or null when it is none (no id, no anchor, no words). */
 export function cleanItem(item, now = new Date().toISOString()) {
   if (!item || typeof item !== "object" || typeof item.id !== "string" || !ID.test(item.id) || typeof item.text !== "string") return null;
   const anchor = cleanAnchor(item.anchor);
   if (!anchor) return null;
   const text = item.text.replace(/\r\n?/g, "\n").slice(0, TEXT_MOST);
+  if (!text.trim()) return null;
   return { id: item.id, created: typeof item.created === "string" ? item.created : now, updated: now, text, anchor };
 }
 
@@ -421,7 +422,6 @@ export const itemsText = (items) => (items.length === 0 ? null : `${JSON.stringi
 export const MARKDOWN_WORDS = {
   head: "以下是我对这份文档的批注，共 {0} 条。请逐条按“建议”修改底稿；每条给出它在文档里的位置、块的 data-block-id 和批注的原文。",
   headOne: "以下是我对这份文档的一条批注。请按“建议”修改底稿；它给出在文档里的位置、块的 data-block-id 和批注的原文。",
-  marks: "没有“建议”的批注只是标记了一个位置，不用改。",
   report: "文档",
   source: "底稿",
   block: "块",
@@ -441,22 +441,20 @@ const fill = (text, ...values) => text.replace(/\{(\d+)\}/g, (whole, index) => (
  * then each annotation in page order: where it is (`where`: the tab, the headings above it, the
  * disclosure it is in; `top`: before the report's first heading, said 页首, which no tab or heading
  * named 正文 is taken for), its blocks' ids (as the file has them), its quote and the suggestion, each
- * of its lines a paragraph (blank lines in it make no more of them). One with no suggestion marks a
- * place: it has no such line, and a line under the first says what such a one is.
+ * of its lines a paragraph (blank lines in it make no more of them).
  * data: { title, path, items: [{ where: [text], top, blocks: [id], whole, quote, text }] }.
  */
 export function annotationsMarkdown({ title, path, items }, words = MARKDOWN_WORDS) {
   const w = { ...MARKDOWN_WORDS, ...words };
   const head = items.length === 1 && w.headOne ? w.headOne : fill(w.head, items.length);
-  const suggestions = items.map((item) => String(item.text ?? "").replace(/\r\n?/g, "\n").split("\n").map((line) => line.trim()).filter(Boolean));
-  const lines = [head, ...(suggestions.some((said) => said.length === 0) ? [w.marks] : []), "", `- ${w.report}${w.colon}${title}`, `- ${w.source}${w.colon}${path}`];
+  const lines = [head, "", `- ${w.report}${w.colon}${title}`, `- ${w.source}${w.colon}${path}`];
   items.forEach((item, index) => {
     const where = item.where?.length ? item.where.join(" › ") : item.top ? w.top : w.body;
     const ids = item.blocks?.length ? item.blocks.map((id) => `\`data-block-id="${id}"\``).join(w.comma) + (item.whole ? w.whole : "") : w.noId;
     lines.push("", `## ${index + 1}. ${where}`, "", `${w.block}${w.colon}${ids}`, "");
     for (const line of String(item.quote ?? "").split("\n")) lines.push(`> ${line}`);
-    const said = suggestions[index];
-    if (said.length > 0) lines.push("", `${w.suggestion}${w.colon}${said[0]}`);
+    const said = String(item.text ?? "").replace(/\r\n?/g, "\n").split("\n").map((line) => line.trim()).filter(Boolean);
+    lines.push("", `${w.suggestion}${w.colon}${said[0] ?? ""}`);
     for (const line of said.slice(1)) lines.push("", line);
   });
   return `${lines.join("\n")}\n`;