@portone/docx-editor 0.2.0 → 0.3.0

package/dist/docx/tableFormatting/reading.js

@@ -1,31 +1,43 @@
 // src/docx/tableFormatting/reading.ts
+import { parsePropsXml } from "../../ooxml/props.js";
+import {
+  ST_MeasurementOrPercent,
+  ST_SignedTwipsMeasure,
+  ST_TwipsMeasure
+} from "../../ooxml/simpleTypes.js";
 import {
   ALIGN_BY_JC,
+  borderLineCss,
+  borderLineOfCss,
   borderSide,
   childValue,
   isOn,
   shadingOf,
-  toNumber,
   twipsToPt,
   wAttr
 } from "../../ooxml/units.js";
 import { childByLocalName } from "../../ooxml/xml.js";
-import { parsePropsXml } from "../propsXml.js";
+var FIFTIETHS_PER_PERCENT = 50;
 function readTableWidth(parent, name) {
   const el = parent ? childByLocalName(parent, name) : null;
   if (!el) return null;
   const type = wAttr(el, "type") ?? "dxa";
+  const width = ST_MeasurementOrPercent.parse(wAttr(el, "w"));
+  if (width?.kind === "percent") {
+    const fiftieths = Math.round(width.value * FIFTIETHS_PER_PERCENT);
+    return Number.isFinite(fiftieths) ? { type: "pct", fiftieths } : null;
+  }
   if (type === "auto") return { type: "auto" };
   if (type === "nil") return { type: "nil" };
-  const raw = wAttr(el, "w");
-  const value = toNumber(raw);
-  if (value === null) return null;
-  if (type === "dxa") return { type: "dxa", twips: value };
+  if (width === null) return null;
+  if (type === "dxa") {
+    return { type: "dxa", twips: width.value };
+  }
   if (type === "pct") {
-    const isPercentText = raw?.endsWith("%") === true;
+    if (width.kind === "twips") return null;
     return {
       type: "pct",
-      fiftieths: isPercentText ? Math.round(value * 50) : value
+      fiftieths: width.value
     };
   }
   return null;
@@ -35,7 +47,7 @@ function readGridCols(tblGrid) {
   const cols = [];
   for (const child of Array.from(tblGrid.children)) {
     if (child.localName !== "gridCol") continue;
-    const w = toNumber(wAttr(child, "w"));
+    const w = ST_TwipsMeasure.parse(wAttr(child, "w"));
     if (w !== null) cols.push(w);
   }
   return cols;
@@ -69,7 +81,7 @@ function marginSide(margins, names) {
     if (!el) continue;
     const type = wAttr(el, "type") ?? "dxa";
     if (type === "nil") return 0;
-    return type === "dxa" ? twipsToPt(wAttr(el, "w")) : null;
+    return type === "dxa" ? twipsToPt(ST_TwipsMeasure.parse(wAttr(el, "w"))) : null;
   }
   return null;
 }
@@ -107,10 +119,18 @@ function gridEdgesOf(rect, grid) {
 }
 function cellBorderDefaults(edges, outer, inside) {
   return {
-    top: edges.top ? outer?.borderTop ?? null : inside.horizontal,
-    bottom: edges.bottom ? outer?.borderBottom ?? null : inside.horizontal,
-    left: edges.left ? outer?.borderLeft ?? null : inside.vertical,
-    right: edges.right ? outer?.borderRight ?? null : inside.vertical
+    top: borderLineOfCss(
+      edges.top ? outer?.borderTop ?? null : inside.horizontal
+    ),
+    bottom: borderLineOfCss(
+      edges.bottom ? outer?.borderBottom ?? null : inside.horizontal
+    ),
+    left: borderLineOfCss(
+      edges.left ? outer?.borderLeft ?? null : inside.vertical
+    ),
+    right: borderLineOfCss(
+      edges.right ? outer?.borderRight ?? null : inside.vertical
+    )
   };
 }
 function tblStyleIdOf(tblPr) {
@@ -133,12 +153,12 @@ function readTableFormat(tblPr) {
   const align = ALIGN_BY_JC[childValue(tblPr, "jc") ?? ""];
   if (align) format.align = align;
   const tblInd = childByLocalName(tblPr, "tblInd");
-  const indentLeftPt = tblInd ? twipsToPt(wAttr(tblInd, "w")) : null;
+  const indentLeftPt = tblInd ? twipsToPt(ST_SignedTwipsMeasure.parse(wAttr(tblInd, "w"))) : null;
   if (indentLeftPt !== null) format.indentLeftPt = indentLeftPt;
   return format;
 }
 function readRowHeight(trHeight) {
-  const pt = twipsToPt(wAttr(trHeight, "val"));
+  const pt = twipsToPt(ST_TwipsMeasure.parse(wAttr(trHeight, "val")));
   if (pt === null || pt <= 0) return null;
   const rule = wAttr(trHeight, "hRule") === "exact" ? "exact" : "atLeast";
   return { rule, pt };
@@ -170,13 +190,13 @@ function readCellPadding(tcPr, margins) {
 function readCellFormat(tcPr, defaults, margins = NO_CELL_MARGINS) {
   const borders = tcPr ? childByLocalName(tcPr, "tcBorders") : null;
   const format = {};
-  const top = borderSide(borders, "top") ?? defaults.top;
+  const top = borderSide(borders, "top") ?? borderLineCss(defaults.top);
   if (top) format.borderTop = top;
-  const bottom = borderSide(borders, "bottom") ?? defaults.bottom;
+  const bottom = borderSide(borders, "bottom") ?? borderLineCss(defaults.bottom);
   if (bottom) format.borderBottom = bottom;
-  const left = borderSide(borders, "left") ?? borderSide(borders, "start") ?? defaults.left;
+  const left = borderSide(borders, "left") ?? borderSide(borders, "start") ?? borderLineCss(defaults.left);
   if (left) format.borderLeft = left;
-  const right = borderSide(borders, "right") ?? borderSide(borders, "end") ?? defaults.right;
+  const right = borderSide(borders, "right") ?? borderSide(borders, "end") ?? borderLineCss(defaults.right);
   if (right) format.borderRight = right;
   if (tcPr) {
     const background = shadingOf(tcPr);

package/dist/docx/tableTemplate.js

@@ -1,7 +1,9 @@
 // src/docx/tableTemplate.ts
+import { elementXml } from "../ooxml/element.js";
+import { wName } from "../ooxml/names.js";
+import { orderedElement, parsePropsXml } from "../ooxml/props.js";
 import { docxSchema } from "../schema/index.js";
 import { A4_PORTRAIT, bodyWidth } from "./pageGeometry.js";
-import { parsePropsXml } from "./propsXml.js";
 import {
   cellBorderDefaults,
   gridEdgesOf,
@@ -25,14 +27,44 @@ var BORDER_SIDES = [
   "insideV"
 ];
 function borderXml(side) {
-  return `<w:${side} w:val="single" w:sz="${BORDER_EIGHTHS}" w:space="0" w:color="000000"/>`;
+  return elementXml(wName(side), [
+    [wName("val"), "single"],
+    [wName("sz"), `${BORDER_EIGHTHS}`],
+    [wName("space"), "0"],
+    [wName("color"), "000000"]
+  ]);
 }
 function tablePropsXml(width) {
-  const borders = BORDER_SIDES.map(borderXml).join("");
-  return `<w:tblPr><w:tblW w:w="${width}" w:type="dxa"/><w:tblBorders>${borders}</w:tblBorders><w:tblLayout w:type="fixed"/></w:tblPr>`;
+  const borders = orderedElement(
+    wName("tblBorders"),
+    [],
+    BORDER_SIDES.map((side) => ({ name: side, xml: borderXml(side) }))
+  );
+  return orderedElement(
+    wName("tblPr"),
+    [],
+    [
+      { name: "tblW", xml: widthXml("tblW", width) },
+      { name: "tblBorders", xml: borders },
+      {
+        name: "tblLayout",
+        xml: elementXml(wName("tblLayout"), [[wName("type"), "fixed"]])
+      }
+    ]
+  );
+}
+function widthXml(name, width) {
+  return elementXml(wName(name), [
+    [wName("w"), `${width}`],
+    [wName("type"), "dxa"]
+  ]);
 }
 function cellPropsXml(width) {
-  return `<w:tcPr><w:tcW w:w="${width}" w:type="dxa"/></w:tcPr>`;
+  return orderedElement(
+    wName("tcPr"),
+    [],
+    [{ name: "tcW", xml: widthXml("tcW", width) }]
+  );
 }
 function evenGridCols(cols, total) {
   const base = Math.floor(total / cols);

package/dist/docx/theme.d.ts

@@ -21,12 +21,6 @@ export interface ThemeFonts {
 }
 /** What applies to a document with no theme part, or one whose theme names no font */
 export declare const NO_THEME_FONTS: ThemeFonts;
-/**
- * The theme attribute paired with each font slot.
- * A theme reference and a name in the same slot cannot both apply, so the name wins,
- * the way Word reads them.
- */
-export declare const THEME_ATTRS: Record<string, readonly string[]>;
 /** The font one theme reference stands for. null for a reference we cannot resolve */
 export declare function themeFontName(fonts: ThemeFonts, value: string | null): string | null;
 /**

package/dist/docx/theme.js

@@ -9,13 +9,6 @@ var NO_THEME_FONTS = {
   major: NO_FONT_SCHEME,
   minor: NO_FONT_SCHEME
 };
-var THEME_ATTRS = {
-  ascii: ["asciiTheme"],
-  hAnsi: ["hAnsiTheme"],
-  eastAsia: ["eastAsiaTheme"],
-  // This is the slot whose capitalization varies from document to document
-  cs: ["cstheme", "csTheme"]
-};
 var THEME_SLOTS = {
   majorascii: { scheme: "major", script: "latin" },
   majorhansi: { scheme: "major", script: "latin" },
@@ -55,7 +48,6 @@ function readThemeFonts(theme) {
 }
 export {
   NO_THEME_FONTS,
-  THEME_ATTRS,
   readThemeFonts,
   themeFontName
 };

package/dist/download.d.ts

@@ -6,6 +6,7 @@
  */
 import type { Node as PMNode } from "prosemirror-model";
 import type { DocxEditorHandle } from "./DocxEditor";
+import type { ExportProblem } from "./docx/invariants";
 export declare const DOCX_MIME_TYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
 export interface DownloadDocxOptions {
     /** The name to save under. The `.docx` suffix may be there or not */
@@ -19,6 +20,9 @@ export type DownloadDocxResult = {
     status: "unavailable";
 } | {
     status: "empty";
+} | {
+    status: "blocked";
+    problems: readonly ExportProblem[];
 };
 /** Settles the end of the name on exactly one `.docx` */
 export declare function withDocxExtension(fileName: string): string;
@@ -48,10 +52,9 @@ export declare function hasExportableContent(doc: PMNode): boolean;
  * Downloads the edited document as a docx file.
  *
  * `unavailable` when the editor is not mounted yet or the document could not be
- * opened, `empty` when there is nothing to export, and `exported` once a file has
- * gone out.
- * If writing the document back is blocked (a new list in a document without
- * numbering.xml, and the like), it is not passed over silently: `DocxExportError`
- * is rethrown as is.
+ * opened, `empty` when there is nothing to export, `blocked` with every reason
+ * when the document cannot be written back (a new list in a document without
+ * numbering.xml, and the like), and `exported` once a file has gone out.
+ * A refusal the check did not foresee is still thrown as `DocxExportError`.
  */
 export declare function downloadDocx(editor: DocxEditorHandle | null | undefined, options: DownloadDocxOptions): DownloadDocxResult;

package/dist/download.js

@@ -29,6 +29,8 @@ function hasExportableContent(doc) {
 function downloadDocx(editor, options) {
   if (!editor) return { status: "unavailable" };
   if (!hasExportableContent(editor.view.state.doc)) return { status: "empty" };
+  const problems = editor.exportProblems();
+  if (problems.length > 0) return { status: "blocked", problems };
   const bytes = editor.exportBytes();
   const fileName = withDocxExtension(options.fileName);
   downloadBlob(createDocxBlob(bytes), fileName);

package/dist/editor/clipboard/images.js

@@ -1,6 +1,11 @@
 // src/editor/clipboard/images.ts
 import { MAX_IMAGE_BYTES } from "../../docx/media.js";
-import { isImageMime, toImageExtent, toImageSrc } from "../../ooxml/image.js";
+import {
+  isImageMime,
+  pxToEmu,
+  toImageExtent,
+  toImageSrc
+} from "../../ooxml/image.js";
 import { editorClassNames } from "../../styles/classNames.js";
 import {
   boundedImageSrc,
@@ -9,8 +14,7 @@ import {
   readImageSource
 } from "../imageFiles.js";
 var PASTED_IMAGE_ATTRIBUTE = "data-docx-pasted-image";
-function extentAttribute(element) {
-  if (!element.classList.contains(editorClassNames.image)) return null;
+function declaredExtent(element) {
   try {
     return toImageExtent(
       JSON.parse(element.getAttribute("data-extent") ?? "null")
@@ -19,6 +23,16 @@ function extentAttribute(element) {
     return null;
   }
 }
+function renderedExtent(element) {
+  const width = Number.parseInt(element.getAttribute("width") ?? "", 10);
+  const height = Number.parseInt(element.getAttribute("height") ?? "", 10);
+  if (!Number.isFinite(width) || !Number.isFinite(height)) return null;
+  return toImageExtent({ cx: pxToEmu(width), cy: pxToEmu(height) });
+}
+function extentAttribute(element) {
+  if (!element.classList.contains(editorClassNames.image)) return null;
+  return declaredExtent(element) ?? renderedExtent(element);
+}
 function fetchableUrl(source) {
   try {
     const url = new URL(source);

package/dist/editor/clipboard/inlineFormatting.d.ts

@@ -15,6 +15,13 @@ export interface InlineContext {
     preserveWhitespace: boolean;
 }
 export type InlineElementReader = (target: PMNode[], element: HTMLElement, context: InlineContext) => boolean;
+/**
+ * The address a link may carry, whichever way it travels.
+ *
+ * A copy writes one out and a paste reads one in, and an address this rule turns down is one
+ * neither end should act on, so both ask here.
+ */
+export declare function safeHref(value: string | null): string | null;
 export declare function contextFor(parent: InlineContext, element: HTMLElement, readElementStyle?: boolean): InlineContext;
 export declare function withInlineStyle(context: InlineContext, style: InlineStyle): InlineContext;
 export declare function marksFor(context: InlineContext): Mark[];

package/dist/editor/clipboard/inlineFormatting.js

@@ -1,5 +1,7 @@
 // src/editor/clipboard/inlineFormatting.ts
-import { editRunProps } from "../../docx/runProps.js";
+import { rPrOf } from "../../docx/formatting.js";
+import { readRunProps } from "../../docx/runProps.js";
+import { HALF_POINTS_PER_PT, ST_HpsMeasure } from "../../ooxml/simpleTypes.js";
 import { docxSchema } from "../../schema/index.js";
 import { editorClassNames } from "../../styles/classNames.js";
 var IGNORED_TAGS = /* @__PURE__ */ new Set([
@@ -76,8 +78,8 @@ function fontSizePt(value) {
   const amount = Number.parseFloat(match[1] ?? "");
   if (!Number.isFinite(amount) || amount <= 0) return null;
   const points = match[2]?.toLowerCase() === "px" ? amount * 0.75 : amount;
-  const rounded = Math.round(points * 2) / 2;
-  return rounded > 0 && rounded <= 819 ? rounded : null;
+  const half = Math.round(points * HALF_POINTS_PER_PT);
+  return ST_HpsMeasure.format(half) === null ? null : half / HALF_POINTS_PER_PT;
 }
 function legacyFontSize(value) {
   const sizes = [8, 10, 12, 14, 18, 24, 36];
@@ -150,34 +152,21 @@ function contextFor(parent, element, readElementStyle = true) {
 function withInlineStyle(context, style) {
   return { ...context, style: { ...context.style, ...style } };
 }
+function settingsOf(style) {
+  const settings = {};
+  if (style.bold) settings.bold = true;
+  if (style.italic) settings.italic = true;
+  if (style.underline) settings.underline = "single";
+  if (style.strike) settings.strike = true;
+  if (style.fontSizePt !== void 0) settings.fontSizePt = style.fontSizePt;
+  if (style.fontFamily !== void 0) settings.fontFamily = style.fontFamily;
+  if (style.color !== void 0) settings.color = style.color;
+  if (style.background !== void 0) settings.background = style.background;
+  return settings;
+}
 function runMark(style) {
-  const edits = [];
-  if (style.bold) edits.push({ kind: "toggle", toggle: "bold", on: true });
-  if (style.italic) edits.push({ kind: "toggle", toggle: "italic", on: true });
-  if (style.underline) {
-    edits.push({ kind: "toggle", toggle: "underline", on: true });
-  }
-  if (style.strike) edits.push({ kind: "toggle", toggle: "strike", on: true });
-  if (style.fontSizePt !== void 0) {
-    edits.push({ kind: "fontSize", pt: style.fontSizePt });
-  }
-  if (style.fontFamily !== void 0) {
-    edits.push({ kind: "fontFamily", name: style.fontFamily });
-  }
-  if (style.color !== void 0)
-    edits.push({ kind: "color", hex: style.color });
-  if (style.background !== void 0) {
-    edits.push({ kind: "background", hex: style.background });
-  }
-  let props = {
-    rPr: null,
-    format: null
-  };
-  for (const edit of edits) {
-    const next = editRunProps(props, null, edit);
-    if (next) props = next;
-  }
-  return props.rPr === null ? null : docxSchema.marks.run.create({ rPr: props.rPr, format: props.format });
+  const rPr = rPrOf(settingsOf(style));
+  return rPr === null ? null : docxSchema.marks.run.create({ rPr, format: readRunProps(rPr) });
 }
 function marksFor(context) {
   const marks = [];
@@ -228,5 +217,6 @@ export {
   appendInline,
   contextFor,
   marksFor,
+  safeHref,
   withInlineStyle
 };

package/dist/editor/commands/breakCommands.js

@@ -1,10 +1,11 @@
 // src/editor/commands/breakCommands.ts
 import { docxSchema } from "../../schema/index.js";
-import { replacementShut } from "../../schema/locks.js";
-import { editsShut } from "../../schema/protectionState.js";
+import { editShut, selectionIntents } from "../../schema/guards.js";
 function insertBreak(brAttrs) {
   return (state, dispatch) => {
-    if (editsShut(state) || replacementShut(state.selection, state.doc)) {
+    if (selectionIntents(state.selection, "replace").some(
+      (intent) => editShut(state, intent)
+    )) {
       return false;
     }
     if (dispatch) {

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

@@ -1,6 +1,6 @@
 /**
- * Dry-runs external commands and checks every produced transaction against document locks and the
- * editor's protection without dispatching them or triggering the locked-content plugin's side
+ * Dry-runs external commands and checks every produced transaction against every guard
+ * (`schema/guards`) without dispatching them or triggering the locked-content plugin's side
  * effects.
  */
 import type { Command, EditorState } from "prosemirror-state";

package/dist/editor/commands/canRunCommand.js

@@ -1,5 +1,5 @@
 // src/editor/commands/canRunCommand.ts
-import { transactionAllowed } from "../../schema/locks.js";
+import { transactionAllowed } from "../../schema/guards.js";
 function canRunCommand(command, state) {
   const built = [];
   if (!command(state, (tr) => built.push(tr))) return false;

package/dist/editor/commands/comments/editing.d.ts

@@ -1,10 +1,14 @@
 /** Edits Word comments through their range markers and reference nodes. */
 import { type Command, type EditorState } from "prosemirror-state";
 import type { NewComment } from "./model";
-/** Whether a non-empty selection in one paragraph can receive a comment. */
-export declare function canAddComment(state: EditorState): boolean;
 /** Adds a plain-text comment to the current text selection. */
 export declare function addComment(comment: NewComment): Command;
+/**
+ * Whether a non-empty selection in one paragraph can receive a comment.
+ * This is the command itself asked without a dispatch, over a comment standing in for the one the
+ * user would write, so the button and the click cannot answer differently.
+ */
+export declare function canAddComment(state: EditorState): boolean;
 /** Replaces the plain-text body of one comment, retaining its author and anchor. */
 export declare function updateComment(id: string, text: string): Command;
 /** Marks a comment thread resolved or open without deleting it. */

package/dist/editor/commands/comments/editing.js

@@ -4,11 +4,11 @@ import {
 } from "prosemirror-state";
 import { commentParaId } from "../../../docx/comments.js";
 import { docxSchema } from "../../../schema/index.js";
-import { transactionAllowed } from "../../../schema/locks.js";
+import { guardedCommand } from "../../../schema/guards.js";
 import {
   reservedCommentIds,
   reservedCommentParaIds
-} from "../../plugins/commentReservations.js";
+} from "../../editorDocument.js";
 import { documentComments, repliesAttr, stringAttr } from "./reading.js";
 function validCommentSelection(state) {
   const { selection } = state;
@@ -113,27 +113,21 @@ function addCommentTransaction(state, comment) {
     null,
     startMarks
   );
-  const transaction = state.tr.insert(to, end).insert(to + 1, reference).insert(from, start);
-  return transactionAllowed(transaction, state) ? transaction : null;
+  return state.tr.insert(to, end).insert(to + 1, reference).insert(from, start);
+}
+function addComment(comment) {
+  return guardedCommand((state) => addCommentTransaction(state, comment));
 }
 function canAddComment(state) {
-  return addCommentTransaction(state, {
+  return addComment({
     text: "comment",
     author: "Author",
     date: "1970-01-01T00:00:00.000Z"
-  }) !== null;
-}
-function addComment(comment) {
-  return (state, dispatch) => {
-    const transaction = addCommentTransaction(state, comment);
-    if (!transaction) return false;
-    dispatch?.(transaction);
-    return true;
-  };
+  })(state);
 }
 function updateComment(id, text) {
-  return (state, dispatch) => {
-    if (text.trim().length === 0) return false;
+  return guardedCommand((state) => {
+    if (text.trim().length === 0) return null;
     let transaction = state.tr;
     let changed = false;
     state.doc.descendants((node, pos) => {
@@ -148,13 +142,11 @@ function updateComment(id, text) {
       }
       return true;
     });
-    if (!changed || !transactionAllowed(transaction, state)) return false;
-    dispatch?.(transaction);
-    return true;
-  };
+    return changed ? transaction : null;
+  });
 }
 function updateReference(id, change) {
-  return (state, dispatch) => {
+  return guardedCommand((state) => {
     let transaction = state.tr;
     let changed = false;
     state.doc.descendants((node, pos) => {
@@ -168,21 +160,17 @@ function updateReference(id, change) {
       }
       return false;
     });
-    if (!changed || !transactionAllowed(transaction, state)) return false;
-    dispatch?.(transaction);
-    return true;
-  };
+    return changed ? transaction : null;
+  });
 }
 function setCommentResolved(id, resolved) {
   return (state, dispatch) => updateReference(id, (node) => {
     if (node.attrs.resolved === resolved) return null;
     return {
       ...node.attrs,
-      paraId: node.attrs.threadImported === true && node.attrs.extensionXml === null ? nextCommentParaId(state, `comment-${id}`) : node.attrs.paraId,
       resolved,
       extensionXml: null,
-      threadImported: false,
-      imported: node.attrs.commentXml !== null && node.attrs.extensionXml === null ? false : node.attrs.imported
+      threadImported: false
     };
   })(state, dispatch);
 }
@@ -192,7 +180,7 @@ function addCommentReply(id, reply) {
     const replyId = nextCommentId(state);
     const date = reply.date ?? (/* @__PURE__ */ new Date()).toISOString();
     return updateReference(id, (node) => {
-      const parentParaId = node.attrs.threadImported === true && node.attrs.extensionXml === null ? nextCommentParaId(state, `comment-${id}`) : stringAttr(node.attrs.paraId) ?? nextCommentParaId(state, `comment-${id}`);
+      const parentParaId = stringAttr(node.attrs.paraId) ?? nextCommentParaId(state, `comment-${id}`);
       const paraId = nextCommentParaId(state, `comment-${replyId}-${date}`, [
         parentParaId
       ]);
@@ -202,7 +190,6 @@ function addCommentReply(id, reply) {
         resolved: false,
         extensionXml: null,
         threadImported: false,
-        imported: node.attrs.commentXml !== null && node.attrs.extensionXml === null ? false : node.attrs.imported,
         replies: [
           ...repliesAttr(node.attrs.replies),
           {
@@ -264,7 +251,7 @@ function removeCommentReply(commentId, replyId) {
   });
 }
 function removeComment(id) {
-  return (state, dispatch) => {
+  return guardedCommand((state) => {
     const positions = [];
     state.doc.descendants((node, pos) => {
       if ((node.type.name === "commentStart" || node.type.name === "commentEnd" || node.type.name === "commentReference") && stringAttr(node.attrs.id) === id) {
@@ -272,15 +259,13 @@ function removeComment(id) {
       }
       return true;
     });
-    if (positions.length === 0) return false;
+    if (positions.length === 0) return null;
     const transaction = state.tr;
     for (const marker of positions.sort((a, b) => b.pos - a.pos)) {
       transaction.delete(marker.pos, marker.pos + marker.size);
     }
-    if (!transactionAllowed(transaction, state)) return false;
-    dispatch?.(transaction);
-    return true;
-  };
+    return transaction;
+  });
 }
 function selectComment(id) {
   return (state, dispatch) => {

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

@@ -0,0 +1,15 @@
+/** Document-level readers for whether the document as it stands can be written back. */
+import type { EditorState } from "prosemirror-state";
+import { type ExportProblem } from "../../docx/invariants";
+export type { ExportProblem } from "../../docx/invariants";
+/**
+ * Every reason writing the document back would be refused, in the order `exportDocx` would raise
+ * them, each with the code and message the refusal would carry and the position in the document
+ * where there is one. Empty when the file would be written.
+ *
+ * A state built without an opened document has no file to write back into, so nothing about it
+ * can be refused and it reports no problem.
+ */
+export declare function documentExportProblems(state: EditorState): readonly ExportProblem[];
+/** Whether the document as it stands can be written back, which is what an export control is drawn from */
+export declare function canExport(state: EditorState): boolean;

package/dist/editor/commands/exportQueries.js

@@ -0,0 +1,14 @@
+// src/editor/commands/exportQueries.ts
+import { exportProblems } from "../../docx/invariants.js";
+import { documentOf } from "../editorDocument.js";
+function documentExportProblems(state) {
+  const { session } = documentOf(state);
+  return session === null ? [] : exportProblems(state.doc, session);
+}
+function canExport(state) {
+  return documentExportProblems(state).length === 0;
+}
+export {
+  canExport,
+  documentExportProblems
+};

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

@@ -0,0 +1,12 @@
+/** Document-level reader for what the open document holds that the editor cannot model. */
+import type { EditorState } from "prosemirror-state";
+import { type FidelityNote } from "../../docx/fidelity";
+export type { FidelityCode, FidelityNote, FidelitySeverity, } from "../../docx/fidelity";
+/**
+ * What the document standing in the editor hides, stands a placeholder in front of, or approximates.
+ *
+ * The notes are read off the document as it is now, so a note goes away as soon as an edit removes
+ * what it was about. `part` is null: an editor state carries the document and not the file it came
+ * from, and `importDocx` is where a note can name the part it belongs to.
+ */
+export declare function documentFidelity(state: EditorState): readonly FidelityNote[];

package/dist/editor/commands/fidelityQueries.js

@@ -0,0 +1,8 @@
+// src/editor/commands/fidelityQueries.ts
+import { fidelityNotesOf } from "../../docx/fidelity.js";
+function documentFidelity(state) {
+  return fidelityNotesOf(state.doc, null);
+}
+export {
+  documentFidelity
+};

package/dist/editor/commands/formatting/editing.d.ts

@@ -1,6 +1,5 @@
-/** Applies inline formatting while preserving each run's untouched XML. */
+/** The character formatting commands the package exports, each built from the property it edits. */
 import type { Command, EditorState } from "prosemirror-state";
-export type { RunToggle } from "../../../docx/runProps";
 /**
  * Whether character formatting reaches anything where the selection stands, which is what a
  * control offering it is drawn from.
@@ -13,6 +12,7 @@ export type { RunToggle } from "../../../docx/runProps";
 export declare function canFormatText(state: EditorState): boolean;
 export declare const toggleBold: Command;
 export declare const toggleItalic: Command;
+/** Switching the underline on writes a single one; a run already underlined keeps the kind it has */
 export declare const toggleUnderline: Command;
 export declare const toggleStrike: Command;
 /** Sets the font size in points. Null withdraws the setting and falls back to the document default */