@portone/docx-editor 0.3.0 → 0.5.0

package/dist/docx/invariants.js

@@ -1,11 +1,13 @@
 // src/docx/invariants.ts
-import { spanCount } from "../model/format.js";
+import { spanCount, toParagraphFormat } from "../model/format.js";
 import {
   attributeByLocalName,
   parseXml,
   W_NS,
   withXmlParser
 } from "../ooxml/xml.js";
+import { visitPreservedFragments } from "../schema/preservedFragments.js";
+import { unattributedCommentAuthors } from "../schema/protection.js";
 import {
   commentReferencesIn,
   commentsChanged,
@@ -22,32 +24,23 @@ import { unrecordedAuthors } from "./comments/people.js";
 import { currentCommentBodies } from "./comments/writing.js";
 import { identityProblems } from "./identities.js";
 import { insertedImageSrcs } from "./media.js";
-import { newNumIds, numberingPartOf } from "./newLists.js";
+import { canDefineNewList, newNumIds, startedLists } from "./newLists.js";
 import { CONTENT_TYPES_PATH } from "./packageParts.js";
-import { lostOriginal } from "./serializeBlock.js";
+import { lostOriginal } from "./serializePreserved.js";
 import {
   originalBlock,
   sessionOf
 } from "./session.js";
-function markerSourceOf(node, session) {
-  if (node.type.name === "rawInline" || node.type.name === "rawBlock") {
-    return typeof node.attrs.xml === "string" ? node.attrs.xml : null;
-  }
-  if (node.type.isInGroup("preserved")) {
-    return originalBlock(node, session)?.xml ?? null;
-  }
-  return null;
-}
 var bookmarkPairs = {
   name: "bookmarkPairs",
   check(doc, session) {
     const problems = [];
     const open = /* @__PURE__ */ new Map();
     const used = /* @__PURE__ */ new Set();
-    doc.descendants((node, pos) => {
-      const source = markerSourceOf(node, session);
-      if (source === null) return true;
-      if (!source.includes("bookmark")) return true;
+    visitPreservedFragments(doc, (node, pos, xml) => {
+      const source = xml ?? originalBlock(node, session)?.xml ?? null;
+      if (source === null) return;
+      if (!source.includes("bookmark")) return;
       let root;
       try {
         root = parseXml(
@@ -59,7 +52,7 @@ var bookmarkPairs = {
           message: "preserved bookmark XML could not be parsed",
           pos
         });
-        return true;
+        return;
       }
       for (const marker of Array.from(root.getElementsByTagName("*"))) {
         if (marker.namespaceURI !== W_NS || marker.localName !== "bookmarkStart" && marker.localName !== "bookmarkEnd")
@@ -91,7 +84,6 @@ var bookmarkPairs = {
           });
         }
       }
-      return true;
     });
     for (const [id, pos] of open) {
       problems.push({
@@ -132,11 +124,16 @@ var tableGrids = {
     return problems;
   }
 };
+var CARRIES_ITS_XML = /* @__PURE__ */ new Set([
+  "rawInline",
+  "rawRunContent"
+]);
 function lostOriginalOf(node, session) {
-  if (node.type.name === "rawInline" || node.type.name === "rawBlock") {
+  if (CARRIES_ITS_XML.has(node.type.name)) {
     return typeof node.attrs.xml === "string" ? null : "a preserved element has lost its original XML";
   }
   if (node.type.isInGroup("preserved")) {
+    if (typeof node.attrs.xml === "string") return null;
     return originalBlock(node, session) ? null : lostOriginal(node, session);
   }
   return null;
@@ -160,17 +157,24 @@ var uniqueIdentities = {
     return identityProblems(doc);
   }
 };
-var numberingPart = {
-  name: "numberingPart",
+var listDefinitions = {
+  name: "listDefinitions",
   check(doc, session) {
-    if (numberingPartOf(session) !== null) return [];
-    if (newNumIds(doc, session).length === 0) return [];
-    return [
-      {
-        code: "missing-numbering-part",
-        message: "cannot add a new list to a document that has no numbering.xml"
-      }
-    ];
+    const undefinedIds = new Set(startedLists(doc, session).unregistered);
+    if (undefinedIds.size === 0) return [];
+    const problems = [];
+    doc.descendants((node, pos) => {
+      if (node.type.name !== "paragraph") return true;
+      const numId = toParagraphFormat(node.attrs.format)?.numbering?.numId;
+      if (numId === void 0 || !undefinedIds.delete(numId)) return false;
+      problems.push({
+        code: "unsupported-content",
+        message: `the list numbered ${numId} has no definition to be written`,
+        pos
+      });
+      return false;
+    });
+    return problems;
   }
 };
 function addsCommentsPart(doc, session) {
@@ -184,7 +188,8 @@ function addsCommentsPart(doc, session) {
     return true;
   return bodyChanged && (peoplePart.pathIn(session) === null || session.comments.people.xml === null) && unrecordedAuthors(
     currentCommentBodies(references).values(),
-    session.comments.people
+    session.comments.people,
+    unattributedCommentAuthors(session.comments.ordered)
   ).size > 0;
 }
 var mediaContentTypes = {
@@ -198,6 +203,12 @@ var mediaContentTypes = {
         message: `cannot add an image to a package that has no ${CONTENT_TYPES_PATH}`
       });
     }
+    if (!canDefineNewList(session) && newNumIds(doc, session).length > 0) {
+      problems.push({
+        code: "missing-content-types",
+        message: `cannot add a part to a package that has no ${CONTENT_TYPES_PATH}`
+      });
+    }
     if (addsCommentsPart(doc, session)) {
       problems.push({
         code: "missing-content-types",
@@ -230,7 +241,7 @@ var EXPORT_INVARIANTS = [
   tableGrids,
   preservedOriginals,
   uniqueIdentities,
-  numberingPart,
+  listDefinitions,
   mediaContentTypes,
   commentPartRoots
 ];

package/dist/docx/newLists.d.ts

@@ -5,7 +5,16 @@
  * writer rather than being read off it.
  */
 import type { Node as PMNode } from "prosemirror-model";
+import { type NewList } from "../numbering/parseNumbering";
 import type { SessionStore } from "./session";
+/**
+ * How the main part relates the numbering part, and what the package declares that part to hold.
+ *
+ * The reader finds the part by this relationship and the writer relates a new one under it, so
+ * neither can name it differently from the other.
+ */
+export declare const NUMBERING_REL_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering";
+export declare const NUMBERING_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml";
 /**
  * The numbering ids that appeared during editing and have no definition.
  *
@@ -13,8 +22,29 @@ import type { SessionStore } from "./session";
  * because exporting such a document without editing it must not disturb numbering.xml.
  */
 export declare function newNumIds(doc: PMNode, session: SessionStore): number[];
+/** The lists started during editing, split by whether a definition was registered for each */
+export interface StartedLists {
+    /** The definition each list was started with, which is what goes into numbering.xml */
+    readonly defined: ReadonlyMap<number, NewList>;
+    /** The numbers a list was started under that no definition stands behind */
+    readonly unregistered: readonly number[];
+}
+/**
+ * The lists started during editing, each against the definition it was started with.
+ *
+ * The definition is the one the document node carries (`numbering/listRegistry`), which the list
+ * commands and the clipboard record as they start a list. A number carrying none is reported here
+ * rather than written bare, which the export invariants turn into a refusal.
+ */
+export declare function startedLists(doc: PMNode, session: SessionStore): StartedLists;
 /** The numbering part as it was opened, which a new definition is spliced into. null when the document has none */
 export declare function numberingPartOf(session: SessionStore): {
     path: string;
     bytes: Uint8Array;
 } | null;
+/**
+ * Whether the definition of a new list has somewhere to go: the numbering part the document was
+ * opened with, or one written from scratch, which only a package that can declare what the new
+ * part holds may take.
+ */
+export declare function canDefineNewList(session: SessionStore): boolean;

package/dist/docx/newLists.js

@@ -1,6 +1,11 @@
 // src/docx/newLists.ts
 import { toParagraphFormat } from "../model/format.js";
+import { NEW_LISTS_ATTR, newListsOf } from "../numbering/listRegistry.js";
 import { parseNumbering } from "../numbering/parseNumbering.js";
+import { R_NS } from "../ooxml/xml.js";
+import { CONTENT_TYPES_PATH } from "./packageParts.js";
+var NUMBERING_REL_TYPE = `${R_NS}/numbering`;
+var NUMBERING_CONTENT_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml";
 function collectNumIds(node, into) {
   const visit = (candidate) => {
     if (candidate.type.name !== "paragraph") return true;
@@ -25,12 +30,30 @@ function newNumIds(doc, session) {
   const atOpen = numIdsAtOpen(session);
   return Array.from(numIdsIn(doc)).filter((numId) => !defined.has(numId) && !atOpen.has(numId)).sort((a, b) => a - b);
 }
+function startedLists(doc, session) {
+  const registered = newListsOf(doc.attrs[NEW_LISTS_ATTR]);
+  const defined = /* @__PURE__ */ new Map();
+  const unregistered = [];
+  for (const numId of newNumIds(doc, session)) {
+    const list = registered.get(numId);
+    if (list === void 0) unregistered.push(numId);
+    else defined.set(numId, list);
+  }
+  return { defined, unregistered };
+}
 function numberingPartOf(session) {
   const path = session.numberingPartPath;
   const bytes = path === null ? void 0 : session.parts.get(path);
   return path === null || bytes === void 0 ? null : { path, bytes };
 }
+function canDefineNewList(session) {
+  return numberingPartOf(session) !== null || session.parts.has(CONTENT_TYPES_PATH);
+}
 export {
+  NUMBERING_CONTENT_TYPE,
+  NUMBERING_REL_TYPE,
+  canDefineNewList,
   newNumIds,
-  numberingPartOf
+  numberingPartOf,
+  startedLists
 };

package/dist/docx/notes.d.ts

@@ -1,14 +1,19 @@
 /** Reads footnote and endnote bodies related from the main document story. */
 export type NoteKind = "footnote" | "endnote";
+/**
+ * One entry of a notes part as it arrived. What the note says is a story of its own, held on the
+ * document node under `footnote:<id>` or `endnote:<id>` (`docx/story`).
+ */
 export interface ImportedNote {
     kind: NoteKind;
     id: string;
     label: string;
-    text: string;
     type: string | null;
 }
 export interface ImportedNotePart {
     partPath: string | null;
+    /** The raw text of the part, which is what the note stories are sliced out of. null for none */
+    xml: string | null;
     ordered: readonly ImportedNote[];
     byId: ReadonlyMap<string, ImportedNote>;
 }

package/dist/docx/notes.js

@@ -4,12 +4,12 @@ import {
   decodeUtf8,
   elementChildren,
   parseXml,
-  R_NS,
-  W_NS
+  R_NS
 } from "../ooxml/xml.js";
 import { relatedPartPath } from "./packageParts.js";
 var EMPTY_PART = {
   partPath: null,
+  xml: null,
   ordered: [],
   byId: /* @__PURE__ */ new Map()
 };
@@ -17,23 +17,13 @@ var NO_NOTES = {
   footnotes: EMPTY_PART,
   endnotes: EMPTY_PART
 };
-function inlineText(node) {
-  if (node.localName === "t") return node.textContent ?? "";
-  if (node.localName === "tab") return "	";
-  if (node.localName === "br" || node.localName === "cr") return "\n";
-  if (node.localName === "noBreakHyphen") return "\u2011";
-  if (node.localName === "softHyphen") return "\xAD";
-  return elementChildren(node).map(inlineText).join("");
-}
-function noteText(el) {
-  return Array.from(el.getElementsByTagNameNS(W_NS, "p")).map(inlineText).join("\n");
-}
 function notePart(parts, mainPartPath, kind) {
   const partPath = relatedPartPath(parts, mainPartPath, `${R_NS}/${kind}s`);
   if (partPath === null) return EMPTY_PART;
   const bytes = parts.get(partPath);
   if (!bytes) return { ...EMPTY_PART, partPath };
-  const root = parseXml(decodeUtf8(bytes).text).documentElement;
+  const xml = decodeUtf8(bytes).text;
+  const root = parseXml(xml).documentElement;
   const elements = elementChildren(root).filter((el) => el.localName === kind);
   const ordered = elements.flatMap((el) => {
     const id = attributeByLocalName(el, "id");
@@ -41,13 +31,13 @@ function notePart(parts, mainPartPath, kind) {
     const type = attributeByLocalName(el, "type");
     const regular = type === null || type === "normal";
     const label = regular ? "?" : "";
-    return [{ kind, id, label, text: noteText(el), type }];
+    return [{ kind, id, label, type }];
   });
   const byId = /* @__PURE__ */ new Map();
   for (const note of ordered) {
     if (!byId.has(note.id)) byId.set(note.id, note);
   }
-  return { partPath, ordered, byId };
+  return { partPath, xml, ordered, byId };
 }
 function readNotes(parts, mainPartPath) {
   return {

package/dist/docx/numberingPlanner.d.ts

@@ -1,8 +1,11 @@
 /**
- * The numbering part with the definition of every list started during editing spliced in.
+ * The numbering part with the definition every list started during editing was started with
+ * spliced in, and the part itself when the document arrived without one.
  *
- * The original text is left as is and only the new definitions go in. Nothing is written when no
- * list was started.
+ * The original text is left as is and only the new definitions go in. A document that has no
+ * numbering part gets one written from scratch, with the relationship that finds it and the
+ * declaration of what it holds asked of the context, so the first list a document takes costs it
+ * nothing outside this planner. Nothing is written when no list was started.
  */
 import type { PartPlanner } from "./partPlan";
 export declare const numberingPlanner: PartPlanner;

package/dist/docx/numberingPlanner.js

@@ -1,17 +1,48 @@
 // src/docx/numberingPlanner.ts
 import { addListDefinitions } from "../numbering/writeNumbering.js";
+import { elementXml, xmlnsAttr } from "../ooxml/element.js";
+import { NAMESPACES, wName } from "../ooxml/names.js";
+import { ensureRootDeclarations } from "../ooxml/partSplice.js";
 import { decodeUtf8, encodeUtf8 } from "../ooxml/xml.js";
-import { newNumIds, numberingPartOf } from "./newLists.js";
+import {
+  NUMBERING_CONTENT_TYPE,
+  NUMBERING_REL_TYPE,
+  numberingPartOf,
+  startedLists
+} from "./newLists.js";
+import { availablePartPath } from "./packageParts.js";
+import { directoryOf } from "./relationships.js";
+function emptyNumberingPart() {
+  return '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>' + elementXml(wName("numbering"), [xmlnsAttr("w")]);
+}
 var numberingPlanner = {
   name: "numbering",
-  plan(doc, session) {
-    const added = newNumIds(doc, session);
+  plan(doc, session, context) {
+    const { defined } = startedLists(doc, session);
+    if (defined.size === 0) return null;
     const original = numberingPartOf(session);
-    if (added.length === 0 || original === null) return null;
+    if (original === null) {
+      const path = session.numberingPartPath ?? availablePartPath(session.parts, session.mainPartPath, "numbering");
+      if (session.numberingPartPath === null) {
+        context.relationships.add({
+          type: NUMBERING_REL_TYPE,
+          target: path.slice(directoryOf(session.mainPartPath).length)
+        });
+      }
+      context.contentTypes.addOverride(path, NUMBERING_CONTENT_TYPE);
+      return /* @__PURE__ */ new Map([
+        [
+          path,
+          encodeUtf8(addListDefinitions(emptyNumberingPart(), defined), false)
+        ]
+      ]);
+    }
     const { text, hadBom } = decodeUtf8(original.bytes);
-    return /* @__PURE__ */ new Map([
-      [original.path, encodeUtf8(addListDefinitions(text, added), hadBom)]
-    ]);
+    const rewritten = ensureRootDeclarations(
+      addListDefinitions(text, defined),
+      { namespaces: { w: NAMESPACES.w } }
+    );
+    return /* @__PURE__ */ new Map([[original.path, encodeUtf8(rewritten, hadBom)]]);
   }
 };
 export {

package/dist/docx/pageGeometry.d.ts

@@ -1,8 +1,8 @@
 /**
  * The paper a document is written on: its size and its margins.
  *
- * A document says so in the `w:sectPr` at the end of its body. The values are read for the screen
- * only: the `w:sectPr` itself rides out with the rest of the preserved tail, so what a document
+ * A document says so in a `w:sectPr`, one per section (`./sections`). The values are read for the
+ * screen only: the `w:sectPr` itself rides out as the text it arrived as, so what a document
  * declares is never rewritten from these numbers.
  *
  * Everything here is in twips (1/1440 inch), the unit `w:pgSz` and `w:pgMar` are written in.
@@ -35,6 +35,9 @@ export declare const A4_PORTRAIT: PageGeometry;
 /**
  * The geometry a `w:sectPr` element lays down, with anything it leaves unsaid taken from A4.
  *
+ * The reading is deliberately forgiving: it runs against a document already opened, and a
+ * `w:sectPr` that cannot be read is a reason to draw A4, never a reason to refuse the file.
+ *
  * `w:orient` is not applied on top of the size: Word writes the width and the height already
  * swapped for a landscape section, so honouring both would turn the paper back upright.
  */
@@ -63,15 +66,3 @@ export declare function bodyWidth(geometry: PageGeometry): BodyWidth;
  * It is what a caller with no document to ask still gets: 11906 - 1247 * 2 = 9412 dxa.
  */
 export declare const A4_BODY_WIDTH: BodyWidth;
-/**
- * The geometry of the first section of an already parsed body.
- *
- * A document may hold a `w:sectPr` per section, each with a paper of its own. The screen draws
- * one paper for the whole document, so the first section decides it; the rest ride out
- * untouched in their preserved blocks and are drawn on the first section's paper.
- * `site/content/docs/features.mdx` records that limit.
- *
- * The reading is deliberately forgiving: this runs against a document already opened, and a
- * `w:sectPr` we cannot read is a reason to draw A4, never a reason to refuse the file.
- */
-export declare function readBodyGeometry(body: Element): PageGeometry;

package/dist/docx/pageGeometry.js

@@ -73,17 +73,6 @@ function bodyWidth(geometry) {
   return { twips, px: twipsToPx(twips) };
 }
 var A4_BODY_WIDTH = bodyWidth(A4_PORTRAIT);
-function readBodyGeometry(body) {
-  return readPageGeometry(firstSectPrIn(body));
-}
-function firstSectPrIn(root) {
-  const found = root.getElementsByTagName("w:sectPr").item(0);
-  if (found) return found;
-  for (const el of root.getElementsByTagName("*")) {
-    if (el.localName === "sectPr") return el;
-  }
-  return null;
-}
 export {
   A4_BODY_WIDTH,
   A4_PORTRAIT,
@@ -91,7 +80,6 @@ export {
   bodyHeightTwips,
   bodyWidth,
   bodyWidthTwips,
-  readBodyGeometry,
   readPageGeometry,
   twipsToPx
 };

package/dist/docx/protectionPolicy.d.ts

@@ -11,7 +11,7 @@
  * undefined, and a caller holding the level alone has nothing to run.
  */
 import { type XmlParser } from "../ooxml/xml";
-import type { EditableComments, EditingProtection } from "../schema/protection";
+import { type EditableComments, type EditingProtection } from "../schema/protection";
 import { type DocxBytes } from "./importDocx";
 import type { SessionStore } from "./session";
 import { type Story } from "./storyProjection";
@@ -59,8 +59,14 @@ export interface StoryPartKind {
     rootKept(before: SessionStore, after: SessionStore): boolean;
     /** The keys this file still stands behind, which is what an entry has to be keyed by */
     referents(story: Story): ReadonlySet<string>;
-    /** Grammar alone: whether the entry is one this editor's writer could have put out, whoever it belongs to */
-    wellFormed(entry: Element): boolean;
+    /**
+     * Grammar alone: whether the entry is one this editor's writer could have put out, whoever it
+     * belongs to. `original` is the entry the file that arrived held under the same key, and null
+     * for one that appeared, because what the writer can put out depends on what it had to work
+     * with: it writes a comment's body out of the blocks it models and passes the rest through from
+     * the entry it read.
+     */
+    wellFormed(entry: Element, original: Element | null): boolean;
     /**
      * Whether the entry came back differing from the one that arrived in nothing but a change this
      * protection leaves to everyone. Such an entry is nobody's rewrite, so it is held neither to
@@ -70,9 +76,11 @@ export interface StoryPartKind {
     /**
      * Permission alone: whether `authorId` may have written (`original === null`) or rewritten this
      * entry under `options`. `session` is the submission's, so a kind can look across at a sibling
-     * part, the way a comment's author resolves through the people part.
+     * part, the way a comment's author resolves through the people part. `unattributed` is the
+     * display names the file that arrived writes comments under while recording nobody for them,
+     * which is what an entry claiming no identity is held against.
      */
-    allowed(entry: Element, original: Element | null, authorId: string, options: PolicyOptions, session: SessionStore): boolean;
+    allowed(entry: Element, original: Element | null, authorId: string, options: PolicyOptions, session: SessionStore, unattributed: ReadonlySet<string>): boolean;
 }
 /** The two reasons the package comparison answers with, whatever the policy */
 export type PackageReason = "part-changed" | "relationship-changed";

package/dist/docx/protectionPolicy.js

@@ -5,6 +5,9 @@ import {
   parseXml,
   withXmlParser
 } from "../ooxml/xml.js";
+import {
+  unattributedCommentAuthors
+} from "../schema/protection.js";
 import { importDocx } from "./importDocx.js";
 import { CONTENT_TYPES_PATH } from "./packageParts.js";
 import {
@@ -31,9 +34,10 @@ function excusedPaths(policy, session) {
     (path) => path !== null
   );
 }
-function aroundTheStory(session) {
-  const preserved = session.blocks.filter((block) => !isModelledBlock(block.node)).map((block) => block.xml).join("");
-  return session.documentPrefix + preserved + session.documentSuffix;
+function aroundTheStory(story) {
+  const preserved = story.session.blocks.filter((block) => !isModelledBlock(block.node)).map((block) => block.xml).join("");
+  const sectPr = story.doc.attrs.sectPr;
+  return story.session.documentPrefix + preserved + (typeof sectPr === "string" ? sectPr : "") + story.session.documentSuffix;
 }
 function relationshipsKept(before, after, relTypes) {
   if (new Set(before.map((entry) => entry.id)).size !== before.length || new Set(after.map((entry) => entry.id)).size !== after.length) {
@@ -77,41 +81,43 @@ function gainedPartsAreNew(policy, before, after) {
   );
 }
 function packageKept(policy, before, after) {
-  if (before.mainPartPath !== after.mainPartPath) {
-    return { ok: false, reason: "part-changed", part: before.mainPartPath };
+  const was = before.session;
+  const now = after.session;
+  if (was.mainPartPath !== now.mainPartPath) {
+    return { ok: false, reason: "part-changed", part: was.mainPartPath };
   }
-  const relsPath = relsPathOf(before.mainPartPath);
+  const relsPath = relsPathOf(was.mainPartPath);
   const untouched = /* @__PURE__ */ new Set([
-    before.mainPartPath,
+    was.mainPartPath,
     relsPath,
     CONTENT_TYPES_PATH,
-    ...excusedPaths(policy, before),
-    ...excusedPaths(policy, after)
+    ...excusedPaths(policy, was),
+    ...excusedPaths(policy, now)
   ]);
-  for (const path of /* @__PURE__ */ new Set([...before.parts.keys(), ...after.parts.keys()])) {
+  for (const path of /* @__PURE__ */ new Set([...was.parts.keys(), ...now.parts.keys()])) {
     if (untouched.has(path)) continue;
-    const was = before.parts.get(path);
-    const now = after.parts.get(path);
-    if (was === void 0 || now === void 0 || !sameBytes(was, now)) {
+    const arrived = was.parts.get(path);
+    const submitted = now.parts.get(path);
+    if (arrived === void 0 || submitted === void 0 || !sameBytes(arrived, submitted)) {
       return { ok: false, reason: "part-changed", part: path };
     }
   }
   if (!relationshipsKept(
-    readRelationships(before.parts, relsPath),
-    readRelationships(after.parts, relsPath),
+    readRelationships(was.parts, relsPath),
+    readRelationships(now.parts, relsPath),
     policy.parts.map((kind) => kind.relType)
-  ) || !gainedPartsAreNew(policy, before, after)) {
+  ) || !gainedPartsAreNew(policy, was, now)) {
     return { ok: false, reason: "relationship-changed", part: relsPath };
   }
   if (!contentTypesKept(
-    contentTypes(before.parts.get(CONTENT_TYPES_PATH)),
-    contentTypes(after.parts.get(CONTENT_TYPES_PATH)),
+    contentTypes(was.parts.get(CONTENT_TYPES_PATH)),
+    contentTypes(now.parts.get(CONTENT_TYPES_PATH)),
     policy.parts.map((kind) => kind.contentType)
   )) {
     return { ok: false, reason: "part-changed", part: CONTENT_TYPES_PATH };
   }
   if (aroundTheStory(before) !== aroundTheStory(after)) {
-    return { ok: false, reason: "part-changed", part: before.mainPartPath };
+    return { ok: false, reason: "part-changed", part: was.mainPartPath };
   }
   return { ok: true };
 }
@@ -120,18 +126,22 @@ function partKept(kind, before, after, authorId, options) {
   const submitted = kind.entriesIn(after.session, "submitted");
   if (submitted === null) return false;
   if (!kind.rootKept(before.session, after.session)) return false;
+  const unattributed = unattributedCommentAuthors(
+    before.session.comments.ordered
+  );
   const stoodBehindNow = kind.referents(after);
   for (const [id, entry] of submitted) {
     const original = arrived.get(id);
     if (original && original.xml === entry.xml) continue;
     if (!stoodBehindNow.has(id)) return false;
     if (original && kind.anyonesChange(entry.el, original.el)) continue;
-    if (!kind.wellFormed(entry.el) || !kind.allowed(
+    if (!kind.wellFormed(entry.el, original?.el ?? null) || !kind.allowed(
       entry.el,
       original?.el ?? null,
       authorId,
       options,
-      after.session
+      after.session,
+      unattributed
     )) {
       return false;
     }
@@ -155,7 +165,7 @@ function verifyChange(policy, original, submitted, authorId, { xmlParser, ...opt
   return withXmlParser(xmlParser, () => {
     const before = importDocx(original);
     const after = importDocx(submitted);
-    const packaged = packageKept(policy, before.session, after.session);
+    const packaged = packageKept(policy, before, after);
     if (!packaged.ok) return packaged;
     const story = policy.storyKept(before, after, authorId, options);
     return story.ok ? partsKept(policy, before, after, authorId, options) : story;

package/dist/docx/scan.d.ts

@@ -1,20 +1,30 @@
 /**
- * Finds the span each individual body block occupies in the raw document.xml text and slices it out.
+ * Finds the span each individual block occupies in the raw text of a part and slices it out.
  *
  * A block that was not edited is exported by writing this fragment back out untouched,
- * which keeps its original bytes intact.
+ * which keeps its original bytes intact. The body of the main part is one such run of blocks;
+ * a comment and a footnote hold another (`docx/story`), and all of them are sliced here so that
+ * one story cannot end up compared or written by rules another does not follow.
  */
-export interface BodyBlockSlice {
+import { type Tag } from "../ooxml/tagScan";
+export interface BlockSlice {
     /** The tag name exactly as written (e.g. "w:p", "w:tbl", "w:sectPr") */
     name: string;
     /** The original XML fragment. It also carries the whitespace that sat between this block and the one before it */
     xml: string;
 }
-export interface BodyScan {
-    /** Everything in the raw text before the first block */
+export interface BlockScan {
+    /** Everything in the raw text before the first block, the container's own opening tag included */
     prefix: string;
-    blocks: BodyBlockSlice[];
-    /** Everything in the raw text after the last block */
+    blocks: BlockSlice[];
+    /** Everything in the raw text after the last block, the container's closing tag included */
     suffix: string;
 }
-export declare function scanBody(source: string): BodyScan;
+/** The tag whose children are the blocks, asked of every opening tag with the depth it stands at */
+export type ContainerTest = (tag: Tag, depth: number) => boolean;
+/**
+ * The blocks the first container this test names holds, and the text on either side of them.
+ * null for a source holding no such container; a caller says in its own words what that means.
+ */
+export declare function scanBlocksIn(source: string, isContainer: ContainerTest): BlockScan | null;
+export declare function scanBody(source: string): BlockScan;