@portone/docx-editor 0.6.0 → 0.6.1

package/dist/editor/clipboard/normalizers.js

@@ -9,6 +9,11 @@ import {
   resolveParagraph,
   resolveRun
 } from "../../docx/formatting.js";
+import {
+  copiedNoteStory,
+  nextNoteId,
+  takenNoteIds
+} from "../../docx/notes/newNote.js";
 import { withListNumbering } from "../../docx/paraProps.js";
 import {
   allocateList,
@@ -20,13 +25,21 @@ import {
   RANGE_MARKERS
 } from "../../ooxml/rangeMarkers.js";
 import { docxSchema } from "../../schema/index.js";
+import {
+  EDITABLE_NOTE_KINDS,
+  storyKey
+} from "../../schema/stories.js";
 import { listRefOf, numIdsIn } from "../commands/listCommands.js";
 import { documentFormatting } from "../documentStyles.js";
+import { documentOf } from "../editorDocument.js";
 import {
   canStartNewList,
   documentNumbering
 } from "../plugins/numberingDecorations.js";
-import { NO_LIST_KINDS } from "./internalChannel.js";
+import {
+  NO_LIST_KINDS,
+  NO_NOTE_STORIES
+} from "./internalChannel.js";
 function xmlAttr(value) {
   return typeof value === "string" ? value : null;
 }
@@ -90,22 +103,25 @@ var rekeyNumbering = (slice, context) => {
     return props === null ? node : withAttrs(node, { ...node.attrs, pPr: props.pPr });
   });
 };
-var ANCHOR_NODES = /* @__PURE__ */ new Set([
-  "commentStart",
-  "commentEnd",
-  "commentReference",
-  "noteReference"
-]);
+var ANCHORS = {
+  commentStart: () => true,
+  commentEnd: () => true,
+  commentReference: () => true
+};
 var REFERENCE_ELEMENTS = [
   "commentReference",
   "footnoteReference",
-  "endnoteReference"
+  "endnoteReference",
+  "footnoteRef",
+  "endnoteRef"
 ];
+var NOTE_OWN_MARKS = ["footnoteRef", "endnoteRef"];
 var ANCHOR_ELEMENTS = /* @__PURE__ */ new Set([
   ...RANGE_MARKERS,
   ...PERMISSION_MARKERS,
   ...COMMENT_RANGE_MARKERS,
-  ...REFERENCE_ELEMENTS
+  ...REFERENCE_ELEMENTS,
+  ...NOTE_OWN_MARKS
 ]);
 var PRESERVED_INLINE = /* @__PURE__ */ new Set([
   "rawInline",
@@ -119,11 +135,26 @@ function preservedName(node) {
   return typeof element === "string" ? element : null;
 }
 var detachAnchors = (slice, { move }) => move ? slice : mapSliceNodes(slice, (node) => {
-  if (ANCHOR_NODES.has(node.type.name)) return null;
+  if (ANCHORS[node.type.name]?.(node) === true) return null;
   if (!PRESERVED_INLINE.has(node.type.name)) return node;
   const name = preservedName(node);
   return name !== null && ANCHOR_ELEMENTS.has(name) ? null : node;
 });
+var duplicateNotes = (slice, { move, noteStories, startNote }) => move ? slice : mapSliceNodes(slice, (node) => {
+  if (node.type !== docxSchema.nodes.noteReference) return node;
+  const kind = EDITABLE_NOTE_KINDS.find(
+    (candidate) => candidate === node.attrs.kind
+  );
+  const id = node.attrs.id;
+  if (kind === void 0 || typeof id !== "string") return null;
+  const story = noteStories.get(storyKey(kind, id));
+  if (story === void 0) return null;
+  return withAttrs(node, {
+    ...node.attrs,
+    id: startNote(kind, story),
+    referenceXml: null
+  });
+});
 var rederiveDisplay = (slice, { state }) => {
   const formatting = documentFormatting(state);
   return mapSliceNodes(slice, (node) => {
@@ -152,6 +183,7 @@ var rederiveDisplay = (slice, { state }) => {
 var DEFAULT_NORMALIZERS = [
   dropSourceIdentity,
   detachAnchors,
+  duplicateNotes,
   rekeyNumbering,
   rederiveDisplay
 ];
@@ -164,11 +196,26 @@ function normalizePasted(content, state, move, normalizers = DEFAULT_NORMALIZERS
     ...content.newLists.keys()
   ]);
   const started = /* @__PURE__ */ new Map();
+  const document = documentOf(state);
+  const takenNotes = /* @__PURE__ */ new Map();
+  const startedNotes = /* @__PURE__ */ new Map();
   const context = {
     state,
     move,
     knownLists: known,
     listKinds: content.listKinds ?? NO_LIST_KINDS,
+    noteStories: content.noteStories ?? NO_NOTE_STORIES,
+    startNote(kind, story) {
+      const ids = takenNotes.get(kind) ?? takenNoteIds(state.doc, kind, document.reservedNoteKeys);
+      takenNotes.set(kind, ids);
+      const id = nextNoteId(ids);
+      ids.add(id);
+      startedNotes.set(
+        storyKey(kind, id),
+        copiedNoteStory(story, document.session)
+      );
+      return id;
+    },
     startList(kind) {
       if (!canStartNewList(state)) return null;
       const list = templateList(kind);
@@ -185,13 +232,15 @@ function normalizePasted(content, state, move, normalizers = DEFAULT_NORMALIZERS
   );
   return {
     slice,
-    newLists: started.size === 0 ? content.newLists : new Map([...content.newLists, ...started])
+    newLists: started.size === 0 ? content.newLists : new Map([...content.newLists, ...started]),
+    newStories: startedNotes.size === 0 ? content.newStories : startedNotes
   };
 }
 export {
   DEFAULT_NORMALIZERS,
   detachAnchors,
   dropSourceIdentity,
+  duplicateNotes,
   mapSliceNodes,
   normalizePasted,
   rederiveDisplay,

package/dist/editor/clipboard/plugin.js

@@ -13,7 +13,9 @@ import { documentOf } from "../editorDocument.js";
 import { insertPlainText } from "../plainText.js";
 import { moveCaretToDrop } from "../plugins/dropCaret.js";
 import { documentNumbering } from "../plugins/numberingDecorations.js";
+import { withPastedStories } from "./htmlReader.js";
 import {
+  draggedNotes,
   INTERNAL_TOKEN_ATTRIBUTE,
   internalTokenOf,
   rememberCopied
@@ -78,6 +80,7 @@ function docxClipboard(options = {}) {
     }
   );
   let started = null;
+  let startedStories = null;
   let dropMove = false;
   let draggingOut = false;
   return new Plugin({
@@ -90,26 +93,33 @@ function docxClipboard(options = {}) {
       };
     },
     /**
-     * The definitions of the lists a paste began, registered on the document once the paste is
-     * in. A list the pasted markup started is numbered as it is read, and only the edit that
-     * lands says whether that number is worn in the end.
+     * What a paste brought beside its text, registered on the document once the paste is in: the
+     * definitions of the lists it began and the notes its references call. A list the pasted
+     * markup started is numbered as it is read, and only the edit that lands says whether that
+     * number is worn in the end.
      */
     appendTransaction(transactions, _before, after) {
       const lists = started;
+      const stories = startedStories;
       started = null;
-      if (lists === null || lists.size === 0 || !transactions.some((tr) => tr.docChanged)) {
-        return null;
+      startedStories = null;
+      if (!transactions.some((tr2) => tr2.docChanged)) return null;
+      const tr = after.tr;
+      if (lists !== null && lists.size > 0) {
+        const worn = numIdsIn(after.doc);
+        const registered = newListsOf(after.doc.attrs[NEW_LISTS_ATTR]);
+        const missing = [...lists].filter(
+          ([numId]) => worn.has(numId) && !registered.has(numId)
+        );
+        if (missing.length > 0) {
+          tr.setDocAttribute(
+            NEW_LISTS_ATTR,
+            newListsValue(new Map([...registered, ...missing]))
+          );
+        }
       }
-      const worn = numIdsIn(after.doc);
-      const registered = newListsOf(after.doc.attrs[NEW_LISTS_ATTR]);
-      const missing = [...lists].filter(
-        ([numId]) => worn.has(numId) && !registered.has(numId)
-      );
-      if (missing.length === 0) return null;
-      return after.tr.setDocAttribute(
-        NEW_LISTS_ATTR,
-        newListsValue(new Map([...registered, ...missing]))
-      );
+      if (stories !== null) withPastedStories(tr, stories);
+      return tr.steps.length === 0 ? null : tr;
     },
     props: {
       handleDOMEvents: {
@@ -145,24 +155,34 @@ function docxClipboard(options = {}) {
       clipboardTextSerializer: clipboardText,
       transformCopied(slice, view) {
         const route = draggingOut ? "drag" : "clipboard";
-        copyToken = rememberCopied(
-          route,
-          slice,
-          documentOf(view.state).session?.sessionId ?? null,
-          documentNumbering(view.state)
-        );
+        const document = documentOf(view.state);
+        copyToken = rememberCopied(route, slice, {
+          sessionId: document.session?.sessionId ?? null,
+          doc: view.state.doc,
+          numbering: documentNumbering(view.state),
+          specialNotes: document.specialNotes
+        });
         return copiedSlice(slice);
       },
       transformPasted(slice, view, plain) {
         if (!plain) parser.setPlainText(false);
         const read = parser.takeRead();
         const content = normalizePasted(
-          read ?? { slice, newLists: NO_NEW_LISTS },
+          // A drop is handed the dragged slice itself rather than markup, so what that slice
+          // carried is looked up by the route it left on rather than by a name written into markup
+          read ?? {
+            slice,
+            newLists: NO_NEW_LISTS,
+            noteStories: draggedNotes(
+              documentOf(view.state).session?.sessionId ?? null
+            )
+          },
           view.state,
           dropMove,
           normalizers
         );
         started = content.newLists;
+        startedStories = content.newStories ?? null;
         return content.slice;
       },
       handlePaste(view, event, slice) {

package/dist/editor/commands/index.d.ts

@@ -90,6 +90,7 @@ export { activeLink, activeLinkSpan, canSetLink, removeLink, setLink, } from "./
 export { activeListKind, decreaseListLevel, increaseListLevel, isInList, toggleBulletList, toggleNumberedList, } from "./listCommands";
 export type { SelectionLock } from "./lockCommands";
 export { documentHasLocked, lockSelection, selectionLock, selectionTouchesLocked, unlockSelection, } from "./lockCommands";
+export { canInsertEndnote, canInsertFootnote, insertEndnote, insertFootnote, openEndnote, openFootnote, setEndnoteBody, setFootnoteBody, } from "./noteCommands";
 export type { DocumentNote } from "./noteQueries";
 export { documentNotes } from "./noteQueries";
 export type { ActiveParagraphAlign, ActiveParagraphStyle, } from "./paragraphCommands";

package/dist/editor/commands/index.js

@@ -81,6 +81,16 @@ import {
   selectionTouchesLocked,
   unlockSelection
 } from "./lockCommands.js";
+import {
+  canInsertEndnote,
+  canInsertFootnote,
+  insertEndnote,
+  insertFootnote,
+  openEndnote,
+  openFootnote,
+  setEndnoteBody,
+  setFootnoteBody
+} from "./noteCommands.js";
 import { documentNotes } from "./noteQueries.js";
 import {
   activeParagraphAlign,
@@ -117,6 +127,8 @@ export {
   canExport,
   canFormatText,
   canIncreaseIndent,
+  canInsertEndnote,
+  canInsertFootnote,
   canInsertImage,
   canInsertTable,
   canRunCommand,
@@ -139,6 +151,8 @@ export {
   imageFilesIn,
   increaseIndent,
   increaseListLevel,
+  insertEndnote,
+  insertFootnote,
   insertImage,
   insertImageFiles,
   insertLineBreak,
@@ -151,6 +165,8 @@ export {
   isStrikeActive,
   isUnderlineActive,
   lockSelection,
+  openEndnote,
+  openFootnote,
   readImageFile,
   redo,
   removeComment,
@@ -161,8 +177,10 @@ export {
   selectionTouchesLocked,
   setCommentBody,
   setCommentResolved,
+  setEndnoteBody,
   setFontFamily,
   setFontSize,
+  setFootnoteBody,
   setLineSpacing,
   setLink,
   setParagraphAlign,

package/dist/editor/commands/noteCommands.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Puts a note into the document and writes what one says, exported once per kind the way
+ * `toggleBold` and `toggleItalic` are rather than as one command taking a kind. Deleting and
+ * copying a reference need no command: the edit that does either settles the note it calls
+ * (`editor/plugins/noteLifecycle`).
+ */
+import type { Node as PMNode } from "prosemirror-model";
+import type { Command, EditorState } from "prosemirror-state";
+import type { NoteKind } from "../../schema/stories";
+/** Writes what one note of this kind says; an editing view's edit reaches the document this way */
+export declare function noteBodyCommand(kind: NoteKind, id: string, body: PMNode): Command;
+/**
+ * Puts a footnote reference at the end of the selection, calling a new, empty footnote, and asks
+ * for that footnote to be opened. The footnote is written in the document's footnote styles where
+ * it defines them, and in superscript where it does not.
+ */
+export declare const insertFootnote: Command;
+/** Whether a footnote can go in at the end of the selection */
+export declare function canInsertFootnote(state: EditorState): boolean;
+/**
+ * Replaces what one footnote says with a `doc` node of `docxSchema`. It applies where an edit at
+ * the footnote's first reference would, and never to a separator, a footnote the text does not
+ * refer to, or a body saying what the footnote already says.
+ */
+export declare function setFootnoteBody(id: string, body: PMNode): Command;
+/**
+ * Puts the caret just after a footnote's reference and opens the footnote for editing, which is
+ * what a press on its number runs. It applies under every mode, since opening a note is reading
+ * it; a footnote opened where the body is shut takes no typing.
+ */
+export declare function openFootnote(id: string): Command;
+/**
+ * Puts an endnote reference at the end of the selection, calling a new, empty endnote, and asks
+ * for that endnote to be opened; `insertFootnote` for an endnote, which is drawn after the last
+ * paragraph of the document rather than at the foot of a page.
+ */
+export declare const insertEndnote: Command;
+/** Whether an endnote can go in at the end of the selection */
+export declare function canInsertEndnote(state: EditorState): boolean;
+/** Replaces what one endnote says with a `doc` node of `docxSchema`, as `setFootnoteBody` does */
+export declare function setEndnoteBody(id: string, body: PMNode): Command;
+/**
+ * Puts the caret just after an endnote's reference and opens the endnote for editing;
+ * `openFootnote` for an endnote, which stands at the end of the document, so this is also what
+ * takes a reader to it.
+ */
+export declare function openEndnote(id: string): Command;

package/dist/editor/commands/noteCommands.js

@@ -0,0 +1,95 @@
+// src/editor/commands/noteCommands.ts
+import {
+  newNoteStory,
+  nextNoteId,
+  noteNumberRunProps,
+  takenNoteIds
+} from "../../docx/notes/newNote.js";
+import { sameStory, setStory, storyKey, storyOf } from "../../docx/story.js";
+import { docxSchema } from "../../schema/index.js";
+import { guardedCommand } from "../../schema/guards.js";
+import { isWrapperType } from "../../schema/wrappers.js";
+import { documentOf } from "../editorDocument.js";
+import {
+  noteReferenceAt,
+  openNoteCommand,
+  requestNote
+} from "../plugins/noteNavigation.js";
+function wrappersBefore(doc, pos) {
+  const $pos = doc.resolve(pos);
+  return ($pos.nodeBefore?.marks ?? $pos.marks()).filter(
+    (mark) => isWrapperType(mark.type)
+  );
+}
+function insertNoteTransaction(state, kind) {
+  const at = state.selection.to;
+  const $at = state.doc.resolve(at);
+  const type = docxSchema.nodes.noteReference;
+  if (!$at.parent.canReplaceWith($at.index(), $at.index(), type)) return null;
+  const { formatting, reservedNoteKeys } = documentOf(state);
+  const id = nextNoteId(takenNoteIds(state.doc, kind, reservedNoteKeys));
+  const reference = type.create({ kind, id }, null, [
+    docxSchema.marks.run.create({ rPr: noteNumberRunProps(kind, formatting) }),
+    ...wrappersBefore(state.doc, at)
+  ]);
+  const key = storyKey(kind, id);
+  return requestNote(
+    setStory(
+      state.tr.insert(at, reference),
+      key,
+      newNoteStory(kind, formatting)
+    ),
+    key
+  );
+}
+function insertNoteCommand(kind) {
+  return guardedCommand((state) => insertNoteTransaction(state, kind));
+}
+function noteBodyTransaction(state, kind, id, body) {
+  const key = storyKey(kind, id);
+  if (body.type !== docxSchema.nodes.doc) return null;
+  if (documentOf(state).specialNotes.has(key)) return null;
+  const found = noteReferenceAt(state.doc, kind, id);
+  if (found === null) return null;
+  if (sameStory(storyOf(state.doc, key), body)) return null;
+  return setStory(state.tr, key, body).setNodeMarkup(
+    found.pos,
+    null,
+    found.node.attrs,
+    found.node.marks
+  );
+}
+function noteBodyCommand(kind, id, body) {
+  return guardedCommand((state) => noteBodyTransaction(state, kind, id, body));
+}
+var insertFootnote = insertNoteCommand("footnote");
+function canInsertFootnote(state) {
+  return insertFootnote(state);
+}
+function setFootnoteBody(id, body) {
+  return noteBodyCommand("footnote", id, body);
+}
+function openFootnote(id) {
+  return openNoteCommand("footnote", id);
+}
+var insertEndnote = insertNoteCommand("endnote");
+function canInsertEndnote(state) {
+  return insertEndnote(state);
+}
+function setEndnoteBody(id, body) {
+  return noteBodyCommand("endnote", id, body);
+}
+function openEndnote(id) {
+  return openNoteCommand("endnote", id);
+}
+export {
+  canInsertEndnote,
+  canInsertFootnote,
+  insertEndnote,
+  insertFootnote,
+  noteBodyCommand,
+  openEndnote,
+  openFootnote,
+  setEndnoteBody,
+  setFootnoteBody
+};

package/dist/editor/commands/noteQueries.d.ts

@@ -1,7 +1,9 @@
 /** Document-level readers for imported footnotes and endnotes. */
+import type { Node as PMNode } from "prosemirror-model";
 import type { EditorState } from "prosemirror-state";
 import { DecorationSet } from "prosemirror-view";
-import type { NoteKind } from "../../docx/notes";
+import { type StoryKey } from "../../docx/story";
+import type { NoteKind } from "../../schema/stories";
 export interface DocumentNote {
     readonly kind: NoteKind;
     readonly id: string;
@@ -9,6 +11,17 @@ export interface DocumentNote {
     readonly text: string;
     readonly referencePos: number;
 }
+/** One note the body refers to, as the notes drawn around the page draw it */
+export interface NoteRow {
+    readonly key: StoryKey;
+    readonly kind: NoteKind;
+    readonly id: string;
+    readonly label: string;
+    /** The note's story, the same node for as long as it says the same thing (`schema/stories`) */
+    readonly story: PMNode;
+    /** Where the first reference to it stands, which is the place in the text it is called from */
+    readonly referencePos: number;
+}
 interface NoteProjection {
     notes: readonly DocumentNote[];
     /**
@@ -17,11 +30,17 @@ interface NoteProjection {
      * says is a story on the document and not an attr of the reference.
      */
     tooltips: DecorationSet;
+    /** The footnotes whose story the document holds, by story key, in first-reference order */
+    footnotes: ReadonlyMap<StoryKey, NoteRow>;
+    /** The endnotes whose story the document holds, in first-reference order */
+    endnotes: readonly NoteRow[];
+    /** Every note of both kinds by story key, which the surface over the open note reads rows from */
+    rows: ReadonlyMap<StoryKey, NoteRow>;
 }
 /**
  * Which notes the document refers to is the document's to decide, so the list is worked out once
- * per edit (`editor/plugins/documentProjection`) rather than once per render of the panel under
- * the page.
+ * per edit (`editor/plugins/documentProjection`) rather than once per render of the notes drawn
+ * around the page.
  */
 export declare const noteProjection: import("../plugins/documentProjection").DocumentProjection<NoteProjection>;
 /** The distinct notes referenced by the main document story, in first-reference order. */

package/dist/editor/commands/noteQueries.js

@@ -8,35 +8,43 @@ function stringAttr(value) {
 function noteKindOf(node) {
   return node.attrs.kind === "endnote" ? "endnote" : "footnote";
 }
-function noteText(doc, kind, id) {
-  return storyText(storyOf(doc, storyKey(kind, id)));
-}
 function deriveNotes(doc) {
   const notes = [];
   const tooltips = [];
+  const footnotes = /* @__PURE__ */ new Map();
+  const endnotes = [];
+  const rows = /* @__PURE__ */ new Map();
   const seen = /* @__PURE__ */ new Set();
   doc.descendants((node, pos) => {
     if (node.type.name !== "noteReference") return true;
     const id = stringAttr(node.attrs.id);
     if (id === null) return true;
     const kind = noteKindOf(node);
-    const text = noteText(doc, kind, id);
+    const key = storyKey(kind, id);
+    const story = storyOf(doc, key);
+    const text = storyText(story);
     if (text !== "") {
       tooltips.push(Decoration.node(pos, pos + node.nodeSize, { title: text }));
     }
-    const key = `${kind}:${id}`;
     if (seen.has(key)) return true;
     seen.add(key);
-    notes.push({
-      kind,
-      id,
-      label: stringAttr(node.attrs.label) ?? "?",
-      text,
-      referencePos: pos
-    });
+    const label = stringAttr(node.attrs.label) ?? "?";
+    notes.push({ kind, id, label, text, referencePos: pos });
+    if (story !== null) {
+      const row = { key, kind, id, label, story, referencePos: pos };
+      rows.set(key, row);
+      if (kind === "footnote") footnotes.set(key, row);
+      else endnotes.push(row);
+    }
     return true;
   });
-  return { notes, tooltips: DecorationSet.create(doc, tooltips) };
+  return {
+    notes,
+    tooltips: DecorationSet.create(doc, tooltips),
+    footnotes,
+    endnotes,
+    rows
+  };
 }
 var noteProjection = documentProjection(
   "docxEditorNotes",

package/dist/editor/createEditor.js

@@ -6,6 +6,7 @@ import { keymap } from "prosemirror-keymap";
 import { EditorState } from "prosemirror-state";
 import { tableEditing } from "prosemirror-tables";
 import { EditorView } from "prosemirror-view";
+import { withNoteLabels } from "../docx/notes/numbering.js";
 import { pageDecorations } from "../page/pageDecorations.js";
 import { pageGeometryStyle, pagePixels } from "../page/pageLayout.js";
 import { editsShut } from "../schema/protectionState.js";
@@ -27,6 +28,7 @@ import { columnResize } from "./plugins/columnResize.js";
 import { commentComposer } from "./plugins/commentComposer.js";
 import { commentDecorations } from "./plugins/commentDecorations.js";
 import { commentRestoration } from "./plugins/commentRestoration.js";
+import { compositionSelection } from "./plugins/compositionSelection.js";
 import {
   displayDerivation,
   withDerivedDisplay
@@ -37,6 +39,9 @@ import { docxKeymap, historyKeys } from "./plugins/keymap.js";
 import { linkPanel } from "./plugins/linkPanel.js";
 import { listInputRules } from "./plugins/listInputRules.js";
 import { lockedContent } from "./plugins/lockedContent.js";
+import { noteLifecycle } from "./plugins/noteLifecycle.js";
+import { noteNavigation } from "./plugins/noteNavigation.js";
+import { noteNumbering } from "./plugins/noteNumbering.js";
 import { numberingMarkers } from "./plugins/numberingDecorations.js";
 import { rowResize } from "./plugins/rowResize.js";
 import { tabCaret } from "./plugins/tabCaret.js";
@@ -58,8 +63,13 @@ function createEditorState(doc, options = {}) {
   } = options;
   return EditorState.create({
     // The values the document arrived with were worked out against whatever opened it; the
-    // state's are worked out against its own snapshot, tables' shared lines included
-    doc: withDerivedDisplay(doc, document),
+    // state's are worked out against its own snapshot, tables' shared lines and note labels
+    // included
+    doc: withNoteLabels(
+      withDerivedDisplay(doc, document),
+      document.noteNumbering,
+      document.specialNotes
+    ),
     plugins: [
       // Consumer plugins lead the array. ProseMirror walks the plugins in order and takes the
       // first answer for a keypress, a paste, a drop or any other DOM event, so this is the
@@ -70,9 +80,12 @@ function createEditorState(doc, options = {}) {
       editorDocument(document),
       // Refuses every edit no guard in `schema/guards` lets through, whoever asked for it. It is
       // not optional: a document that locked a part of itself stays locked in every consumer, and
-      // the preserved bookmark markers and note references stay where the file put them.
+      // the preserved bookmark markers stay where the file put them.
       lockedContent(),
       documentProtection({ protection, author, editableComments }),
+      // Ahead of the keys and the clipboard: the plugin registered first sees a DOM event first,
+      // and this one hands every composition on
+      compositionSelection(),
       history(),
       keymap(docxKeymap),
       historyKeys(),
@@ -100,8 +113,13 @@ function createEditorState(doc, options = {}) {
       // A comment outlives the text it was written for: an edit that sweeps its reference away has
       // it put back where the deletion left, detached from the page (`plugins/commentRestoration`)
       commentRestoration(),
+      // A note goes with the last reference to it, and a copied reference gets a note of its own.
+      // It stands ahead of the numbering, which then labels what it settled
+      noteLifecycle(),
+      noteNumbering(),
       // What the notes under the page are, worked out from the document the same way
       noteProjection.plugin,
+      noteNavigation(),
       // Adjacent text tabs still need separate DOM ranges for layout and pointer selection.
       tabDecorations(),
       tabPointer(),

package/dist/editor/documentStyles.d.ts

@@ -36,6 +36,9 @@ export declare function documentGeometry(state: EditorState): PageGeometry;
  * section is where the document says it is, and the snapshot holds the first section's paper
  * alone. Reading it walks every block, so a caller drawing a whole document asks once and looks
  * its positions up (`page/pageLayout`) rather than calling this per block.
+ *
+ * A side story writes down no section, so its own blocks say nothing about the paper: what it is
+ * drawn on is the paper of the place it is called from, which its snapshot carries.
  */
 export declare function sectionGeometryAt(state: EditorState, pos: number): PageGeometry;
 /** The document-wide interval between automatic tab stops, in points. */

package/dist/editor/documentStyles.js

@@ -19,7 +19,8 @@ function documentGeometry(state) {
   return documentOf(state).geometry;
 }
 function sectionGeometryAt(state, pos) {
-  return sectionAt(state.doc, pos).props.geometry;
+  const document = documentOf(state);
+  return document.sideStory ? document.geometry : sectionAt(state.doc, pos).props.geometry;
 }
 function documentDefaultTabStopPt(state) {
   return documentOf(state).defaultTabStopPt;