@stll/folio-core 0.45.0 → 0.46.0

package/dist/docx/containerChildren.gen.js

@@ -0,0 +1,246 @@
+//#region src/docx/containerChildren.gen.ts
+/**
+* GENERATED FILE — do not edit.
+*
+* Every child the Transitional content model declares for a container folio
+* dispatches, derived from the committed schema graph by
+* `scripts/generate-container-children.ts`. The shared child dispatcher makes
+* a handler map total over these names, so a container cannot gain a declared
+* child without somebody deciding whether it is modelled or captured.
+* Regenerate with:
+*
+*   bun run generate:container-children
+*/
+const CONTAINER_CHILDREN = {
+	"w:comment": [
+		"altChunk",
+		"bookmarkEnd",
+		"bookmarkStart",
+		"commentRangeEnd",
+		"commentRangeStart",
+		"customXml",
+		"customXmlDelRangeEnd",
+		"customXmlDelRangeStart",
+		"customXmlInsRangeEnd",
+		"customXmlInsRangeStart",
+		"customXmlMoveFromRangeEnd",
+		"customXmlMoveFromRangeStart",
+		"customXmlMoveToRangeEnd",
+		"customXmlMoveToRangeStart",
+		"del",
+		"ins",
+		"moveFrom",
+		"moveFromRangeEnd",
+		"moveFromRangeStart",
+		"moveTo",
+		"moveToRangeEnd",
+		"moveToRangeStart",
+		"p",
+		"permEnd",
+		"permStart",
+		"proofErr",
+		"sdt",
+		"tbl"
+	],
+	"run-level-content": [
+		"bdo",
+		"bookmarkEnd",
+		"bookmarkStart",
+		"commentRangeEnd",
+		"commentRangeStart",
+		"customXml",
+		"customXmlDelRangeEnd",
+		"customXmlDelRangeStart",
+		"customXmlInsRangeEnd",
+		"customXmlInsRangeStart",
+		"customXmlMoveFromRangeEnd",
+		"customXmlMoveFromRangeStart",
+		"customXmlMoveToRangeEnd",
+		"customXmlMoveToRangeStart",
+		"del",
+		"dir",
+		"fldSimple",
+		"hyperlink",
+		"ins",
+		"moveFrom",
+		"moveFromRangeEnd",
+		"moveFromRangeStart",
+		"moveTo",
+		"moveToRangeEnd",
+		"moveToRangeStart",
+		"pPr",
+		"permEnd",
+		"permStart",
+		"proofErr",
+		"r",
+		"sdt",
+		"smartTag",
+		"smartTagPr",
+		"subDoc"
+	],
+	"table-content": [
+		"bookmarkEnd",
+		"bookmarkStart",
+		"commentRangeEnd",
+		"commentRangeStart",
+		"customXml",
+		"customXmlDelRangeEnd",
+		"customXmlDelRangeStart",
+		"customXmlInsRangeEnd",
+		"customXmlInsRangeStart",
+		"customXmlMoveFromRangeEnd",
+		"customXmlMoveFromRangeStart",
+		"customXmlMoveToRangeEnd",
+		"customXmlMoveToRangeStart",
+		"customXmlPr",
+		"del",
+		"ins",
+		"moveFrom",
+		"moveFromRangeEnd",
+		"moveFromRangeStart",
+		"moveTo",
+		"moveToRangeEnd",
+		"moveToRangeStart",
+		"permEnd",
+		"permStart",
+		"proofErr",
+		"sdt",
+		"tblGrid",
+		"tblPr",
+		"tr"
+	],
+	"row-content": [
+		"bookmarkEnd",
+		"bookmarkStart",
+		"commentRangeEnd",
+		"commentRangeStart",
+		"customXml",
+		"customXmlDelRangeEnd",
+		"customXmlDelRangeStart",
+		"customXmlInsRangeEnd",
+		"customXmlInsRangeStart",
+		"customXmlMoveFromRangeEnd",
+		"customXmlMoveFromRangeStart",
+		"customXmlMoveToRangeEnd",
+		"customXmlMoveToRangeStart",
+		"del",
+		"ins",
+		"moveFrom",
+		"moveFromRangeEnd",
+		"moveFromRangeStart",
+		"moveTo",
+		"moveToRangeEnd",
+		"moveToRangeStart",
+		"permEnd",
+		"permStart",
+		"proofErr",
+		"sdt",
+		"tblPrEx",
+		"tc",
+		"tr",
+		"trPr"
+	],
+	"w:hyperlink": [
+		"bdo",
+		"bookmarkEnd",
+		"bookmarkStart",
+		"commentRangeEnd",
+		"commentRangeStart",
+		"customXml",
+		"customXmlDelRangeEnd",
+		"customXmlDelRangeStart",
+		"customXmlInsRangeEnd",
+		"customXmlInsRangeStart",
+		"customXmlMoveFromRangeEnd",
+		"customXmlMoveFromRangeStart",
+		"customXmlMoveToRangeEnd",
+		"customXmlMoveToRangeStart",
+		"del",
+		"dir",
+		"fldSimple",
+		"hyperlink",
+		"ins",
+		"moveFrom",
+		"moveFromRangeEnd",
+		"moveFromRangeStart",
+		"moveTo",
+		"moveToRangeEnd",
+		"moveToRangeStart",
+		"permEnd",
+		"permStart",
+		"proofErr",
+		"r",
+		"sdt",
+		"smartTag",
+		"subDoc"
+	],
+	"w:fldSimple": [
+		"bdo",
+		"bookmarkEnd",
+		"bookmarkStart",
+		"commentRangeEnd",
+		"commentRangeStart",
+		"customXml",
+		"customXmlDelRangeEnd",
+		"customXmlDelRangeStart",
+		"customXmlInsRangeEnd",
+		"customXmlInsRangeStart",
+		"customXmlMoveFromRangeEnd",
+		"customXmlMoveFromRangeStart",
+		"customXmlMoveToRangeEnd",
+		"customXmlMoveToRangeStart",
+		"del",
+		"dir",
+		"fldData",
+		"fldSimple",
+		"hyperlink",
+		"ins",
+		"moveFrom",
+		"moveFromRangeEnd",
+		"moveFromRangeStart",
+		"moveTo",
+		"moveToRangeEnd",
+		"moveToRangeStart",
+		"permEnd",
+		"permStart",
+		"proofErr",
+		"r",
+		"sdt",
+		"smartTag",
+		"subDoc"
+	],
+	"block-content": [
+		"altChunk",
+		"bookmarkEnd",
+		"bookmarkStart",
+		"commentRangeEnd",
+		"commentRangeStart",
+		"customXml",
+		"customXmlDelRangeEnd",
+		"customXmlDelRangeStart",
+		"customXmlInsRangeEnd",
+		"customXmlInsRangeStart",
+		"customXmlMoveFromRangeEnd",
+		"customXmlMoveFromRangeStart",
+		"customXmlMoveToRangeEnd",
+		"customXmlMoveToRangeStart",
+		"del",
+		"ins",
+		"moveFrom",
+		"moveFromRangeEnd",
+		"moveFromRangeStart",
+		"moveTo",
+		"moveToRangeEnd",
+		"moveToRangeStart",
+		"p",
+		"permEnd",
+		"permStart",
+		"proofErr",
+		"sdt",
+		"sectPr",
+		"tbl",
+		"tcPr"
+	]
+};
+//#endregion
+export { CONTAINER_CHILDREN };

package/dist/docx/containerChildren.js

@@ -0,0 +1,103 @@
+import { TRANSITIONAL_NAMESPACE_BY_STRICT_URI } from "./strictValueEncodings.gen.js";
+import { captureVerbatimXml } from "./verbatimCapture.js";
+import { WORDPROCESSINGML_NAMESPACE_URIS, getChildElements, getLocalName, getNamespaceUri } from "./xmlParser.js";
+//#region src/docx/containerChildren.ts
+/** Keep this child's markup verbatim, in place. */
+const CAPTURE = "capture";
+/**
+* Another reader owns this child, and re-emits it.
+*
+* `w:rPr` under a run, read by `parseRunProperties`; `w:commentReference`
+* under a run, lifted out by the paragraph parser. Capturing one of these as
+* well would write it twice, so the disposition has to be stated rather than
+* left to a bare `break`.
+*/
+const OWNED_ELSEWHERE = "owned-elsewhere";
+/**
+* This child goes with the wrapper folio does not keep.
+*
+* `w:smartTagPr` is the case: folio unwraps `w:smartTag` and splices its
+* content into the paragraph, so the properties describing the wrapper have
+* nothing left to describe and capturing them would put a `w:smartTagPr`
+* where the schema does not admit one. The drop is stated here and recorded
+* in `specifications/container-contract/contract.json`, which is the whole
+* difference between this and a `default` that says nothing.
+*/
+const DROPPED_WITH_ITS_WRAPPER = "dropped-with-its-wrapper";
+/**
+* The Transitional spelling of a namespace, so one disposition covers both.
+*
+* ISO Strict writes the same content model under its own URIs: maths is
+* `purl.oclc.org/ooxml/officeDocument/math` rather than
+* `schemas.openxmlformats.org/officeDocument/2006/math`. A namespace-keyed
+* disposition written in Transitional would otherwise send a Strict
+* document's maths to the sink, which models it as bytes instead of an
+* equation. The pairs come from the generated table rather than a second list
+* here, so a namespace cannot be paired in one place and forgotten in the
+* other.
+*/
+const transitionalNamespaceOf = (namespace) => TRANSITIONAL_NAMESPACE_BY_STRICT_URI.get(namespace) ?? namespace;
+/**
+* Walk a container's children, handing each to its handler and the rest to the
+* sink.
+*
+* @returns the container's unmodelled markup, or `undefined` when it held
+*   none — an empty record is never written, so a fully modelled container
+*   stays byte-identical in the model.
+*/
+const dispatchChildren = ({ element, handlers, modelledCount, undeclared, undeclaredNamespaces }) => {
+	const children = [];
+	const capture = (child) => {
+		children.push({
+			index: modelledCount(),
+			xml: captureVerbatimXml(child)
+		});
+	};
+	const declared = new Map(Object.entries(handlers));
+	const byName = new Map(Object.entries(undeclared ?? {}));
+	const byNamespace = new Map(Object.entries(undeclaredNamespaces ?? {}));
+	for (const child of getChildElements(element)) {
+		const localName = getLocalName(child.name);
+		const namespace = getNamespaceUri(child);
+		const disposition = namespace === void 0 || WORDPROCESSINGML_NAMESPACE_URIS.has(namespace) ? declared.get(localName) ?? byName.get(localName) : byName.get(localName) ?? byNamespace.get(transitionalNamespaceOf(namespace));
+		if (disposition === void 0 || disposition === "capture") {
+			capture(child);
+			continue;
+		}
+		if (disposition === "dropped-with-its-wrapper" || disposition === "owned-elsewhere") continue;
+		disposition(child);
+	}
+	return children.length === 0 ? void 0 : { children };
+};
+/**
+* Put a container's modelled children back with its preserved ones between
+* them, in source position.
+*
+* Where the content model demands schema order the caller has already put its
+* modelled children in that order; the sink's `index` then places each capture
+* between the same two siblings it sat between when it was read.
+*
+* @param wrap turns one capture's markup into whatever the caller's list holds
+*/
+const withPreservedChildren = (modelled, preserved, wrap) => {
+	const captures = preserved?.children;
+	if (captures === void 0 || captures.length === 0) return [...modelled];
+	const byIndex = /* @__PURE__ */ new Map();
+	for (const { index, xml } of captures) {
+		const slot = Math.min(Math.max(index, 0), modelled.length);
+		const bucket = byIndex.get(slot);
+		if (bucket) {
+			bucket.push(wrap(xml));
+			continue;
+		}
+		byIndex.set(slot, [wrap(xml)]);
+	}
+	const items = [];
+	for (const [index, item] of modelled.entries()) items.push(...byIndex.get(index) ?? [], item);
+	items.push(...byIndex.get(modelled.length) ?? []);
+	return items;
+};
+/** {@link withPreservedChildren} for a caller that already holds markup. */
+const serializeWithPreservedChildren = (modelled, preserved) => withPreservedChildren(modelled, preserved, (xml) => xml).join("");
+//#endregion
+export { CAPTURE, DROPPED_WITH_ITS_WRAPPER, OWNED_ELSEWHERE, dispatchChildren, serializeWithPreservedChildren, transitionalNamespaceOf, withPreservedChildren };

package/dist/docx/documentParser.d.ts

@@ -1,7 +1,7 @@
 import { document_d_exports } from "../types/document.js";
 import { NumberingMap } from "./numberingParser.js";
-import { StyleMap } from "./styleParser.js";
 import { ParseContext } from "./parseContext.js";
+import { StyleMap } from "./styleParser.js";
 //#region src/docx/documentParser.d.ts
 /**
  * Extract template variables from text

package/dist/docx/documentParser.js

@@ -49,7 +49,7 @@ function extractTableVariables(table) {
 	for (const row of table.rows) for (const cell of row.cells) for (const cellContent of cell.content) if (cellContent.type === "paragraph") {
 		const vars = extractTemplateVariables(getParagraphText(cellContent));
 		for (const v of vars) if (!variables.includes(v)) variables.push(v);
-	} else {
+	} else if (cellContent.type === "table") {
 		const nestedVars = extractTableVariables(cellContent);
 		for (const v of nestedVars) if (!variables.includes(v)) variables.push(v);
 	}
@@ -149,7 +149,7 @@ function getAllParagraphs(body) {
 function getTableParagraphs(table) {
 	const paragraphs = [];
 	for (const row of table.rows) for (const cell of row.cells) for (const content of cell.content) if (content.type === "paragraph") paragraphs.push(content);
-	else paragraphs.push(...getTableParagraphs(content));
+	else if (content.type === "table") paragraphs.push(...getTableParagraphs(content));
 	return paragraphs;
 }
 /**
@@ -193,7 +193,7 @@ function getTableText(table) {
 		for (const cell of row.cells) {
 			const cellTexts = [];
 			for (const content of cell.content) if (content.type === "paragraph") cellTexts.push(getParagraphText(content));
-			else cellTexts.push(getTableText(content));
+			else if (content.type === "table") cellTexts.push(getTableText(content));
 			rowTexts.push(cellTexts.join("\n"));
 		}
 		lines.push(rowTexts.join("	"));

package/dist/docx/ensureParaIds.js

@@ -1,5 +1,5 @@
 import { deterministicHexId } from "../utils/hexId.js";
-import { isXmlNameBoundary } from "./selectiveXmlPatch.js";
+import { isXmlNameBoundary, spliceXml } from "./selectiveXmlPatch.js";
 import { loadDocxArchive } from "./server/boundedArchive.js";
 import { TaggedError } from "better-result";
 import JSZip from "jszip";
@@ -97,11 +97,21 @@ const OPEN_TAG_TEXT_ID_PATTERN = /\sw(?:14)?:textId=(?<quote>["'])(?<id>[\s\S]*?
 const XMLNS_W14_PATTERN = /\sxmlns:w14=(?<quote>["'])(?<value>[\s\S]*?)\k<quote>/u;
 const XMLNS_MC_PATTERN = /\sxmlns:mc=(?<quote>["'])(?<value>[\s\S]*?)\k<quote>/u;
 const MC_IGNORABLE_PATTERN = /\smc:Ignorable=(?<quote>["'])(?<value>[\s\S]*?)\k<quote>/u;
-const applySplices = (xml, edits) => {
-	const ordered = [...edits].sort((a, b) => b.start - a.start);
-	let result = xml;
-	for (const { start, end, text } of ordered) result = result.slice(0, start) + text + result.slice(end);
-	return result;
+/**
+* Stamp the edits into the part through the splice owner, which refuses a
+* result that would leave a comment range with only one half. These edits
+* rewrite `<w:p …>` open tags and the root element's attributes, so they
+* should never cut across a range marker; the owner is what makes that
+* structural rather than a reading of the scanner.
+*/
+const applySplices = (xml, edits, partPath) => {
+	const patched = spliceXml(xml, edits.map(({ start, end, text }) => ({
+		start,
+		end,
+		newXml: text
+	})));
+	if (patched === null) throw createEnsureParaIdsError(`Stamping paragraph ids into ${partPath} broke a comment range`);
+	return patched;
 };
 const createEnsureParaIdsError = (message, cause) => new EnsureParaIdsError({
 	message,
@@ -382,7 +392,7 @@ const ensureParaIdsInternal = async (docx, options) => {
 		if (scan.edits.length === 0) continue;
 		assigned += scan.assigned;
 		deduplicated += scan.deduplicated;
-		updates.set(partPath, applySplices(xml, [...scan.edits, ...ensureRootNamespaces(xml, partPath)]));
+		updates.set(partPath, applySplices(xml, [...scan.edits, ...ensureRootNamespaces(xml, partPath)], partPath));
 	}
 	if (updates.size === 0) return {
 		docx: toUint8Array(docx),

package/dist/docx/fieldParser.d.ts

@@ -1,6 +1,6 @@
 import { document_d_exports } from "../types/document.js";
-import { StyleMap } from "./styleParser.js";
 import { XmlElement } from "./xmlParser.js";
+import { StyleMap } from "./styleParser.js";
 //#region src/docx/fieldParser.d.ts
 /**
  * All known field types from OOXML specification

package/dist/docx/fieldParser.js

@@ -1,7 +1,8 @@
+import { parseFieldState } from "./fieldState.js";
 import { formatOoxmlCounter } from "./ooxmlCounterFormatter.js";
 import { FieldTypeSchema, narrowEnum } from "./parserEnums.js";
 import { parseRun } from "./runParser.js";
-import { findChildren, getAttribute, parseOnOffAttribute } from "./xmlParser.js";
+import { findChildren, getAttribute } from "./xmlParser.js";
 //#region src/docx/fieldParser.ts
 /**
 * All known field types from OOXML specification
@@ -162,10 +163,9 @@ function parseSimpleField(node, styles, theme) {
 		type: "simpleField",
 		instruction,
 		fieldType: parseFieldType(instruction),
-		content: []
+		content: [],
+		...parseFieldState(node)
 	};
-	if (parseOnOffAttribute(node, "w", "fldLock") === true) field.fldLock = true;
-	if (parseOnOffAttribute(node, "w", "dirty") === true) field.dirty = true;
 	const children = findChildren(node, "w", "r");
 	for (const child of children) {
 		const run = parseRun(child, styles, theme);

package/dist/docx/fieldState.d.ts

@@ -0,0 +1,26 @@
+import { XmlElement } from "./xmlParser.js";
+//#region src/docx/fieldState.d.ts
+/** What a field element states about its lock and dirty flags. */
+type FieldState = {
+  fldLock?: boolean;
+  dirty?: boolean;
+};
+/** Read both attributes off a `w:fldSimple` or `w:fldChar`, keeping an explicit off. */
+declare const parseFieldState: (element: XmlElement) => FieldState;
+/**
+ * The stated flags of a field, without the rest of it.
+ *
+ * The complex-field assembly carries the begin `w:fldChar`'s state across the
+ * runs between `begin` and `end`, and this is the one place that knows which
+ * fields that state is made of.
+ */
+declare const fieldStateOf: ({ fldLock, dirty }: FieldState) => FieldState;
+/**
+ * The attributes to write for a field's stated flags, in schema order.
+ *
+ * `1`/`0` is what Word writes and what the table, section and border
+ * serializers write.
+ */
+declare const fieldStateAttributes: ({ fldLock, dirty }: FieldState) => string[];
+//#endregion
+export { FieldState, fieldStateAttributes, fieldStateOf, parseFieldState };

package/dist/docx/fieldState.js

@@ -0,0 +1,53 @@
+import { parseOnOffAttribute } from "./xmlParser.js";
+//#region src/docx/fieldState.ts
+/**
+* `@w:fldLock` and `@w:dirty`, the two `ST_OnOff` attributes every field form
+* carries.
+*
+* A simple field states them on `<w:fldSimple>`; a complex field states them on
+* the `<w:fldChar w:fldCharType="begin"/>` that opens it, and folio hoists them
+* from there onto the assembled `ComplexField`. Neither attribute has an XSD
+* default, so a field states one of three things about each: nothing, an
+* explicit off, an explicit on. `w:dirty="0"` on a field inside a `TOC` result
+* is the case that matters: it says "do not recompute this", which is not what
+* an absent attribute says.
+*
+* Three readers and three writers had drifted into the same `=== true` /
+* truthiness collapse, so both directions live here instead.
+*/
+/** Read both attributes off a `w:fldSimple` or `w:fldChar`, keeping an explicit off. */
+const parseFieldState = (element) => {
+	const state = {};
+	const fldLock = parseOnOffAttribute(element, "w", "fldLock");
+	if (fldLock !== void 0) state.fldLock = fldLock;
+	const dirty = parseOnOffAttribute(element, "w", "dirty");
+	if (dirty !== void 0) state.dirty = dirty;
+	return state;
+};
+/**
+* The stated flags of a field, without the rest of it.
+*
+* The complex-field assembly carries the begin `w:fldChar`'s state across the
+* runs between `begin` and `end`, and this is the one place that knows which
+* fields that state is made of.
+*/
+const fieldStateOf = ({ fldLock, dirty }) => {
+	const state = {};
+	if (fldLock !== void 0) state.fldLock = fldLock;
+	if (dirty !== void 0) state.dirty = dirty;
+	return state;
+};
+/**
+* The attributes to write for a field's stated flags, in schema order.
+*
+* `1`/`0` is what Word writes and what the table, section and border
+* serializers write.
+*/
+const fieldStateAttributes = ({ fldLock, dirty }) => {
+	const attrs = [];
+	if (fldLock !== void 0) attrs.push(`w:fldLock="${fldLock ? "1" : "0"}"`);
+	if (dirty !== void 0) attrs.push(`w:dirty="${dirty ? "1" : "0"}"`);
+	return attrs;
+};
+//#endregion
+export { fieldStateAttributes, fieldStateOf, parseFieldState };

package/dist/docx/footnoteParser.d.ts

@@ -1,7 +1,7 @@
 import { document_d_exports } from "../types/document.js";
 import { NumberingMap } from "./numberingParser.js";
-import { StyleMap } from "./styleParser.js";
 import { ParseContext } from "./parseContext.js";
+import { StyleMap } from "./styleParser.js";
 import { parseEndnoteProperties, parseFootnoteProperties } from "./notePropertiesParser.js";
 //#region src/docx/footnoteParser.d.ts
 /**

package/dist/docx/graphicFrameLocks.d.ts

@@ -12,11 +12,23 @@ declare const GRAPHIC_FRAME_LOCK_KEYS: ("noGrp" | "noDrilldown" | "noSelect" | "
  */
 declare const parseGraphicFrameLocks: (parent: XmlElement) => document_d_exports.ImageFrameLocks | undefined;
 /**
- * Emit the whole `wp:cNvGraphicFramePr` element for regenerated DrawingML.
+ * The locks folio gives a picture it creates itself, at the insert that creates
+ * it: Word writes `noChangeAspect="1"` on a picture inserted through its own
+ * UI, and an inserted picture should behave the same in both.
  *
- * Absent locks mean no authored frame was ever parsed (a Folio-created
- * picture), which keeps the historical `noChangeAspect="1"`.
+ * It lives here because it is a fact about this element, and it is applied at
+ * construction rather than at serialization, where "the author wrote no frame"
+ * and "folio made this picture" are the same `undefined`.
+ */
+declare const FOLIO_INSERTED_PICTURE_FRAME_LOCKS: document_d_exports.ImageFrameLocks;
+/**
+ * Emit `wp:cNvGraphicFramePr` for regenerated DrawingML, or nothing.
+ *
+ * Absent locks are the author's silence, and silence is written back as
+ * silence: a frame the source never carried is not invented on the rebuild
+ * path, where it would appear on every edited document and on none of the
+ * replayed ones.
  */
 declare const serializeGraphicFrameLocks: (locks: document_d_exports.ImageFrameLocks | undefined) => string;
 //#endregion
-export { GRAPHIC_FRAME_LOCK_KEYS, parseGraphicFrameLocks, serializeGraphicFrameLocks };
+export { FOLIO_INSERTED_PICTURE_FRAME_LOCKS, GRAPHIC_FRAME_LOCK_KEYS, parseGraphicFrameLocks, serializeGraphicFrameLocks };

package/dist/docx/graphicFrameLocks.js

@@ -38,18 +38,31 @@ const parseGraphicFrameLocks = (parent) => {
 	return present ? locks : void 0;
 };
 /**
-* Emit the whole `wp:cNvGraphicFramePr` element for regenerated DrawingML.
+* The locks folio gives a picture it creates itself, at the insert that creates
+* it: Word writes `noChangeAspect="1"` on a picture inserted through its own
+* UI, and an inserted picture should behave the same in both.
 *
-* Absent locks mean no authored frame was ever parsed (a Folio-created
-* picture), which keeps the historical `noChangeAspect="1"`.
+* It lives here because it is a fact about this element, and it is applied at
+* construction rather than at serialization, where "the author wrote no frame"
+* and "folio made this picture" are the same `undefined`.
+*/
+const FOLIO_INSERTED_PICTURE_FRAME_LOCKS = { noChangeAspect: true };
+/**
+* Emit `wp:cNvGraphicFramePr` for regenerated DrawingML, or nothing.
+*
+* Absent locks are the author's silence, and silence is written back as
+* silence: a frame the source never carried is not invented on the rebuild
+* path, where it would appear on every edited document and on none of the
+* replayed ones.
 */
 const serializeGraphicFrameLocks = (locks) => {
-	const attrs = locks ? GRAPHIC_FRAME_LOCK_KEYS.flatMap((key) => {
+	if (!locks) return "";
+	const attrs = GRAPHIC_FRAME_LOCK_KEYS.flatMap((key) => {
 		const value = locks[key];
 		return value === void 0 ? [] : [`${GRAPHIC_FRAME_LOCK_ATTRIBUTES[key]}="${value ? "1" : "0"}"`];
-	}) : ["noChangeAspect=\"1\""];
+	});
 	const attrList = attrs.length > 0 ? ` ${attrs.join(" ")}` : "";
 	return `<wp:cNvGraphicFramePr><a:graphicFrameLocks ${DRAWINGML_NAMESPACE}${attrList}/></wp:cNvGraphicFramePr>`;
 };
 //#endregion
-export { GRAPHIC_FRAME_LOCK_KEYS, parseGraphicFrameLocks, serializeGraphicFrameLocks };
+export { FOLIO_INSERTED_PICTURE_FRAME_LOCKS, GRAPHIC_FRAME_LOCK_KEYS, parseGraphicFrameLocks, serializeGraphicFrameLocks };

package/dist/docx/headerFooterParser.js

@@ -155,7 +155,7 @@ function getHeaderFooterText(hf) {
 function isEmptyHeaderFooter(hf) {
 	if (hf.content.length === 0) return true;
 	for (const item of hf.content) {
-		if (item.type === "table") return false;
+		if (item.type !== "paragraph") return false;
 		if (item.content.length > 0) for (const content of item.content) {
 			if (content.type !== "run") return false;
 			for (const rc of content.content) {

package/dist/docx/headerFooterReferenceNormalization.js

@@ -38,6 +38,7 @@ const normalizeHeaderFooterReferences = ({ documentBody, headers, footers }) =>
 			normalizeTable(block);
 			return;
 		}
+		if (block.type === "preservedBlock") return;
 		normalizeBlocks(block.content);
 	};
 	const normalizeBlocks = (blocks) => {