@portone/docx-editor 0.4.0 → 0.5.0

package/dist/docx/comments/model.js

@@ -26,9 +26,6 @@ function importedCommentReplies(comments, rootId) {
       authorId: reply.authorId,
       initials: reply.initials,
       date: reply.date,
-      text: reply.text,
-      commentXml: reply.xml,
-      imported: true,
       paraId,
       parentParaId,
       extensionXml: reply.extensionXml
@@ -59,9 +56,6 @@ function replyData(value) {
         authorId: nullableString(entry.authorId),
         initials: nullableString(entry.initials),
         date: nullableString(entry.date),
-        text: nullableString(entry.text) ?? "",
-        commentXml: nullableString(entry.commentXml),
-        imported: entry.imported === true,
         paraId,
         parentParaId,
         extensionXml: nullableString(entry.extensionXml)
@@ -79,9 +73,6 @@ function referenceData(node) {
     authorId: nullableString(node.attrs.authorId),
     initials: nullableString(node.attrs.initials),
     date: nullableString(node.attrs.date),
-    text: nullableString(node.attrs.text) ?? "",
-    commentXml: nullableString(node.attrs.commentXml),
-    imported: node.attrs.imported === true,
     paraId: nullableString(node.attrs.paraId) ?? "00000001",
     resolved: node.attrs.resolved === true,
     extensionXml: nullableString(node.attrs.extensionXml),

package/dist/docx/comments/parts.d.ts

@@ -11,16 +11,17 @@
  * have made the change. Asking them as one would refuse a moderator rewriting somebody else's
  * comment under `editableComments: "all"`, which is a thing the editor lets them do.
  */
-import type { EditableComments } from "../../schema/protection";
+import { type EditableComments } from "../../schema/protection";
 import type { StoryPartKind } from "../protectionPolicy";
 import { type ImportedPeople } from "./people";
 /**
  * Whether this editor's writer could have put the entry out, whoever it belongs to.
  *
- * Shape alone: which attributes it carries and what stands inside it. Who may have written it is
- * `entryAllowed`'s question. Each kind is read where it is written (`./grammar`).
+ * Shape alone: which attributes it carries and what stands inside it, judged against the entry the
+ * original file held under the same id. Who may have written it is `entryAllowed`'s question.
+ * Each kind is read where it is written (`./grammar`).
  */
-export declare function wellFormedEntry(entry: Element): boolean;
+export declare function wellFormedEntry(entry: Element, original: Element | null): boolean;
 /**
  * Whether the only thing between the two is that a thread gained its key.
  *
@@ -34,13 +35,18 @@ export declare function threadKeyAlone(entry: Element, original: Element): boole
  * Whether `authorId` could have written or rewritten this entry.
  *
  * Permission alone: whether the shape is one this editor writes is `wellFormedEntry`'s question.
- * An entry that appeared has to be this author's. One that arrived keeps the identity it arrived
- * with; settling its thread or replying to it belong to everyone and leave what it says alone,
- * while rewriting what it says is its author's, a moderator's, or anyone's where no identity was
- * recorded for it. That last is the rule the editor holds to (`schema/protection`), and the two
- * have to answer alike or a file the editor wrote would be turned down here.
+ * An entry that appeared has to be one this author could have written, which
+ * `commentAdditionAllowed` decides here as it does over the story. One that arrived keeps the
+ * identity it arrived with; settling its thread or replying to it belong to everyone and leave
+ * what it says alone, while rewriting what it says is its author's, a moderator's, or anyone's
+ * where no identity was recorded for it. Both are the rules the editor holds to
+ * (`schema/protection`), and the two have to answer alike or a file the editor wrote would be
+ * turned down here.
+ *
+ * `unattributed` is read from the file that arrived, since it says what the submission is judged
+ * against; `people` is the submission's, since it says who the submission names.
  */
-export declare function entryAllowed(entry: Element, original: Element | null, authorId: string, editableComments: EditableComments, people: ImportedPeople): boolean;
+export declare function entryAllowed(entry: Element, original: Element | null, authorId: string, editableComments: EditableComments, people: ImportedPeople, unattributed: ReadonlySet<string>): boolean;
 export declare const commentsPart: StoryPartKind;
 export declare const commentsExtendedPart: StoryPartKind;
 export declare const peoplePart: StoryPartKind;

package/dist/docx/comments/parts.js

@@ -7,7 +7,16 @@ import {
   serializeXml,
   W_NS
 } from "../../ooxml/xml.js";
+import { isPreservedNode } from "../../schema/preservedFragments.js";
+import {
+  commentAdditionAllowed
+} from "../../schema/protection.js";
+import { NO_FORMATTING } from "../formatting.js";
+import { NO_IMPORT_SOURCES } from "../importParagraph.js";
 import { availablePartPath } from "../packageParts.js";
+import { serializeBlock } from "../serializeBlock.js";
+import { buildBlock } from "../story.js";
+import { isModelledBlock } from "../storyProjection.js";
 import {
   COMMENTS_CONTENT_TYPE,
   COMMENTS_EXTENDED_CONTENT_TYPE,
@@ -21,9 +30,11 @@ import {
 import {
   attributesWithin,
   COMMENT_ATTRIBUTES,
+  declarationsWritten,
   declarationWritten,
+  holdsElementsAndLayout,
+  isLayoutText,
   lastBodyParagraph,
-  readStrictCommentBody,
   recordedIdentity,
   wellFormedCommentExtension,
   wellFormedPerson
@@ -42,9 +53,46 @@ function sameAttributes(entry, original, names) {
     (name) => attributeByLocalName(entry, name) === attributeByLocalName(original, name)
   );
 }
-function wellFormedEntry(entry) {
+function holdsPreserved(node) {
+  if (isPreservedNode(node)) return true;
+  let found = false;
+  node.descendants((child) => {
+    if (isPreservedNode(child)) found = true;
+    return !found;
+  });
+  return found;
+}
+var BLOCK_DECLARATIONS = Object.entries(NAMESPACES).map(([prefix, uri]) => `xmlns:${prefix}="${uri}"`).join(" ");
+function normalizedBlock(xml) {
+  try {
+    const root = parseXml(
+      `<b ${BLOCK_DECLARATIONS}>${xml}</b>`
+    ).documentElement;
+    const [block] = Array.from(root.children);
+    return block === void 0 || root.children.length !== 1 ? null : serializeXml(block);
+  } catch {
+    return null;
+  }
+}
+function writtenBlock(el) {
+  if (!declarationsWritten(el)) return false;
+  const node = buildBlock(el, "", NO_IMPORT_SOURCES, NO_FORMATTING);
+  if (!isModelledBlock(node) || holdsPreserved(node)) return false;
+  const written = normalizedBlock(serializeBlock(node));
+  return written !== null && written === normalizedBlock(serializeXml(el));
+}
+function wellFormedStoryBody(entry, original) {
+  if (!holdsElementsAndLayout(entry)) return false;
+  const kept = new Set(
+    original === null ? [] : Array.from(original.children, serializeXml)
+  );
+  return Array.from(entry.children).every(
+    (block) => kept.has(serializeXml(block)) || writtenBlock(block)
+  );
+}
+function wellFormedEntry(entry, original) {
   if (entry.namespaceURI === W_NS && entry.localName === "comment") {
-    return attributesWithin(entry, COMMENT_ATTRIBUTES) && readStrictCommentBody(entry) !== null;
+    return attributesWithin(entry, COMMENT_ATTRIBUTES) && wellFormedStoryBody(entry, original);
   }
   if (entry.namespaceURI === W15_NS && entry.localName === "commentEx") {
     return wellFormedCommentExtension(entry);
@@ -67,11 +115,17 @@ function threadKeyAlone(entry, original) {
   const kept = before === null || after === before;
   return kept && withoutThreadKey(entry) === withoutThreadKey(original);
 }
-function entryAllowed(entry, original, authorId, editableComments, people) {
+function entryAllowed(entry, original, authorId, editableComments, people, unattributed) {
   if (entry.namespaceURI === W_NS && entry.localName === "comment") {
     const author = attributeByLocalName(entry, "author");
     const recorded = author === null ? null : commentAuthorId(people, author);
-    if (original === null) return recorded === authorId;
+    if (original === null) {
+      return commentAdditionAllowed(
+        { author, authorId: recorded },
+        authorId,
+        unattributed
+      );
+    }
     const paraId = lastParagraphId(original);
     if (!sameAttributes(entry, original, COMMENT_IDENTITY) || paraId !== null && lastParagraphId(entry) !== paraId) {
       return false;
@@ -83,23 +137,20 @@ function entryAllowed(entry, original, authorId, editableComments, people) {
     return sameAttributes(entry, original, ["paraId", "paraIdParent"]);
   }
   if (entry.namespaceURI === W15_NS && entry.localName === "person") {
-    return original === null && recordedIdentity(entry) === authorId;
+    const author = attributeByLocalName(entry, "author");
+    return original === null && recordedIdentity(entry) === authorId && author !== null && !unattributed.has(author);
   }
   return false;
 }
-var TEXT_NODE = 3;
 var COMPATIBILITY = /* @__PURE__ */ new Map([
   ["xmlns:w14", NAMESPACES.w14],
   ["xmlns:mc", NAMESPACES.mc]
 ]);
 var IGNORABLE = "mc:Ignorable";
 var IGNORED = "w14";
-function isLayout(node) {
-  return node.nodeType === TEXT_NODE && /^[ \t\r\n]*$/.test(node.nodeValue ?? "");
-}
 function surroundingNodes(parent) {
   return parent === null ? [] : Array.from(parent.childNodes).filter(
-    (node) => !isElement(node) && !isLayout(node)
+    (node) => !isElement(node) && !isLayoutText(node)
   );
 }
 function sameNodes(now, was) {
@@ -192,12 +243,13 @@ function storyPart(shape) {
     referents: shape.referents,
     wellFormed: wellFormedEntry,
     anyonesChange: threadKeyAlone,
-    allowed: (entry, original, authorId, options, session) => entryAllowed(
+    allowed: (entry, original, authorId, options, session, unattributed) => entryAllowed(
       entry,
       original,
       authorId,
       options.editableComments,
-      session.comments.people
+      session.comments.people,
+      unattributed
     )
   };
 }

package/dist/docx/comments/people.d.ts

@@ -8,6 +8,8 @@
  * part by, so a name stands for one identity per file: a name the part already records is read as
  * it stands and never appended to. Appending a second person for it would leave a file naming two
  * identities for one name, where a reader keying by name hands one author's comments to the other.
+ * A name the file's comments already write under carries the same weight, recorded or not: a
+ * person appended for it would claim those comments too.
  */
 import type { PartPlanContext } from "../partPlan";
 import type { StoryPartKind } from "../protectionPolicy";
@@ -33,10 +35,16 @@ export declare function readPeople(parts: Map<string, Uint8Array>, mainPartPath:
  */
 export declare function commentAuthorId(people: ImportedPeople, author: string): string | null;
 /**
- * The authors the part records no person for at all, each under the name they write as. A name it
- * already records is left as it stands, whichever provider recorded it and whatever it resolves to.
+ * The authors to record a person for, each under the name they write as: the ones the comments
+ * name one identity for and the part does not record already. A name the part records is left as
+ * it stands, whichever provider recorded it and whatever it resolves to. So is a name the comments
+ * carry under more than one identity, one identity and none among them: recording it would hand
+ * the comments carrying no identity to whoever the name then resolved to, and a document saved by
+ * a Word that wrote no people part carries every one of its comments that way.
+ * `unattributed` also reserves names from the original Comments part, including preserved entries
+ * the current editable bodies do not carry. The planner and export invariants use this same set.
  */
-export declare function unrecordedAuthors(bodies: Iterable<CommentReferenceData | CommentReplyData>, people: ImportedPeople): Map<string, string>;
+export declare function unrecordedAuthors(bodies: Iterable<CommentReferenceData | CommentReplyData>, people: ImportedPeople, unattributed: ReadonlySet<string>): Map<string, string>;
 /**
  * Plans the people part, its relationship and its content type for every identity the current
  * comments carry that the document has not recorded. Null when it has recorded them all, which

package/dist/docx/comments/people.js

@@ -10,6 +10,7 @@ import {
   encodeUtf8,
   parseXml
 } from "../../ooxml/xml.js";
+import { unattributedCommentAuthors } from "../../schema/protection.js";
 import { relatedPartPath } from "../packageParts.js";
 import { directoryOf } from "../relationships.js";
 import { COMMENT_AUTHOR_PROVIDER, PEOPLE_REL_TYPE, W15_NS } from "./constants.js";
@@ -51,12 +52,21 @@ function readPeople(parts, mainPartPath) {
 function commentAuthorId(people, author) {
   return people.byAuthor.get(author) ?? null;
 }
-function unrecordedAuthors(bodies, people) {
-  const unrecorded = /* @__PURE__ */ new Map();
+function unrecordedAuthors(bodies, people, unattributed) {
+  const identities = /* @__PURE__ */ new Map();
   for (const body of bodies) {
-    if (body.author === null || body.authorId === null) continue;
-    if (people.byAuthor.has(body.author)) continue;
-    unrecorded.set(body.author, body.authorId);
+    if (body.author === null) continue;
+    if (people.byAuthor.has(body.author) || unattributed.has(body.author))
+      continue;
+    const ids = identities.get(body.author) ?? /* @__PURE__ */ new Set();
+    ids.add(body.authorId);
+    identities.set(body.author, ids);
+  }
+  const unrecorded = /* @__PURE__ */ new Map();
+  for (const [author, ids] of identities) {
+    if (ids.size !== 1) continue;
+    const only = Array.from(ids)[0] ?? null;
+    if (only !== null) unrecorded.set(author, only);
   }
   return unrecorded;
 }
@@ -94,7 +104,11 @@ function peopleXml(people, added) {
 }
 function planPeoplePart(part, bodies, session, context) {
   const people = session.comments.people;
-  const added = unrecordedAuthors(bodies, people);
+  const added = unrecordedAuthors(
+    bodies,
+    people,
+    unattributedCommentAuthors(session.comments.ordered)
+  );
   if (added.size === 0) return null;
   const parts = /* @__PURE__ */ new Map();
   const addingPart = part.pathIn(session) === null;

package/dist/docx/comments/policy.js

@@ -3,6 +3,7 @@ import {
   commentAdditionsBy,
   commentEditsOwned,
   commentIdentitiesKept,
+  unattributedCommentAuthors,
   withoutComments
 } from "../../schema/protection.js";
 import {
@@ -18,7 +19,12 @@ function sameBody(before, after) {
 }
 function commentsStoryKept(before, after, authorId, { editableComments }) {
   if (!sameBody(before, after)) return refused("body-changed");
-  if (!commentIdentitiesKept(before.doc, after.doc) || !commentAdditionsBy(before.doc, after.doc, authorId)) {
+  if (!commentIdentitiesKept(before.doc, after.doc) || !commentAdditionsBy(
+    before.doc,
+    after.doc,
+    authorId,
+    unattributedCommentAuthors(before.session.comments.ordered)
+  )) {
     return refused("comment-author-forged");
   }
   if (!commentEditsOwned(before.doc, after.doc, {

package/dist/docx/comments/reading.d.ts

@@ -2,6 +2,10 @@
  * Reads comment and comment-extension package parts.
  */
 import { type ImportedPeople } from "./people";
+/**
+ * One entry of the Comments part as it arrived, everything about it but what it says: that is a
+ * story of its own, sliced and read the way a body block is (`docx/story`).
+ */
 export interface ImportedComment {
     id: string;
     author: string | null;
@@ -13,8 +17,6 @@ export interface ImportedComment {
     authorId: string | null;
     initials: string | null;
     date: string | null;
-    text: string;
-    xml: string;
     paraId: string | null;
     parentParaId: string | null;
     resolved: boolean;

package/dist/docx/comments/reading.js

@@ -4,8 +4,7 @@ import {
   decodeUtf8,
   elementChildren,
   parseXml,
-  serializeXml,
-  W_NS
+  serializeXml
 } from "../../ooxml/xml.js";
 import { relatedPartPath } from "../packageParts.js";
 import { COMMENTS_EXTENDED_REL_TYPE, COMMENTS_REL_TYPE } from "./constants.js";
@@ -15,16 +14,6 @@ import {
   NO_PEOPLE,
   readPeople
 } from "./people.js";
-function inlineCommentText(node) {
-  if (node.localName === "t") return node.textContent ?? "";
-  if (node.localName === "tab") return "	";
-  if (node.localName === "br" || node.localName === "cr") return "\n";
-  return elementChildren(node).map(inlineCommentText).join("");
-}
-function commentText(el) {
-  const paragraphs = Array.from(el.getElementsByTagNameNS(W_NS, "p"));
-  return paragraphs.map(inlineCommentText).join("\n");
-}
 var NO_COMMENTS = {
   partPath: null,
   xml: null,
@@ -117,8 +106,6 @@ function readComments(parts, mainPartPath) {
         authorId: author === null ? null : commentAuthorId(people, author),
         initials: attributeByLocalName(el, "initials"),
         date: attributeByLocalName(el, "date"),
-        text: commentText(el),
-        xml: serializeXml(el),
         paraId,
         parentParaId: extension?.parentParaId ?? null,
         resolved: extension?.resolved ?? false,

package/dist/docx/comments/writing.js

@@ -1,5 +1,5 @@
 // src/docx/comments/writing.ts
-import { elementXml } from "../../ooxml/element.js";
+import { attrsText } from "../../ooxml/element.js";
 import { NAMESPACES, wName, xmlnsDecl } from "../../ooxml/names.js";
 import {
   ensureRootDeclarations,
@@ -7,10 +7,18 @@ import {
   splicePart
 } from "../../ooxml/partSplice.js";
 import { encodeUtf8 } from "../../ooxml/xml.js";
+import { sameSource } from "../../schema/sourceEquality.js";
+import { NO_EXPORT_REFS } from "../exportRefs.js";
 import { directoryOf } from "../relationships.js";
+import { serializeStory } from "../serializeStory.js";
+import {
+  storyFromText,
+  storyKey,
+  storyOf,
+  withThreadKeyOn
+} from "../story.js";
 import {
   arrivedEntries,
-  renderCommentBody,
   renderCommentExtension,
   withThreadKey
 } from "./grammar.js";
@@ -20,7 +28,26 @@ import {
 import { commentsExtendedPart, commentsPart, peoplePart } from "./parts.js";
 import { planPeoplePart } from "./people.js";
 function needsThreadKey(id, comment, session) {
-  return comment.imported && carriesThreadMetadata(comment) && (session.comments.byId.get(id)?.paraId ?? null) === null;
+  return session.comments.byId.has(id) && carriesThreadMetadata(comment) && (session.comments.byId.get(id)?.paraId ?? null) === null;
+}
+function bodyStory(doc, id) {
+  return storyOf(doc, storyKey("comment", id));
+}
+function importedBody(session, id) {
+  return session.stories.get(storyKey("comment", id)) ?? null;
+}
+function importedEntry(comment, session) {
+  const arrived = session.comments.byId.get(comment.id);
+  if (arrived === void 0 || arrived.author !== comment.author || arrived.date !== comment.date || arrived.initials !== comment.initials) {
+    return null;
+  }
+  return importedBody(session, comment.id);
+}
+function bodyKept(doc, comment, session) {
+  const imported = importedEntry(comment, session);
+  if (imported === null) return null;
+  const current = bodyStory(doc, comment.id);
+  return current === null || sameSource(current, imported.doc) ? imported : null;
 }
 function commentsChanged(doc, session) {
   const current = commentReferencesIn(doc);
@@ -34,12 +61,8 @@ function commentsChanged(doc, session) {
   for (const id of originalBodies) {
     if (!currentBodies.has(id)) return true;
   }
-  for (const id of session.commentReferenceIds) {
-    const comment = current.get(id);
-    if (!comment?.imported) return true;
-  }
-  for (const comment of current.values()) {
-    if (comment.replies.some((reply) => !reply.imported)) return true;
+  for (const comment of currentBodies.values()) {
+    if (bodyKept(doc, comment, session) === null) return true;
   }
   for (const [id, comment] of current) {
     if (needsThreadKey(id, comment, session)) return true;
@@ -111,27 +134,34 @@ function carriesThreadMetadata(comment) {
 function keyedEntry(comment, arrivedKeyed) {
   return carriesThreadMetadata(comment) || arrivedKeyed.has(comment.id);
 }
-function renderedComment(comment, arrivedKeyed, arrived) {
-  if (comment.imported && comment.commentXml !== null) {
-    return carriesThreadMetadata(comment) ? withThreadKey(
-      comment.commentXml,
-      comment.paraId,
-      arrived.get(comment.id) ?? null
-    ) : comment.commentXml;
-  }
+function writtenContainer(comment) {
   const attrs = [
     [wName("id"), comment.id],
     comment.author === null ? null : [wName("author"), comment.author],
     comment.date === null ? null : [wName("date"), comment.date],
     comment.initials === null ? null : [wName("initials"), comment.initials]
   ];
-  const paraId = keyedEntry(comment, arrivedKeyed) ? comment.paraId : null;
-  const body = renderCommentBody(comment.text, paraId);
-  return elementXml(
-    wName("comment"),
-    attrs.filter((attr) => attr !== null),
-    [body]
+  const text = attrsText(
+    attrs.filter((attr) => attr !== null)
   );
+  return {
+    open: text === "" ? `<${wName("comment")}>` : `<${wName("comment")} ${text}>`,
+    close: `</${wName("comment")}>`
+  };
+}
+function renderedComment(comment, arrivedKeyed, arrived, doc, session) {
+  const kept = bodyKept(doc, comment, session);
+  if (kept !== null) {
+    return carriesThreadMetadata(comment) ? withThreadKey(kept.xml, comment.paraId, arrived.get(comment.id) ?? null) : kept.xml;
+  }
+  const paraId = keyedEntry(comment, arrivedKeyed) ? comment.paraId : null;
+  const entry = importedEntry(comment, session);
+  const said = bodyStory(doc, comment.id) ?? storyFromText("");
+  const body = paraId === null ? said : withThreadKeyOn(said, paraId);
+  return serializeStory(body, null, entry ?? writtenContainer(comment), {
+    ...NO_EXPORT_REFS,
+    session
+  });
 }
 var COMMENT_MARKUP = { namespaces: { w: NAMESPACES.w } };
 var THREAD_MARKUP = {
@@ -160,7 +190,8 @@ function originalThreadIds(comments, rootIds) {
   }
   return ids;
 }
-function commentsXml(references, comments, originallyReferenced) {
+function commentsXml(doc, session, references, originallyReferenced) {
+  const comments = session.comments;
   const currentBodies = currentCommentBodies(references);
   const arrivedKeyed = new Set(
     Array.from(comments.byId.values()).flatMap(
@@ -175,20 +206,26 @@ function commentsXml(references, comments, originallyReferenced) {
   const pieces = [];
   const written = /* @__PURE__ */ new Set();
   for (const original of comments.ordered) {
+    if (written.has(original.id)) continue;
     const current = currentBodies.get(original.id);
     if (current) {
-      pieces.push(renderedComment(current, arrivedKeyed, arrived));
+      pieces.push(
+        renderedComment(current, arrivedKeyed, arrived, doc, session)
+      );
       written.add(original.id);
       continue;
     }
     if (!originalThreads.has(original.id)) {
-      pieces.push(original.xml);
+      const story = importedBody(session, original.id);
+      if (story !== null) pieces.push(story.xml);
       written.add(original.id);
     }
   }
   for (const [id, comment] of currentBodies) {
     if (!written.has(id)) {
-      pieces.push(renderedComment(comment, arrivedKeyed, arrived));
+      pieces.push(
+        renderedComment(comment, arrivedKeyed, arrived, doc, session)
+      );
     }
   }
   if (comments.xml === null) {
@@ -221,7 +258,7 @@ function planCommentParts(doc, session, context) {
     parts.set(
       partPath,
       encodeUtf8(
-        commentsXml(references, session.comments, session.commentReferenceIds),
+        commentsXml(doc, session, references, session.commentReferenceIds),
         session.comments.hadBom
       )
     );

package/dist/docx/exportDocx.js

@@ -10,12 +10,12 @@ import {
   W_NS,
   withXmlParser
 } from "../ooxml/xml.js";
-import { sameSource } from "../schema/sourceEquality.js";
 import { commentsPlanner } from "./comments.js";
 import { repackParts } from "./container.js";
 import {
   fidelityNotesOf
 } from "./fidelity.js";
+import { headerFooterPlanner } from "./headersFooters.js";
 import { hyperlinkRefs } from "./hyperlink.js";
 import { withUniqueIdentities } from "./identities.js";
 import { problemsOf } from "./invariants.js";
@@ -31,21 +31,15 @@ import {
   relationshipWriter,
   relsPathOf
 } from "./relationships.js";
-import { serializeBlock } from "./serializeBlock.js";
-import {
-  originalBlock,
-  sessionOf
-} from "./session.js";
-function blockXml(node, session, refs) {
-  const imported = originalBlock(node, session);
-  if (imported && sameSource(node, imported.node)) return imported.xml;
-  return serializeBlock(node, session, refs);
-}
+import { blockXml } from "./serializeBlock.js";
+import { sessionOf } from "./session.js";
 function buildDocumentXml(doc, session, refs) {
   const pieces = [session.documentPrefix];
   withUniqueIdentities(doc).forEach((child) => {
-    pieces.push(blockXml(child, session, refs));
+    pieces.push(blockXml(child, refs, doc.childCount === 1));
   });
+  const sectPr = doc.attrs.sectPr;
+  if (typeof sectPr === "string") pieces.push(sectPr);
   pieces.push(session.documentSuffix);
   return pieces.join("");
 }
@@ -113,7 +107,8 @@ function assertMainPart(documentXml, wroteLinks) {
 var LINK_MARKUP = { namespaces: { r: R_NS } };
 var PART_PLANNERS = [
   numberingPlanner,
-  commentsPlanner
+  commentsPlanner,
+  headerFooterPlanner
 ];
 function exportDocx(doc, session, options) {
   return exportDocxReport(doc, session, options).bytes;
@@ -153,7 +148,8 @@ function writeDocx(doc, store, notes, planners) {
   const body = buildDocumentXml(doc, store, {
     images: media?.refs ?? NO_IMAGE_REFS,
     links,
-    notes
+    notes,
+    session: store
   });
   const documentXml = links.addedRelId() ? ensureRootDeclarations(body, LINK_MARKUP) : body;
   assertMainPart(documentXml, links.addedRelId());

package/dist/docx/exportRefs.d.ts

@@ -1,19 +1,24 @@
 /**
  * What the serializers need from the rest of the package while a body is being written: which
  * relationship an inserted image ended up on (`docx/media`), which one each link's address lives
- * on (`docx/hyperlink`), and where to record an approximation a writer had to make
- * (`docx/fidelity`).
+ * on (`docx/hyperlink`), where to record an approximation a writer had to make (`docx/fidelity`),
+ * and the fragments the document was opened from (`docx/session`).
  *
  * They travel as one value so that a serializer taking a body apart passes on everything the
- * pieces of it may need, whatever a later kind of content turns out to require.
+ * pieces of it may need, whatever a later kind of content turns out to require. The session is
+ * among them because a preserved block names the fragment it stands for wherever it ends up: an
+ * edit may move one into a table cell, and the cell writer has no other way to reach the original.
  */
 import { type FidelityCollector } from "./fidelity";
 import { type LinkRefs } from "./hyperlink";
 import { type ImageRefs } from "./media";
+import type { SessionStore } from "./session";
 export interface ExportRefs {
     images: ImageRefs;
     links: LinkRefs;
     notes: FidelityCollector;
+    /** null for a serializer called on a document nobody opened */
+    session: SessionStore | null;
 }
 /** What a serializer called on its own, outside an export, has to work with */
 export declare const NO_EXPORT_REFS: ExportRefs;

package/dist/docx/exportRefs.js

@@ -5,7 +5,8 @@ import { NO_IMAGE_REFS } from "./media.js";
 var NO_EXPORT_REFS = {
   images: NO_IMAGE_REFS,
   links: NO_LINK_REFS,
-  notes: NO_FIDELITY_COLLECTOR
+  notes: NO_FIDELITY_COLLECTOR,
+  session: null
 };
 export {
   NO_EXPORT_REFS