@portone/docx-editor 0.1.0 → 0.2.0

package/dist/docx/comments/contentTypes.js

@@ -0,0 +1,38 @@
+// src/docx/comments/contentTypes.ts
+import { DocxExportError } from "../../ooxml/errors.js";
+import { decodeUtf8, encodeUtf8 } from "../../ooxml/xml.js";
+import { CONTENT_TYPES_PATH } from "./constants.js";
+var TYPES_OPEN_TAG = /<(?:[\w.-]+:)?Types\b[^>]*>/;
+function withContentType(parts, partPath, contentType, current) {
+  const original = current ?? parts.get(CONTENT_TYPES_PATH);
+  if (!original) {
+    throw new DocxExportError(
+      "missing-content-types",
+      `cannot add a part to a package that has no ${CONTENT_TYPES_PATH}`
+    );
+  }
+  const { text, hadBom } = decodeUtf8(original);
+  const partName = `/${partPath}`;
+  if (new RegExp(
+    `<(?:[\\w.-]+:)?Override[^>]+PartName=["']${partName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']`,
+    "i"
+  ).test(text)) {
+    return null;
+  }
+  const open = TYPES_OPEN_TAG.exec(text);
+  if (!open) {
+    throw new DocxExportError(
+      "malformed-xml",
+      `${CONTENT_TYPES_PATH} has no Types element`
+    );
+  }
+  const rootName = /^<([^\s>]+)/.exec(open[0])?.[1] ?? "Types";
+  const separator = rootName.indexOf(":");
+  const prefix = separator < 0 ? "" : `${rootName.slice(0, separator)}:`;
+  const declaration = `<${prefix}Override PartName="${partName}" ContentType="${contentType}"/>`;
+  const at = open.index + open[0].length;
+  return encodeUtf8(text.slice(0, at) + declaration + text.slice(at), hadBom);
+}
+export {
+  withContentType
+};

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

@@ -6,6 +6,7 @@ import type { ImportedComments } from "./reading";
 export interface CommentReferenceData {
     id: string;
     author: string | null;
+    authorId: string | null;
     initials: string | null;
     date: string | null;
     text: string;
@@ -20,6 +21,7 @@ export interface CommentReferenceData {
 export interface CommentReplyData {
     id: string;
     author: string | null;
+    authorId: string | null;
     initials: string | null;
     date: string | null;
     text: string;

package/dist/docx/comments/model.js

@@ -23,6 +23,7 @@ function importedCommentReplies(comments, rootId) {
     replies.push({
       id: reply.id,
       author: reply.author,
+      authorId: reply.authorId,
       initials: reply.initials,
       date: reply.date,
       text: reply.text,
@@ -55,6 +56,7 @@ function replyData(value) {
       {
         id,
         author: nullableString(entry.author),
+        authorId: nullableString(entry.authorId),
         initials: nullableString(entry.initials),
         date: nullableString(entry.date),
         text: nullableString(entry.text) ?? "",
@@ -74,6 +76,7 @@ function referenceData(node) {
   return {
     id,
     author: nullableString(node.attrs.author),
+    authorId: nullableString(node.attrs.authorId),
     initials: nullableString(node.attrs.initials),
     date: nullableString(node.attrs.date),
     text: nullableString(node.attrs.text) ?? "",

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

@@ -0,0 +1,39 @@
+/**
+ * The people part, where Word records who a comment author is beyond the display name
+ * (`w15:people`): a `w15:person` carrying a `w15:presenceInfo` whose `w15:providerId` names the
+ * directory that issued `w15:userId`.
+ *
+ * This editor records the identity a host application hands it under a provider of its own
+ * (`COMMENT_AUTHOR_PROVIDER`). The `w15:author` name is the key both Word and this editor read the
+ * part by, so a name stands for one identity per file: a name the part already records is read as
+ * it stands and never appended to. Appending a second person for it would leave a file naming two
+ * identities for one name, where a reader keying by name hands one author's comments to the other.
+ */
+import { type RelationshipWriter } from "../relationships";
+import type { SessionStore } from "../session";
+import type { CommentReferenceData, CommentReplyData } from "./model";
+export interface ImportedPeople {
+    partPath: string | null;
+    xml: string | null;
+    hadBom: boolean;
+    /**
+     * Every author name the part records, mapped to the identity it stands for. Null where this
+     * editor cannot vouch for the name: another provider recorded it, or it is recorded twice over
+     * under different identities and nothing in the file says which of them wrote what.
+     */
+    byAuthor: ReadonlyMap<string, string | null>;
+}
+export declare const NO_PEOPLE: ImportedPeople;
+/** Reads the people part related from the main document story. */
+export declare function readPeople(parts: Map<string, Uint8Array>, mainPartPath: string): ImportedPeople;
+/**
+ * The identity this editor recorded for the author of that name. Null for a name it did not
+ * record, and for one the part records under more than one identity.
+ */
+export declare function commentAuthorId(people: ImportedPeople, author: string): string | null;
+/**
+ * Plans the people part, its relationship and its content type for every identity the current
+ * comments carry that the document has not recorded. Null when it has recorded them all, which
+ * leaves the part as it arrived.
+ */
+export declare function planPeoplePart(bodies: Iterable<CommentReferenceData | CommentReplyData>, session: SessionStore, relationships: RelationshipWriter, currentContentTypes: Uint8Array | undefined): ReadonlyMap<string, Uint8Array> | null;

package/dist/docx/comments/people.js

@@ -0,0 +1,198 @@
+// src/docx/comments/people.ts
+import { DocxExportError } from "../../ooxml/errors.js";
+import {
+  childByLocalName,
+  decodeUtf8,
+  elementChildren,
+  encodeUtf8,
+  escapeXml,
+  parseXml
+} from "../../ooxml/xml.js";
+import {
+  directoryOf,
+  readRelationships,
+  relsPathOf,
+  resolveTarget
+} from "../relationships.js";
+import {
+  COMMENT_AUTHOR_PROVIDER,
+  CONTENT_TYPES_PATH,
+  PEOPLE_CONTENT_TYPE,
+  PEOPLE_REL_TYPE,
+  W15_NS
+} from "./constants.js";
+import { withContentType } from "./contentTypes.js";
+var NO_PEOPLE = {
+  partPath: null,
+  xml: null,
+  hadBom: false,
+  byAuthor: /* @__PURE__ */ new Map()
+};
+function attribute(el, localName) {
+  return Array.from(el.attributes).find((entry) => entry.localName === localName)?.value ?? null;
+}
+function readPeople(parts, mainPartPath) {
+  const relationship = readRelationships(parts, relsPathOf(mainPartPath)).find(
+    (entry) => entry.type === PEOPLE_REL_TYPE && !entry.external
+  );
+  if (!relationship) return NO_PEOPLE;
+  const partPath = resolveTarget(mainPartPath, relationship.target);
+  const bytes = parts.get(partPath);
+  if (!bytes) return { ...NO_PEOPLE, partPath };
+  const { text, hadBom } = decodeUtf8(bytes);
+  const root = parseXml(text).documentElement;
+  const ourIds = /* @__PURE__ */ new Map();
+  const byAuthor = /* @__PURE__ */ new Map();
+  for (const el of elementChildren(root)) {
+    if (el.localName !== "person") continue;
+    const author = attribute(el, "author");
+    if (author === null) continue;
+    byAuthor.set(author, null);
+    const presence = childByLocalName(el, "presenceInfo");
+    if (presence === null) continue;
+    if (attribute(presence, "providerId") !== COMMENT_AUTHOR_PROVIDER) continue;
+    const ids = ourIds.get(author) ?? /* @__PURE__ */ new Set();
+    ids.add(attribute(presence, "userId"));
+    ourIds.set(author, ids);
+  }
+  for (const [author, ids] of ourIds) {
+    if (ids.size !== 1) continue;
+    byAuthor.set(author, Array.from(ids)[0] ?? null);
+  }
+  return { partPath, xml: text, hadBom, byAuthor };
+}
+function commentAuthorId(people, author) {
+  return people.byAuthor.get(author) ?? null;
+}
+function personXml(author, userId, prefix, declaration) {
+  return `<${prefix}person${declaration} ${prefix}author="${escapeXml(author)}"><${prefix}presenceInfo ${prefix}providerId="${COMMENT_AUTHOR_PROVIDER}" ${prefix}userId="${escapeXml(userId)}"/></${prefix}person>`;
+}
+function unrecordedAuthors(bodies, people) {
+  const unrecorded = /* @__PURE__ */ new Map();
+  for (const body of bodies) {
+    if (body.author === null || body.authorId === null) continue;
+    if (people.byAuthor.has(body.author)) continue;
+    unrecorded.set(body.author, body.authorId);
+  }
+  return unrecorded;
+}
+function w15Prefix(root) {
+  if (root.namespaceURI === W15_NS) {
+    return root.prefix === null ? "" : `${root.prefix}:`;
+  }
+  const declaration = Array.from(root.attributes).find(
+    (attr) => attr.value === W15_NS && (attr.name === "xmlns" || attr.name.startsWith("xmlns:"))
+  );
+  if (declaration === void 0) return null;
+  const prefix = declaration.name.slice("xmlns:".length);
+  return prefix === "" ? "" : `${prefix}:`;
+}
+function rootTagStart(xml) {
+  let at = 0;
+  for (; ; ) {
+    const opens = xml.indexOf("<", at);
+    if (opens === -1) return -1;
+    if (xml.startsWith("<!--", opens)) {
+      at = xml.indexOf("-->", opens + 4) + 3;
+      continue;
+    }
+    if (xml.startsWith("<?", opens)) {
+      at = xml.indexOf("?>", opens + 2) + 2;
+      continue;
+    }
+    return opens;
+  }
+}
+function openTagEnd(xml, at) {
+  let quote = null;
+  for (let i = at; i < xml.length; i += 1) {
+    const character = xml[i];
+    if (quote !== null) {
+      if (character === quote) quote = null;
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (character === ">") {
+      return { end: i + 1, selfClosing: xml[i - 1] === "/" };
+    }
+  }
+  return null;
+}
+function malformed(detail) {
+  return new DocxExportError("malformed-xml", `the people part ${detail}`);
+}
+function peopleXml(people, added) {
+  const xml = people.xml;
+  if (xml === null) {
+    const persons2 = Array.from(
+      added,
+      ([author, userId]) => personXml(author, userId, "w15:", "")
+    );
+    return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w15:people xmlns:w15="${W15_NS}">${persons2.join("")}</w15:people>`;
+  }
+  const root = parseXml(xml).documentElement;
+  if (root.localName !== "people") {
+    throw malformed("has no people root element");
+  }
+  const prefix = w15Prefix(root);
+  const persons = Array.from(
+    added,
+    ([author, userId]) => personXml(
+      author,
+      userId,
+      prefix ?? "w15:",
+      prefix === null ? ` xmlns:w15="${W15_NS}"` : ""
+    )
+  ).join("");
+  const start = rootTagStart(xml);
+  const open = start === -1 ? null : openTagEnd(xml, start);
+  if (open === null) throw malformed("has no people root element");
+  if (open.selfClosing) {
+    return `${xml.slice(0, open.end - 2)}>${persons}</${root.nodeName}>` + xml.slice(open.end);
+  }
+  const close = xml.lastIndexOf(`</${root.nodeName}`);
+  if (close === -1) throw malformed("has no closing people tag");
+  return xml.slice(0, close) + persons + xml.slice(close);
+}
+function availablePeoplePath(session) {
+  const directory = directoryOf(session.mainPartPath);
+  for (let suffix = 0; ; suffix += 1) {
+    const name = suffix === 0 ? "people.xml" : `people${suffix + 1}.xml`;
+    const path = directory + name;
+    if (!session.parts.has(path)) return path;
+  }
+}
+function planPeoplePart(bodies, session, relationships, currentContentTypes) {
+  const people = session.comments.people;
+  const added = unrecordedAuthors(bodies, people);
+  if (added.size === 0) return null;
+  const parts = /* @__PURE__ */ new Map();
+  const addingPart = people.partPath === null;
+  const partPath = people.partPath ?? availablePeoplePath(session);
+  if (addingPart) {
+    relationships.add({
+      type: PEOPLE_REL_TYPE,
+      target: partPath.slice(directoryOf(session.mainPartPath).length)
+    });
+  }
+  parts.set(partPath, encodeUtf8(peopleXml(people, added), people.hadBom));
+  if (addingPart || people.xml === null) {
+    const contentTypes = withContentType(
+      session.parts,
+      partPath,
+      PEOPLE_CONTENT_TYPE,
+      currentContentTypes
+    );
+    if (contentTypes) parts.set(CONTENT_TYPES_PATH, contentTypes);
+  }
+  return parts;
+}
+export {
+  NO_PEOPLE,
+  commentAuthorId,
+  planPeoplePart,
+  readPeople
+};

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

@@ -1,9 +1,16 @@
 /**
  * Reads comment and comment-extension package parts.
  */
+import { type ImportedPeople } from "./people";
 export interface ImportedComment {
     id: string;
     author: string | null;
+    /**
+     * The identity the people part records for `author` under this editor's provider. Null when it
+     * records none, and null as well when it records that name under more than one identity, which
+     * leaves no way to tell whose comment this is.
+     */
+    authorId: string | null;
     initials: string | null;
     date: string | null;
     text: string;
@@ -24,6 +31,8 @@ export interface ImportedComments {
     extendedXml: string | null;
     extendedHadBom: boolean;
     extendedOrdered: readonly ImportedCommentExtension[];
+    /** The people part as opened, which is where an author's identity is looked up */
+    people: ImportedPeople;
 }
 export declare const NO_COMMENTS: ImportedComments;
 export interface ImportedCommentExtension {
@@ -32,5 +41,11 @@ export interface ImportedCommentExtension {
     resolved: boolean;
     xml: string;
 }
-/** Reads the Comments part related from the main document story. */
+/**
+ * Reads the Comments part related from the main document story.
+ *
+ * The people part is read whether or not there are comments: a document may carry one with no
+ * comment left, and a comment added to it then has to be recorded in that part rather than in a
+ * second one.
+ */
 export declare function readComments(parts: Map<string, Uint8Array>, mainPartPath: string): ImportedComments;

package/dist/docx/comments/reading.js

@@ -8,6 +8,11 @@ import {
 } from "../../ooxml/xml.js";
 import { readRelationships, relsPathOf, resolveTarget } from "../relationships.js";
 import { COMMENTS_EXTENDED_REL_TYPE, COMMENTS_REL_TYPE } from "./constants.js";
+import {
+  commentAuthorId,
+  NO_PEOPLE,
+  readPeople
+} from "./people.js";
 function attribute(el, localName) {
   return Array.from(el.attributes).find((entry) => entry.localName === localName)?.value ?? null;
 }
@@ -31,7 +36,8 @@ var NO_COMMENTS = {
   extendedPartPath: null,
   extendedXml: null,
   extendedHadBom: false,
-  extendedOrdered: []
+  extendedOrdered: [],
+  people: NO_PEOPLE
 };
 function lastParagraphId(comment) {
   const paragraphs = Array.from(comment.getElementsByTagNameNS(W_NS, "p"));
@@ -83,13 +89,14 @@ function readCommentExtensions(parts, mainPartPath) {
   return { partPath, xml: text, hadBom, byParaId, ordered };
 }
 function readComments(parts, mainPartPath) {
+  const people = readPeople(parts, mainPartPath);
   const relationship = readRelationships(parts, relsPathOf(mainPartPath)).find(
     (entry) => entry.type === COMMENTS_REL_TYPE && !entry.external
   );
-  if (!relationship) return NO_COMMENTS;
+  if (!relationship) return { ...NO_COMMENTS, people };
   const partPath = resolveTarget(mainPartPath, relationship.target);
   const bytes = parts.get(partPath);
-  if (!bytes) return { ...NO_COMMENTS, partPath };
+  if (!bytes) return { ...NO_COMMENTS, partPath, people };
   const { text, hadBom } = decodeUtf8(bytes);
   const root = parseXml(text).documentElement;
   const extensions = readCommentExtensions(parts, mainPartPath);
@@ -98,10 +105,12 @@ function readComments(parts, mainPartPath) {
     if (id === null) return [];
     const paraId = lastParagraphId(el);
     const extension = paraId ? extensions.byParaId.get(paraId) : void 0;
+    const author = attribute(el, "author");
     return [
       {
         id,
-        author: attribute(el, "author"),
+        author,
+        authorId: author === null ? null : commentAuthorId(people, author),
         initials: attribute(el, "initials"),
         date: attribute(el, "date"),
         text: commentText(el),
@@ -140,7 +149,8 @@ function readComments(parts, mainPartPath) {
     extendedPartPath: extensions.partPath,
     extendedXml: extensions.xml,
     extendedHadBom: extensions.hadBom,
-    extendedOrdered: extensions.ordered
+    extendedOrdered: extensions.ordered,
+    people
   };
 }
 export {

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

@@ -7,5 +7,8 @@ import type { SessionStore } from "../session";
 export interface CommentPartChanges {
     parts: ReadonlyMap<string, Uint8Array>;
 }
-/** Plans the Comments part, relationship and content type only when comment state changed. */
+/**
+ * Plans the Comments part, relationship and content type only when comment state changed, and the
+ * people part beside them for an author whose identity the document has yet to record.
+ */
 export declare function planCommentParts(doc: PMNode, session: SessionStore, relationships: RelationshipWriter, currentContentTypes?: Uint8Array): CommentPartChanges | null;

package/dist/docx/comments/writing.js

@@ -1,6 +1,6 @@
 // src/docx/comments/writing.ts
 import { DocxExportError } from "../../ooxml/errors.js";
-import { decodeUtf8, encodeUtf8, escapeXml, W_NS } from "../../ooxml/xml.js";
+import { encodeUtf8, escapeXml, W_NS } from "../../ooxml/xml.js";
 import { directoryOf } from "../relationships.js";
 import {
   COMMENTS_CONTENT_TYPE,
@@ -12,9 +12,11 @@ import {
   W14_NS,
   W15_NS
 } from "./constants.js";
+import { withContentType } from "./contentTypes.js";
 import {
   commentReferencesIn
 } from "./model.js";
+import { planPeoplePart } from "./people.js";
 function commentsChanged(doc, session) {
   const current = commentReferencesIn(doc);
   if (current.size !== session.commentReferenceIds.size) return true;
@@ -213,37 +215,6 @@ function commentsXml(references, comments, originallyReferenced) {
   const openTag = hasThreadMetadata ? withThreadMarkupCompatibility(open[0]) : open[0];
   return comments.xml.slice(0, open.index) + openTag + pieces.join("") + comments.xml.slice(close);
 }
-var TYPES_OPEN_TAG = /<(?:[\w.-]+:)?Types\b[^>]*>/;
-function withContentType(parts, partPath, contentType, current) {
-  const original = current ?? parts.get(CONTENT_TYPES_PATH);
-  if (!original) {
-    throw new DocxExportError(
-      "missing-content-types",
-      `cannot add a Comments part to a package that has no ${CONTENT_TYPES_PATH}`
-    );
-  }
-  const { text, hadBom } = decodeUtf8(original);
-  const partName = `/${partPath}`;
-  if (new RegExp(
-    `<(?:[\\w.-]+:)?Override[^>]+PartName=["']${partName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["']`,
-    "i"
-  ).test(text)) {
-    return null;
-  }
-  const open = TYPES_OPEN_TAG.exec(text);
-  if (!open) {
-    throw new DocxExportError(
-      "malformed-xml",
-      `${CONTENT_TYPES_PATH} has no Types element`
-    );
-  }
-  const rootName = /^<([^\s>]+)/.exec(open[0])?.[1] ?? "Types";
-  const separator = rootName.indexOf(":");
-  const prefix = separator < 0 ? "" : `${rootName.slice(0, separator)}:`;
-  const declaration = `<${prefix}Override PartName="${partName}" ContentType="${contentType}"/>`;
-  const at = open.index + open[0].length;
-  return encodeUtf8(text.slice(0, at) + declaration + text.slice(at), hadBom);
-}
 function availableCommentsPath(session) {
   const directory = directoryOf(session.mainPartPath);
   for (let suffix = 0; ; suffix += 1) {
@@ -320,6 +291,15 @@ function planCommentParts(doc, session, relationships, currentContentTypes) {
       if (contentTypes) parts.set(CONTENT_TYPES_PATH, contentTypes);
     }
   }
+  if (bodyChanged) {
+    const people = planPeoplePart(
+      currentCommentBodies(references).values(),
+      session,
+      relationships,
+      parts.get(CONTENT_TYPES_PATH) ?? currentContentTypes
+    );
+    for (const [path, bytes] of people ?? []) parts.set(path, bytes);
+  }
   return { parts };
 }
 export {

package/dist/docx/importParagraph.js

@@ -81,6 +81,7 @@ function buildRunChild(el, marks, images, comments, notes, noteLabel) {
             id,
             referenceXml: serializeXml(el),
             author: comment?.author ?? null,
+            authorId: comment?.authorId ?? null,
             initials: comment?.initials ?? null,
             date: comment?.date ?? null,
             text: comment?.text ?? "",

package/dist/editor/commands/breakCommands.js

@@ -1,9 +1,12 @@
 // src/editor/commands/breakCommands.ts
 import { docxSchema } from "../../schema/index.js";
 import { replacementShut } from "../../schema/locks.js";
+import { editsShut } from "../../schema/protectionState.js";
 function insertBreak(brAttrs) {
   return (state, dispatch) => {
-    if (replacementShut(state.selection, state.doc)) return false;
+    if (editsShut(state) || replacementShut(state.selection, state.doc)) {
+      return false;
+    }
     if (dispatch) {
       const br = docxSchema.nodes.hardBreak.create({ brAttrs });
       dispatch(state.tr.replaceSelectionWith(br).scrollIntoView());

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

@@ -1,6 +1,7 @@
 /**
- * Dry-runs external commands and checks every produced transaction against document locks without
- * dispatching them or triggering the locked-content plugin's side effects.
+ * 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
+ * effects.
  */
 import type { Command, EditorState } from "prosemirror-state";
 export declare function canRunCommand(command: Command, state: EditorState): boolean;

package/dist/editor/commands/canRunCommand.js

@@ -3,7 +3,7 @@ import { transactionAllowed } from "../../schema/locks.js";
 function canRunCommand(command, state) {
   const built = [];
   if (!command(state, (tr) => built.push(tr))) return false;
-  return built.every((tr) => transactionAllowed(tr, state.doc));
+  return built.every((tr) => transactionAllowed(tr, state));
 }
 export {
   canRunCommand

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

@@ -93,6 +93,7 @@ function addCommentTransaction(state, comment) {
       id,
       referenceXml: null,
       author: comment.author,
+      authorId: comment.authorId ?? null,
       initials: comment.initials ?? null,
       date,
       text: comment.text,
@@ -113,7 +114,7 @@ function addCommentTransaction(state, comment) {
     startMarks
   );
   const transaction = state.tr.insert(to, end).insert(to + 1, reference).insert(from, start);
-  return transactionAllowed(transaction, state.doc) ? transaction : null;
+  return transactionAllowed(transaction, state) ? transaction : null;
 }
 function canAddComment(state) {
   return addCommentTransaction(state, {
@@ -147,7 +148,7 @@ function updateComment(id, text) {
       }
       return true;
     });
-    if (!changed || !transactionAllowed(transaction, state.doc)) return false;
+    if (!changed || !transactionAllowed(transaction, state)) return false;
     dispatch?.(transaction);
     return true;
   };
@@ -167,7 +168,7 @@ function updateReference(id, change) {
       }
       return false;
     });
-    if (!changed || !transactionAllowed(transaction, state.doc)) return false;
+    if (!changed || !transactionAllowed(transaction, state)) return false;
     dispatch?.(transaction);
     return true;
   };
@@ -207,6 +208,7 @@ function addCommentReply(id, reply) {
           {
             id: replyId,
             author: reply.author,
+            authorId: reply.authorId ?? null,
             initials: reply.initials ?? null,
             date,
             text: reply.text,
@@ -275,7 +277,7 @@ function removeComment(id) {
     for (const marker of positions.sort((a, b) => b.pos - a.pos)) {
       transaction.delete(marker.pos, marker.pos + marker.size);
     }
-    if (!transactionAllowed(transaction, state.doc)) return false;
+    if (!transactionAllowed(transaction, state)) return false;
     dispatch?.(transaction);
     return true;
   };

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

@@ -1,11 +1,18 @@
 /** Public comment values and shared attribute readers. */
 export interface CommentAuthor {
+    /**
+     * The identity behind the name, an opaque string the host application chooses. Recorded in the
+     * document's people part, and what decides whose comment a comment is (`schema/protection`).
+     */
+    id: string;
     name: string;
     initials?: string;
 }
 export interface NewComment {
     text: string;
     author: string;
+    /** The identity behind `author`. A comment written without one belongs to nobody in particular */
+    authorId?: string;
     initials?: string;
     /** ISO 8601 timestamp. The current time is used when omitted. */
     date?: string;
@@ -13,6 +20,7 @@ export interface NewComment {
 export interface DocumentComment {
     id: string;
     author: string | null;
+    authorId: string | null;
     initials: string | null;
     date: string | null;
     text: string;
@@ -25,6 +33,7 @@ export interface DocumentComment {
 export interface DocumentCommentReply {
     id: string;
     author: string | null;
+    authorId: string | null;
     initials: string | null;
     date: string | null;
     text: string;

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

@@ -6,3 +6,10 @@ export declare function stringAttr(value: unknown): string | null;
 export declare function repliesAttr(value: unknown): readonly CommentReplyData[];
 /** Comments in document order, including point comments that have no explicit range. */
 export declare function documentComments(state: EditorState): readonly DocumentComment[];
+/**
+ * Whether the body of this comment, or of one of its replies, may be edited or deleted here: the
+ * protection lets comments be edited at all, and the body is one of one's own to edit
+ * (`schema/protection`). Replying and settling a thread are not governed by this; a comment command
+ * asked without `dispatch` answers for those.
+ */
+export declare function canEditComment(state: EditorState, commentId: string, replyId?: string | null): boolean;