@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash/command-chunks/{chunk-Q6JLT2EY.js → chunk-TL3KDYEM.js}

@@ -1,104 +1,12 @@
-// packages/safe-bash-pptx-engine/src/errors.ts
-var OfficeError = class extends Error {
-  constructor(code, message, phase) {
-    super(message);
-    this.code = code;
-    this.phase = phase;
-  }
-  code;
-  phase;
-  name = "OfficeError";
-};
-var InvalidHandleError = class extends OfficeError {
-  name = "InvalidHandleError";
-  constructor() {
-    super("invalid-handle", "Model handle was invalidated.", "select");
-  }
-};
-var InvalidXmlError = class extends OfficeError {
-  name = "InvalidXmlError";
-  constructor(message = "Invalid XML or structured edit.") {
-    super("invalid-xml", message, "parse");
-  }
-};
-var PackageNotFoundError = class extends OfficeError {
-  name = "PackageNotFoundError";
-  constructor(message = "Input package was not found.") {
-    super("io-failure", message, "admit");
-  }
-};
-var IndexError = class extends OfficeError {
-  name = "IndexError";
-  constructor(message = "Sequence position is out of range.") {
-    super("index-out-of-range", message, "select");
-  }
-};
-var KeyError = class extends OfficeError {
-  name = "KeyError";
-  constructor(message = "Required collection key is missing.") {
-    super("missing-key", message, "select");
-  }
-};
-var ValueError = class extends OfficeError {
-  name = "ValueError";
-  constructor(message = "Invalid model value.") {
-    super("invalid-value", message, "usage");
-  }
-};
-var TypeError = class extends OfficeError {
-  name = "TypeError";
-  constructor(message = "Invalid model value type.") {
-    super("invalid-type", message, "usage");
-  }
-};
-var PropertyAccessError = class extends OfficeError {
-  name = "PropertyAccessError";
-  constructor(message = "Model property is unavailable.") {
-    super("property-unavailable", message, "select");
-  }
-};
-
-// packages/safe-bash-pptx-engine/src/resource-limits.ts
-function resourceContext(context = {}) {
-  if (!context || typeof context !== "object" || Array.isArray(context))
-    throw new OfficeError("invalid-type", "Expected a resource context.", "usage");
-  for (const key of Reflect.ownKeys(context)) {
-    if (!("value" in Object.getOwnPropertyDescriptor(context, key)))
-      throw new OfficeError("invalid-value", "Resource context requires stored data.", "usage");
-  }
-  for (const limits of [context.limits, context.archiveLimits, context.xmlLimits, context.relationshipLimits]) {
-    if (limits === void 0) continue;
-    if (!limits || typeof limits !== "object" || Array.isArray(limits) || Reflect.ownKeys(limits).some((key) => !("value" in Object.getOwnPropertyDescriptor(limits, key))))
-      throw new OfficeError("invalid-value", "Limits require stored data.", "usage");
-  }
-  const resolved = {
-    ...context,
-    limits: { maxBytes: Infinity, maxReads: Infinity, chunkBytes: 65536, ...context.limits },
-    archiveLimits: {
-      maxArchiveBytes: Infinity,
-      maxEntryBytes: Infinity,
-      maxTotalBytes: Infinity,
-      maxMembers: Infinity,
-      maxPathBytes: Infinity,
-      maxDepth: Infinity,
-      maxPaxBytes: Infinity,
-      maxTextBytes: Infinity,
-      chunkSize: 65536,
-      ...context.archiveLimits
-    },
-    xmlLimits: { maxBytes: Infinity, maxNodes: Infinity, maxDepth: Infinity, ...context.xmlLimits },
-    relationshipLimits: { maxBytes: Infinity, maxParts: Infinity, maxRelationships: Infinity, ...context.relationshipLimits }
-  };
-  for (const limits of [resolved.limits, resolved.archiveLimits, resolved.xmlLimits, resolved.relationshipLimits]) {
-    for (const [key, value] of Object.entries(limits)) {
-      if (value !== Infinity && !Number.isSafeInteger(value) || value < 1 || (key === "chunkSize" || key === "chunkBytes") && !Number.isSafeInteger(value))
-        throw new OfficeError("invalid-value", "Limits must be positive safe integers or unlimited.", "usage");
-    }
-  }
-  return resolved;
-}
+import {
+  resourceContext
+} from "./chunk-FOO3AXFK.js";
+import {
+  OfficeError,
+  PackageNotFoundError
+} from "./chunk-RR6QQ25D.js";
 
-// packages/safe-bash-pptx-engine/src/bytes.ts
+// packages/safe-bash-presentation-engine/src/bytes.ts
 function admitLimits(context, options, output) {
   if (!context || !options || typeof options !== "object") {
     throw new OfficeError("invalid-type", "Explicit byte limits are required.", "usage");
@@ -260,16 +168,6 @@ async function writeBinary(bytes, sink, context = {}, options = {}) {
 }
 
 export {
-  OfficeError,
-  InvalidHandleError,
-  InvalidXmlError,
-  PackageNotFoundError,
-  IndexError,
-  KeyError,
-  ValueError,
-  TypeError,
-  PropertyAccessError,
-  resourceContext,
   binarySource,
   readBinary,
   writeBinary

package/dist/safe-bash/command-chunks/chunk-TVAEX4WQ.js

@@ -0,0 +1,473 @@
+import {
+  openNotes
+} from "./chunk-Y6KHC3JB.js";
+import {
+  reviewResourceDate
+} from "./chunk-NSM366N6.js";
+import {
+  assertOutsideFields,
+  parseFields
+} from "./chunk-6EHVFKM7.js";
+import {
+  openDocumentLocations,
+  resolveDocxSelection
+} from "./chunk-LHDB4QO5.js";
+import {
+  incomingResourceReferences,
+  measurePackageResourceSerialization
+} from "./chunk-W6DV2CLS.js";
+import {
+  validateDocxInvocation
+} from "./chunk-DE66JRWJ.js";
+import {
+  commentStoryParts,
+  nextCommentId,
+  storedCommentId
+} from "./chunk-3JQ3RF2O.js";
+import {
+  paragraphTextRun,
+  replaceParagraphContent
+} from "./chunk-GGOZXIGH.js";
+import {
+  commentParagraphNamespace,
+  inventoryCommentExtensions,
+  synchronizeCommentExtensions
+} from "./chunk-IFNLDOJ4.js";
+import {
+  findRelationshipPart
+} from "./chunk-4LXDJES2.js";
+import {
+  assertDocumentEditable,
+  publishDocumentArchive
+} from "./chunk-HPKUFWHW.js";
+import {
+  writeArchive
+} from "./chunk-3VETFXYR.js";
+import {
+  DocumentPackage
+} from "./chunk-GLPIFP7N.js";
+import {
+  DocumentXmlEditor,
+  UnsupportedEditError,
+  activeXmlChildren,
+  replaceCommentRangeXml,
+  xmlValue
+} from "./chunk-YPVBU7QF.js";
+import {
+  normalizePropertyDate,
+  parseStoredDateTime
+} from "./chunk-VEUQWV2V.js";
+import {
+  dialectForNamespace,
+  documentDialects
+} from "./chunk-MG7AJD5E.js";
+import {
+  compatibilityContainers,
+  documentCompatibilityProfile
+} from "./chunk-GZ2N24A2.js";
+import {
+  SelectionError,
+  closedRecord,
+  encodeGeneratedLocation
+} from "./chunk-LQOKYG3O.js";
+import {
+  relativePartTarget
+} from "./chunk-WAKYUXVQ.js";
+import {
+  InvalidPackageError,
+  isXmlContentType,
+  parseMediaType
+} from "./chunk-MWAAMNAM.js";
+import {
+  DocxUsageError
+} from "./chunk-2P7BLWWI.js";
+import {
+  InvalidValueError,
+  archiveSettings,
+  documentSession
+} from "./chunk-IQFRPIXH.js";
+
+// packages/safe-bash-docx-engine/src/comments-state.ts
+var commentAttribute = (node, name) => node.attributes.find((a) => a.namespace === node.namespace && a.localName === name)?.value;
+function idOf(node) {
+  const id = storedCommentId(commentAttribute(node, "id"));
+  if (id === null)
+    throw new InvalidPackageError("Comment IDs require nonnegative safe integers.");
+  return id;
+}
+async function openComments(input, context) {
+  const settings = archiveSettings(context), budget = settings.budget;
+  const document = await openDocumentLocations(input, settings), archive = document.snapshot();
+  const main = document.list("story", { scope: "body" })[0].value.part;
+  const graph = new DocumentPackage(archive, settings.limits, budget);
+  const editors = new Map(graph.parts.filter((p) => isXmlContentType(p.content_type)).map((p) => [p.partname, new DocumentXmlEditor(p.bytes, {}, void 0, budget)]));
+  const dialect = dialectForNamespace(editors.get(main).root.namespace);
+  const { w, r } = documentDialects[dialect];
+  const edges = graph.relationships(main).filter((e) => e.reltype === r + "/comments");
+  if (edges.length > 1 || edges.some((e) => e.is_external)) throw new InvalidPackageError("Comments require one internal owning relationship.");
+  const part = edges[0]?.target_part.partname;
+  const extensions = inventoryCommentExtensions(graph, editors, budget);
+  if (part && extensions.length) editors.set(part, new DocumentXmlEditor(graph.getPart(part).bytes, {}, { ...documentCompatibilityProfile, understoodNamespaces: [...documentCompatibilityProfile.understoodNamespaces, commentParagraphNamespace] }, budget));
+  const editor = part ? editors.get(part) : void 0;
+  if (part && (!editor || editor.root.namespace !== w || editor.root.localName !== "comments" || parseMediaType(graph.getPart(part).content_type) !== "application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml"))
+    throw new InvalidPackageError("Invalid comments part.");
+  const markers = [];
+  const stories = commentStoryParts(graph, main, part, w, r, (name) => editors.get(name).root, budget);
+  for (const [name, xml] of editors) {
+    if (!stories.has(name)) continue;
+    const children = activeXmlChildren(xml, budget);
+    const containers = new Set(xml.compatibility[compatibilityContainers]);
+    const parents = /* @__PURE__ */ new Map();
+    const active = [xml.root];
+    while (active.length) {
+      const node = active.pop();
+      budget.charge("work", 1);
+      const nested = children(node);
+      budget.charge("retainedBytes", nested.length * 32);
+      for (const child of nested) {
+        parents.set(child, node);
+        active.push(child);
+      }
+    }
+    let order = 0;
+    const depth = /* @__PURE__ */ new Map();
+    budget.charge("retainedBytes", 80);
+    const path = [];
+    const frames = [{ node: xml.root, parent: xml.root, container: xml.root, unsafe: xml.root.localName === "glossaryDocument", next: -1 }];
+    while (frames.length) {
+      budget.charge("work", 1);
+      const frame = frames.at(-1);
+      if (frame.next === -1) {
+        const { node, parent } = frame;
+        if (node.namespace === w && ["body", "hdr", "ftr", "footnote", "endnote", "comment", "tc", "txbxContent"].includes(node.localName)) frame.container = node;
+        frame.unsafe ||= !containers.has(node) && (node.namespace !== w || ["hdr", "ftr", "comment", "sdt", "ins", "del", "moveFrom", "moveTo", "fldSimple", "hyperlink", "customXml"].includes(node.localName) || ["footnote", "endnote"].includes(node.localName) && (commentAttribute(node, "type") ?? "normal") !== "normal");
+        if (node.namespace === w && node.localName === "fldChar" && parents.has(node)) {
+          const kind = commentAttribute(node, "fldCharType"), current = depth.get(frame.container) ?? 0;
+          if (kind === "begin" || kind === "end") {
+            if (!depth.has(frame.container)) budget.charge("retainedBytes", 24);
+            depth.set(frame.container, kind === "begin" ? current + 1 : Math.max(0, current - 1));
+          }
+        }
+        if (node.namespace === w && ["commentRangeStart", "commentRangeEnd", "commentReference"].includes(node.localName)) {
+          const reference = node.localName === "commentReference";
+          const logicalParent = parents.get(node);
+          budget.charge("work", path.length);
+          budget.charge("retainedBytes", 192 + path.length * 8);
+          markers.push({
+            id: idOf(node),
+            node,
+            parent,
+            editor: xml,
+            part: name,
+            path: [...path],
+            order,
+            container: frame.container,
+            safe: !frame.unsafe && !(depth.get(frame.container) ?? 0) && logicalParent?.namespace === w && logicalParent.localName === (reference ? "r" : "p") && !node.children.length && !node.content.some((c) => c.kind !== "text" || c.text.trim())
+          });
+        }
+        order++;
+        frame.next = 0;
+      } else if (frame.next < frame.node.children.length) {
+        const index = frame.next++;
+        budget.charge("retainedBytes", 88);
+        path.push(index);
+        frames.push({ node: frame.node.children[index], parent: frame.node, container: frame.container, unsafe: frame.unsafe, next: -1 });
+      } else {
+        frames.pop();
+        path.pop();
+      }
+    }
+  }
+  const locations = document.list("story", { scope: "comments" });
+  const bodies = editor ? activeXmlChildren(editor, budget)(editor.root) : [];
+  const records = bodies.filter((n) => n.namespace === w && n.localName === "comment").map((node) => {
+    const id = idOf(node), owned = markers.filter((m) => m.id === id);
+    const starts = owned.filter((m) => m.node.localName === "commentRangeStart");
+    const ends = owned.filter((m) => m.node.localName === "commentRangeEnd");
+    const refs = owned.filter((m) => m.node.localName === "commentReference");
+    const issues2 = [];
+    if (!owned.length) issues2.push("deleted-anchor");
+    else if (starts.length !== 1 || ends.length !== 1 || refs.length !== 1 || starts[0].part !== ends[0].part || starts[0].part !== refs[0].part || starts[0].container !== ends[0].container || starts[0].container !== refs[0].container || starts[0].order >= ends[0].order || ends[0].order >= refs[0].order) issues2.push("inconsistent-range");
+    if (owned.some((m) => !m.safe)) issues2.push("unsafe-anchor");
+    return {
+      id,
+      node,
+      editor,
+      part,
+      markers: owned,
+      start: starts[0],
+      end: ends[0],
+      reference: refs[0],
+      issues: issues2,
+      location: locations.find((l) => l.value.part === part && l.value.story === part + "#comment:" + commentAttribute(node, "id"))
+    };
+  });
+  const ids = /* @__PURE__ */ new Set();
+  for (const record of records) {
+    if (ids.has(record.id)) throw new InvalidPackageError("Duplicate comment body ID.");
+    ids.add(record.id);
+  }
+  for (const record of records) if (record.start && record.end) {
+    if (records.some((other) => other !== record && other.start && other.end && other.start.part === record.start.part && other.start.order < record.end.order && record.start.order < other.end.order)) record.issues.push("overlapping-comments");
+  }
+  const issues = [.../* @__PURE__ */ new Set([...records.flatMap((n) => n.issues), ...markers.some((m) => !ids.has(m.id)) ? ["missing-body"] : []])];
+  const modern = extensions.length > 0;
+  return { document, archive, main, graph, editors, dialect, w, r, part, records, markers, issues, modern, extensions, budget };
+}
+
+// packages/safe-bash-docx-engine/src/comments.ts
+function selectedComments(state, operation, options) {
+  let records = [...state.records].sort((a, b) => a.id - b.id);
+  if (options.select) {
+    const location = state.document.resolve(options.select);
+    if (location.value.range) throw new DocxUsageError("Comment body operations require a whole comment token.");
+    records = records.filter((n) => n.location?.token === location.token);
+    if (!records.length) throw new SelectionError("missing-selection");
+  } else if (options.comment !== void 0) records = records.slice(options.comment - 1, options.comment);
+  if (!records.length && operation !== "comments.list" && !options.allowEmpty) throw new SelectionError("missing-selection");
+  if (records.length > 1 && operation !== "comments.list" && !options.all) throw new SelectionError("ambiguous-selection");
+  state.budget.check("matches", records.length);
+  return records;
+}
+async function inspectDocumentComments(input, request, context, projection = "snapshot") {
+  if (projection !== "snapshot" && projection !== "resource") throw new InvalidValueError("Expected a declared comment projection.");
+  closedRecord(request, ["operation", "options"]);
+  if (!["comments.list", "comments.get"].includes(request.operation)) throw new DocxUsageError("Expected a comment read operation.");
+  const settings = archiveSettings(context);
+  const invocation = validateDocxInvocation({ operation: request.operation, inputs: ["document"], options: request.options }, settings.budget);
+  const options = invocation.options;
+  const budget = settings.budget.lower(Object.fromEntries((options.limit ?? []).map((i) => [i.name, i.value])));
+  const state = await openComments(input, { ...settings, budget });
+  const data = { items: selectedComments(state, request.operation, options).map((n) => {
+    if (!n.location) throw new UnsupportedEditError("Comment body is outside admitted stories.");
+    const anchor = (m) => ({ part: m.part, path: m.path });
+    return {
+      comment_id: n.id,
+      author: commentAttribute(n.node, "author") ?? "",
+      initials: commentAttribute(n.node, "initials") ?? null,
+      timestamp: commentAttribute(n.node, "date") ?? null,
+      text: state.document.text({ select: n.location.token }).text,
+      location: n.location,
+      range: n.start && n.end && n.reference ? { start: anchor(n.start), end: anchor(n.end), reference: anchor(n.reference) } : null,
+      issues: n.issues
+    };
+  }), issues: state.issues, modern: state.modern ? "preserve" : null, extensions: state.extensions };
+  let result = data;
+  if (projection === "resource") {
+    const references = state.part === void 0 ? [] : incomingResourceReferences(state.graph, state.part, budget);
+    const annotations = state.document.list("annotation", { scope: "all-stories" });
+    const items = data.items.map((note) => {
+      budget.charge("retainedBytes", 1024);
+      return {
+        kind: "comments",
+        location: note.location,
+        text: note.text,
+        properties: [
+          { name: "comment_id", type: "integer", value: note.comment_id, writable: false, cached: false },
+          { name: "author", type: "string", value: note.author, writable: true, cached: false },
+          { name: "initials", type: "string", value: note.initials, writable: true, cached: false },
+          { name: "timestamp", type: "date", value: reviewResourceDate(note.timestamp), writable: false, cached: false },
+          { name: "stored_timestamp", type: "string", value: note.timestamp, writable: false, cached: false },
+          { name: "text", type: "string", value: note.text, writable: false, cached: false }
+        ],
+        references,
+        support: data.modern !== null || note.issues.some((issue) => issue !== "deleted-anchor") ? "preserve" : "read",
+        details: {
+          kind: "comments",
+          commentId: note.comment_id,
+          author: note.author,
+          timestamp: reviewResourceDate(note.timestamp),
+          initials: note.initials,
+          modern: state.modern,
+          anchors: annotations.filter((location) => state.markers.some((marker) => marker.id === note.comment_id && marker.node.localName === "commentRangeStart" && marker.part === location.value.part && marker.path.length === location.value.path.length && marker.path.every((index, position) => index === location.value.path[position])))
+        }
+      };
+    });
+    result = request.operation === "comments.get" ? { item: items[0] } : { items };
+  }
+  const serializedBytes = measurePackageResourceSerialization({ version: 1, operation: request.operation, ok: true, data: result, affected: 0, locations: data.items.map((n) => n.location), warnings: [], errors: [] }, budget) + 1;
+  budget.check("serializedOutput", serializedBytes);
+  return result;
+}
+async function editDocumentComments(input, request, context) {
+  closedRecord(request, ["operation", "options", "input"]);
+  if (!["comments.add", "comments.set", "comments.remove"].includes(request.operation)) throw new DocxUsageError("Expected a comment editing operation.");
+  const settings = archiveSettings(context);
+  const invocation = validateDocxInvocation({ operation: request.operation, inputs: [request.input?.path ?? "document"], options: request.options }, settings.budget);
+  const options = invocation.options;
+  const budget = settings.budget.lower(Object.fromEntries((options.limit ?? []).map((i) => [i.name, i.value])));
+  const state = await openComments(input, { ...settings, budget });
+  const { archive, graph, editors, main, w, r } = state;
+  const memberNames = new Map(graph.parts.map((part2) => [part2.partname, part2.name]));
+  assertDocumentEditable(archive, { ...settings, budget });
+  const updates = [];
+  let part = state.part;
+  const editPart = (name, initial) => {
+    const existing = editors.get(name);
+    if (existing) return existing;
+    const editor = new DocumentXmlEditor(archive.members.find((m) => m.name === (memberNames.get(name) ?? name.slice(1)))?.bytes ?? new TextEncoder().encode(initial), {}, void 0, budget);
+    editors.set(name, editor);
+    return editor;
+  };
+  if (request.operation === "comments.add") {
+    if (state.issues.some((i) => i !== "deleted-anchor")) throw new UnsupportedEditError("Comment ranges must be consistent before insertion.");
+    const selected = resolveDocxSelection(state.document, invocation);
+    if (selected.length !== 1) throw new SelectionError("missing-selection");
+    const before = selected[0], range = before.value.range;
+    if (!range || range.start >= range.end) throw new UnsupportedEditError("Comment creation requires a nonempty paragraph range at run boundaries.");
+    const editor = editors.get(before.value.part);
+    let p = editor.root;
+    const ancestors = [p];
+    for (const i of before.value.path) {
+      p = p.children[i];
+      ancestors.push(p);
+    }
+    const containers = new Set(editor.compatibility[compatibilityContainers]);
+    if (p.namespace !== w || p.localName !== "p" || ancestors.some((n) => !containers.has(n) && (n.namespace !== w || ["hdr", "ftr", "comment", "sdt", "ins", "del", "moveFrom", "moveTo", "fldSimple", "hyperlink", "customXml"].includes(n.localName)))) throw new UnsupportedEditError("Comment anchors cannot cross controlled content.");
+    const owner = state.document.list("story", { scope: "all-stories" }).find((story2) => story2.value.story === before.value.story);
+    if (!owner) throw new UnsupportedEditError("Comment anchors require an admitted story.");
+    const story = ancestors[owner.value.path.length];
+    if (["footnote", "endnote"].includes(story.localName)) {
+      const notes = await openNotes(input, { ...settings, budget });
+      const note = notes.records.find((record) => record.part === before.value.part && record.node.localName === story.localName && record.id === Number(commentAttribute(story, "id")));
+      if (!note || note.type !== "normal") throw new UnsupportedEditError("Comment anchors require an ordinary note story.");
+      if (note.references.length > 1) throw new SelectionError("ambiguous-selection", [before.token]);
+    }
+    const fields = parseFields(ancestors[owner.value.path.length], owner.value.path, budget, editor.compatibility.content);
+    let offset = 0;
+    let first, last;
+    const runs = state.document.list("run", { scope: "all-stories" }).filter((l) => l.value.story === before.value.story && l.value.part === before.value.part && l.value.path.length > before.value.path.length && before.value.path.every((v, i) => l.value.path[i] === v));
+    const children = activeXmlChildren(editor, budget), paragraphChildren = children(p);
+    budget.charge("retainedBytes", paragraphChildren.length * 24);
+    const direct = new Set(paragraphChildren), lengths = /* @__PURE__ */ new Map();
+    const paths = /* @__PURE__ */ new Map();
+    for (const run of runs) {
+      let child = p;
+      for (let depth = before.value.path.length; depth < run.value.path.length; depth++) {
+        budget.charge("work", 1);
+        child = child.children[run.value.path[depth]];
+        if (!direct.has(child)) continue;
+        budget.charge("retainedBytes", 64 + (depth + 1) * 8);
+        paths.set(child, run.value.path.slice(0, depth + 1));
+        lengths.set(child, (lengths.get(child) ?? 0) + [...state.document.text({ select: run.token }).text].length);
+        break;
+      }
+    }
+    for (const node of paragraphChildren) {
+      budget.charge("work", 1);
+      if (node.namespace === w && ["pPr", "bookmarkStart", "bookmarkEnd", "commentRangeStart", "commentRangeEnd", "proofErr", "permStart", "permEnd"].includes(node.localName)) continue;
+      const count = lengths.get(node) ?? 0;
+      if (offset === range.start && count) first = node;
+      if (offset + count === range.end && count) last = node;
+      if (offset < range.end && offset + count > range.start) {
+        if (node.namespace !== w || node.localName !== "r" || children(node).some((n) => n.namespace !== w || !["rPr", "t", "tab", "ptab", "br", "cr", "noBreakHyphen", "softHyphen"].includes(n.localName))) throw new UnsupportedEditError("Comment range crosses unsupported run content.");
+        assertOutsideFields(fields, paths.get(node));
+      }
+      offset += count;
+    }
+    if (!first || !last) throw new UnsupportedEditError("Comment endpoints must coincide with existing run boundaries.");
+    const firstPath = paths.get(first);
+    const lastPath = paths.get(last);
+    const compare = (a, b) => {
+      for (let i = 0; i < Math.min(a.length, b.length); i++) if (a[i] !== b[i]) return a[i] - b[i];
+      return a.length - b.length;
+    };
+    if (state.records.some((n) => n.start?.part === before.value.part && n.end && compare(n.start.path, lastPath) < 0 && compare(firstPath, n.end.path) < 0)) throw new UnsupportedEditError("Comment ranges cannot overlap existing comments.");
+    const id = nextCommentId(state.records.map((n) => n.id), budget);
+    const patches = /* @__PURE__ */ new Map([[first, `<cm:commentRangeStart xmlns:cm="${w}" cm:id="${id}"/>` + editor.sourceXml(first)]]);
+    patches.set(last, (patches.get(last) ?? editor.sourceXml(last)) + `<cm:commentRangeEnd xmlns:cm="${w}" cm:id="${id}"/><cm:r xmlns:cm="${w}"><cm:rPr><cm:rStyle cm:val="CommentReference"/></cm:rPr><cm:commentReference cm:id="${id}"/></cm:r>`);
+    editor[replaceCommentRangeXml](p, editor.sourceXml(p, patches));
+    if (!part) {
+      part = graph.allocatePartName(main.slice(0, main.lastIndexOf("/") + 1) + "comments", ".xml");
+      const relName = findRelationshipPart(graph, main, budget)?.partname ?? main.slice(0, main.lastIndexOf("/") + 1) + "_rels/" + main.slice(main.lastIndexOf("/") + 1) + ".rels";
+      const ns = "http://schemas.openxmlformats.org/package/2006/relationships";
+      const rels = editPart(relName, `<Relationships xmlns="${ns}"/>`);
+      rels.insertChildren(rels.root, `<Relationship xmlns="${ns}" Id="${graph.allocateRelationshipId(main)}" Type="${r}/comments" Target="${xmlValue(relativePartTarget(main, part))}"/>`);
+      const types = editPart("/[Content_Types].xml", "");
+      types.insertChildren(types.root, `<Override xmlns="http://schemas.openxmlformats.org/package/2006/content-types" PartName="${xmlValue(part)}" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml"/>`);
+    }
+    const comments = editPart(part, `<w:comments xmlns:w="${w}"/>`);
+    parseStoredDateTime(normalizePropertyDate(options.timestamp), "xsd");
+    comments.insertChildren(comments.root, `<cm:comment xmlns:cm="${w}" cm:id="${id}" cm:author="${xmlValue(options.author)}" cm:date="${normalizePropertyDate(options.timestamp)}"${options.initials === null ? "" : ` cm:initials="${xmlValue(options.initials ?? "")}"`}><cm:p>${paragraphTextRun(w, options.text ?? "")}</cm:p></cm:comment>`);
+    updates.push({ before, id, kind: "insert" });
+  } else {
+    const records = selectedComments(state, request.operation, options);
+    synchronizeCommentExtensions(state, records, request.operation === "comments.remove");
+    for (const record of records) {
+      await budget.checkpoint();
+      if (!record.location || record.issues.some((i) => i !== "deleted-anchor")) throw new UnsupportedEditError("Selected comment anchors are unsafe.");
+      if (request.operation === "comments.set") {
+        const paragraphs = record.node.children;
+        if (paragraphs.some((p) => p.namespace !== w || p.localName !== "p")) throw new UnsupportedEditError("Comment text assignment cannot discard rich blocks.");
+        if (paragraphs.length === 1 && state.document.text({ select: record.location.token }).text === options.text) continue;
+        const replacements = paragraphs.map((p, i) => {
+          if (i && (p.content.some((c) => c.kind !== "element" && (c.kind !== "text" || c.text.trim())) || p.children.some((n) => !["pPr", "r", "hyperlink"].includes(n.localName))))
+            throw new UnsupportedEditError("Comment text assignment cannot discard annotated paragraphs.");
+          const properties = p.children.find((n) => n.namespace === w && n.localName === "pPr");
+          const replacement = replaceParagraphContent(record.editor, p, properties ? record.editor.sourceXml(properties) : "", i ? "" : options.text, budget);
+          return i ? "" : replacement;
+        });
+        if (state.modern && paragraphs.length === 1) {
+          const p = paragraphs[0];
+          const content = p.children.filter((n) => n.namespace === w && ["r", "hyperlink"].includes(n.localName));
+          content.forEach((n, i) => record.editor.replaceElement(n, i ? "" : paragraphTextRun(w, options.text)));
+          if (!content.length) record.editor.insertChildren(p, paragraphTextRun(w, options.text));
+        } else paragraphs.forEach((p, i) => record.editor.replaceElement(p, replacements[i]));
+        if (!paragraphs.length) record.editor.insertChildren(record.node, `<cm:p xmlns:cm="${w}">${paragraphTextRun(w, options.text)}</cm:p>`);
+      } else {
+        const pending = [record.node];
+        budget.charge("retainedBytes", 8);
+        while (pending.length) {
+          const node = pending.pop();
+          budget.charge("work", 1);
+          if (node.namespace === w && ["bookmarkStart", "bookmarkEnd", "commentRangeStart", "commentRangeEnd", "commentReference", "permStart", "permEnd"].includes(node.localName)) throw new UnsupportedEditError("Comment removal cannot discard independently owned annotations.");
+          budget.charge("retainedBytes", node.children.length * 8);
+          for (let index = node.children.length - 1; index >= 0; index--) pending.push(node.children[index]);
+        }
+        record.editor.replaceElement(record.node, "");
+        for (const marker of record.markers) {
+          const parent = marker.parent;
+          const emptyReferenceRun = marker.node.localName === "commentReference" && parent.children.every((n) => n === marker.node || n.namespace === w && n.localName === "rPr") && parent.content.every((c) => c.kind === "element" || c.kind === "text" && !c.text.trim());
+          marker.editor.replaceElement(emptyReferenceRun ? parent : marker.node, "");
+        }
+      }
+      updates.push({ before: record.location, id: record.id, kind: request.operation === "comments.set" ? "replace" : "remove" });
+    }
+  }
+  const staged = new Map([...editors].filter(([name, editor]) => editor.dirtyNodes.length || !memberNames.has(name)).map(([name, editor]) => [memberNames.get(name) ?? name.slice(1), editor.serialize()]));
+  const finalArchive = { ...archive, members: [
+    ...archive.members.map((m) => ({ ...m, bytes: staged.get(m.name) ?? m.bytes })),
+    ...[...staged].filter(([name]) => !archive.members.some((m) => m.name === name)).map(([name, bytes]) => ({ name, bytes, directory: false, modified: /* @__PURE__ */ new Date("1980-01-01T00:00:00Z") }))
+  ] };
+  const publication = { ...request.input ? { input: request.input } : {}, ...options.output === void 0 ? {} : { output: options.output }, ...options.inPlace === void 0 ? {} : { inPlace: options.inPlace }, ...options.force === void 0 ? {} : { force: options.force }, ...options.dryRun === void 0 ? {} : { dryRun: options.dryRun }, ...options.json === void 0 ? {} : { json: options.json } };
+  const chunks = [];
+  await writeArchive(finalArchive, { async write(bytes) {
+    budget.charge("retainedBytes", bytes.length);
+    chunks.push(bytes.slice());
+  } }, { order: "input", compression: "store" }, { ...settings, budget });
+  const encoded = new Uint8Array(chunks.reduce((sum, bytes) => sum + bytes.length, 0));
+  let cursor = 0;
+  for (const chunk of chunks) {
+    encoded.set(chunk, cursor);
+    cursor += chunk.length;
+  }
+  const verification = { ...settings, budget };
+  delete verification[documentSession];
+  const finalState = await openComments(encoded, verification);
+  const changes = updates.map((update) => {
+    const record = finalState.records.find((n) => n.id === update.id);
+    if (update.kind !== "remove" && (!record || record.issues.some((i) => i !== "deleted-anchor"))) throw new UnsupportedEditError("Comment edit produced inconsistent anchors.");
+    const value = record?.location && { ...record.location.value, sourceSha256: update.before.value.sourceSha256, generation: update.before.value.generation + 1 };
+    const after = update.kind === "remove" ? null : { ...record.location, value, token: encodeGeneratedLocation(value) };
+    return { kind: update.kind, before: update.before, after };
+  });
+  const prospective = { changed: changes.length > 0, changes, dryRun: options.dryRun ?? false, output: options.dryRun ? null : { path: options.output ?? request.input?.path ?? null, bytes: Math.min(settings.limits.maxArchiveBytes, Number.MAX_SAFE_INTEGER), sha256: "0".repeat(64) } };
+  budget.check("serializedOutput", new TextEncoder().encode(JSON.stringify({ version: 1, operation: request.operation, ok: true, data: prospective, affected: changes.length, locations: changes.flatMap((c) => c.after ? [c.after] : []), warnings: [], errors: [] }) + "\n").length);
+  const result = await publishDocumentArchive(finalArchive, publication, { ...context, budget });
+  return { changed: changes.length > 0, changes, dryRun: options.dryRun ?? false, output: result.published.length ? { path: result.published[0].path, bytes: result.published[0].bytes, sha256: result.archiveSha256 } : null };
+}
+
+export {
+  inspectDocumentComments,
+  editDocumentComments
+};