@beyondwork/docx-react-component 1.0.0

package/test/preservation/package-preservation.test.ts

@@ -0,0 +1,395 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { createExportSession } from "../../src/io/export/export-session.ts";
+import {
+  collectBrokenInternalRelationshipTargets,
+  collectPreservedPackageParts,
+} from "../../src/preservation/package-preservation.ts";
+import {
+  extractDocumentRootAttributes,
+  extractMarkupCompatibilityAttributes,
+} from "../../src/preservation/markup-compatibility.ts";
+import { readOpcPackage, type OpcPackage } from "../../src/io/opc/package-reader.ts";
+import { writeOpcPackage } from "../../src/io/opc/package-writer.ts";
+
+const MAIN_DOCUMENT_CONTENT_TYPE =
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml";
+const FOOTNOTES_CONTENT_TYPE =
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml";
+const ENDNOTES_CONTENT_TYPE =
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml";
+const CUSTOM_XML_CONTENT_TYPE = "application/xml";
+
+test("preserved package manifest records preserve-only note and custom XML surfaces", () => {
+  const sourcePackage = readOpcPackage(createPackageWithPreservedSurfaces());
+  const preservedParts = collectPreservedPackageParts(sourcePackage);
+
+  assert.deepEqual(Object.keys(preservedParts).sort(), [
+    "/customXml/item1.xml",
+    "/word/endnotes.xml",
+    "/word/footnotes.xml",
+  ]);
+  assert.deepEqual(preservedParts["/word/footnotes.xml"]?.relationshipIds, ["rIdFootnotes"]);
+  assert.deepEqual(preservedParts["/word/endnotes.xml"]?.relationshipIds, ["rIdEndnotes"]);
+  assert.deepEqual(preservedParts["/customXml/item1.xml"]?.relationshipIds, ["rIdCustomXml1"]);
+});
+
+test("export session reattaches preserved note and custom XML parts before package serialization", () => {
+  const sourceBytes = createPackageWithPreservedSurfaces();
+  const sourcePackage = readOpcPackage(sourceBytes);
+  const editedDocumentXml = toBytes(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:document
+  xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+  xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+  xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+  xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml"
+  mc:Ignorable="w14">
+  <w:body>
+    <w:p><w:r><w:t>Edited</w:t></w:r></w:p>
+    <w:p><w:r><w:footnoteReference w:id="2"/></w:r></w:p>
+    <w:p><w:r><w:endnoteReference w:id="2"/></w:r></w:p>
+    <w:sectPr/>
+  </w:body>
+</w:document>`);
+
+  const exportedBytes = createExportSession(sourcePackage, ["/word/document.xml"])
+    .withOwnedPart({
+      path: "/word/document.xml",
+      bytes: editedDocumentXml,
+      contentType: MAIN_DOCUMENT_CONTENT_TYPE,
+      relationships: sourcePackage.parts.get("/word/document.xml")?.relationships,
+    })
+    .serialize();
+  const exportedPackage = readOpcPackage(exportedBytes);
+
+  assert.equal(
+    text(exportedPackage.parts.get("/word/footnotes.xml")?.bytes),
+    text(sourcePackage.parts.get("/word/footnotes.xml")?.bytes),
+  );
+  assert.equal(
+    text(exportedPackage.parts.get("/word/endnotes.xml")?.bytes),
+    text(sourcePackage.parts.get("/word/endnotes.xml")?.bytes),
+  );
+  assert.equal(
+    text(exportedPackage.parts.get("/customXml/item1.xml")?.bytes),
+    text(sourcePackage.parts.get("/customXml/item1.xml")?.bytes),
+  );
+  assert.equal(
+    exportedPackage.manifest.contentTypes.overrides["/word/footnotes.xml"],
+    FOOTNOTES_CONTENT_TYPE,
+  );
+  assert.equal(
+    exportedPackage.manifest.contentTypes.overrides["/word/endnotes.xml"],
+    ENDNOTES_CONTENT_TYPE,
+  );
+  assert.equal(
+    exportedPackage.parts.get("/word/document.xml")?.relationships.find(
+      (relationship) => relationship.id === "rIdFootnotes",
+    )?.target,
+    "footnotes.xml",
+  );
+  assert.equal(
+    exportedPackage.manifest.packageRelationships.find(
+      (relationship) => relationship.id === "rIdCustomXml1",
+    )?.target,
+    "customXml/item1.xml",
+  );
+});
+
+test("broken internal relationship collector reports unique missing targets", () => {
+  const sourcePackage = createBrokenPackage();
+
+  assert.deepEqual(collectBrokenInternalRelationshipTargets(sourcePackage), [
+    "/customXml/missing-item.xml",
+    "/word/missing-footnotes.xml",
+  ]);
+});
+
+test("markup compatibility helpers preserve mc attributes and extension namespaces", () => {
+  const documentXml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:document
+  xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+  xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+  xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+  xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml"
+  mc:Ignorable="w14"
+  mc:PreserveElements="w14:custom">
+  <w:body><w:p><w:r><w:t>Compatibility</w:t></w:r></w:p></w:body>
+</w:document>`;
+
+  assert.equal(
+    extractDocumentRootAttributes(documentXml)["xmlns:mc"],
+    "http://schemas.openxmlformats.org/markup-compatibility/2006",
+  );
+  assert.deepEqual(extractMarkupCompatibilityAttributes(documentXml), {
+    "xmlns:mc": "http://schemas.openxmlformats.org/markup-compatibility/2006",
+    "xmlns:w14": "http://schemas.microsoft.com/office/word/2010/wordml",
+    "mc:Ignorable": "w14",
+    "mc:PreserveElements": "w14:custom",
+  });
+});
+
+function createPackageWithPreservedSurfaces(): Uint8Array {
+  const documentXml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:document
+  xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+  xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+  xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+  xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml"
+  mc:Ignorable="w14">
+  <w:body>
+    <w:p><w:r><w:t>Preserved package graph</w:t></w:r></w:p>
+    <w:p><w:r><w:footnoteReference w:id="2"/></w:r></w:p>
+    <w:p><w:r><w:endnoteReference w:id="2"/></w:r></w:p>
+    <mc:AlternateContent>
+      <mc:Choice Requires="w14">
+        <w14:smartTag><w:r xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:t>Future</w:t></w:r></w14:smartTag>
+      </mc:Choice>
+      <mc:Fallback>
+        <w:p><w:r><w:t>Fallback</w:t></w:r></w:p>
+      </mc:Fallback>
+    </mc:AlternateContent>
+    <w:sectPr/>
+  </w:body>
+</w:document>`;
+  const footnotesXml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:footnotes xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+  <w:footnote w:id="2"><w:p><w:r><w:t>Preserved footnote</w:t></w:r></w:p></w:footnote>
+</w:footnotes>`;
+  const endnotesXml = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<w:endnotes xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+  <w:endnote w:id="2"><w:p><w:r><w:t>Preserved endnote</w:t></w:r></w:p></w:endnote>
+</w:endnotes>`;
+  const customXml = `<root><assembly preserved="true"/></root>`;
+
+  return writeOpcPackage({
+    manifest: {
+      contentTypes: {
+        defaults: {
+          rels: "application/vnd.openxmlformats-package.relationships+xml",
+          xml: "application/xml",
+        },
+        overrides: {
+          "/word/document.xml": MAIN_DOCUMENT_CONTENT_TYPE,
+          "/word/footnotes.xml": FOOTNOTES_CONTENT_TYPE,
+          "/word/endnotes.xml": ENDNOTES_CONTENT_TYPE,
+        },
+      },
+      packageRelationships: [
+        {
+          id: "rId1",
+          type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+          target: "word/document.xml",
+          targetMode: "internal",
+        },
+        {
+          id: "rIdCustomXml1",
+          type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXml",
+          target: "customXml/item1.xml",
+          targetMode: "internal",
+        },
+      ],
+      parts: [
+        {
+          path: "/customXml/item1.xml",
+          surfaceKind: "content",
+          contentType: CUSTOM_XML_CONTENT_TYPE,
+          relationshipsPartPath: "/customXml/_rels/item1.xml.rels",
+          relationships: [],
+          compression: "deflate",
+          byteLength: toBytes(customXml).byteLength,
+        },
+        {
+          path: "/word/document.xml",
+          surfaceKind: "content",
+          contentType: MAIN_DOCUMENT_CONTENT_TYPE,
+          relationshipsPartPath: "/word/_rels/document.xml.rels",
+          relationships: [
+            {
+              id: "rIdFootnotes",
+              type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes",
+              target: "footnotes.xml",
+              targetMode: "internal",
+            },
+            {
+              id: "rIdEndnotes",
+              type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/endnotes",
+              target: "endnotes.xml",
+              targetMode: "internal",
+            },
+          ],
+          compression: "deflate",
+          byteLength: toBytes(documentXml).byteLength,
+        },
+        {
+          path: "/word/endnotes.xml",
+          surfaceKind: "content",
+          contentType: ENDNOTES_CONTENT_TYPE,
+          relationshipsPartPath: "/word/_rels/endnotes.xml.rels",
+          relationships: [],
+          compression: "deflate",
+          byteLength: toBytes(endnotesXml).byteLength,
+        },
+        {
+          path: "/word/footnotes.xml",
+          surfaceKind: "content",
+          contentType: FOOTNOTES_CONTENT_TYPE,
+          relationshipsPartPath: "/word/_rels/footnotes.xml.rels",
+          relationships: [],
+          compression: "deflate",
+          byteLength: toBytes(footnotesXml).byteLength,
+        },
+      ],
+    },
+    parts: new Map([
+      [
+        "/customXml/item1.xml",
+        {
+          path: "/customXml/item1.xml",
+          surfaceKind: "content",
+          contentType: CUSTOM_XML_CONTENT_TYPE,
+          relationshipsPartPath: "/customXml/_rels/item1.xml.rels",
+          relationships: [],
+          compression: "deflate",
+          bytes: toBytes(customXml),
+          crc32: 0,
+        },
+      ],
+      [
+        "/word/document.xml",
+        {
+          path: "/word/document.xml",
+          surfaceKind: "content",
+          contentType: MAIN_DOCUMENT_CONTENT_TYPE,
+          relationshipsPartPath: "/word/_rels/document.xml.rels",
+          relationships: [
+            {
+              id: "rIdFootnotes",
+              type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes",
+              target: "footnotes.xml",
+              targetMode: "internal",
+            },
+            {
+              id: "rIdEndnotes",
+              type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/endnotes",
+              target: "endnotes.xml",
+              targetMode: "internal",
+            },
+          ],
+          compression: "deflate",
+          bytes: toBytes(documentXml),
+          crc32: 0,
+        },
+      ],
+      [
+        "/word/endnotes.xml",
+        {
+          path: "/word/endnotes.xml",
+          surfaceKind: "content",
+          contentType: ENDNOTES_CONTENT_TYPE,
+          relationshipsPartPath: "/word/_rels/endnotes.xml.rels",
+          relationships: [],
+          compression: "deflate",
+          bytes: toBytes(endnotesXml),
+          crc32: 0,
+        },
+      ],
+      [
+        "/word/footnotes.xml",
+        {
+          path: "/word/footnotes.xml",
+          surfaceKind: "content",
+          contentType: FOOTNOTES_CONTENT_TYPE,
+          relationshipsPartPath: "/word/_rels/footnotes.xml.rels",
+          relationships: [],
+          compression: "deflate",
+          bytes: toBytes(footnotesXml),
+          crc32: 0,
+        },
+      ],
+    ]),
+    sourceByteLength: 0,
+  });
+}
+
+function createBrokenPackage(): OpcPackage {
+  return readOpcPackage(
+    writeOpcPackage({
+      manifest: {
+        contentTypes: {
+          defaults: {
+            rels: "application/vnd.openxmlformats-package.relationships+xml",
+            xml: "application/xml",
+          },
+          overrides: {
+            "/word/document.xml": MAIN_DOCUMENT_CONTENT_TYPE,
+          },
+        },
+        packageRelationships: [
+          {
+            id: "rId1",
+            type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+            target: "word/document.xml",
+            targetMode: "internal",
+          },
+          {
+            id: "rIdCustomXmlMissing",
+            type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXml",
+            target: "customXml/missing-item.xml",
+            targetMode: "internal",
+          },
+        ],
+        parts: [
+          {
+            path: "/word/document.xml",
+            surfaceKind: "content",
+            contentType: MAIN_DOCUMENT_CONTENT_TYPE,
+            relationshipsPartPath: "/word/_rels/document.xml.rels",
+            relationships: [
+              {
+                id: "rIdFootnotes",
+                type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes",
+                target: "missing-footnotes.xml",
+                targetMode: "internal",
+              },
+            ],
+            compression: "deflate",
+            byteLength: 0,
+          },
+        ],
+      },
+      parts: new Map([
+        [
+          "/word/document.xml",
+          {
+            path: "/word/document.xml",
+            surfaceKind: "content",
+            contentType: MAIN_DOCUMENT_CONTENT_TYPE,
+            relationshipsPartPath: "/word/_rels/document.xml.rels",
+            relationships: [
+              {
+                id: "rIdFootnotes",
+                type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes",
+                target: "missing-footnotes.xml",
+                targetMode: "internal",
+              },
+            ],
+            compression: "deflate",
+            bytes: toBytes("<w:document xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:body><w:p/></w:body></w:document>"),
+            crc32: 0,
+          },
+        ],
+      ]),
+      sourceByteLength: 0,
+    }),
+  );
+}
+
+function toBytes(value: string): Uint8Array {
+  return new Uint8Array(Buffer.from(value, "utf8"));
+}
+
+function text(value: Uint8Array | undefined): string | undefined {
+  return value ? Buffer.from(value).toString("utf8") : undefined;
+}

package/test/preservation/store.test.ts

@@ -0,0 +1,84 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  describeOpaqueFragment,
+  findOpaqueFragmentsIntersectingRange,
+  listOpaqueFragments,
+  listPreservedPackageParts,
+} from "../../src/preservation/store.ts";
+
+test("preservation store descriptors classify common locked OOXML fragments", () => {
+  const section = describeOpaqueFragment({
+    fragmentId: "fragment:section-1",
+    payloadKind: "xml-subtree",
+    payloadReference: "<w:sectPr/>",
+    featureClass: "preserve-only",
+    lastKnownRange: { from: 4, to: 5 },
+    warningId: "warning:section-1",
+    packagePartName: "/word/document.xml",
+  });
+  const table = describeOpaqueFragment({
+    fragmentId: "fragment:table-1",
+    payloadKind: "xml-subtree",
+    payloadReference: "<w:tbl><w:tr/></w:tbl>",
+    featureClass: "preserve-only",
+    lastKnownRange: { from: 10, to: 11 },
+    warningId: "warning:table-1",
+    packagePartName: "/word/document.xml",
+  });
+  const alternateContent = describeOpaqueFragment({
+    fragmentId: "fragment:mc-1",
+    payloadKind: "xml-subtree",
+    payloadReference: "<mc:AlternateContent/>",
+    featureClass: "preserve-only",
+    lastKnownRange: { from: 12, to: 13 },
+    warningId: "warning:mc-1",
+    packagePartName: "/word/document.xml",
+  });
+
+  assert.equal(section.featureKey, "sections");
+  assert.match(section.detail, /word\/document\.xml/);
+  assert.equal(table.featureKey, "tables");
+  assert.equal(alternateContent.featureKey, "alternate-content");
+});
+
+test("preservation store helpers tolerate sparse state and find intersecting locked fragments", () => {
+  const store = {
+    opaqueFragments: {
+      "fragment:section-1": {
+        fragmentId: "fragment:section-1",
+        payloadKind: "xml-subtree",
+        payloadReference: "<w:sectPr/>",
+        featureClass: "preserve-only",
+        lastKnownRange: { from: 4, to: 5 },
+        warningId: "warning:section-1",
+      },
+      "fragment:table-1": {
+        fragmentId: "fragment:table-1",
+        payloadKind: "xml-subtree",
+        payloadReference: "<w:tbl><w:tr/></w:tbl>",
+        featureClass: "preserve-only",
+        lastKnownRange: { from: 10, to: 11 },
+        warningId: "warning:table-1",
+      },
+    },
+    packageParts: {
+      "/custom/item1.xml": {
+        packagePartName: "/custom/item1.xml",
+        contentType: "application/xml",
+        relationshipIds: ["rId55"],
+      },
+    },
+  };
+
+  assert.equal(listOpaqueFragments(store).length, 2);
+  assert.equal(listPreservedPackageParts(store).length, 1);
+  assert.deepEqual(
+    findOpaqueFragmentsIntersectingRange(store, { from: 3, to: 6 }).map(
+      (fragment) => fragment.fragmentId,
+    ),
+    ["fragment:section-1"],
+  );
+  assert.equal(listOpaqueFragments({} as never).length, 0);
+});

package/test/review/comment-remapping.test.ts

@@ -0,0 +1,220 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  createCommentReviewAnchor,
+  rangeStaysWithinSingleParagraph,
+} from "../../src/core/selection/review-anchors.ts";
+import type {
+  CanonicalDocumentEnvelope,
+  CommentThreadRecord,
+  EditorState,
+} from "../../src/core/state/editor-state.ts";
+import { applyReviewRuntimeMapping } from "../../src/runtime/review-runtime.ts";
+import { remapCommentThread, remapCommentThreads } from "../../src/review/store/comment-remapping.ts";
+
+const TIMESTAMP = "2026-03-26T12:00:00.000Z";
+
+function createDocument(text: string): CanonicalDocumentEnvelope {
+  return {
+    schemaVersion: "cds/1.0.0",
+    docId: "doc-1",
+    createdAt: TIMESTAMP,
+    updatedAt: TIMESTAMP,
+    metadata: {},
+    styles: {},
+    numbering: {},
+    media: {},
+    content: {
+      type: "doc",
+      children: text.split("\n").map((paragraph) => ({
+        type: "paragraph",
+        children: paragraph.length > 0 ? [{ type: "text", text: paragraph }] : [],
+      })),
+    },
+    review: {
+      comments: {},
+      revisions: {},
+    },
+    preservation: {},
+    diagnostics: {},
+  };
+}
+
+function createComment(
+  commentId: string,
+  from: number,
+  to: number,
+): CommentThreadRecord {
+  return {
+    commentId,
+    body: "Comment body",
+    anchor: createCommentReviewAnchor(from, to),
+    authorId: "user:a",
+    createdAt: TIMESTAMP,
+    isResolved: false,
+  };
+}
+
+function createRuntimeState(
+  comment: CommentThreadRecord,
+  content: CanonicalDocumentEnvelope["content"],
+): Pick<EditorState, "document" | "warnings" | "runtime"> {
+  return {
+    document: {
+      ...createDocument("AlphaBeta"),
+      content,
+      review: {
+        comments: {
+          [comment.commentId]: comment,
+        },
+        revisions: {},
+      },
+    },
+    warnings: [],
+    runtime: {
+      hasFocus: true,
+      activeCommentId: comment.commentId,
+    },
+  };
+}
+
+test("comment anchors exclude inserted text at both boundaries", () => {
+  const comment = createComment("comment-1", 2, 7);
+  const result = remapCommentThread(
+    comment,
+    {
+      steps: [
+        { from: 2, to: 2, insertSize: 1 },
+        { from: 8, to: 8, insertSize: 2 },
+      ],
+    },
+    createDocument("AlXphaBeYZta").content,
+  );
+
+  assert.equal(result.anchor.kind, "range");
+  if (result.anchor.kind === "range") {
+    assert.deepEqual(result.anchor.range, { from: 3, to: 8 });
+  }
+});
+
+test("whole-range deletions detach comments instead of collapsing them to a caret", () => {
+  const comment = createComment("comment-2", 2, 7);
+  const result = remapCommentThread(
+    comment,
+    {
+      steps: [{ from: 2, to: 7, insertSize: 0 }],
+    },
+    createDocument("Alta").content,
+  );
+
+  assert.equal(result.anchor.kind, "detached");
+  if (result.anchor.kind === "detached") {
+    assert.equal(result.anchor.reason, "deleted");
+    assert.deepEqual(result.anchor.lastKnownRange, { from: 2, to: 7 });
+  }
+});
+
+test("paragraph splits inside a comment slice detach the anchor as unsupported structure drift", () => {
+  const comment = createComment("comment-3", 2, 7);
+  const result = remapCommentThread(
+    comment,
+    {
+      steps: [{ from: 5, to: 5, insertSize: 1 }],
+      metadata: {
+        invalidatesStructures: true,
+      },
+    },
+    createDocument("Alpha\nBeta").content,
+  );
+
+  assert.equal(result.anchor.kind, "detached");
+  if (result.anchor.kind === "detached") {
+    assert.equal(result.anchor.reason, "invalidatedByStructureChange");
+    assert.deepEqual(result.anchor.lastKnownRange, { from: 2, to: 7 });
+  }
+});
+
+test("paragraph merges keep comments active when the mapped slice stays within one paragraph", () => {
+  const comment = createComment("comment-4", 6, 10);
+  const result = remapCommentThread(
+    comment,
+    {
+      steps: [{ from: 5, to: 6, insertSize: 0 }],
+      metadata: {
+        invalidatesStructures: true,
+      },
+    },
+    createDocument("AlphaBeta").content,
+  );
+
+  assert.equal(result.anchor.kind, "range");
+  if (result.anchor.kind === "range") {
+    assert.deepEqual(result.anchor.range, { from: 5, to: 9 });
+  }
+});
+
+test("review runtime emits detached-anchor warnings and preserves active thread ids", () => {
+  const comment = createComment("comment-5", 2, 7);
+  const state = createRuntimeState(comment, createDocument("AlphaBeta").content);
+  const result = applyReviewRuntimeMapping({
+    state,
+    mapping: {
+      steps: [{ from: 2, to: 7, insertSize: 0 }],
+    },
+    nextContent: createDocument("Alta").content,
+  });
+
+  assert.deepEqual(result.detachedCommentIds, ["comment-5"]);
+  assert.equal(result.activeCommentId, "comment-5");
+  assert.equal(result.comments["comment-5"]?.anchor.kind, "detached");
+  assert.equal(result.warnings.length, 1);
+  assert.equal(result.warnings[0]?.code, "comment_anchor_detached");
+  assert.equal(result.warnings[0]?.details?.commentId, "comment-5");
+});
+
+test("single-paragraph review helper rejects paragraph-crossing slices after remap", () => {
+  assert.equal(
+    rangeStaysWithinSingleParagraph(createDocument("Alpha\nBeta").content, {
+      from: 2,
+      to: 7,
+    }),
+    false,
+  );
+
+  assert.equal(
+    rangeStaysWithinSingleParagraph(createDocument("AlphaBeta").content, {
+      from: 2,
+      to: 7,
+    }),
+    true,
+  );
+});
+
+test("existing detached warnings are retained without duplication", () => {
+  const comment = createComment("comment-6", 2, 7);
+  const result = remapCommentThreads({
+    comments: {
+      [comment.commentId]: comment,
+    },
+    mapping: {
+      steps: [{ from: 2, to: 7, insertSize: 0 }],
+    },
+    nextContent: createDocument("Alta").content,
+    existingWarnings: [
+      {
+        warningId: "warning:comment-anchor-detached:comment-6",
+        code: "comment_anchor_detached",
+        severity: "warning",
+        message: "Comment comment-6 detached after edit remapping.",
+        source: "review",
+        details: {
+          commentId: "comment-6",
+        },
+      },
+    ],
+  });
+
+  assert.equal(result.warnings.length, 1);
+  assert.equal(result.warnings[0]?.warningId, "warning:comment-anchor-detached:comment-6");
+});