@a3s-lab/office 0.2.2 → 0.4.0

package/dist/0~work-office-diagnostics.js

@@ -1,15 +1,98 @@
-import { docxCaptionSequenceKind, docxFieldOccurrences, docxCaptionBookmark, docxCaptionReferenceTarget, docxFieldInstructions } from "./0~152.js";
-import { documentCitationTagsFromInstruction, docxDocumentFieldKind } from "./2881.js";
-import { contentTypeForPart, directChildren, formulaHasStructuredReference, OoxmlPackage, formulaHasExternalReference, firstDescendant, parseSpreadsheetPrintTitles, stripSpreadsheetSheetQualifier, descendants, directChild, attribute, volatileSpreadsheetFormulaFunctions } from "./8715.js";
-import { readDocxBibliography } from "./0~work-docx-bibliography.js";
+import { descendants, directChildren, directChild, OoxmlPackage, attribute, firstDescendant, contentTypeForPart } from "./5184.js";
+import { normalizeDocumentBookmarkName, docxBookmarkReferenceTarget, normalizeDocumentBookmarkNativeId, isDocumentParagraphArtBorderStyle, supportedDocxBookmarkReferenceInstruction, documentCitationTagsFromInstruction, docxDocumentFieldKind } from "./8928.js";
+import { markDocxParagraphShading, inspectDocxPageSize, docxCaptionBookmark, hasInvalidDocxFieldStructure, inspectDocxPageMargins, inspectDocxPaperSource, createDocxParagraphStyleResolver, createDocxTableStyleResolver, docxFieldOccurrences, inspectDocxEquation, inspectDocxPageMarginSettings, markDocxParagraphBorders, docxFieldOccurrenceIsInlineEditable, docxCaptionSequenceKind, inspectDocxPageBorders, docxFieldInstructions, isSupportedDocxEquationPlacement } from "./0~7754.js";
+import { normalizeDocumentHref } from "./0~work-document-links.js";
+import { xmlAttributeLocalName, parseDocxParagraphDefaultCollapsed, readDocxBibliography, DOCX_WORDPROCESSING_NAMESPACES, xmlAttributeNamespace, createDocxThemeResolver } from "./0~2805.js";
 import { isSupportedXlsxCombinationChartNodes, MAX_XLSX_WORKSHEET_IMAGE_BYTES, inspectXlsxPivotTables, isSupportedXlsxWorksheetImageContentType, isSupportedXlsxChartLegend, isSupportedXlsxChartPlotLayout, xlsxChartNodeUsesStackedGrouping, isSupportedXlsxChartSeriesFormatting, readXlsxFormulaFeaturesFromPackage, inspectXlsxHeaderFooterText, isEditableXlsxPaperSizeCode, diagnoseXlsxProtection, xlsxChartSeriesFormattingShapeProperties } from "./4104.js";
-import { spreadsheetConditionalComparisonNeedsUpperValue, isSpreadsheetConditionalIconSetName, isSpreadsheetConditionalComparisonOperator, spreadsheetConditionalIconSetCount } from "./8728.js";
+import { spreadsheetConditionalComparisonNeedsUpperValue, isSpreadsheetConditionalIconSetName, isSpreadsheetConditionalComparisonOperator, spreadsheetConditionalIconSetCount } from "./4476.js";
+import { formulaHasStructuredReference, formulaHasExternalReference, parseSpreadsheetPrintTitles, volatileSpreadsheetFormulaFunctions, stripSpreadsheetSheetQualifier } from "./8715.js";
 import { unsupportedSpreadsheetFormulaFunctions } from "./0~work-spreadsheet-formula-support.js";
+async function diagnoseDocxBookmarksAndLinks(archive, document) {
+    const starts = descendants(document, 'bookmarkStart');
+    const ends = descendants(document, 'bookmarkEnd');
+    const hyperlinks = descendants(document, 'hyperlink');
+    if (!starts.length && !ends.length && !hyperlinks.length) return [];
+    const issues = [
+        bookmarkIssue('docx.bookmarks-links', 'Paired body bookmarks remain editable native bookmark ranges. Bookmark REF fields stay live and editable, internal hyperlinks retain Word anchor semantics without external relationships, and supported web and email links retain external hyperlink relationships.', 'info')
+    ];
+    const startsById = groupedByAttribute(starts, 'id');
+    const endsById = groupedByAttribute(ends, 'id');
+    const boundaryIds = new Set([
+        ...startsById.keys(),
+        ...endsById.keys()
+    ]);
+    if (starts.some((start)=>!attribute(start, 'id')?.trim()) || ends.some((end)=>!attribute(end, 'id')?.trim()) || Array.from(boundaryIds).some((id)=>(startsById.get(id)?.length ?? 0) !== (endsById.get(id)?.length ?? 0))) issues.push(bookmarkIssue('docx.bookmarks.structure', 'Unpaired bookmark boundaries cannot form a complete editable range and are omitted during editing import.'));
+    const names = new Set();
+    const nativeIds = new Set();
+    let normalizedIdentity = false;
+    for (const start of starts){
+        const sourceName = attribute(start, 'name')?.trim() ?? '';
+        const name = normalizeDocumentBookmarkName(sourceName);
+        const sourceNativeId = attribute(start, 'id');
+        const nativeId = normalizeDocumentBookmarkNativeId(sourceNativeId);
+        const foldedName = name?.toLowerCase();
+        if (!name || !foldedName || names.has(foldedName) || null === nativeId || nativeIds.has(nativeId)) normalizedIdentity = true;
+        if (foldedName) names.add(foldedName);
+        if (null !== nativeId) nativeIds.add(nativeId);
+    }
+    if (normalizedIdentity) issues.push(bookmarkIssue('docx.bookmarks.identity', 'Invalid, duplicate, or over-40-character bookmark names are made unique and Word-compatible. Missing or reused numeric identifiers are reassigned, and matching internal links are redirected to the retained target.'));
+    if (starts.some((start)=>null !== attribute(start, 'colFirst') || null !== attribute(start, 'colLast'))) issues.push(bookmarkIssue('docx.bookmarks.columns', 'Column-scoped table bookmarks are imported as ordinary editable bookmark ranges; column boundary metadata is normalized.'));
+    const targetNames = new Set(starts.flatMap((start)=>{
+        const name = attribute(start, 'name')?.trim().toLowerCase() ?? '';
+        return name ? [
+            name
+        ] : [];
+    }));
+    const bookmarkReferences = docxFieldOccurrences(document).filter((field)=>{
+        const target = docxBookmarkReferenceTarget(field.instruction);
+        return Boolean(target && targetNames.has(target.toLowerCase()));
+    });
+    if (bookmarkReferences.some((field)=>!supportedDocxBookmarkReferenceInstruction(field.instruction))) issues.push(bookmarkIssue('docx.bookmark-references.switches', 'Bookmark REF fields with relative-position, paragraph-number, or other advanced switches normalize to bookmarked text with an optional hyperlink switch.'));
+    const danglingAnchors = hyperlinks.some((hyperlink)=>{
+        const anchor = attribute(hyperlink, 'anchor')?.trim();
+        return Boolean(anchor && !targetNames.has(anchor.toLowerCase()));
+    });
+    if (danglingAnchors) issues.push(bookmarkIssue('docx.hyperlinks.missing-target', 'One or more internal hyperlinks do not resolve to a body bookmark. Their anchors are retained and shown with an explicit missing-target state.'));
+    const relationships = await archive.relationships('word/document.xml');
+    const unsupportedExternalLink = hyperlinks.some((hyperlink)=>{
+        const relationshipId = attribute(hyperlink, 'r:id')?.trim();
+        if (!relationshipId) return false;
+        const relationship = relationships.get(relationshipId);
+        if (!relationship) return true;
+        return !relationship.type.endsWith('/hyperlink') || relationship.targetMode?.toLowerCase() !== 'external' || null === normalizeDocumentHref(relationship.target);
+    });
+    if (unsupportedExternalLink) issues.push(bookmarkIssue('docx.hyperlinks.external', 'Hyperlink relationships outside http, https, and mailto, or unresolved hyperlink relationships, are converted to plain linked text.'));
+    if (hyperlinks.some((hyperlink)=>null !== attribute(hyperlink, 'tooltip') || null !== attribute(hyperlink, 'tgtFrame') || null !== attribute(hyperlink, 'docLocation') || null !== attribute(hyperlink, 'anchor') && null !== attribute(hyperlink, 'r:id'))) issues.push(bookmarkIssue('docx.hyperlinks.metadata', 'Hyperlink tooltips, target frames, external document locations, and combined external-plus-anchor destinations normalize to the supported link destination.'));
+    return issues;
+}
+function groupedByAttribute(elements, name) {
+    const groups = new Map();
+    for (const element of elements){
+        const value = attribute(element, name)?.trim() ?? '';
+        const matches = groups.get(value) ?? [];
+        matches.push(element);
+        groups.set(value, matches);
+    }
+    return groups;
+}
+function bookmarkIssue(code, message, severity = 'warning') {
+    return {
+        code,
+        feature: 'Bookmarks and hyperlinks',
+        message,
+        severity
+    };
+}
 function diagnoseDocxCaptions(document) {
     const fields = docxFieldOccurrences(document);
     const sequences = fields.filter((field)=>docxCaptionSequenceKind(field.instruction));
-    const bodyFields = fields.filter((field)=>docxDocumentFieldKind(field.instruction));
-    const bookmarkNames = captionBookmarkNames(sequences);
+    const bodyFields = fields.filter((field)=>'orphan' !== field.syntax && Boolean(docxDocumentFieldKind(field.instruction)));
+    const editableBodyFields = bodyFields.filter(docxFieldOccurrenceIsInlineEditable);
+    const hasUnsupportedFieldStructure = hasInvalidDocxFieldStructure(document) || bodyFields.some((field)=>!docxFieldOccurrenceIsInlineEditable(field));
+    const bookmarkNames = new Set([
+        ...captionBookmarkNames(sequences),
+        ...pairedBookmarkNames(document)
+    ]);
     return {
         issues: [
             ...sequences.length ? [
@@ -20,16 +103,24 @@ function diagnoseDocxCaptions(document) {
                     severity: 'info'
                 }
             ] : [],
-            ...bodyFields.length ? [
+            ...editableBodyFields.length ? [
                 {
                     code: 'docx.fields.body',
                     feature: 'Body fields',
                     message: 'PAGE, NUMPAGES, SECTION, SECTIONPAGES, DATE, and TIME fields remain live, editable body fields and update in preview, PDF, and native DOCX output.',
                     severity: 'info'
                 }
+            ] : [],
+            ...hasUnsupportedFieldStructure ? [
+                {
+                    code: 'docx.fields.structure',
+                    feature: 'Field structure',
+                    message: 'Incomplete, nested, cross-paragraph, deleted, or instructionless fields cannot form one editable inline field; their current results are retained as text.',
+                    severity: 'warning'
+                }
             ] : []
         ],
-        hasUnsupportedFields: fields.some((field)=>!isSupportedCaptionField(field.instruction, bookmarkNames))
+        hasUnsupportedFields: hasUnsupportedFieldStructure || fields.some((field)=>!isSupportedCaptionField(field.instruction, bookmarkNames))
     };
 }
 function captionBookmarkNames(fields) {
@@ -39,7 +130,7 @@ function captionBookmarkNames(fields) {
         if (!paragraph) continue;
         const bookmark = docxCaptionBookmark(paragraph, field);
         const name = attribute(bookmark ?? paragraph, 'name')?.trim();
-        if (name) names.add(name);
+        if (name) names.add(name.toLowerCase());
     }
     return names;
 }
@@ -47,8 +138,18 @@ function isSupportedCaptionField(instruction, bookmarkNames) {
     if (documentCitationTagsFromInstruction(instruction).length || /^\s*BIBLIOGRAPHY\b/i.test(instruction)) return true;
     if (docxDocumentFieldKind(instruction)) return true;
     if (docxCaptionSequenceKind(instruction)) return true;
-    const target = docxCaptionReferenceTarget(instruction);
-    return Boolean(target && bookmarkNames.has(target));
+    const target = docxBookmarkReferenceTarget(instruction);
+    return Boolean(target && bookmarkNames.has(target.toLowerCase()));
+}
+function pairedBookmarkNames(document) {
+    const endIds = new Set(descendants(document, 'bookmarkEnd').map((bookmark)=>attribute(bookmark, 'id')?.trim() ?? ''));
+    return new Set(descendants(document, 'bookmarkStart').flatMap((bookmark)=>{
+        const id = attribute(bookmark, 'id')?.trim() ?? '';
+        const name = attribute(bookmark, 'name')?.trim().toLowerCase() ?? '';
+        return id && name && endIds.has(id) ? [
+            name
+        ] : [];
+    }));
 }
 function closestAncestor(element, localName) {
     let current = element;
@@ -114,21 +215,99 @@ async function diagnoseDocxCitations(archive, document) {
     });
     return issues;
 }
+const EQUATION_PART_PATTERN = /^word\/(?:header\d*|footer\d*|footnotes|endnotes)\.xml$/i;
+const MAX_EDITABLE_EQUATIONS = 4096;
+async function diagnoseDocxEquations(archive, document) {
+    const parts = document ? [
+        {
+            path: 'word/document.xml',
+            document
+        }
+    ] : [];
+    for (const path of archive.paths('word/').filter((candidate)=>EQUATION_PART_PATTERN.test(candidate)))parts.push({
+        path,
+        document: await archive.xml(path)
+    });
+    let supported = 0;
+    let unsupported = 0;
+    let spoofed = 0;
+    for (const part of parts)for (const element of Array.from(part.document.querySelectorAll('*')).filter((candidate)=>'oMath' === candidate.localName || 'oMathPara' === candidate.localName)){
+        if (closestEquationRoot(element.parentElement)) continue;
+        const inspection = inspectDocxEquation(element);
+        if ('supported' === inspection.status && isSupportedDocxEquationPlacement(element)) supported += 1;
+        else if ('spoofed' === inspection.status) spoofed += 1;
+        else unsupported += 1;
+    }
+    const total = supported + unsupported + spoofed;
+    if (!total) return [];
+    const issues = [];
+    if (supported) issues.push(equationIssue('docx.equations', `${supported} native OMML equation(s) use the editable structured subset. Inline equations and display equations with left, right, center, or center-group paragraph justification, Unicode math runs with literal/normal-text semantics, six math scripts, four styles, manual breaks, alignment points, ordered core Word run formatting for fonts/theme references, emphasis, casing, strike, relief effects, legacy text animations, bounded line borders, proofing/grid flags, visibility, colors, bounded character spacing, horizontal scaling, kerning thresholds, signed baseline positions, half-point sizes, named highlights, patterned shading, bounded manual run widths with optional grouping IDs, explicit baseline/superscript/subscript run alignment, all five Word emphasis-mark values, underlines, script direction, languages, native-only East Asian typography with signed run IDs, two-lines-in-one brackets, rotation, and compression, inert paragraph-mark visibility resets, and Office 2010 text glow, shadow, reflection, text-outline, text-fill, 3D-scene, and 3D-property effects with bounded radii, offsets, outline widths, extrusion heights, and contour widths, exact direction and reflection opacity/position/fade geometry, signed scale and skew, rectangle and pen alignment, glow/shadow/outline/fill/extrusion/contour RGB or theme colors and ordered transform chains, none/solid/gradient outline and text fills with bounded stops and linear/path shading, preset dashes, round/bevel/miter joins, all camera, light-rig, bevel, and material presets, all light directions, exact optional rotation angles, ordered top/bottom bevel plus extrusion/contour color branches, all 16 ligature combinations, three numeral forms, three numeral-spacing modes, bounded Office 2010 stylistic-set lists, and explicit contextual-alternate controls with exact combined CSS OpenType projection and distinct clig/calt behavior, with exact direct RGB and default-black text fills projected to MathML while complex effects remain native metadata, and the same bounded Word formatting in ordered object-level control properties and native-only argument-slot control properties, bounded insertion, deletion, move-source, and move-destination provenance around those math controls, ordered fractions with four native types and a bar default, ordered right-side scripts with aligned sub/superscripts, left-side pre-sub/superscripts with empty script slots, radicals with optional degrees and canonical square-root slots, functions with required, optionally empty name/argument slots, canonical empty arguments across every supported construct, ordered argument/control properties, bounded relative argument sizes with Word-effective MathML script-level projection and native-only preservation elsewhere, and strictly aligned matrix-cell, equation-array-row, and delimiter-argument metadata, ordered n-ary operators with default integrals, canonical empty limit slots, and optional operand growth, combining accents, overbars and underbars, group characters with explicit character position and baseline justification, phantoms with visible or hidden bases, zeroed width/ascent/descent, and transparent spacing, border boxes with independently visible edges and four strike directions, semantic boxes with operator-emulation, no-break, differential-spacing, manual-break, and alignment properties, bounded rectangular matrices with ordered row-spacing, column-gap, and minimum-width controls, equation arrays with bounded rows, vertical base alignment, distribution, row-spacing, and alignment/spacer markers, lower and upper limit objects, ordered delimiters with distinct omitted/empty characters, bounded empty argument slots, growing or fixed sizing, and centered or content-matched shape, and their accessible MathML previews round-trip through body text, headers, footers, footnotes, and endnotes.`, 'info'));
+    if (unsupported || spoofed) issues.push(equationIssue('docx.equations.unsupported', `${unsupported + spoofed} equation-like object(s) use unsupported, malformed, misplaced, namespace-spoofed, relationship-bound, or ambiguous markup. They are flattened to bounded text instead of being treated as trusted structured OMML. Invalid or non-combining accent characters, malformed math-run, script, function, argument-property, or math-paragraph structures, unknown, duplicated, reordered, spoofed, out-of-range, or contradictory Word math-run casing, strike, relief, animation, line-border, visibility, geometry, manual-width, vertical-alignment, emphasis-mark, East Asian typography, paragraph-mark visibility, Office 2010 glow/shadow/outline/text-fill color transforms, glow/shadow/reflection geometry, outline fill/gradient/dash/join structure, text-fill wrapper/fill/gradient structure, 3D-scene camera/light structure, or 3D-property extrusion/contour/bevel/color structure, missing, malformed, or non-leaf Office 2010 ligature, numeral-form, or numeral-spacing values, malformed or over-limit stylistic-set containers, entries, IDs, or on/off values, malformed contextual-alternate leaves or on/off values, coordinate values, preset values, directions, or rotation angles, highlight, shading, object-control, or argument-control formatting, malformed control-revision identities, dates, children, or nesting, out-of-range or malformed argument sizes, invalid or contradictory fraction, radical, n-ary, delimiter, bar, group-character, phantom, border-box, box, or equation-array properties, malformed pre-script or lower/upper limit structures, malformed, duplicated, reordered, or out-of-range matrix spacing/gap properties, ragged or over-limit matrices, over-limit equation arrays, and nested Office Math remain outside the structured subset.`));
+    if (total > MAX_EDITABLE_EQUATIONS) issues.push(equationIssue('docx.equations.limit', `Only the first ${MAX_EDITABLE_EQUATIONS} valid equations enter the editable structured model; later equations are flattened to bounded text.`));
+    return issues;
+}
+function closestEquationRoot(element) {
+    let current = element;
+    while(current){
+        if ('oMath' === current.localName || 'oMathPara' === current.localName) return current;
+        current = current.parentElement;
+    }
+    return null;
+}
+function equationIssue(code, message, severity = 'warning') {
+    return {
+        code,
+        feature: 'Equations',
+        message,
+        severity
+    };
+}
+const WORDPROCESSINGML_NAMESPACES = new Set([
+    'http://schemas.openxmlformats.org/wordprocessingml/2006/main',
+    'http://purl.oclc.org/ooxml/wordprocessingml/main'
+]);
+const WORDPROCESSING_DRAWING_NAMESPACES = new Set([
+    'http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing',
+    'http://purl.oclc.org/ooxml/drawingml/wordprocessingDrawing'
+]);
+const DRAWINGML_NAMESPACES = new Set([
+    'http://schemas.openxmlformats.org/drawingml/2006/main',
+    'http://purl.oclc.org/ooxml/drawingml/main'
+]);
+const PICTURE_NAMESPACES = new Set([
+    'http://schemas.openxmlformats.org/drawingml/2006/picture',
+    'http://purl.oclc.org/ooxml/drawingml/picture'
+]);
+const RELATIONSHIP_NAMESPACES = new Set([
+    'http://schemas.openxmlformats.org/officeDocument/2006/relationships',
+    'http://purl.oclc.org/ooxml/officeDocument/relationships'
+]);
 async function diagnoseDocxNotes(archive, document) {
     const noteParts = [
-        'word/footnotes.xml',
-        'word/endnotes.xml'
-    ].filter((part)=>archive.has(part));
-    const noteDocuments = await Promise.all(noteParts.map((part)=>archive.xml(part)));
-    const hasNotes = Boolean(document && (descendants(document, 'footnoteReference').length || descendants(document, 'endnoteReference').length)) || noteDocuments.some((notes)=>[
-            ...descendants(notes, 'footnote'),
-            ...descendants(notes, 'endnote')
-        ].some((note)=>Number(attribute(note, 'id')) > 0));
+        {
+            path: 'word/footnotes.xml',
+            kind: 'footnote',
+            reference: 'footnoteReference'
+        },
+        {
+            path: 'word/endnotes.xml',
+            kind: 'endnote',
+            reference: 'endnoteReference'
+        }
+    ].filter(({ path })=>archive.has(path));
+    const noteDocuments = await Promise.all(noteParts.map(async ({ path, kind, reference })=>({
+            kind,
+            reference,
+            document: await archive.xml(path)
+        })));
+    const hasNotes = Boolean(document && (descendants(document, 'footnoteReference').length || descendants(document, 'endnoteReference').length)) || noteDocuments.some(({ document: notes, kind })=>normalNoteDefinitions(notes, kind).length);
     if (!hasNotes) return [];
     const issues = [
-        noteIssue('docx.notes', 'Footnote and endnote references, editable note text, common inline formatting, preview placement, and native DOCX note parts are preserved.', 'info')
+        noteIssue('docx.notes', 'Footnote and endnote references, stable native IDs, editable note text, native tables, DrawingML pictures, supported structured OMML equations, common inline formatting, safe web, mail, and internal hyperlinks, eligible static text content controls, preview placement, native DOCX note parts, and eligible passive definition, paragraph, table, drawing, wrapper, and text-stable run metadata are preserved.', 'info')
     ];
-    if (noteDocuments.some((notes)=>descendants(notes, 'tbl').length > 0 || descendants(notes, 'drawing').length > 0 || descendants(notes, 'pict').length > 0)) issues.push(noteIssue('docx.notes.rich-content', 'Tables, drawings, and embedded media inside notes may be flattened or converted to inline content.'));
+    if (hasInvalidNoteStructure(document, noteDocuments)) issues.push(noteIssue('docx.notes.structure', 'Missing, duplicate, unreferenced, or nested footnote and endnote identities cannot form a unique editable pair; unmatched content is omitted and repeated references receive new identities during editing import.'));
+    if (noteDocuments.some(({ document: notes })=>descendants(notes, 'pict').length > 0 || noteHasUnsupportedEquation(notes) || descendants(notes, 'drawing').some((drawing)=>!isSupportedNotePicture(drawing)))) issues.push(noteIssue('docx.notes.rich-content', 'Legacy VML pictures, shapes, SmartArt, unsupported or malformed equations, and non-picture drawings inside notes may be flattened or converted to bounded inline content. Native paragraphs, tables, validated DrawingML pictures, and supported structured OMML equations remain editable within the declared static-content boundary.'));
+    if (noteDocuments.some(({ document: notes })=>descendants(notes, 'sdt').length > 0)) issues.push(noteIssue('docx.notes.content-controls', 'Text-stable static rich-text and plain-text controls retain eligible inline or contiguous block wrappers and metadata. Rich-text block controls may include uniquely matched stable tables and nested tables while generated geometry remains authoritative. Data-bound, placeholder, form, nested, relationship-bound, ambiguous, edited-structure, math, drawing-bearing, or mixed-hyperlink control wrappers normalize instead of being reattached unsafely.'));
     const settings = archive.has('word/settings.xml') ? await archive.xml('word/settings.xml') : null;
     const noteProperties = [
         ...document ? descendants(document, 'footnotePr') : [],
@@ -139,6 +318,58 @@ async function diagnoseDocxNotes(archive, document) {
     if (noteProperties.some((properties)=>directChildren(properties).length > 0)) issues.push(noteIssue('docx.notes.numbering', 'Custom note symbols, numbering formats, restart rules, separators, and placement settings normalize to continuous Arabic numbering with footnotes per page and endnotes at document end.'));
     return issues;
 }
+function noteHasUnsupportedEquation(document) {
+    return Array.from(document.querySelectorAll('*')).some((element)=>('oMath' === element.localName || 'oMathPara' === element.localName) && ('supported' !== inspectDocxEquation(element).status || !isSupportedDocxEquationPlacement(element)));
+}
+function isSupportedNotePicture(drawing) {
+    if (!WORDPROCESSINGML_NAMESPACES.has(drawing.namespaceURI ?? '')) return false;
+    const containers = directChildren(drawing).filter((element)=>('anchor' === element.localName || 'inline' === element.localName) && WORDPROCESSING_DRAWING_NAMESPACES.has(element.namespaceURI ?? ''));
+    if (1 !== containers.length) return false;
+    const container = containers[0];
+    const graphicData = descendants(container, 'graphicData').filter((element)=>DRAWINGML_NAMESPACES.has(element.namespaceURI ?? ''));
+    const pictures = descendants(container, 'pic').filter((element)=>PICTURE_NAMESPACES.has(element.namespaceURI ?? ''));
+    const blips = descendants(container, 'blip').filter((element)=>DRAWINGML_NAMESPACES.has(element.namespaceURI ?? ''));
+    return 1 === graphicData.length && PICTURE_NAMESPACES.has(graphicData[0].getAttribute('uri') ?? '') && 1 === pictures.length && 1 === blips.length && hasRelationshipAttribute(blips[0], 'embed');
+}
+function hasRelationshipAttribute(element, name) {
+    return Array.from(element.attributes).some((item)=>xmlAttributeLocalName(item) === name && RELATIONSHIP_NAMESPACES.has(xmlAttributeNamespace(element, item) ?? '') && Boolean(item.value.trim()));
+}
+function hasInvalidNoteStructure(document, parts) {
+    for (const part of parts){
+        const definitions = normalNoteDefinitions(part.document, part.kind);
+        const definitionsById = groupedById(definitions);
+        const references = document ? descendants(document, part.reference) : [];
+        const referencesById = groupedById(references);
+        const referenceIds = new Set(references.flatMap((reference)=>{
+            const id = attribute(reference, 'id')?.trim() ?? '';
+            return id ? [
+                id
+            ] : [];
+        }));
+        if (references.some((reference)=>!attribute(reference, 'id')?.trim()) || Array.from(referencesById.values()).some((matches)=>matches.length > 1) || references.some((reference)=>{
+            const id = attribute(reference, 'id')?.trim() ?? '';
+            return id && (definitionsById.get(id)?.length ?? 0) !== 1;
+        }) || definitions.some((definition)=>!attribute(definition, 'id')?.trim()) || Array.from(definitionsById.values()).some((matches)=>matches.length > 1) || Array.from(definitionsById.keys()).some((id)=>!referenceIds.has(id)) || descendants(part.document, 'footnoteReference').length > 0 || descendants(part.document, 'endnoteReference').length > 0) return true;
+    }
+    if (!document) return false;
+    return descendants(document, 'footnoteReference').length > 0 && !parts.some(({ kind })=>'footnote' === kind) || descendants(document, 'endnoteReference').length > 0 && !parts.some(({ kind })=>'endnote' === kind);
+}
+function normalNoteDefinitions(document, kind) {
+    return descendants(document, kind).filter((note)=>{
+        const type = attribute(note, 'type')?.trim().toLowerCase() ?? '';
+        return !type || 'normal' === type;
+    });
+}
+function groupedById(elements) {
+    const groups = new Map();
+    for (const element of elements){
+        const id = attribute(element, 'id')?.trim() ?? '';
+        const matches = groups.get(id) ?? [];
+        matches.push(element);
+        groups.set(id, matches);
+    }
+    return groups;
+}
 function noteIssue(code, message, severity = 'warning') {
     return {
         code,
@@ -147,6 +378,67 @@ function noteIssue(code, message, severity = 'warning') {
         severity
     };
 }
+async function diagnoseDocxPageBorders(archive, document) {
+    const themePath = archive.paths('word/theme/').find((path)=>/\/theme\d*\.xml$/i.test(path));
+    const themeDocument = themePath ? await archive.xml(themePath) : null;
+    const settingsDocument = archive.has('word/settings.xml') ? await archive.xml('word/settings.xml') : null;
+    const theme = createDocxThemeResolver(themeDocument, settingsDocument);
+    const sections = descendants(document, 'sectPr').filter((element)=>DOCX_WORDPROCESSING_NAMESPACES.has(element.namespaceURI ?? '') && !hasAncestor(element, 'sectPrChange'));
+    const inspected = sections.map((section)=>inspectDocxPageBorders(section, theme));
+    const valid = inspected.flatMap((item)=>'valid' === item.status && item.pageBorders ? [
+            item.pageBorders
+        ] : []);
+    const invalidCount = inspected.reduce((count, item)=>count + item.invalidCount, 0);
+    const spoofedCount = inspected.reduce((count, item)=>count + item.spoofedCount, 0);
+    if (!valid.length && !invalidCount && !spoofedCount) return [];
+    const issues = [];
+    if (valid.length) {
+        const edgeCount = valid.reduce((count, pageBorders)=>count + Object.values(pageBorders.edges).filter(Boolean).length, 0);
+        const artCount = valid.reduce((count, pageBorders)=>count + Object.values(pageBorders.edges).filter((border)=>border && isDocumentParagraphArtBorderStyle(border.style)).length, 0);
+        issues.push({
+            code: 'docx.page-borders',
+            severity: 'info',
+            feature: 'Page borders',
+            message: `${valid.length} section page-border set(s) with ${edgeCount} native edge(s) preserve page/text offsets, first/not-first-page display, front/back z-order, theme colors, widths, spacing, shadows, frames, and all Word line or art styles. The paginated editor and PDF surface honor section/page visibility and Word defaults; ${artCount} art edge(s) use a bounded browser approximation while native OOXML remains authoritative on DOCX export.`
+        });
+    }
+    if (invalidCount || spoofedCount) issues.push({
+        code: 'docx.page-borders.invalid',
+        severity: 'warning',
+        feature: 'Page borders',
+        message: `${invalidCount + spoofedCount} malformed, out-of-order, duplicated, namespace-spoofed, relationship-bound, or unresolved theme page-border value(s) are ignored or normalized to explicit nil edges instead of applying unsafe or stale section formatting.`
+    });
+    const modifiers = settingsDocument ? [
+        'alignBordersAndEdges',
+        'bordersDoNotSurroundHeader',
+        'bordersDoNotSurroundFooter'
+    ].filter((name)=>enabledSetting(settingsDocument, name)) : [];
+    if (valid.length && modifiers.length) issues.push({
+        code: 'docx.page-borders.settings',
+        severity: 'warning',
+        feature: 'Page-border compatibility settings',
+        message: `${modifiers.join(', ')} modifies Word's interaction between page borders, page edges, headers, or footers. Native section borders remain editable and exact, but the browser preview uses the standardized pgBorders geometry and may not reproduce these application-specific document-wide adjustments.`
+    });
+    return issues;
+}
+function enabledSetting(document, localName) {
+    const element = descendants(document, localName).find((candidate)=>DOCX_WORDPROCESSING_NAMESPACES.has(candidate.namespaceURI ?? ''));
+    if (!element) return false;
+    const value = attribute(element, 'val')?.trim().toLowerCase();
+    return !value || ![
+        '0',
+        'false',
+        'off'
+    ].includes(value);
+}
+function hasAncestor(element, localName) {
+    let ancestor = element.parentElement;
+    while(ancestor){
+        if (ancestor.localName === localName) return true;
+        ancestor = ancestor.parentElement;
+    }
+    return false;
+}
 const PAGE_FIELD = /^\s*PAGE(?:\s|\\|$)/i;
 const ADVANCED_POSITIONING = new Set([
     'anchor',
@@ -176,11 +468,12 @@ async function diagnoseDocxPageChrome(archive) {
             document: await archive.xml(path)
         })));
     const issues = [
-        pageChromeIssue('docx.headers', 'Rich default, first-page, and even-page headers and footers, common formatting, tables, links, inline raster images, and PAGE numbering are preserved, editable, and used by preview, PDF, and native DOCX output.', 'info')
+        pageChromeIssue('docx.headers', 'Rich default, first-page, and even-page headers and footers, common formatting, tables, links, inline raster images, supported structured OMML equations, and PAGE numbering are preserved, editable, and used by preview, PDF, and native DOCX output.', 'info')
     ];
     const instructions = documents.flatMap(({ document })=>docxFieldInstructions(document));
     if (instructions.some((instruction)=>!PAGE_FIELD.test(instruction))) issues.push(pageChromeIssue('docx.headers.fields', 'PAGE numbering is preserved. Other header/footer field codes are flattened to their current displayed text and no longer update automatically.'));
     if (documents.some(({ path, document })=>path.startsWith('word/header') && docxFieldInstructions(document).some((instruction)=>PAGE_FIELD.test(instruction)))) issues.push(pageChromeIssue('docx.headers.page-field-position', "PAGE fields placed in a header are preserved through Work's centered footer page-number slot."));
+    if (documents.some(({ document })=>Array.from(document.querySelectorAll('*')).some((element)=>('oMath' === element.localName || 'oMathPara' === element.localName) && ('supported' !== inspectDocxEquation(element).status || !isSupportedDocxEquationPlacement(element))))) issues.push(pageChromeIssue('docx.headers.equations', 'Unsupported, malformed, misplaced, or namespace-spoofed header/footer equations are flattened to bounded text instead of entering the editable OMML model.'));
     if (documents.some(({ document })=>descendants(document, 'sdt').length > 0)) issues.push(pageChromeIssue('docx.headers.content-controls', 'Header/footer content controls are flattened to editable content; bindings, locking, and repeating behavior are not preserved.'));
     if (documents.some(({ document })=>Array.from(document.querySelectorAll('*')).some((element)=>ADVANCED_POSITIONING.has(element.localName)))) issues.push(pageChromeIssue('docx.headers.positioning', 'Floating drawings, text boxes, tab stops, indents, and advanced header/footer positioning are normalized to inline flow.'));
     return issues;
@@ -193,6 +486,178 @@ function pageChromeIssue(code, message, severity = 'warning') {
         severity
     };
 }
+async function diagnoseDocxPageMargins(archive, document) {
+    const settingsDocument = archive.has('word/settings.xml') ? await archive.xml('word/settings.xml') : null;
+    const settings = inspectDocxPageMarginSettings(settingsDocument);
+    const sections = descendants(document, 'sectPr').filter((element)=>DOCX_WORDPROCESSING_NAMESPACES.has(element.namespaceURI ?? '') && !work_docx_page_margins_diagnostics_hasAncestor(element, 'sectPrChange'));
+    const inspected = sections.map((section)=>inspectDocxPageMargins(section, settings));
+    const valid = inspected.flatMap((item, index)=>'valid' === item.status && item.pageMargins ? [
+            {
+                section: sections[index],
+                pageMargins: item.pageMargins
+            }
+        ] : []);
+    const invalidCount = settings.invalidCount + inspected.reduce((count, item)=>count + item.invalidCount, 0);
+    const spoofedCount = settings.spoofedCount + inspected.reduce((count, item)=>count + item.spoofedCount, 0);
+    if (!valid.length && !invalidCount && !spoofedCount) return [];
+    const issues = [];
+    if (valid.length) {
+        const gutterSections = valid.filter(({ pageMargins })=>pageMargins.gutter > 0).length;
+        const overlapSections = valid.filter(({ pageMargins })=>pageMargins.top < 0 || pageMargins.bottom < 0).length;
+        issues.push({
+            code: 'docx.page-margins',
+            severity: 'info',
+            feature: 'Page margins',
+            message: `${valid.length} section page-margin set(s) preserve all seven native pgMar values in exact twips, including header and footer distances, ${gutterSections} binding gutter(s), ${overlapSections} signed header/footer-overlap geometry set(s), document-wide mirror/top-gutter settings, per-section right-side gutters, strict namespaces, editing controls, paginated preview, and exact DOCX output.`
+        });
+    }
+    if (invalidCount || spoofedCount) issues.push({
+        code: 'docx.page-margins.invalid',
+        severity: 'warning',
+        feature: 'Page margins',
+        message: `${invalidCount + spoofedCount} malformed, duplicated, incomplete, out-of-range, namespace-spoofed, relationship-bound, or structurally invalid pgMar, mirrorMargins, gutterAtTop, or rtlGutter value(s) are ignored instead of becoming trusted page geometry.`
+    });
+    const incompatible = settings.incompatible;
+    if (valid.some(({ pageMargins })=>pageMargins.gutterAtTop) && incompatible.length) issues.push({
+        code: 'docx.page-margins.gutter-conflict',
+        severity: 'warning',
+        feature: 'Page-margin compatibility settings',
+        message: `${incompatible.join(', ')} conflicts with gutterAtTop under WordprocessingML. Native values remain explicit, but the browser applies the facing-page or print-layout setting before the top-gutter request.`
+    });
+    if (valid.some(({ pageMargins })=>pageMargins.mirrorMargins && (pageMargins.left !== pageMargins.right || pageMargins.gutter > 0))) issues.push({
+        code: 'docx.page-margins.facing-pages',
+        severity: 'warning',
+        feature: 'Facing-page margins',
+        message: 'PDF pages and page decorations swap facing-page margins and the binding gutter per physical page. The continuous live editing surface keeps the same text width and native geometry but projects the first-page horizontal origin between page breaks.'
+    });
+    const bounded = valid.filter(({ section, pageMargins })=>{
+        const inspectedSize = inspectDocxPageSize(section);
+        const width = inspectedSize.pageGeometry?.width ?? 11906;
+        const height = inspectedSize.pageGeometry?.height ?? 16838;
+        const topGutter = true === pageMargins.gutterAtTop && true !== pageMargins.mirrorMargins;
+        return pageMargins.left + pageMargins.right + (topGutter ? 0 : pageMargins.gutter) >= width || Math.abs(pageMargins.top) + Math.abs(pageMargins.bottom) + (topGutter ? pageMargins.gutter : 0) >= height;
+    }).length;
+    if (bounded) issues.push({
+        code: 'docx.page-margins.body-bounds',
+        severity: 'warning',
+        feature: 'Page-margin body bounds',
+        message: `${bounded} section(s) leave no positive body rectangle. Exact native values remain authoritative for DOCX output; browser rendering proportionally bounds the affected margin pair to retain a one-millimetre inspectable body surface.`
+    });
+    return issues;
+}
+function work_docx_page_margins_diagnostics_hasAncestor(element, localName) {
+    let ancestor = element.parentElement;
+    while(ancestor){
+        if (ancestor.localName === localName) return true;
+        ancestor = ancestor.parentElement;
+    }
+    return false;
+}
+function diagnoseDocxPageSize(document) {
+    const sections = descendants(document, 'sectPr').filter((element)=>DOCX_WORDPROCESSING_NAMESPACES.has(element.namespaceURI ?? '') && !work_docx_page_size_diagnostics_hasAncestor(element, 'sectPrChange'));
+    const sizes = sections.map(inspectDocxPageSize);
+    const sources = sections.map(inspectDocxPaperSource);
+    const validSizes = sizes.flatMap((item)=>'valid' === item.status && item.pageGeometry ? [
+            item.pageGeometry
+        ] : []);
+    const validSources = sources.flatMap((item)=>'valid' === item.status && item.paperSource ? [
+            item.paperSource
+        ] : []);
+    const invalidCount = [
+        ...sizes,
+        ...sources
+    ].reduce((count, item)=>count + item.invalidCount + item.spoofedCount, 0);
+    if (!validSizes.length && !validSources.length && !invalidCount) return [];
+    const issues = [];
+    if (validSizes.length) {
+        const customCodes = validSizes.filter((geometry)=>void 0 !== geometry.code).length;
+        const explicitOrientations = validSizes.filter((geometry)=>void 0 !== geometry.orientation).length;
+        issues.push({
+            code: 'docx.page-size',
+            severity: 'info',
+            feature: 'Page size',
+            message: `${validSizes.length} explicit section page-size set(s) preserve exact native width and height in twips, ${explicitOrientations} explicit orientation value(s), and ${customCodes} Word paper code(s) through editing, preview, PDF, and DOCX output. Strict OOXML universal measures are accepted only when they convert to an exact integer twip.`
+        });
+    }
+    if (validSources.length) issues.push({
+        code: 'docx.paper-source',
+        severity: 'info',
+        feature: 'Printer paper source',
+        message: `${validSources.length} section printer paper-source set(s) preserve their exact first-page and other-page tray codes in DOCX. The browser does not reinterpret printer-driver-specific tray numbers.`
+    });
+    if (invalidCount) issues.push({
+        code: 'docx.page-size.invalid',
+        severity: 'warning',
+        feature: 'Page setup',
+        message: `${invalidCount} malformed, duplicated, incomplete, out-of-range, namespace-spoofed, relationship-bound, or structurally invalid pgSz or paperSrc value(s) are ignored instead of becoming trusted page or printer geometry.`
+    });
+    const bounded = validSizes.filter((geometry)=>geometry.width < 1440 || geometry.height < 1440).length;
+    if (bounded) issues.push({
+        code: 'docx.page-size.browser-bounds',
+        severity: 'warning',
+        feature: 'Small page rendering',
+        message: `${bounded} valid section page-size set(s) use an edge below one inch. Exact native values remain authoritative for DOCX output; browser editing and PDF projection bound the affected edge to one inch so the page remains inspectable.`
+    });
+    return issues;
+}
+function work_docx_page_size_diagnostics_hasAncestor(element, localName) {
+    let ancestor = element.parentElement;
+    while(ancestor){
+        if (ancestor.localName === localName) return true;
+        ancestor = ancestor.parentElement;
+    }
+    return false;
+}
+async function diagnoseDocxParagraphBorders(archive, document) {
+    const stylesDocument = archive.has('word/styles.xml') ? await archive.xml('word/styles.xml') : null;
+    const themePath = archive.paths('word/theme/').find((path)=>/\/theme\d*\.xml$/i.test(path));
+    const themeDocument = themePath ? await archive.xml(themePath) : null;
+    const settingsDocument = archive.has('word/settings.xml') ? await archive.xml('word/settings.xml') : null;
+    const markers = markDocxParagraphBorders(document.cloneNode(true), createDocxParagraphStyleResolver(stylesDocument), createDocxThemeResolver(themeDocument, settingsDocument), createDocxTableStyleResolver(stylesDocument));
+    const nativeCount = Array.from(document.getElementsByTagName('*')).filter((element)=>'pBdr' === element.localName && element.parentElement?.localName === 'pPr' && DOCX_WORDPROCESSING_NAMESPACES.has(element.namespaceURI ?? '')).length;
+    if (!nativeCount && !markers.paragraphs.length && !markers.invalidCount && !markers.spoofedCount) return [];
+    const issues = [];
+    if (markers.paragraphs.length) {
+        const artCount = markers.paragraphs.reduce((count, paragraph)=>count + Object.values(paragraph.borders).filter((border)=>border && isDocumentParagraphArtBorderStyle(border.style)).length, 0);
+        const specialCount = markers.paragraphs.reduce((count, paragraph)=>count + Number(Boolean(paragraph.borders.between)) + Number(Boolean(paragraph.borders.bar)), 0);
+        issues.push({
+            code: 'docx.paragraph-borders',
+            severity: 'info',
+            feature: 'Paragraph borders',
+            message: `${markers.paragraphs.length} paragraph border set(s) resolve through document defaults, based-on paragraph styles, conditional table styles, and direct formatting. All six native edges, theme colors, widths, spacing, shadows, frames, and all Word line or art styles round-trip; ${artCount + specialCount} art, between-paragraph, or facing-page edge(s) use a bounded browser approximation while retaining native OOXML semantics.`
+        });
+    }
+    if (markers.invalidCount || markers.spoofedCount) issues.push({
+        code: 'docx.paragraph-borders.invalid',
+        severity: 'warning',
+        feature: 'Paragraph borders',
+        message: `${markers.invalidCount + markers.spoofedCount} malformed, out-of-order, duplicated, namespace-spoofed, relationship-bound, or unresolved theme paragraph border value(s) are ignored or normalized to explicit nil resets instead of inheriting stale formatting.`
+    });
+    return issues;
+}
+async function diagnoseDocxParagraphShading(archive, document) {
+    const stylesDocument = archive.has('word/styles.xml') ? await archive.xml('word/styles.xml') : null;
+    const themePath = archive.paths('word/theme/').find((path)=>/\/theme\d*\.xml$/i.test(path));
+    const themeDocument = themePath ? await archive.xml(themePath) : null;
+    const settingsDocument = archive.has('word/settings.xml') ? await archive.xml('word/settings.xml') : null;
+    const markers = markDocxParagraphShading(document.cloneNode(true), createDocxParagraphStyleResolver(stylesDocument), createDocxThemeResolver(themeDocument, settingsDocument), createDocxTableStyleResolver(stylesDocument));
+    const nativeCount = Array.from(document.getElementsByTagName('*')).filter((element)=>'shd' === element.localName && element.parentElement?.localName === 'pPr' && DOCX_WORDPROCESSING_NAMESPACES.has(element.namespaceURI ?? '')).length;
+    if (!nativeCount && !markers.paragraphs.length && !markers.invalidCount && !markers.spoofedCount) return [];
+    const issues = [];
+    if (markers.paragraphs.length) issues.push({
+        code: 'docx.paragraph-shading',
+        severity: 'info',
+        feature: 'Paragraph shading',
+        message: `${markers.paragraphs.length} paragraph shading value(s) resolve through document defaults, based-on paragraph styles, conditional table styles, and direct formatting. All Word pattern masks, direct or automatic foreground/background colors, and independently tinted or shaded theme references remain editable and round-trip to native w:shd markup.`
+    });
+    if (markers.invalidCount || markers.spoofedCount) issues.push({
+        code: 'docx.paragraph-shading.invalid',
+        severity: 'warning',
+        feature: 'Paragraph shading',
+        message: `${markers.invalidCount + markers.spoofedCount} malformed, duplicated, namespace-spoofed, relationship-bound, or unresolved theme paragraph shading value(s) are ignored or normalized to an explicit nil reset instead of inheriting stale formatting.`
+    });
+    return issues;
+}
 const SUPPORTED_CHART_ELEMENTS = new Set([
     'barChart',
     'lineChart',
@@ -1163,35 +1628,64 @@ async function diagnoseXlsxPivots(archive) {
 }
 async function analyzeDocxCompatibility(file, messages) {
     const issues = [
-        work_office_diagnostics_issue('docx.page-layout', 'Page layout', 'Per-section paper size, orientation, basic margins, one-to-six equal or custom-width columns, section breaks, and explicit page breaks are preserved; exact pagination and line wrapping may normalize.')
+        work_office_diagnostics_issue('docx.page-layout', 'Page layout', 'Per-section paper size, orientation, exact native page margins, one-to-six equal or custom-width columns, section breaks, and explicit page breaks are preserved; exact pagination and line wrapping may normalize.'),
+        work_office_diagnostics_issue('docx.package-state', 'OOXML package state', 'Source-backed export retains safe source-only parts byte-for-byte and reconnects their content types and relationships. Passive relationship-free extensions in settings XML, uniquely matched style or numbering identities, stable picture drawings, unchanged native-identity paragraphs, stable table, row, or cell scopes, and uniquely matched footnote, endnote, comment, or comment-thread records are preserved against the final package graph. Text-stable direct, supported-hyperlink-wrapped, and eligible static-content-control note and comment runs retain paragraph, table, wrapper, run, and run-property metadata; native note tables and DrawingML pictures remain editable, note image relationships and media targets are repaired and validated, bounded structured OMML equations remain atomically updateable in supported Word stories, uniquely matched table-bearing rich-text controls are reconstructed, safe web, mail, and internal note/comment links are rebound to collision-free final relationship IDs, and content-control ID collisions are rewritten. Native note, comment, and note-picture identities survive reorderings, comment durable IDs are rebound to regenerated paragraph IDs, and eligible source font-table metadata is retained. Generated Word semantics remain authoritative; source-only, changed-text or table structure, malformed, duplicate or cross-kind, active, unsupported wrappers, mixed-semantic, unsafe relationship-bound, legacy VML, non-picture drawings, or unsupported rich content may normalize.', 'info')
     ];
     for (const message of messages)issues.push(work_office_diagnostics_issue(`docx.converter.${message.type}`, 'Document conversion', message.message, 'error' === message.type ? 'error' : 'warning'));
     try {
         const archive = await OoxmlPackage.load(await file.arrayBuffer());
+        const packagePaths = archive.paths('');
+        const normalizedPackagePaths = packagePaths.map((path)=>path.toLowerCase());
         const document = archive.has('word/document.xml') ? await archive.xml('word/document.xml') : null;
+        if (normalizedPackagePaths.some((path)=>path.startsWith('_xmlsignatures/'))) issues.push(work_office_diagnostics_issue('docx.signatures.removed', 'Digital signatures', 'Package signatures become invalid after an edit and are deliberately omitted from the exported DOCX.'));
+        if (normalizedPackagePaths.some((path)=>'word/vbaproject.bin' === path || 'word/vbadata.xml' === path || path.startsWith('word/activex/') || path.startsWith('customui/'))) issues.push(work_office_diagnostics_issue('docx.active-content.removed', 'Active content', 'VBA, ActiveX, and custom-ribbon parts are never executed and are omitted from the macro-free DOCX export.'));
+        if (archive.has('word/fontTable.xml')) {
+            const fontTable = await archive.xml('word/fontTable.xml');
+            const embeddedFontReferences = [
+                'embedRegular',
+                'embedBold',
+                'embedItalic',
+                'embedBoldItalic'
+            ].reduce((count, localName)=>count + descendants(fontTable, localName).length, 0);
+            if (embeddedFontReferences) issues.push(work_office_diagnostics_issue('docx.embedded-fonts', 'Embedded fonts', `${embeddedFontReferences} embedded font reference(s) were found. Eligible internal obfuscated-font payloads, metadata, relationships, and remapped IDs survive source-backed DOCX export, but the browser editor, preview, and PDF renderer use registered A3S fonts or substitution and may wrap text differently.`));
+        }
         if (archive.has('word/comments.xml')) {
             const comments = await archive.xml('word/comments.xml');
             const commentDefinitions = descendants(comments, 'comment');
             if (commentDefinitions.length) {
-                issues.push(work_office_diagnostics_issue('docx.comments', 'Comments', `${commentDefinitions.length} comment or reply record(s), text anchors, authors, dates, thread relationships, and resolved state are preserved and editable.`, 'info'));
+                issues.push(work_office_diagnostics_issue('docx.comments', 'Comments', `${commentDefinitions.length} comment or reply record(s), stable native IDs, text anchors, authors, dates, thread relationships, resolved state, eligible durable IDs, unchanged direct-run formatting, safely rebound web, mail, or internal hyperlinks, and eligible static text content controls are preserved. Comment text remains editable.`, 'info'));
                 if ([
                     'tbl',
                     'drawing',
                     'pict',
                     'sdt',
                     'altChunk'
-                ].some((name)=>descendants(comments, name).length) || descendants(comments, 'rPr').length) issues.push(work_office_diagnostics_issue('docx.comments.formatting', 'Comment formatting', 'Comment text is editable, but rich formatting, tables, images, and content controls inside comments are normalized to plain text.'));
+                ].some((name)=>descendants(comments, name).length) || descendants(comments, 'rPr').length || descendants(comments, 'hyperlink').length) issues.push(work_office_diagnostics_issue('docx.comments.formatting', 'Comment formatting', 'Relationship-free formatting on uniquely matched unchanged direct text runs and eligible reconstructed control runs is retained. Supported HTTP(S), mailto, and internal hyperlink wrappers keep stable formatting, safe tooltips, and collision-free relationship IDs. Eligible static rich-text or plain-text controls retain inline or contiguous block wrappers, aliases, tags, locks, rewritten collision IDs, appearance, color, end formatting, and passive metadata. Editing comment text or using active bindings, placeholder state, form or nested controls, tables, images, math, mixed hyperlinks, unsupported wrappers, malformed relationships, or relationship-bound properties normalizes the affected content to safe plain text.'));
+                if (archive.has('word/commentsExtensible.xml') || archive.has('word/people.xml')) issues.push(work_office_diagnostics_issue('docx.comments.modern-sidecars', 'Modern comment metadata', 'Durable comment IDs are safely rebound, but follow-up flags, reactions, and people metadata in modern comment sidecars are not editable and are omitted rather than reattached to a stale comment identity.'));
             }
         }
         issues.push(...await diagnoseDocxNotes(archive, document));
+        issues.push(...await diagnoseDocxEquations(archive, document));
         issues.push(...await diagnoseDocxPageChrome(archive));
-        if (archive.paths('word/embeddings/').length) issues.push(work_office_diagnostics_issue('docx.embedded', 'Embedded objects', 'Embedded Office and OLE objects remain in the original file only.'));
+        if (archive.paths('word/embeddings/').length) issues.push(work_office_diagnostics_issue('docx.embedded', 'Embedded objects', 'Embedded Office and OLE payload parts plus safe relationships are retained in source-backed exports, but Work does not render or edit their object anchors; placement inside regenerated document XML may normalize.'));
         if (document) {
+            issues.push(...diagnoseDocxPageSize(document));
+            issues.push(...await diagnoseDocxPageMargins(archive, document));
+            issues.push(...await diagnoseDocxPageBorders(archive, document));
+            issues.push(...await diagnoseDocxParagraphBorders(archive, document));
+            issues.push(...await diagnoseDocxParagraphShading(archive, document));
+            const defaultCollapsedStates = descendants(document, 'pPr').map(parseDocxParagraphDefaultCollapsed).filter((state)=>'absent' !== state.status);
+            if (defaultCollapsedStates.length) {
+                const invalid = defaultCollapsedStates.filter((state)=>'invalid' === state.status).length;
+                issues.push(work_office_diagnostics_issue('docx.headings.default-collapsed', 'Default-collapsed headings', invalid ? `Office 2013 default-collapsed heading state is preserved for exact core Word on/off values, but ${invalid} malformed or duplicated paragraph property value(s) are ignored instead of inheriting a stale state.` : "Office 2013 default-collapsed heading state is preserved as native paragraph metadata. Browser content remains expanded and editable because the property controls Word's initial document view rather than content visibility.", invalid ? 'warning' : 'info'));
+            }
+            if (descendants(document, 'AlternateContent').length) issues.push(work_office_diagnostics_issue('docx.markup-compatibility', 'Markup compatibility', '`mc:AlternateContent` branches outside supported stable paragraph, picture-drawing, table, row, or cell scopes can normalize. Safe settings-level and uniquely matched passive branches are preserved separately, but source-backed package preservation does not imply general body-content fallback preservation.'));
+            issues.push(...await diagnoseDocxBookmarksAndLinks(archive, document));
             issues.push(...await diagnoseDocxCitations(archive, document));
             const captionDiagnostics = diagnoseDocxCaptions(document);
             issues.push(...captionDiagnostics.issues);
-            if (descendants(document, 'tbl').length) issues.push(work_office_diagnostics_issue('docx.tables', 'Tables', 'Table rows, non-splitting rows, repeated headers, cell shading, vertical alignment, per-edge borders, and paragraph-boundary row continuation remain editable. Layout algorithm, preferred auto, percentage, or pixel width, alignment, indent, table-level cell margins, and cell-level margin overrides are preserved independently across edit, preview, and DOCX export. Common inherited Word table styles apply whole-table, banded row or column, first or last row or column, corner-cell, border, fill, text-emphasis, paragraph alignment, direction, indents, spacing, line, pagination, and tab-stop rules before direct table, cell, paragraph, and run formatting. Theme tint and shade values resolve to stable RGB for edit, preview, and export; less-common conditional paragraph properties, semantic theme references after export, nested tables, and complex merged-cell flow may be normalized.'));
-            if (descendants(document, 'drawing').length || descendants(document, 'pict').length) issues.push(work_office_diagnostics_issue('docx.images', 'Images', 'Inline images and supported square or top-and-bottom floating images remain embedded with editable size, alternative text, alignment, and wrap distance. Precise offsets, crop, contour wrapping, layering, and unsupported drawing types may be normalized.'));
+            if (descendants(document, 'tbl').length) issues.push(work_office_diagnostics_issue('docx.tables', 'Tables', 'Table rows, non-splitting rows, repeated headers, cell shading, vertical alignment, per-edge borders, and paragraph-boundary row continuation remain editable. Native row identities survive body and page-chrome HTML; uniquely matched passive extensions on stable table, row, and cell scopes and their property nodes are retained, while duplicate, cross-kind, relationship-bound, or semantic branches fail closed. Layout algorithm, preferred auto, percentage, or pixel width, alignment, indent, percentage or pixel column widths, table-level cell margins, and cell-level margin overrides are preserved independently across edit, preview, and DOCX export. Percentage column preferences use pixel grid widths as responsive browser fallbacks and remain coherent through merged cells. Nested tables retain independent edit and DOCX geometry, and tall outer rows can paginate at nested-row boundaries. Row-spanning cells continue through every covered physical row with in-cell page breaks and contiguous content ranges; combined row and column spans retain native DOCX merge semantics. Common inherited Word table styles apply whole-table, banded row or column, first or last row or column, corner-cell, border, fill, text-emphasis, paragraph alignment, direction, indents, spacing, line, pagination, and tab-stop rules before direct table, cell, paragraph, and run formatting. Theme tint and shade values resolve to stable RGB for edit and preview, while untouched run colors, run shading, cell fills, and per-edge borders retain their semantic theme references on export; explicit color edits use direct RGB. Less-common conditional paragraph properties may be normalized.'));
+            if (descendants(document, 'drawing').length || descendants(document, 'pict').length) issues.push(work_office_diagnostics_issue('docx.images', 'Images', 'Inline images and supported square, tight, through, top-and-bottom, or no-wrap free-floating images remain embedded with editable size, alternative text, alignment, wrap side and distance where applicable, signed horizontal or vertical offsets relative to the column, paragraph, margin, or page, four-edge percentage cropping, and drawing-layer options. Aligned and precise DOCX anchors retain their distinct position semantics; inline and floating crop geometry round-trips as DrawingML source rectangles; tight or through anchors retain their ordered wrap polygons; no-wrap anchors remain outside the body text flow and use behind-text placement to choose their side of the text; and supported floating images preserve relative Z-order, overlap and cell-layout policy, and anchor locking. Inline and floating pictures retain unique drawing-property and anchor IDs together with their edit IDs. Copies receive independent identities while move, delete, undo, and relationship regeneration retain the original object identity. Unsupported drawing types may be normalized.'));
             const textRevisions = [
                 ...descendants(document, 'ins'),
                 ...descendants(document, 'del')
@@ -1208,7 +1702,7 @@ async function analyzeDocxCompatibility(file, messages) {
                 'sectPrChange',
                 'numberingChange'
             ].some((name)=>descendants(document, name).length)) issues.push(work_office_diagnostics_issue('docx.revisions.structural', 'Structural revisions', 'Moved content plus formatting, numbering, section, row, cell, and table-property revisions may be normalized; Work currently reviews body-text insertions and deletions.'));
-            if (captionDiagnostics.hasUnsupportedFields) issues.push(work_office_diagnostics_issue('docx.fields', 'Fields', 'Fields beyond supported body fields, citations, bibliographies, caption SEQ fields, and caption REF fields are converted to their current displayed value.'));
+            if (captionDiagnostics.hasUnsupportedFields) issues.push(work_office_diagnostics_issue('docx.fields', 'Fields', 'Fields beyond supported body fields, citations, bibliographies, caption SEQ fields, and bookmark or caption REF fields are converted to their current displayed value.'));
             const sectionProperties = descendants(document, 'sectPr');
             const columnProperties = descendants(document, 'cols');
             if (sectionProperties.length > 1 || columnProperties.length) issues.push(work_office_diagnostics_issue('docx.sections', 'Sections and columns', `${sectionProperties.length || 1} section(s) and equal or custom-width column settings are preserved, editable, and applied to document PDF output.`, 'info'));