@superdoc/mcp 1.3.0-next.1 → 1.3.0-next.3

package/dist/index.js

@@ -31316,7 +31316,7 @@ var init_host = __esm(() => {
 });
 
 // ../../packages/sdk/langs/node/src/runtime/sdk-version.generated.ts
-var SDK_VERSION = "2.16.0-next.1";
+var SDK_VERSION = "2.16.0-next.3";
 
 // ../../packages/sdk/langs/node/src/runtime/embedded-platform.ts
 import { chmodSync, existsSync } from "node:fs";
@@ -106248,7 +106248,7 @@ function refConfigSchemas() {
     failure: refFailureSchema
   };
 }
-var trackChangeTypeValues, sourcePathSchema, diagnosticPathSchema, conversionSourceRangeSchema, conversionSourceSchema, diagnosticProperties, sdDiagnosticSchema, sdConversionDiagnosticSchema, conversionReportSchema, receiptSuccessMetadataProperties, nodeTypeValues, blockNodeTypeValues, deletableBlockNodeTypeValues, inlineNodeTypeValues, knownTargetKindValues, SHARED_DEFS, rangeSchema, positionSchema, inlineAnchorSchema, targetKindSchema, textAddressSchema, textTargetSchema, commentTrackedChangeTargetSchema, textSearchCommentTargetSchema, blockNodeAddressSchema, deletableBlockNodeAddressSchema, tableAddressSchema, tableRowAddressSchema, tableCellAddressSchema, tableOrCellAddressSchema, paragraphAddressSchema, headingAddressSchema, listItemAddressSchema, listsV2BlockTargetSchema, paragraphTargetSchema, sectionAddressSchema, watermarkSlotTargetSchema, watermarkTargetSchema, watermarkAddressSchema, watermarkHorizontalPlacementSchema, watermarkVerticalPlacementSchema, watermarkPlacementSchema, textWatermarkSchema, pictureWatermarkInputSchema, retainedPictureWatermarkInputSchema, watermarksApplyTargetSchema, pictureWatermarkInfoSchema, watermarkInfoSchema, watermarksApplySuccessSchema, watermarksApplyFailureSchema, inlineNodeAddressSchema, nodeAddressSchema, commentAddressSchema, trackedChangeAddressSchema, entityAddressSchema, selectionTargetSchema, commentTrackedChangeLinkSchema, targetLocatorSchema, deleteBehaviorSchema, resolvedHandleSchema, pageInfoSchema, receiptSuccessSchema, commentsCreateSuccessSchema, textMutationRangeSchema, textMutationResolutionSchema, textMutationSuccessSchema, matchRunSchema, matchBlockSchema, storyLocatorSchema, bodyStoryLocatorSchema, markRunColorRefSchema, markRunFontsSchema, markRunLanguagesSchema, markRunUnderlineSchema, markRunShadingSchema, markRunBorderSchema, markRunPropsSchema, trackChangeRefSchema, createParagraphSuccessSchema, createHeadingSuccessSchema, createHeadingLevelSchema, semanticHeadingLevelSchema, listsInsertSuccessSchema, listsMutateItemSuccessSchema, listsExitSuccessSchema, nodeSummarySchema, nodeInfoSchema, matchContextSchema, unknownNodeDiagnosticSchema, textSelectorSchema, planTextSelectorSchema, nodeSelectorSchema, selectorShorthandSchema, sdTextSelectorSchema, sdNodeSelectorSchema, sdSelectorSchema, sdReadOptionsSchema, sdFindInputSchema, sdNodeResultSchema, sdFindResultSchema, sdMutationResolutionSchema, evaluatedRevisionSchema, sdMutationSuccessSchema, documentInfoCountsSchema, documentInfoOutlineItemSchema, documentInfoCapabilitiesSchema, documentStyleInfoSchema, documentStylesSchema, documentDefaultsSchema, documentInfoSchema, listKindSchema, listInsertPositionSchema, listItemInfoSchema, listItemDomainItemSchema, listsListResultSchema, sectionBreakTypeSchema, sectionOrientationSchema, sectionVerticalAlignSchema, sectionDirectionSchema, sectionHeaderFooterKindSchema, sectionHeaderFooterVariantSchema, sectionLineNumberRestartSchema, sectionPageNumberFormatSchema, sectionRangeDomainSchema, sectionPageMarginsSchema, sectionHeaderFooterMarginsSchema, sectionPageSetupSchema, sectionColumnsSchema, sectionLineNumberingSchema, sectionPageNumberingSchema, sectionHeaderFooterRefsSchema, sectionBorderSpecSchema, sectionPageBordersSchema, sectionInfoSchema, sectionResolvedHandleSchema, sectionDomainItemSchema, sectionsListResultSchema, sectionMutationSuccessSchema, documentMutationSuccessSchema, paragraphMutationTargetSchema, paragraphMutationSuccessSchema, createSectionBreakSuccessSchema, commentMetadataSchema, commentInfoSchema, commentDomainItemSchema, commentsListResultSchema, trackChangeWordRevisionIdsSchema, trackChangeSourceIdsSchema, trackChangeBroadTypeEnum, trackChangeGroupingEnum, trackChangeCanonicalizationKindEnum, trackChangeAddressKindEnum, trackChangeSourcePlatformEnum, trackChangeReplacementSideSchema, trackChangeReplacementSchema, trackChangeOverlapRelationshipSchema, trackChangeOverlapLayerSchema, trackChangeOverlapInfoSchema, trackChangeFormattingSnapshotSchema, trackChangeListDeltaKindEnum, trackChangeListDeltaSideSchema, trackChangeListMemberDeltaSchema, trackChangeListDeltaSummarySchema, trackChangeTargetSchema, trackChangeSnapshotSchema, trackChangeCustomAttributeSchema, trackChangeRewriteReviewGroupSchema, trackChangeInfoSchema, trackChangeDomainItemSchema, trackChangesListResultSchema, reviewDecideRangeTargetOptions, historyActionCollaborationSchema, capabilityReasonCodeSchema, capabilityReasonsSchema, capabilitySupportDecisionSchema, capabilityFlagSchema, operationRuntimeCapabilitySchema, operationCapabilitiesSchema, inlinePropertyCapabilitySchema, inlinePropertyCapabilitiesByKeySchema, formatCapabilitiesSchema, planEngineCapabilitiesSchema, capabilitiesOutputSchema, strictEmptyObjectSchema, tableBorderColorPattern, tableBorderSpecSchema, nullableTableBorderSpecSchema, sdFragmentSchema, conversionFragmentSchema, placementSchema, nestingPolicySchema, insertInputSchema, supportCheckRichInsertInputSchema, supportCheckRichReplaceInputSchema, supportCheckProjectionInputSchema, supportCheckInputSchema, supportCheckFailureSchema, supportCheckGuardSchema, supportCheckCommonProperties, supportCheckOutputSchema, tableLocatorSchema, cellLocatorSchema, cellOrTableScopedCellLocatorSchema, tableOrCellLocatorSchema, mergeRangeLocatorSchema, tableAnchorLocationMembers, tableAnchorLocationSchema, tableCreateLocationSchema, tableMutationSuccessSchema, createTableSuccessSchema, tableMutationFailureCodes, tableMutationFailureSchema, tableMutationResultSchema, createTableResultSchema, historyActionSuccessSchema, historyActionFailureSchema, formatInlineAliasOperationSchemas, tocMutationFailureCodes, tocMutationFailureSchema, tocMutationSuccessSchema, tocEntryMutationFailureCodes, tocEntryMutationFailureSchema, tocEntryMutationSuccessSchema, hyperlinkTargetSchema, hyperlinkReadPropertiesSchema, hyperlinkDestinationSchema, hyperlinkSpecSchema, hyperlinkPatchSchema, hyperlinkDomainSchema, hyperlinkMutationSuccessSchema, hyperlinkMutationFailureCodes, hyperlinkMutationFailureSchema, hyperlinkInfoSchema, contentControlTargetSchema, contentControlMoveDestinationSchema, contentControlMutationSuccessSchema, contentControlMutationFailureSchema, ccInfoSchema, ccListResultSchema, refListQueryProperties, refListQuerySchema, discoveryOutputSchema, receiptFailureSchema, refFailureSchema, bookmarkAddressSchema, bookmarkMutation, customXmlPartTargetSchema, customXmlPartMutation, customXmlPartCreateMutation, anchoredMetadataAttachMutation, anchoredMetadataMutation, footnoteAddressSchema, footnoteConfigScopeSchema, footnoteNumberingSchema, footnoteMutation, footnoteConfig, crossRefAddressSchema, crossRefTargetSchema, crossRefDisplaySchema, crossRefMutation, indexAddressSchema, indexEntryAddressSchema, indexConfigSchema, indexEntryDataSchema, indexEntryPatchSchema, indexMutation, indexEntryMutation, captionAddressSchema, captionMutation, captionConfig, fieldAddressSchema, fieldMutation, citationAddressSchema, citationSourceAddressSchema, bibliographyAddressSchema, citationMutation, citationSourceMutation, bibliographyMutation, citationPersonSchema, citationSourceFieldsSchema, tocCreateLocationSchema, authoritiesAddressSchema, authorityEntryAddressSchema, authoritiesConfigSchema, authorityEntryDataSchema, authorityEntryPatchSchema, authoritiesMutation, authorityEntryMutation, diffCoverageSchema, diffSummarySchema, diffSnapshotSchema, diffApplyEligibilityBlockerSchema, diffApplyModeEligibilitySchema, diffApplyEligibilitySchema, diffPayloadSchema, diffApplyResultSchema, operationSchemas;
+var trackChangeTypeValues, sourcePathSchema, diagnosticPathSchema, conversionSourceRangeSchema, conversionSourceSchema, diagnosticProperties, sdDiagnosticSchema, sdConversionDiagnosticSchema, conversionReportSchema, receiptSuccessMetadataProperties, nodeTypeValues, blockNodeTypeValues, deletableBlockNodeTypeValues, inlineNodeTypeValues, knownTargetKindValues, SHARED_DEFS, rangeSchema, positionSchema, inlineAnchorSchema, targetKindSchema, textAddressSchema, textTargetSchema, commentTrackedChangeTargetSchema, textSearchCommentTargetSchema, blockNodeAddressSchema, deletableBlockNodeAddressSchema, tableAddressSchema, tableRowAddressSchema, tableCellAddressSchema, tableOrCellAddressSchema, paragraphAddressSchema, headingAddressSchema, listItemAddressSchema, listsV2BlockTargetSchema, paragraphTargetSchema, sectionAddressSchema, watermarkSlotTargetSchema, watermarkTargetSchema, watermarkAddressSchema, watermarkHorizontalPlacementSchema, watermarkVerticalPlacementSchema, watermarkPlacementSchema, textWatermarkSchema, pictureWatermarkInputSchema, retainedPictureWatermarkInputSchema, watermarksApplyTargetSchema, pictureWatermarkInfoSchema, watermarkInfoSchema, watermarksApplySuccessSchema, watermarksApplyFailureSchema, inlineNodeAddressSchema, nodeAddressSchema, commentAddressSchema, trackedChangeAddressSchema, entityAddressSchema, selectionTargetSchema, commentTrackedChangeLinkSchema, targetLocatorSchema, deleteBehaviorSchema, resolvedHandleSchema, pageInfoSchema, receiptSuccessSchema, commentsCreateSuccessSchema, textMutationRangeSchema, textMutationResolutionSchema, textMutationSuccessSchema, matchRunSchema, matchBlockSchema, storyLocatorSchema, bodyStoryLocatorSchema, markRunColorRefSchema, markRunFontsSchema, markRunLanguagesSchema, markRunUnderlineSchema, markRunShadingSchema, markRunBorderSchema, markRunPropsSchema, trackChangeRefSchema, createParagraphSuccessSchema, createHeadingSuccessSchema, createHeadingLevelSchema, semanticHeadingLevelSchema, listsInsertSuccessSchema, listsMutateItemSuccessSchema, listsExitSuccessSchema, nodeSummarySchema, nodeInfoSchema, matchContextSchema, unknownNodeDiagnosticSchema, textSelectorSchema, planTextSelectorSchema, nodeSelectorSchema, selectorShorthandSchema, sdTextSelectorSchema, sdNodeSelectorSchema, sdSelectorSchema, sdReadOptionsSchema, sdFindInputSchema, sdNodeResultSchema, sdFindResultSchema, sdMutationResolutionSchema, evaluatedRevisionSchema, sdMutationSuccessSchema, documentInfoCountsSchema, documentInfoOutlineItemSchema, documentInfoCapabilitiesSchema, documentStyleInfoSchema, documentStylesSchema, documentDefaultsSchema, documentInfoSchema, listKindSchema, listInsertPositionSchema, listItemInfoSchema, listItemDomainItemSchema, listsListResultSchema, sectionBreakTypeSchema, sectionOrientationSchema, sectionVerticalAlignSchema, sectionDirectionSchema, sectionHeaderFooterKindSchema, sectionHeaderFooterVariantSchema, sectionLineNumberRestartSchema, sectionPageNumberFormatSchema, sectionRangeDomainSchema, sectionPageMarginsSchema, sectionHeaderFooterMarginsSchema, sectionPageSetupSchema, sectionColumnsSchema, sectionLineNumberingSchema, sectionPageNumberingSchema, sectionHeaderFooterRefsSchema, sectionBorderSpecSchema, sectionPageBordersSchema, sectionInfoSchema, sectionResolvedHandleSchema, sectionDomainItemSchema, sectionsListResultSchema, sectionMutationSuccessSchema, documentMutationSuccessSchema, paragraphMutationTargetSchema, paragraphMutationSuccessSchema, createSectionBreakSuccessSchema, commentMetadataSchema, commentInfoSchema, commentDomainItemSchema, commentsListResultSchema, trackChangeWordRevisionIdsSchema, trackChangeSourceIdsSchema, trackChangeBroadTypeEnum, trackChangeGroupingEnum, trackChangeCanonicalizationKindEnum, trackChangeAddressKindEnum, trackChangeSourcePlatformEnum, trackChangeReplacementSideSchema, trackChangeReplacementSchema, trackChangeOverlapRelationshipSchema, trackChangeOverlapLayerSchema, trackChangeOverlapInfoSchema, trackChangeFormattingSnapshotSchema, trackChangeListDeltaKindEnum, trackChangeListDeltaSideSchema, trackChangeListMemberDeltaSchema, trackChangeListDeltaSummarySchema, trackChangeTargetSchema, trackChangeSnapshotSchema, trackChangeCustomAttributeSchema, trackChangeRewriteReviewGroupSchema, trackChangeComparisonHunkReviewGroupSchema, trackChangeReviewGroupSchema, trackChangeInfoSchema, trackChangeDomainItemSchema, trackChangesListResultSchema, reviewDecideRangeTargetOptions, historyActionCollaborationSchema, capabilityReasonCodeSchema, capabilityReasonsSchema, capabilitySupportDecisionSchema, capabilityFlagSchema, operationRuntimeCapabilitySchema, operationCapabilitiesSchema, inlinePropertyCapabilitySchema, inlinePropertyCapabilitiesByKeySchema, formatCapabilitiesSchema, planEngineCapabilitiesSchema, capabilitiesOutputSchema, strictEmptyObjectSchema, tableBorderColorPattern, tableBorderSpecSchema, nullableTableBorderSpecSchema, sdFragmentSchema, conversionFragmentSchema, placementSchema, nestingPolicySchema, insertInputSchema, supportCheckRichInsertInputSchema, supportCheckRichReplaceInputSchema, supportCheckProjectionInputSchema, supportCheckInputSchema, supportCheckFailureSchema, supportCheckGuardSchema, supportCheckCommonProperties, supportCheckOutputSchema, tableLocatorSchema, cellLocatorSchema, cellOrTableScopedCellLocatorSchema, tableOrCellLocatorSchema, mergeRangeLocatorSchema, tableAnchorLocationMembers, tableAnchorLocationSchema, tableCreateLocationSchema, tableMutationSuccessSchema, createTableSuccessSchema, tableMutationFailureCodes, tableMutationFailureSchema, tableMutationResultSchema, createTableResultSchema, historyActionSuccessSchema, historyActionFailureSchema, formatInlineAliasOperationSchemas, tocMutationFailureCodes, tocMutationFailureSchema, tocMutationSuccessSchema, tocEntryMutationFailureCodes, tocEntryMutationFailureSchema, tocEntryMutationSuccessSchema, hyperlinkTargetSchema, hyperlinkReadPropertiesSchema, hyperlinkDestinationSchema, hyperlinkSpecSchema, hyperlinkPatchSchema, hyperlinkDomainSchema, hyperlinkMutationSuccessSchema, hyperlinkMutationFailureCodes, hyperlinkMutationFailureSchema, hyperlinkInfoSchema, contentControlTargetSchema, contentControlMoveDestinationSchema, contentControlMutationSuccessSchema, contentControlMutationFailureSchema, ccInfoSchema, ccListResultSchema, refListQueryProperties, refListQuerySchema, discoveryOutputSchema, receiptFailureSchema, refFailureSchema, bookmarkAddressSchema, bookmarkMutation, customXmlPartTargetSchema, customXmlPartMutation, customXmlPartCreateMutation, anchoredMetadataAttachMutation, anchoredMetadataMutation, footnoteAddressSchema, footnoteConfigScopeSchema, footnoteNumberingSchema, footnoteMutation, footnoteConfig, crossRefAddressSchema, crossRefTargetSchema, crossRefDisplaySchema, crossRefMutation, indexAddressSchema, indexEntryAddressSchema, indexConfigSchema, indexEntryDataSchema, indexEntryPatchSchema, indexMutation, indexEntryMutation, captionAddressSchema, captionMutation, captionConfig, fieldAddressSchema, fieldMutation, citationAddressSchema, citationSourceAddressSchema, bibliographyAddressSchema, citationMutation, citationSourceMutation, bibliographyMutation, citationPersonSchema, citationSourceFieldsSchema, tocCreateLocationSchema, authoritiesAddressSchema, authorityEntryAddressSchema, authoritiesConfigSchema, authorityEntryDataSchema, authorityEntryPatchSchema, authoritiesMutation, authorityEntryMutation, diffCoverageSchema, diffSummarySchema, diffSnapshotSchema, diffApplyEligibilityBlockerSchema, diffApplyModeEligibilitySchema, diffApplyEligibilitySchema, diffPayloadSchema, diffApplyResultSchema, operationSchemas;
 var init_schemas4 = __esm(() => {
   init_command_catalog();
   init_types4();
@@ -107794,6 +107794,7 @@ var init_schemas4 = __esm(() => {
   }, ["name", "namespaceUri", "localName", "value"]);
   trackChangeRewriteReviewGroupSchema = objectSchema2({
     kind: { const: "text-rewrite" },
+    groupOrigin: { const: "authored-operation" },
     role: { enum: ["parent", "child"] },
     parentId: { type: "string" },
     childChangeIds: { type: "array", items: { type: "string" } },
@@ -107806,7 +107807,26 @@ var init_schemas4 = __esm(() => {
         sourceIds: trackChangeSourceIdsSchema
       }, ["id", "type", "subtype", "sourceIds"])
     }
-  }, ["kind", "role", "childChangeIds", "members"]);
+  }, ["kind", "groupOrigin", "role", "childChangeIds", "members"]);
+  trackChangeComparisonHunkReviewGroupSchema = objectSchema2({
+    kind: { const: "comparison-hunk" },
+    groupOrigin: { const: "comparison-hunk" },
+    role: { enum: ["parent", "child"] },
+    parentId: { type: "string" },
+    childChangeIds: { type: "array", items: { type: "string" } },
+    members: {
+      type: "array",
+      items: objectSchema2({
+        id: { type: "string" },
+        type: { enum: [...trackChangeBroadTypeEnum] },
+        subtype: { type: "string" },
+        sourceIds: trackChangeSourceIdsSchema
+      }, ["id", "type", "subtype", "sourceIds"])
+    }
+  }, ["kind", "groupOrigin", "role", "childChangeIds", "members"]);
+  trackChangeReviewGroupSchema = {
+    oneOf: [trackChangeRewriteReviewGroupSchema, trackChangeComparisonHunkReviewGroupSchema]
+  };
   trackChangeInfoSchema = objectSchema2({
     address: trackedChangeAddressSchema,
     id: { type: "string" },
@@ -107819,7 +107839,7 @@ var init_schemas4 = __esm(() => {
     sourceIds: trackChangeSourceIdsSchema,
     wordRevisionIds: trackChangeWordRevisionIdsSchema,
     revisionGroupId: { type: "string" },
-    reviewGroup: trackChangeRewriteReviewGroupSchema,
+    reviewGroup: trackChangeReviewGroupSchema,
     splitFromId: { oneOf: [{ type: "string" }, { type: "null" }] },
     replacement: trackChangeReplacementSchema,
     author: { type: "string" },
@@ -107870,7 +107890,7 @@ var init_schemas4 = __esm(() => {
     sourceIds: trackChangeSourceIdsSchema,
     wordRevisionIds: trackChangeWordRevisionIdsSchema,
     revisionGroupId: { type: "string" },
-    reviewGroup: trackChangeRewriteReviewGroupSchema,
+    reviewGroup: trackChangeReviewGroupSchema,
     author: { type: "string" },
     authorEmail: { type: "string" },
     authorImage: { type: "string" },
@@ -119891,7 +119911,7 @@ function capabilityFailureResult(operationId, capability, decision) {
   return operationId === "templates.apply" ? Promise.resolve(result) : result;
 }
 function installCapabilityPreflight(api2, adapter) {
-  if (!adapter.resolve)
+  if (!adapter?.resolve)
     return;
   for (const operationId of OPERATION_IDS) {
     if (operationId.startsWith("capabilities."))
@@ -132248,6 +132268,7 @@ function createSDTxPerfProbe() {
     trackedChangeTextSplices: null,
     trackedChangeTextSpliceMs: null,
     trackedChangeTextNormalizeMs: null,
+    trackedChangeRunMergeMs: null,
     trackedChangeTextEncodeMs: null,
     trackedChangeSubsumedTextFragments: null,
     trackedChangeSubsumedFormattingFragments: null,
@@ -171362,6 +171383,7 @@ function projectTextRewriteReviewGroup(entry, logical) {
   const group = entry.reviewGroup;
   return {
     kind: "text-rewrite",
+    groupOrigin: "authored-operation",
     role: group.role,
     ...group.parentId ? { parentId: group.parentId } : {},
     childChangeIds: group.ownedChildIds,
@@ -171394,6 +171416,187 @@ var init_rewrite_groups = __esm(() => {
   init_logical_catalog();
 });
 
+// ../../../v2/editor-core/dist/document/transactions/tracked-changes/comparison-hunk-groups.js
+function readComparisonHunkOrigin(carrier) {
+  const attrs = carrier.customAttributes?.filter((attribute) => attribute.namespaceUri === COMPARISON_HUNK_NAMESPACE);
+  if (!attrs || attrs.length === 0)
+    return null;
+  const byLocalName = (localName2) => attrs.filter((attribute) => attribute.localName === localName2);
+  const idAttrs = byLocalName("originId");
+  const kindAttrs = byLocalName("originKind");
+  if (idAttrs.length !== 1 || kindAttrs.length !== 1)
+    return null;
+  const idValue = idAttrs[0].value;
+  const kindValue = kindAttrs[0].value;
+  if (!/^[\w.:-]{1,200}$/.test(idValue))
+    return null;
+  if (kindValue !== "rewrite" && kindValue !== "comparison-hunk")
+    return null;
+  return { id: idValue, kind: kindValue };
+}
+function stampComparisonHunkOrigins(xml, originsByRsid, source) {
+  if (originsByRsid.size === 0)
+    return xml;
+  if ([...originsByRsid.values()].some((id) => !/^[\w.:-]{1,200}$/.test(id)))
+    return null;
+  const replacements = [];
+  const parsed = walkXmlElements(xml, {
+    fragment: true,
+    additionalNamespaces: xmlFragmentAdditionalNamespaces(xml, new Map, { w: NS_W }),
+    onOpenTag: ({ tag, end, namespaceBindings }) => {
+      if (tag.namespaceUri !== NS_W || tag.isSelfClosing || tag.localName !== "ins" && tag.localName !== "del")
+        return;
+      const rsid = tag.attributes.find((attribute) => attribute.namespaceUri === NS_W && attribute.localName === (tag.localName === "ins" ? "rsidR" : "rsidDel"))?.value;
+      const id = rsid ? originsByRsid.get(rsid) : undefined;
+      if (!id)
+        return;
+      const availablePrefix = (seed) => {
+        let prefix2 = seed;
+        for (let index = 1;namespaceBindings[prefix2]; index += 1)
+          prefix2 = `${seed}${index}`;
+        return prefix2;
+      };
+      const prefix = availablePrefix("sdReview");
+      const mc = availablePrefix("sdReviewMc");
+      replacements.push({
+        at: end - 1,
+        text: ` xmlns:${prefix}="${COMPARISON_HUNK_NAMESPACE}" xmlns:${mc}="${MC_NAMESPACE2}" ${mc}:Ignorable="${prefix}" ${prefix}:originId="${id}" ${prefix}:originKind="comparison-hunk"`
+      });
+    }
+  });
+  if (parsed.errors.length > 0)
+    return null;
+  let cursor = 0;
+  const chunks = [];
+  for (const replacement of replacements) {
+    chunks.push(xml.slice(cursor, replacement.at), replacement.text);
+    cursor = replacement.at;
+  }
+  chunks.push(xml.slice(cursor));
+  return chunks.join("");
+}
+function buildComparisonHunkReviewGroupId(storyId, origin) {
+  return buildLogicalId(storyId, "comparison-hunk-group", origin);
+}
+function projectComparisonHunkGroups(input) {
+  const groups = new Map;
+  for (const entry of input.byId.values()) {
+    if (entry.reviewGroup)
+      continue;
+    if (!["insertion", "deletion", "replacement"].includes(entry.type))
+      continue;
+    const carriers = entry.fragments;
+    if (carriers.length === 0)
+      continue;
+    const origin = readComparisonHunkOrigin(carriers[0]);
+    if (!origin || origin.kind !== "comparison-hunk")
+      continue;
+    if (carriers.some((carrier) => readComparisonHunkOrigin(carrier)?.id !== origin.id))
+      continue;
+    const id = buildComparisonHunkReviewGroupId(entry.storyId, origin.id);
+    const members = groups.get(id) ?? [];
+    members.push(entry);
+    groups.set(id, members);
+  }
+  for (const [id, children] of groups) {
+    children.sort((a, b) => a.documentOrderStart - b.documentOrderStart || a.id.localeCompare(b.id));
+    const first = children[0];
+    const fragments = children.flatMap((child) => child.fragments).sort((a, b) => a.byteStart - b.byteStart);
+    const inserted = fragments.filter((fragment2) => fragment2.kind === "ins");
+    const deleted = fragments.filter((fragment2) => fragment2.kind === "del");
+    const type = inserted.length === 0 ? "deletion" : deleted.length === 0 ? "insertion" : "replacement";
+    const wordIdInsert = inserted.find((fragment2) => fragment2.wId)?.wId ?? children.find((child) => child.sourceIds.wordIdInsert)?.sourceIds.wordIdInsert;
+    const wordIdDelete = deleted.find((fragment2) => fragment2.wId)?.wId ?? children.find((child) => child.sourceIds.wordIdDelete)?.sourceIds.wordIdDelete;
+    const rsids = [...new Set(children.flatMap((child) => child.sourceIds.rsids))];
+    const parent = {
+      ...first,
+      id,
+      type,
+      subtype: type === "replacement" ? "text-replacement" : type === "insertion" ? "text-insertion" : "text-deletion",
+      revisionGroupId: id,
+      splitFromId: null,
+      documentOrderStart: children.reduce((start, child) => Math.min(start, child.documentOrderStart), first.documentOrderStart),
+      documentOrderEnd: children.reduce((end, child) => Math.max(end, child.documentOrderEnd), first.documentOrderEnd),
+      before: { text: children.map((child) => child.before.text ?? "").join("") },
+      after: { text: children.map((child) => child.after.text ?? "").join("") },
+      sides: null,
+      contributingRsids: rsids,
+      sourceIds: {
+        wordIdInsert,
+        wordIdDelete,
+        wordIdOther: [
+          ...new Set(children.flatMap((child) => [
+            ...child.sourceIds.wordIdOther,
+            ...child.sourceIds.wordIdInsert ? [child.sourceIds.wordIdInsert] : [],
+            ...child.sourceIds.wordIdDelete ? [child.sourceIds.wordIdDelete] : []
+          ]).filter((value) => Boolean(value) && value !== wordIdInsert && value !== wordIdDelete))
+        ],
+        rsids
+      },
+      fragments,
+      structuralFragments: [],
+      reviewGroup: {
+        kind: "comparison-hunk",
+        role: "parent",
+        parentId: null,
+        ownedChildIds: children.map((child) => child.id),
+        duplicateDisplayPolicy: "subsumed",
+        members: children.flatMap((child) => child.fragments.map((fragment2) => ({
+          logicalId: child.id,
+          carrier: "text",
+          partUri: fragment2.partUri,
+          storyId: fragment2.storyId,
+          rsid: fragment2.rsid,
+          wordId: fragment2.wId,
+          subtype: child.subtype,
+          byteStart: fragment2.byteStart,
+          byteEnd: fragment2.byteEnd
+        })))
+      }
+    };
+    for (const child of children) {
+      child.reviewGroup = {
+        kind: "comparison-hunk",
+        role: "child",
+        parentId: id,
+        ownedChildIds: [],
+        duplicateDisplayPolicy: "subsumed",
+        members: []
+      };
+    }
+    input.byId.set(id, parent);
+    input.byStory.get(first.storyId).push(parent);
+  }
+}
+function projectComparisonHunkReviewGroup(entry, logical) {
+  if (entry.reviewGroup?.kind !== "comparison-hunk")
+    return;
+  const group = entry.reviewGroup;
+  return {
+    kind: "comparison-hunk",
+    groupOrigin: "comparison-hunk",
+    role: group.role,
+    ...group.parentId ? { parentId: group.parentId } : {},
+    childChangeIds: group.ownedChildIds,
+    members: group.ownedChildIds.flatMap((id) => {
+      const child = logical.byId.get(id);
+      return child ? [
+        {
+          id,
+          type: child.type,
+          subtype: child.subtype,
+          sourceIds: child.sourceIds
+        }
+      ] : [];
+    })
+  };
+}
+var COMPARISON_HUNK_NAMESPACE = "urn:superdoc:tracked-review:1", MC_NAMESPACE2 = "http://schemas.openxmlformats.org/markup-compatibility/2006";
+var init_comparison_hunk_groups = __esm(() => {
+  init_xml_sax();
+  init_logical_catalog();
+});
+
 // ../../../v2/editor-core/dist/document/transactions/tracked-changes/table-split-paragraph.js
 function isEmptyTableSplitParagraph(xml, excludedStart, excludedEnd) {
   const shell = /\s+|<[\w.-]+:(?:p|r)\b(?:"[^"]*"|'[^']*'|[^>"'])*>|<\/[\w.-]+:(?:p|r)>/y;
@@ -172134,6 +172337,7 @@ function buildLogicalCatalogWithLookupContext(lookupContext, raw, replacementMod
     partXmlByUri
   }, lookupContext);
   projectRewriteGroups({ byId, byStory });
+  projectComparisonHunkGroups({ byId, byStory });
   projectWordFormattingGroups({
     byId,
     byStory,
@@ -175981,6 +176185,14 @@ function enrichLogicalChangeExcerpts(catalog, partXmlByUri) {
     parent.after = { text: children.map((child) => child.after.text).filter(Boolean).join(" … ") };
     parent.excerpt = parent.after.text || parent.before.text || "";
   }
+  for (const parent of catalog.byId.values()) {
+    if (parent.reviewGroup?.kind !== "comparison-hunk" || parent.reviewGroup.role !== "parent")
+      continue;
+    const children = parent.reviewGroup.ownedChildIds.map((id) => catalog.byId.get(id));
+    parent.before = { text: children.map((child) => child.before.text ?? "").join("") };
+    parent.after = { text: children.map((child) => child.after.text ?? "").join("") };
+    parent.excerpt = parent.after.text || parent.before.text || "";
+  }
 }
 function decodePartXmlForLogicalCatalog(raw, readPartBytes2) {
   const out = new Map;
@@ -176136,6 +176348,7 @@ var init_logical_catalog = __esm(() => {
   init_numbering_catalog();
   init_review_groups();
   init_rewrite_groups();
+  init_comparison_hunk_groups();
   init_table_split_paragraph();
   init_list_deltas();
   init_comment_range_invariance();
@@ -194832,6 +195045,19 @@ function runTrackedEditTextBatchCommit(input, edits) {
         return rejected2(txId, "invalid-input");
       afterBytes = TE16.encode(stamped);
     }
+    const comparisonHunkGroups = new Map;
+    for (const edit of blockEdits) {
+      if (!edit.comparisonHunkGroupId)
+        continue;
+      for (const rsid of emittedByEdit.get(edit) ?? [])
+        comparisonHunkGroups.set(rsid, edit.comparisonHunkGroupId);
+    }
+    if (comparisonHunkGroups.size > 0) {
+      const stamped = stampComparisonHunkOrigins(TD39.decode(afterBytes), comparisonHunkGroups, { partUri, storyId });
+      if (stamped === null)
+        return rejected2(txId, "invalid-input");
+      afterBytes = TE16.encode(stamped);
+    }
     if (!bytesEqual5(beforeBytes, afterBytes)) {
       trackedAnnotations.push(...captureBatchTrackedAnnotations(afterBytes, new Set(blockEdits.flatMap((edit) => emittedByEdit.get(edit) ?? []))));
       patches.push({
@@ -199569,6 +199795,7 @@ function collectPerPartRevisions(state, partUris) {
 var TD39, TE16, TRACKED_WRAPPER_OPEN_RE, INLINE_CONTROL_PLACEHOLDER = "";
 var init_compile_edit_text = __esm(() => {
   init_rewrite_groups();
+  init_comparison_hunk_groups();
   init_word_text_payload();
   init_textbox_atom_replacement();
   init_part_payload();
@@ -202959,6 +203186,119 @@ function mergeAdjacentTableXml(lookupContext, firstTableXml, secondTableXml) {
 function isSingleParagraphXml2(xml) {
   return /^<[\w.-]+:p\b[^>]*\/>$/.test(xml) || /^<[\w.-]+:p\b[\s\S]*<\/[\w.-]+:p>$/.test(xml);
 }
+function mergeAdjacentIdenticallyFormattedRuns(xml, namespaceBindings) {
+  const fragment2 = !xml.trimStart().startsWith("<?xml");
+  const additionalNamespaces = xmlFragmentAdditionalNamespaces(xml, new Map(Object.entries(namespaceBindings ?? {})), { w: NS_W4 });
+  const { ranges, errors: errors4 } = collectXmlElementRanges(xml, { fragment: fragment2, additionalNamespaces });
+  if (errors4.length > 0)
+    return xml;
+  const entries = ranges.map((range) => ({
+    start: range.start,
+    end: range.end,
+    openEnd: range.openEnd,
+    closeStart: range.closeStart,
+    localName: range.tag.localName,
+    namespaceUri: range.tag.namespaceUri,
+    isSelfClosing: range.tag.isSelfClosing,
+    parent: null
+  })).sort((a, b) => a.start - b.start || b.end - a.end);
+  const stack = [];
+  for (const entry of entries) {
+    while (stack.length > 0 && stack[stack.length - 1].end <= entry.start)
+      stack.pop();
+    entry.parent = stack[stack.length - 1] ?? null;
+    if (!entry.isSelfClosing)
+      stack.push(entry);
+  }
+  const directChildren = (parent) => entries.filter((entry) => entry.parent === parent);
+  function classifyRun(runEntry) {
+    const children = directChildren(runEntry);
+    if (children.length === 0)
+      return null;
+    let rPrChild = null;
+    let tChild = null;
+    for (const child of children) {
+      if (child.namespaceUri === NS_W4 && child.localName === "rPr" && !rPrChild && !tChild) {
+        rPrChild = child;
+        continue;
+      }
+      if (child.namespaceUri === NS_W4 && child.localName === "t" && !tChild) {
+        tChild = child;
+        continue;
+      }
+      return null;
+    }
+    if (!tChild || runEntry.isSelfClosing)
+      return null;
+    const formattingKey = xml.slice(runEntry.start, rPrChild ? rPrChild.end : runEntry.openEnd);
+    const rPrXml = rPrChild ? xml.slice(rPrChild.start, rPrChild.end) : "";
+    const text = tChild.isSelfClosing ? "" : xml.slice(tChild.openEnd, tChild.closeStart);
+    const tOpenTag = xml.slice(tChild.start, tChild.openEnd);
+    const tQNameMatch = /^<([^\s/>]+)/.exec(tOpenTag);
+    if (!tQNameMatch)
+      return null;
+    return {
+      entry: runEntry,
+      formattingKey,
+      runOpenTag: xml.slice(runEntry.start, runEntry.openEnd),
+      runCloseTag: xml.slice(runEntry.closeStart, runEntry.end),
+      rPrXml,
+      tQName: tQNameMatch[1],
+      text
+    };
+  }
+  const edits = [];
+  const paragraphs = entries.filter((entry) => entry.namespaceUri === NS_W4 && entry.localName === "p" && !entry.isSelfClosing);
+  for (const paragraph of paragraphs) {
+    const children = directChildren(paragraph);
+    let index = 0;
+    while (index < children.length) {
+      const child = children[index];
+      if (child.namespaceUri !== NS_W4 || child.localName !== "r") {
+        index += 1;
+        continue;
+      }
+      const first = classifyRun(child);
+      if (!first) {
+        index += 1;
+        continue;
+      }
+      const group = [first];
+      let next = index + 1;
+      while (next < children.length) {
+        const candidate2 = children[next];
+        if (candidate2.namespaceUri !== NS_W4 || candidate2.localName !== "r")
+          break;
+        const classified = classifyRun(candidate2);
+        if (!classified || classified.formattingKey !== first.formattingKey)
+          break;
+        group.push(classified);
+        next += 1;
+      }
+      if (group.length > 1) {
+        const mergedText = group.map((run) => run.text).join("");
+        const preserve = /^\s|\s$/.test(mergedText) ? ' xml:space="preserve"' : "";
+        const replacement = `${first.runOpenTag}${first.rPrXml}` + `<${first.tQName}${preserve}>${mergedText}</${first.tQName}>` + first.runCloseTag;
+        edits.push({
+          start: group[0].entry.start,
+          end: group[group.length - 1].entry.end,
+          replacement
+        });
+      }
+      index = next;
+    }
+  }
+  if (edits.length === 0)
+    return xml;
+  edits.sort((a, b) => a.start - b.start);
+  let cursor = 0;
+  let output = "";
+  for (const edit of edits) {
+    output += xml.slice(cursor, edit.start) + edit.replacement;
+    cursor = edit.end;
+  }
+  return output + xml.slice(cursor);
+}
 function applyFormattingDecisionToFragment(input, lookupContext) {
   return withStructuralLookupContext(lookupContext, (context) => applyFormattingDecisionToFragmentWithLookupContext(context, input));
 }
@@ -203569,7 +203909,9 @@ function tryRunLocalTrackedChangeDecideCommit(input) {
   for (const decision of [...orderedDecisions].reverse()) {
     rewrittenXml = rewrittenXml.slice(0, decision.localFragment.byteStart) + decision.result.replacement + rewrittenXml.slice(decision.localFragment.byteEnd);
   }
-  const afterXml = normalizeBlockDeletionText(rewrittenXml);
+  const hasComparisonHunkDecision = orderedDecisions.some((decision) => readComparisonHunkOrigin(decision.localFragment)?.kind === "comparison-hunk");
+  const normalizedXml = normalizeBlockDeletionText(rewrittenXml);
+  const afterXml = hasComparisonHunkDecision ? mergeAdjacentIdenticallyFormattedRuns(normalizedXml, state.mainStorySourceOverlay?.rootNamespaceBindings) : normalizedXml;
   if (!sameNoteReferences(beforeXml, afterXml)) {
     return null;
   }
@@ -203950,6 +204292,7 @@ var init_compile_tracked_change_decide_local = __esm(() => {
   init_catalog3();
   init_logical_catalog();
   init_decide_engine();
+  init_comparison_hunk_groups();
   init_block_deletion_text();
   init_structural_inline_decision();
   TD42 = new TextDecoder;
@@ -204184,6 +204527,7 @@ function compileBoundedPartDecisions(input) {
   const shiftCandidates = [];
   const stories = new Set;
   const markerIdsByRsid = new Map;
+  let hasComparisonHunkDecision = false;
   for (const target of input.targets) {
     if (target.formatting || target.structural || target.derivedStructural)
       continue;
@@ -204211,6 +204555,8 @@ function compileBoundedPartDecisions(input) {
         return { ok: false, reason: "unsupported-context" };
       if ((fragment2.kind === "ins" && input.decision === "reject" || fragment2.kind === "del" && input.decision === "accept") && ownerContainsTrackedHyperlink(input.xml, local.byteStart, local.byteEnd))
         return { ok: false, reason: "unsupported-context" };
+      if (readComparisonHunkOrigin(fragment2)?.kind === "comparison-hunk")
+        hasComparisonHunkDecision = true;
       edits.push({ start: local.byteStart, end: local.byteEnd, replacement: result.replacement });
       if (result.visibleTextDelta !== 0) {
         shiftCandidates.push({
@@ -204252,6 +204598,8 @@ function compileBoundedPartDecisions(input) {
       });
       if (!result.ok)
         return result;
+      if (readComparisonHunkOrigin(fragment2)?.kind === "comparison-hunk")
+        hasComparisonHunkDecision = true;
       edits.push({ start: result.spliceStart, end: result.spliceEnd, replacement: result.replacement });
       invalidatedRefs.push({
         kind: "trackedChange",
@@ -204286,9 +204634,10 @@ function compileBoundedPartDecisions(input) {
     }
   }
   const dedupedEdits = dedupeEdits(edits);
-  const xml = assemble(input.xml, dedupedEdits);
-  if (xml == null)
+  const assembled = assemble(input.xml, dedupedEdits);
+  if (assembled == null)
     return { ok: false, reason: "unsupported-context" };
+  const xml = dedupedEdits.length > 0 && hasComparisonHunkDecision ? mergeAdjacentIdenticallyFormattedRuns(assembled, input.namespaceBindings) : assembled;
   return {
     ok: true,
     changed: dedupedEdits.length > 0,
@@ -204461,6 +204810,7 @@ var init_compile_tracked_change_decide_fenced = __esm(() => {
   init_prepared_mutation();
   init_patch_substrate();
   init_decide_engine();
+  init_comparison_hunk_groups();
   init_catalog3();
   init_source_inventory();
   TD43 = new TextDecoder;
@@ -206253,6 +206603,19 @@ function runTrackedChangeDecideCommitWithLookupContext(lookupContext, input) {
       }
     }
   }
+  const partsWithComparisonHunkFragments = new Set;
+  for (const fragments of fragmentsByPart.values()) {
+    for (const fragment2 of fragments) {
+      if (readComparisonHunkOrigin(fragment2)?.kind === "comparison-hunk") {
+        partsWithComparisonHunkFragments.add(fragment2.partUri);
+      }
+    }
+  }
+  for (const fragment2 of formattingTargets) {
+    if (readComparisonHunkOrigin(fragment2)?.kind === "comparison-hunk") {
+      partsWithComparisonHunkFragments.add(fragment2.partUri);
+    }
+  }
   for (const [partUri, fragments] of fragmentsByPart.entries()) {
     const bytes = state.packageBytes.get(partUri);
     if (!bytes)
@@ -207170,6 +207533,16 @@ function runTrackedChangeDecideCommitWithLookupContext(lookupContext, input) {
       storyPartOwnership.set(groups[0].fragments[0].storyId, partUri);
     }
   }
+  for (const partUri of partsWithComparisonHunkFragments) {
+    const patch = firstReplacePatch(perPart[partUri]);
+    if (!patch)
+      continue;
+    const mergedXml = measureSDTxPerf("trackedChangeRunMergeMs", () => mergeAdjacentIdenticallyFormattedRuns(TD47.decode(patch.bytes)));
+    const mergedBytes = TE23.encode(mergedXml);
+    if (mergedBytes.length === patch.bytes.length && bytesEqual8(mergedBytes, patch.bytes))
+      continue;
+    perPart[partUri] = { kind: "modify", patches: [{ ...patch, bytes: mergedBytes }] };
+  }
   const hyperlinkRelationshipCleanup = applyRejectedHyperlinkRelationshipCleanup({
     state,
     removedHyperlinkRIdsByPart,
@@ -209041,7 +209414,7 @@ function buildLogicalIdByTextFragmentKey(logical) {
   }
   const out = new Map;
   for (const entry of logical.byId.values()) {
-    if (entry.reviewGroup?.kind === "text-rewrite" && entry.reviewGroup.role === "parent")
+    if (entry.reviewGroup?.role === "parent" && (entry.reviewGroup.kind === "text-rewrite" || entry.reviewGroup.kind === "comparison-hunk"))
       continue;
     for (const fragment2 of entry.fragments) {
       if ((logicalIdsByRsid.get(fragment2.rsid)?.size ?? 0) <= 1)
@@ -209054,7 +209427,7 @@ function buildLogicalIdByTextFragmentKey(logical) {
 function buildExactLogicalIdByTextFragmentKey(logical) {
   const out = new Map;
   for (const entry of logical.byId.values()) {
-    if (entry.reviewGroup?.kind === "text-rewrite" && entry.reviewGroup.role === "parent")
+    if (entry.reviewGroup?.role === "parent" && (entry.reviewGroup.kind === "text-rewrite" || entry.reviewGroup.kind === "comparison-hunk"))
       continue;
     for (const fragment2 of entry.fragments) {
       out.set(trackedChangeFragmentKey(fragment2), entry.id);
@@ -210525,6 +210898,7 @@ var init_compile_tracked_change_decide = __esm(() => {
   init_package_graph();
   init_decide_engine();
   init_block_deletion_text();
+  init_comparison_hunk_groups();
   init_shared_table_grid_decision();
   init_structural_inline_decision();
   init_structural_groups();
@@ -220367,6 +220741,423 @@ var init_tracked_table_properties = __esm(() => {
   TOPOLOGY = new Set(["gridSpan", "hMerge", "vMerge", "gridBefore", "gridAfter"]);
 });
 
+// ../../../v2/editor-core/dist/document/transactions/word-diff.js
+function myersDiff(oldSeq, newSeq, isEqual, traceCellBudget = MAX_MYERS_TRACE_CELLS, keyOf) {
+  const oldLen = oldSeq.length;
+  const newLen = newSeq.length;
+  if (oldLen === 0 && newLen === 0) {
+    return [];
+  }
+  const max2 = oldLen + newLen;
+  const size = 2 * max2 + 3;
+  if (size > traceCellBudget)
+    return linearSpaceDiff(oldSeq, newSeq, isEqual, keyOf);
+  const offset = max2 + 1;
+  const v = new Int32Array(size).fill(-1);
+  v[offset + 1] = 0;
+  const trace = [];
+  let retainedCells = 0;
+  let foundPath = false;
+  for (let d = 0;d <= max2 && !foundPath; d += 1) {
+    const nextCells = 2 * d + 1;
+    if (retainedCells + nextCells > traceCellBudget)
+      return linearSpaceDiff(oldSeq, newSeq, isEqual, keyOf);
+    for (let k = -d;k <= d; k += 2) {
+      const index = offset + k;
+      let x2;
+      if (k === -d || k !== d && v[index - 1] < v[index + 1]) {
+        x2 = v[index + 1];
+      } else {
+        x2 = v[index - 1] + 1;
+      }
+      let y = x2 - k;
+      while (x2 < oldLen && y < newLen && isEqual(oldSeq[x2], newSeq[y])) {
+        x2 += 1;
+        y += 1;
+      }
+      v[index] = x2;
+      if (x2 >= oldLen && y >= newLen) {
+        foundPath = true;
+        break;
+      }
+    }
+    trace.push(v.slice(offset - d, offset + d + 1));
+    retainedCells += nextCells;
+  }
+  return backtrackMyers(trace, oldLen, newLen);
+}
+function diffWordTokens(oldSeq, newSeq) {
+  const oldKeys = Array.from(oldSeq, (token) => token.text);
+  const newKeys = Array.from(newSeq, (token) => token.text);
+  const oldSet = new Set(oldKeys);
+  const newSet = new Set(newKeys);
+  let oldIndex = 0;
+  let newIndex = 0;
+  while (true) {
+    while (oldIndex < oldKeys.length && !newSet.has(oldKeys[oldIndex]))
+      oldIndex += 1;
+    while (newIndex < newKeys.length && !oldSet.has(newKeys[newIndex]))
+      newIndex += 1;
+    if (oldIndex === oldKeys.length || newIndex === newKeys.length) {
+      if (oldIndex !== oldKeys.length || newIndex !== newKeys.length)
+        break;
+      const operations = [];
+      oldIndex = 0;
+      newIndex = 0;
+      while (oldIndex < oldKeys.length || newIndex < newKeys.length) {
+        while (oldIndex < oldKeys.length && !newSet.has(oldKeys[oldIndex])) {
+          operations.push("delete");
+          oldIndex += 1;
+        }
+        while (newIndex < newKeys.length && !oldSet.has(newKeys[newIndex])) {
+          operations.push("insert");
+          newIndex += 1;
+        }
+        if (oldIndex < oldKeys.length && newIndex < newKeys.length) {
+          operations.push("equal");
+          oldIndex += 1;
+          newIndex += 1;
+        }
+      }
+      return operations;
+    }
+    if (oldKeys[oldIndex] !== newKeys[newIndex])
+      break;
+    oldIndex += 1;
+    newIndex += 1;
+  }
+  return myersDiff(oldSeq, newSeq, (a, b) => a.text === b.text, MAX_MYERS_TRACE_CELLS, (item) => item.text);
+}
+function backtrackMyers(trace, oldLen, newLen) {
+  const operations = [];
+  let x2 = oldLen;
+  let y = newLen;
+  for (let d = trace.length - 1;d > 0; d -= 1) {
+    const v = trace[d - 1];
+    const k = x2 - y;
+    const index = d - 1 + k;
+    let prevK;
+    if (k === -d || k !== d && v[index - 1] < v[index + 1]) {
+      prevK = k + 1;
+    } else {
+      prevK = k - 1;
+    }
+    const prevIndex = d - 1 + prevK;
+    const prevX = v[prevIndex];
+    const prevY = prevX - prevK;
+    while (x2 > prevX && y > prevY) {
+      x2 -= 1;
+      y -= 1;
+      operations.push("equal");
+    }
+    if (x2 === prevX) {
+      y -= 1;
+      operations.push("insert");
+    } else {
+      x2 -= 1;
+      operations.push("delete");
+    }
+  }
+  while (x2 > 0 && y > 0) {
+    x2 -= 1;
+    y -= 1;
+    operations.push("equal");
+  }
+  while (x2 > 0) {
+    x2 -= 1;
+    operations.push("delete");
+  }
+  while (y > 0) {
+    y -= 1;
+    operations.push("insert");
+  }
+  return operations.reverse();
+}
+function linearSpaceDiff(oldSeq, newSeq, isEqual, keyOf) {
+  const result = [];
+  function lcsRow(oldFrom, oldTo, newFrom, newTo, reverse) {
+    const newLength = newTo - newFrom;
+    let useBitset = Boolean(keyOf && newLength >= 64);
+    if (useBitset) {
+      const distinctKeys = new Set;
+      for (let column = 0;column < newLength; column += 1) {
+        const newIndex = reverse ? newTo - column - 1 : newFrom + column;
+        distinctKeys.add(keyOf(newSeq[newIndex]));
+        if (distinctKeys.size * newLength > MAX_BITSET_MASK_BITS) {
+          useBitset = false;
+          break;
+        }
+      }
+    }
+    if (useBitset && keyOf) {
+      const masks = new Map;
+      for (let column = 0;column < newLength; column += 1) {
+        const newIndex = reverse ? newTo - column - 1 : newFrom + column;
+        const key2 = keyOf(newSeq[newIndex]);
+        masks.set(key2, (masks.get(key2) ?? 0n) | 1n << BigInt(column));
+      }
+      let bits2 = 0n;
+      for (let oldIndex = oldFrom;oldIndex < oldTo; oldIndex += 1) {
+        const oldValue = reverse ? oldSeq[oldTo - 1 - (oldIndex - oldFrom)] : oldSeq[oldIndex];
+        const matches = masks.get(keyOf(oldValue)) ?? 0n;
+        const x2 = matches | bits2;
+        bits2 = x2 & ~(x2 - (bits2 << 1n | 1n));
+      }
+      const row2 = new Uint32Array(newLength + 1);
+      for (let column = 1;column <= newLength; column += 1) {
+        row2[column] = row2[column - 1] + Number(bits2 & 1n);
+        bits2 >>= 1n;
+      }
+      return row2;
+    }
+    if (keyOf && newLength >= 64) {
+      const positions = new Map;
+      for (let column = 0;column < newLength; column += 1) {
+        const newIndex = reverse ? newTo - column - 1 : newFrom + column;
+        const key2 = keyOf(newSeq[newIndex]);
+        const list = positions.get(key2);
+        if (list)
+          list.push(column);
+        else
+          positions.set(key2, [column]);
+      }
+      const bits2 = new Uint32Array(Math.ceil(newLength / 32));
+      const x2 = new Uint32Array(bits2.length);
+      for (let oldIndex = oldFrom;oldIndex < oldTo; oldIndex += 1) {
+        const oldValue = reverse ? oldSeq[oldTo - 1 - (oldIndex - oldFrom)] : oldSeq[oldIndex];
+        x2.set(bits2);
+        for (const column of positions.get(keyOf(oldValue)) ?? [])
+          x2[column >>> 5] |= 1 << (column & 31);
+        let carry = 1;
+        let borrow = 0;
+        for (let word2 = 0;word2 < bits2.length; word2 += 1) {
+          const previous = bits2[word2];
+          const shifted = (previous << 1 | carry) >>> 0;
+          carry = previous >>> 31;
+          const subtrahend = shifted + borrow;
+          const difference = x2[word2] - subtrahend >>> 0;
+          borrow = x2[word2] < subtrahend ? 1 : 0;
+          bits2[word2] = x2[word2] & ~difference;
+        }
+      }
+      const row2 = new Uint32Array(newLength + 1);
+      for (let column = 1;column <= newLength; column += 1) {
+        row2[column] = row2[column - 1] + (bits2[column - 1 >>> 5] >>> (column - 1 & 31) & 1);
+      }
+      return row2;
+    }
+    const row = new Uint32Array(newLength + 1);
+    for (let oldIndex = oldFrom;oldIndex < oldTo; oldIndex += 1) {
+      const oldValue = reverse ? oldSeq[oldTo - 1 - (oldIndex - oldFrom)] : oldSeq[oldIndex];
+      let diagonal = 0;
+      for (let column = 1;column <= newLength; column += 1) {
+        const previous = row[column];
+        const newIndex = reverse ? newTo - column : newFrom + column - 1;
+        row[column] = isEqual(oldValue, newSeq[newIndex]) ? diagonal + 1 : Math.max(row[column - 1], previous);
+        diagonal = previous;
+      }
+    }
+    return row;
+  }
+  function splitNew(oldFrom, oldMiddle, oldTo, newFrom, newTo) {
+    const left = lcsRow(oldFrom, oldMiddle, newFrom, newTo, false);
+    const right = lcsRow(oldMiddle, oldTo, newFrom, newTo, true);
+    const newLength = newTo - newFrom;
+    let bestColumn = 0;
+    let bestLength = -1;
+    for (let column = 0;column <= newLength; column += 1) {
+      const length = left[column] + right[newLength - column];
+      if (length > bestLength) {
+        bestLength = length;
+        bestColumn = column;
+      }
+    }
+    return newFrom + bestColumn;
+  }
+  function emit(oldFrom, oldTo, newFrom, newTo) {
+    while (oldFrom < oldTo && newFrom < newTo && isEqual(oldSeq[oldFrom], newSeq[newFrom])) {
+      result.push("equal");
+      oldFrom += 1;
+      newFrom += 1;
+    }
+    let commonSuffix = 0;
+    while (oldFrom + commonSuffix < oldTo && newFrom + commonSuffix < newTo && isEqual(oldSeq[oldTo - commonSuffix - 1], newSeq[newTo - commonSuffix - 1]))
+      commonSuffix += 1;
+    oldTo -= commonSuffix;
+    newTo -= commonSuffix;
+    const oldLength = oldTo - oldFrom;
+    const newLength = newTo - newFrom;
+    if (oldLength === 0) {
+      for (let index = 0;index < newLength; index += 1)
+        result.push("insert");
+    } else if (newLength === 0) {
+      for (let index = 0;index < oldLength; index += 1)
+        result.push("delete");
+    } else if (oldLength === 1) {
+      let match = -1;
+      for (let index = newFrom;index < newTo; index += 1) {
+        if (isEqual(oldSeq[oldFrom], newSeq[index])) {
+          match = index;
+          break;
+        }
+      }
+      if (match === -1) {
+        result.push("delete");
+        for (let index = 0;index < newLength; index += 1)
+          result.push("insert");
+      } else {
+        for (let index = newFrom;index < match; index += 1)
+          result.push("insert");
+        result.push("equal");
+        for (let index = match + 1;index < newTo; index += 1)
+          result.push("insert");
+      }
+    } else {
+      const middle = oldFrom + Math.floor(oldLength / 2);
+      const newMiddle = splitNew(oldFrom, middle, oldTo, newFrom, newTo);
+      emit(oldFrom, middle, newFrom, newMiddle);
+      emit(middle, oldTo, newMiddle, newTo);
+    }
+    for (let index = 0;index < commonSuffix; index += 1)
+      result.push("equal");
+  }
+  emit(0, oldSeq.length, 0, newSeq.length);
+  return result;
+}
+function tokenizeWords(text) {
+  const tokens = [];
+  const regex = /(\s+|[\p{L}\p{N}_]+|[^\s\p{L}\p{N}_]+)/gu;
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    tokens.push({ text: match[0], offset: match.index });
+  }
+  return tokens;
+}
+function necessarilyExceedsWordDiffRatio(oldText, newText, ratio) {
+  const oldTokens = tokenizeWords(oldText);
+  const newTokens = tokenizeWords(newText);
+  const oldCounts = new Map;
+  const newCounts = new Map;
+  for (const token of oldTokens)
+    oldCounts.set(token.text, (oldCounts.get(token.text) ?? 0) + 1);
+  for (const token of newTokens)
+    newCounts.set(token.text, (newCounts.get(token.text) ?? 0) + 1);
+  let maxEqualChars = 0;
+  for (const [text, count] of oldCounts) {
+    maxEqualChars += Math.min(count, newCounts.get(text) ?? 0) * text.length;
+  }
+  const totalChars = oldText.length + newText.length;
+  if (totalChars === 0)
+    return false;
+  if (1 - 2 * maxEqualChars / totalChars > ratio)
+    return true;
+  const uniqueOldPositions = new Map;
+  let uniqueChars = 0;
+  let longestUniqueWord = 0;
+  for (const token of oldTokens) {
+    const text = token.text;
+    if (oldCounts.get(text) !== 1 || newCounts.get(text) !== 1 || !/^[\p{L}\p{N}_]+$/u.test(text))
+      continue;
+    uniqueOldPositions.set(text, uniqueOldPositions.size);
+    uniqueChars += text.length;
+    longestUniqueWord = Math.max(longestUniqueWord, text.length);
+  }
+  if (uniqueOldPositions.size === 0)
+    return false;
+  const tails = [];
+  for (const token of newTokens) {
+    const position = uniqueOldPositions.get(token.text);
+    if (position === undefined)
+      continue;
+    let low = 0;
+    let high = tails.length;
+    while (low < high) {
+      const middle = low + high >>> 1;
+      if (tails[middle] < position)
+        low = middle + 1;
+      else
+        high = middle;
+    }
+    tails[low] = position;
+  }
+  maxEqualChars -= uniqueChars - Math.min(uniqueChars, tails.length * longestUniqueWord);
+  return 1 - 2 * maxEqualChars / totalChars > ratio;
+}
+function getWordChanges(oldText, newText) {
+  if (oldText === newText) {
+    return [];
+  }
+  const oldTokens = tokenizeWords(oldText);
+  const newTokens = tokenizeWords(newText);
+  if (oldTokens.length === 0 && newTokens.length === 0) {
+    return [];
+  }
+  if (oldTokens.length === 0) {
+    return [{ type: "insert", insertAt: 0, newText }];
+  }
+  if (newTokens.length === 0) {
+    return [{ type: "delete", oldFrom: 0, oldTo: oldText.length }];
+  }
+  const ops = diffWordTokens(oldTokens, newTokens);
+  const steps = [];
+  let oldIdx = 0;
+  let newIdx = 0;
+  for (const op of ops) {
+    steps.push({ type: op, oldIdx, newIdx });
+    if (op === "equal") {
+      oldIdx++;
+      newIdx++;
+    } else if (op === "delete") {
+      oldIdx++;
+    } else {
+      newIdx++;
+    }
+  }
+  const result = [];
+  let i2 = 0;
+  while (i2 < steps.length) {
+    const step2 = steps[i2];
+    if (step2.type === "equal") {
+      i2++;
+      continue;
+    }
+    const groupStart = i2;
+    let deleteStart = -1;
+    let deleteEnd = -1;
+    let insertText = "";
+    while (i2 < steps.length && (steps[i2].type === "delete" || steps[i2].type === "insert")) {
+      const s = steps[i2];
+      if (s.type === "delete") {
+        const token = oldTokens[s.oldIdx];
+        if (deleteStart === -1)
+          deleteStart = token.offset;
+        deleteEnd = token.offset + token.text.length;
+      } else {
+        insertText += newTokens[s.newIdx].text;
+      }
+      i2++;
+    }
+    if (deleteStart !== -1 && insertText.length > 0) {
+      result.push({ type: "replace", oldFrom: deleteStart, oldTo: deleteEnd, newText: insertText });
+    } else if (deleteStart !== -1) {
+      result.push({ type: "delete", oldFrom: deleteStart, oldTo: deleteEnd });
+    } else if (insertText.length > 0) {
+      const prevStep = groupStart > 0 ? steps[groupStart - 1] : null;
+      let insertAt = 0;
+      if (prevStep && prevStep.type === "equal") {
+        const prevToken = oldTokens[prevStep.oldIdx];
+        insertAt = prevToken.offset + prevToken.text.length;
+      } else if (result.length > 0) {
+        const lastOp = result[result.length - 1];
+        insertAt = "oldTo" in lastOp ? lastOp.oldTo : ("insertAt" in lastOp) ? lastOp.insertAt : 0;
+      }
+      result.push({ type: "insert", insertAt, newText: insertText });
+    }
+  }
+  return result;
+}
+var MAX_MYERS_TRACE_CELLS = 4000000, MAX_BITSET_MASK_BITS = 4000000;
+
 // ../../../v2/editor-core/dist/document/transactions/compare-table-block-replay.js
 function prepareCompareTableBlockReplay(bytes, step2) {
   const xml = TD58.decode(bytes);
@@ -220764,6 +221555,9 @@ function runCompareApplyCommit(input) {
   if (new Set(executableOperationIds).size !== executableOperationIds.length) {
     return rejected14(txId, "unsupported-context");
   }
+  if (changeMode === "tracked" && referenceReplaySteps.some((step2) => (step2.kind === "field-topology" || step2.kind === "complex-field") && (!step2.beforeFragmentXml || !step2.afterFragmentXml || !isRunOnlyTrackedFieldFragment(step2.beforeFragmentXml, step2.beforeNamespaceBindings ?? {}) || !isRunOnlyTrackedFieldFragment(step2.afterFragmentXml, step2.afterNamespaceBindings ?? {})))) {
+    return rejected14(txId, "unsupported-context");
+  }
   if (changeMode === "tracked" && (groups.length > 0 || storyPackageOperations.length > 0 || tableTopologySteps.length > 0 || tableBlockSteps.length > 0 || tablePropertySteps.length > 0 || sectionReplaySteps.length > 0 || referenceReplaySteps.length > 0) && !(input.authorOverride ?? input.author)) {
     return rejected14(txId, "no-author-configured");
   }
@@ -221734,7 +222528,7 @@ function collectProtectedReferenceTokens(xml, referenceSteps) {
       }
       continue;
     }
-    if (step2.kind === "bookmark-range" || step2.kind === "complex-field") {
+    if (step2.kind === "bookmark-range" || step2.kind === "complex-field" || step2.kind === "field-topology") {
       const fragment2 = step2.beforeFragmentXml;
       if (!fragment2)
         return null;
@@ -221901,6 +222695,9 @@ function runBodyStep(input, storyId, noteId, step2, changeMode, options, pushHis
       }
       return runCompareBodyEditCommit(input, storyId, step2, changeMode, options, pushHistory, referenceSteps);
     }
+    const localizedEditOp = changeMode === "tracked" ? tryLocalizedCompareEditTextOp(state, storyId, step2.blockId, adjustedEdit.previousText, adjustedEdit.text, txId) : null;
+    if (localizedEditOp)
+      return runEditTextCommit({ ...subInput, op: localizedEditOp });
     const range = adjustedEdit.trimmedTrailingNoteMarkers > 0 ? resolveParagraphSliceRange(state, storyId, step2.blockId, 0, adjustedEdit.editableEndOffset) : resolveWholeParagraphRange(state, storyId, step2.blockId);
     if (!range)
       return rejected14(txId, "invalid-range");
@@ -222599,7 +223396,6 @@ function runCompareBodyEditCommit(input, storyId, step2, changeMode, options, pu
     const stamps = compareTrackedStampPair(input, paragraphPropertiesChanged);
     if (!stamps)
       return rejected14(txId, "no-author-configured");
-    createdRefs.push({ kind: "trackedChange", entityId: stamps.ins.rsid, storyId });
     if (stamps.paragraphProperties) {
       createdRefs.push({
         kind: "trackedChange",
@@ -222608,13 +223404,34 @@ function runCompareBodyEditCommit(input, storyId, step2, changeMode, options, pu
       });
     }
     const oldRunsDel = oldRunsRaw.replace(/<((?:[\w.-]+:)?)t(\b[^>]*)>/g, "<$1delText$2>").replace(/<\/((?:[\w.-]+:)?)t>/g, "</$1delText>");
-    const protectedRuns = renderTrackedRunsWithProtectedReferences(oldRunsRaw, newRuns, protectedReferenceSteps, stamps, paragraphWrapper.wordprocessingPrefix);
+    const hunkStamps = makeCompareHunkStampSource(stamps, input);
+    const protectedRuns = renderTrackedRunsWithProtectedReferences(oldRunsRaw, newRuns, protectedReferenceSteps, hunkStamps.next, paragraphWrapper.wordprocessingPrefix);
     if (!protectedRuns && stableBookmarkSteps?.length)
       return rejected14(txId, "unsupported-context");
-    const delXml = protectedRuns?.xml ?? (oldRunsDel ? wrapTracked("del", oldRunsDel, stamps.del, "rsidDel", paragraphWrapper.wordprocessingPrefix) : "");
-    const insXml = protectedRuns ? "" : newRuns ? wrapTracked("ins", newRuns, stamps.ins, "rsidR", paragraphWrapper.wordprocessingPrefix) : "";
+    let delXml;
+    let insXml;
+    if (protectedRuns) {
+      delXml = protectedRuns.xml;
+      insXml = "";
+    } else {
+      const fallbackPair = hunkStamps.next();
+      delXml = oldRunsDel ? wrapTracked("del", oldRunsDel, fallbackPair.del, "rsidDel", paragraphWrapper.wordprocessingPrefix) : "";
+      insXml = newRuns ? wrapTracked("ins", newRuns, fallbackPair.ins, "rsidR", paragraphWrapper.wordprocessingPrefix) : "";
+    }
     const trackedPPrXml = buildTrackedParagraphProperties(targetParagraphPropertiesXml, pPrXml, stamps.paragraphProperties ?? stamps.ins, paragraphWrapper.wordprocessingPrefix);
-    newParaXml = `${paragraphWrapper.openTag}${trackedPPrXml}${delXml}${insXml}${paragraphWrapper.closeTag}`;
+    const assembledParaXml = `${paragraphWrapper.openTag}${trackedPPrXml}${delXml}${insXml}${paragraphWrapper.closeTag}`;
+    if (hunkStamps.usedPairs.length === 0) {
+      newParaXml = assembledParaXml;
+    } else {
+      for (const pair of hunkStamps.usedPairs) {
+        createdRefs.push({ kind: "trackedChange", entityId: pair.del.rsid, storyId });
+      }
+      const hunkGroupsByRsid = new Map(hunkStamps.usedPairs.map((pair, ordinal) => [pair.del.rsid, `${txId}:${step2.blockId}:${ordinal}`]));
+      const stamped = stampComparisonHunkOrigins(assembledParaXml, hunkGroupsByRsid, { partUri, storyId });
+      if (stamped === null)
+        return rejected14(txId, "invalid-input");
+      newParaXml = stamped;
+    }
   } else {
     newParaXml = `${paragraphWrapper.openTag}${targetParagraphPropertiesXml ?? pPrXml}${newRuns}${paragraphWrapper.closeTag}`;
   }
@@ -222639,10 +223456,10 @@ function runCompareBodyEditCommit(input, storyId, step2, changeMode, options, pu
     targetBlockIds: [step2.blockId]
   });
 }
-function renderTrackedRunsWithProtectedReferences(oldRuns, targetRuns, referenceSteps, stamps, prefix) {
+function renderTrackedRunsWithProtectedReferences(oldRuns, targetRuns, referenceSteps, getStamp, prefix) {
   const oldTokens = collectProtectedReferenceTokens(oldRuns, referenceSteps);
   const targetTokens = collectProtectedReferenceTokens(targetRuns, referenceSteps);
-  if (!oldTokens || !targetTokens || oldTokens.length === 0 || oldTokens.length !== targetTokens.length)
+  if (!oldTokens || !targetTokens || oldTokens.length !== targetTokens.length)
     return null;
   if (oldTokens.some((token, index) => token.key !== targetTokens[index].key))
     return null;
@@ -222657,11 +223474,19 @@ function renderTrackedRunsWithProtectedReferences(oldRuns, targetRuns, reference
     if (oldSegment === targetSegment) {
       xml += oldSegment;
     } else {
-      const deleted = oldSegment.replace(/<((?:[\w.-]+:)?)t(\b[^>]*)>/g, "<$1delText$2>").replace(/<\/((?:[\w.-]+:)?)t>/g, "</$1delText>");
-      if (deleted)
-        xml += wrapTracked("del", deleted, stamps.del, "rsidDel", prefix);
-      if (targetSegment)
-        xml += wrapTracked("ins", targetSegment, stamps.ins, "rsidR", prefix);
+      const wordLevel = renderWordLevelTrackedRunSegment(oldSegment, targetSegment, getStamp, prefix);
+      if (wordLevel) {
+        xml += wordLevel.xml;
+      } else {
+        const deleted = oldSegment.replace(/<((?:[\w.-]+:)?)t(\b[^>]*)>/g, "<$1delText$2>").replace(/<\/((?:[\w.-]+:)?)t>/g, "</$1delText>");
+        if (deleted || targetSegment) {
+          const pair = getStamp();
+          if (deleted)
+            xml += wrapTracked("del", deleted, pair.del, "rsidDel", prefix);
+          if (targetSegment)
+            xml += wrapTracked("ins", targetSegment, pair.ins, "rsidR", prefix);
+        }
+      }
     }
     if (!oldToken || !targetToken)
       break;
@@ -222671,6 +223496,155 @@ function renderTrackedRunsWithProtectedReferences(oldRuns, targetRuns, reference
   }
   return { xml };
 }
+function shouldFallBackFromWordDiff(ops, oldLength, newLength) {
+  const changedOldChars = ops.reduce((sum, op) => sum + (op.type === "insert" ? 0 : op.oldTo - op.oldFrom), 0);
+  const changedNewChars = ops.reduce((sum, op) => sum + (op.type === "delete" ? 0 : op.newText.length), 0);
+  const totalChars = oldLength + newLength;
+  if (totalChars === 0)
+    return false;
+  const changedRatio = (changedOldChars + changedNewChars) / totalChars;
+  return changedRatio > WORD_DIFF_FALLBACK_RATIO || ops.length > MAX_WORD_DIFF_HUNKS && changedRatio > DENSE_WORD_DIFF_RATIO;
+}
+function parseSimpleRunTokens(xml) {
+  const runRe = /<([\w.-]+):r\b([^>]*)>([\s\S]*?)<\/\1:r>/g;
+  const tokens = [];
+  let cursor = 0;
+  let visibleOffset = 0;
+  let match;
+  while (match = runRe.exec(xml)) {
+    if (xml.slice(cursor, match.index).trim().length > 0)
+      return null;
+    const prefix = match[1];
+    const runAttrs = match[2] ?? "";
+    const inner = match[3] ?? "";
+    const leadingWs = inner.match(/^\s*/)?.[0] ?? "";
+    const rPrXml = matchLeadingElement(inner.slice(leadingWs.length), "rPr");
+    const afterRPr = inner.slice(leadingWs.length + rPrXml.length);
+    const tMatch = /^\s*<([\w.-]+):t\b([^>]*)>([\s\S]*?)<\/\1:t>\s*$/.exec(afterRPr);
+    if (!tMatch)
+      return null;
+    const text = decodeCompareXmlText(tMatch[3] ?? "");
+    tokens.push({
+      rawXml: match[0],
+      openTag: `<${prefix}:r${runAttrs}>${rPrXml}`,
+      runPrefix: prefix,
+      text,
+      startOffset: visibleOffset
+    });
+    visibleOffset += text.length;
+    cursor = runRe.lastIndex;
+  }
+  if (xml.slice(cursor).trim().length > 0)
+    return null;
+  return tokens;
+}
+function renderCompareRunTokenSpan(token, start, end, mode) {
+  const tokenEnd = token.startOffset + token.text.length;
+  if (mode === "passthrough" && start === token.startOffset && end === tokenEnd)
+    return token.rawXml;
+  const text = token.text.slice(start - token.startOffset, end - token.startOffset);
+  if (!text)
+    return "";
+  const localName2 = mode === "del" ? "delText" : "t";
+  const preserve = needsXmlSpacePreserve(text) ? ' xml:space="preserve"' : "";
+  return `${token.openTag}<${token.runPrefix}:${localName2}${preserve}>${escapeXmlText(text)}</${token.runPrefix}:${localName2}></${token.runPrefix}:r>`;
+}
+function renderCompareRunRange(tokens, from, to, mode) {
+  let xml = "";
+  for (const token of tokens) {
+    const tokenEnd = token.startOffset + token.text.length;
+    const start = Math.max(from, token.startOffset);
+    const end = Math.min(to, tokenEnd);
+    if (start >= end)
+      continue;
+    xml += renderCompareRunTokenSpan(token, start, end, mode);
+  }
+  return xml;
+}
+function tokenizeCompareWordRuns(tokens) {
+  const words = [];
+  const regex = /(\s+|[\p{L}\p{N}_]+|[^\s\p{L}\p{N}_]+)/gu;
+  for (const token of tokens) {
+    let match;
+    while ((match = regex.exec(token.text)) !== null) {
+      words.push({
+        text: match[0],
+        openTag: token.openTag
+      });
+    }
+  }
+  return words;
+}
+function equalWordTokensPreserveFormatting(oldTokens, targetTokens) {
+  const oldWords = tokenizeCompareWordRuns(oldTokens);
+  const targetWords = tokenizeCompareWordRuns(targetTokens);
+  const ops = diffWordTokens(oldWords, targetWords);
+  let oldIndex = 0;
+  let targetIndex = 0;
+  for (const op of ops) {
+    if (op === "equal") {
+      if (oldWords[oldIndex]?.openTag !== targetWords[targetIndex]?.openTag)
+        return false;
+      oldIndex += 1;
+      targetIndex += 1;
+      continue;
+    }
+    if (op === "delete") {
+      oldIndex += 1;
+      continue;
+    }
+    targetIndex += 1;
+  }
+  return true;
+}
+function renderWordLevelTrackedRunSegment(oldSegment, targetSegment, getStamp, prefix) {
+  const oldTokens = parseSimpleRunTokens(oldSegment);
+  const targetTokens = parseSimpleRunTokens(targetSegment);
+  if (!oldTokens || !targetTokens)
+    return null;
+  const oldText = oldTokens.map((token) => token.text).join("");
+  const targetText = targetTokens.map((token) => token.text).join("");
+  if (oldText === targetText)
+    return null;
+  if (necessarilyExceedsWordDiffRatio(oldText, targetText, WORD_DIFF_FALLBACK_RATIO))
+    return null;
+  if (!equalWordTokensPreserveFormatting(oldTokens, targetTokens))
+    return null;
+  const ops = getWordChanges(oldText, targetText);
+  if (ops.length === 0)
+    return null;
+  if (shouldFallBackFromWordDiff(ops, oldText.length, targetText.length))
+    return null;
+  let xml = "";
+  let oldCursor = 0;
+  let newCursor = 0;
+  for (const op of ops) {
+    const opOldStart = op.type === "insert" ? op.insertAt : op.oldFrom;
+    if (opOldStart > oldCursor) {
+      xml += renderCompareRunRange(oldTokens, oldCursor, opOldStart, "passthrough");
+      newCursor += opOldStart - oldCursor;
+      oldCursor = opOldStart;
+    }
+    let opStamp = null;
+    const stampForOp = () => opStamp ?? (opStamp = getStamp());
+    if (op.type === "delete" || op.type === "replace") {
+      const deletedXml = renderCompareRunRange(oldTokens, op.oldFrom, op.oldTo, "del");
+      if (deletedXml)
+        xml += wrapTracked("del", deletedXml, stampForOp().del, "rsidDel", prefix);
+      oldCursor = op.oldTo;
+    }
+    if (op.type === "insert" || op.type === "replace") {
+      const insertedXml = renderCompareRunRange(targetTokens, newCursor, newCursor + op.newText.length, "ins");
+      if (insertedXml)
+        xml += wrapTracked("ins", insertedXml, stampForOp().ins, "rsidR", prefix);
+      newCursor += op.newText.length;
+    }
+  }
+  if (oldCursor < oldText.length) {
+    xml += renderCompareRunRange(oldTokens, oldCursor, oldText.length, "passthrough");
+  }
+  return { xml };
+}
 function runCompareBodyFormatEditCommit(input, storyId, step2, changeMode, options, pushHistory, referenceSteps) {
   const { state, txId } = input;
   const partUri = storyPartUriFromStoryId2(storyId);
@@ -222761,7 +223735,7 @@ function runCompareBodyFormatEditCommit(input, storyId, step2, changeMode, optio
       if (!stamps)
         return rejected14(txId, "no-author-configured");
       const oldRunsDel = oldRunsRaw.replace(/<((?:[\w.-]+:)?)t(\b[^>]*)>/g, "<$1delText$2>").replace(/<\/((?:[\w.-]+:)?)t>/g, "</$1delText>");
-      const protectedRuns = renderTrackedRunsWithProtectedReferences(oldRunsRaw, targetRunXml, protectedReferenceSteps, stamps, paragraphWrapper.wordprocessingPrefix);
+      const protectedRuns = renderTrackedRunsWithProtectedReferences(oldRunsRaw, targetRunXml, protectedReferenceSteps, () => stamps, paragraphWrapper.wordprocessingPrefix);
       if (!protectedRuns && stableBookmarkSteps?.length)
         return rejected14(txId, "unsupported-context");
       const delXml = protectedRuns?.xml ?? (oldRunsDel ? wrapTracked("del", oldRunsDel, stamps.del, "rsidDel", paragraphWrapper.wordprocessingPrefix) : "");
@@ -222853,6 +223827,43 @@ function compareTrackedStampPair(input, includeParagraphProperties = false) {
     ...includeParagraphProperties ? { paragraphProperties: { rsid, wId: wId + 2, author, date: input.txTimestamp } } : {}
   };
 }
+function makeCompareHunkStampSource(primary, input) {
+  const usedPairs = [];
+  const reservedRsids = new Set([primary.del.rsid]);
+  let issued = false;
+  let pendingRsids = [];
+  let batchOrdinal = 0;
+  const nextRsid = () => {
+    for (;; ) {
+      const candidate2 = pendingRsids.shift();
+      if (candidate2 !== undefined) {
+        if (reservedRsids.has(candidate2))
+          continue;
+        return candidate2;
+      }
+      const batchSize = 2 ** batchOrdinal;
+      pendingRsids = allocateDistinctBatchRsids(input.state, `${input.txId}:hunk-batch:${batchOrdinal}`, batchSize);
+      batchOrdinal += 1;
+    }
+  };
+  const next = () => {
+    if (!issued) {
+      issued = true;
+      usedPairs.push(primary);
+      return primary;
+    }
+    const wId = reserveRevisionWIdBlock(input.state, 2);
+    const rsid = nextRsid();
+    reservedRsids.add(rsid);
+    const pair = {
+      del: { rsid, wId, author: primary.del.author, date: primary.del.date },
+      ins: { rsid, wId: wId + 1, author: primary.ins.author, date: primary.ins.date }
+    };
+    usedPairs.push(pair);
+    return pair;
+  };
+  return { next, usedPairs };
+}
 function compareParagraphFormattingEntityKey(storyId, stamp) {
   return buildFormattingRevisionEntityKey({
     storyId,
@@ -223057,6 +224068,9 @@ function isSafeReferenceReplayStep(step2, context) {
   if (step2.kind === "bookmark-range") {
     return isBalancedAddedBookmarkFragment(afterFragment, beforeFragment, context.parentNamespaceBindings) || isBalancedAddedBookmarkFragment(beforeFragment, afterFragment, context.parentNamespaceBindings);
   }
+  if (step2.kind === "field-topology") {
+    return isSafeFieldTopologyFragment(beforeFragment, afterFragment, context.parentNamespaceBindings);
+  }
   return isCompleteAddedRefFieldFragment(afterFragment, beforeFragment, context.parentNamespaceBindings);
 }
 function referenceReplayElementName(step2) {
@@ -223090,6 +224104,61 @@ function isCompleteAddedRefFieldFragment(xml, expectedResult, namespaceBindings)
   const instruction = parsed.ranges.filter((range) => range.tag.namespaceUri === NS_W && range.tag.localName === "instrText" && range.start > chars[0].end && range.end < chars[1].start).map((range) => xml.slice(range.start, range.end).replace(/^<[^>]+>|<\/[^>]+>$/g, "")).join("");
   return /^\s*REF\s+[A-Za-z_][A-Za-z0-9_.]*(?:\s|$)/i.test(instruction) && xml.slice(parentRunEnd(parsed.ranges, chars[1]), parentRunStart(parsed.ranges, chars[2])) === expectedResult;
 }
+function isSafeFieldTopologyFragment(before, after, namespaceBindings) {
+  const field = isSimpleRefFieldFragment(after, before, namespaceBindings) || isCompleteAddedRefFieldFragment(after, before, namespaceBindings) || isSimpleRefFieldFragment(before, after, namespaceBindings) || isCompleteAddedRefFieldFragment(before, after, namespaceBindings);
+  return field;
+}
+function isSimpleRefFieldFragment(fieldXml, expectedResult, namespaceBindings) {
+  const parsed = collectXmlElementRanges(fieldXml, {
+    fragment: true,
+    additionalNamespaces: { ...namespaceBindings }
+  });
+  if (parsed.errors.length > 0)
+    return false;
+  const field = parsed.ranges.find((range) => range.start === 0 && range.end === fieldXml.length && range.tag.namespaceUri === NS_W && range.tag.localName === "fldSimple");
+  if (!field || field.tag.isSelfClosing)
+    return false;
+  const instruction = readResolvedReplayAttribute(field, "instr");
+  if (!instruction || !/^\s*REF\s+[A-Za-z_][A-Za-z0-9_.]*(?:\s|$)/i.test(instruction))
+    return false;
+  const disallowed = new Set([
+    "fldSimple",
+    "fldChar",
+    "hyperlink",
+    "drawing",
+    "object",
+    "pict",
+    "sdt",
+    "customXml",
+    "ins",
+    "del",
+    "footnoteReference",
+    "endnoteReference",
+    "commentReference",
+    "bookmarkStart",
+    "bookmarkEnd"
+  ]);
+  if (parsed.ranges.some((range) => range !== field && (range.tag.namespaceUri !== NS_W || disallowed.has(range.tag.localName))))
+    return false;
+  return fieldXml.slice(field.openEnd, field.closeStart) === expectedResult && parsed.ranges.some((range) => range.tag.namespaceUri === NS_W && range.tag.localName === "r");
+}
+function isRunOnlyTrackedFieldFragment(xml, namespaceBindings) {
+  const parsed = collectXmlElementRanges(xml, {
+    fragment: true,
+    additionalNamespaces: { ...namespaceBindings }
+  });
+  if (parsed.errors.length > 0)
+    return false;
+  let end = 0;
+  for (const range of parsed.ranges.sort((left, right) => left.start - right.start || right.end - left.end)) {
+    if (range.start < end)
+      continue;
+    if (range.start !== end || range.tag.namespaceUri !== NS_W || range.tag.localName !== "r")
+      return false;
+    end = range.end;
+  }
+  return end === xml.length;
+}
 function parentRunStart(ranges, child) {
   return ranges.find((range) => range.tag.namespaceUri === NS_W && range.tag.localName === "r" && range.start <= child.start && range.end >= child.end)?.start ?? -1;
 }
@@ -223220,7 +224289,7 @@ function renderTrackedSectionReplay(step2, stamp, context) {
   return step2.afterXml.slice(0, close) + marker + step2.afterXml.slice(close);
 }
 function renderTrackedReferenceReplay(step2, stamps, context) {
-  if (step2.kind === "bookmark-range" || step2.kind === "complex-field") {
+  if (step2.kind === "bookmark-range" || step2.kind === "complex-field" || step2.kind === "field-topology") {
     const beforeFragment = step2.beforeFragmentXml;
     const afterFragment = step2.afterFragmentXml;
     const deletionXml2 = renameWordTextElementsToDeletedText(beforeFragment, context.parentNamespaceBindings);
@@ -223287,9 +224356,9 @@ function renameWordTextElementsToDeletedText(xml, namespaceBindings) {
     return xml;
   const edits = [];
   for (const range of parsed.ranges) {
-    if (range.tag.namespaceUri !== NS_W || range.tag.localName !== "t")
+    if (range.tag.namespaceUri !== NS_W || range.tag.localName !== "t" && range.tag.localName !== "instrText")
       continue;
-    const replacementName = qualifiedName(range.tag.prefix, "delText");
+    const replacementName = qualifiedName(range.tag.prefix, range.tag.localName === "t" ? "delText" : "delInstrText");
     edits.push({ start: range.start + 1, end: range.start + 1 + range.tag.name.length, value: replacementName });
     if (!range.tag.isSelfClosing) {
       edits.push({ start: range.closeStart + 2, end: range.closeStart + 2 + range.tag.name.length, value: replacementName });
@@ -224307,15 +225376,9 @@ function adjustCompareEditForTrailingNoteMarker(step2) {
     trimmedTrailingNoteMarkers: trailingMarkers
   };
 }
-function resolveParagraphSliceRange(state, storyId, blockId, startOffset, endOffset) {
-  const index = getStoryParagraphIndexFromState(state, storyId);
-  const entry = index?.byParaId(blockId) ?? null;
-  if (!entry || startOffset < 0 || endOffset < startOffset || endOffset > entry.textLength)
+function sliceParagraphRangeFromOffsetMap(entry, offsetMap, blockId, startOffset, endOffset) {
+  if (startOffset < 0 || endOffset < startOffset || endOffset > entry.textLength)
     return null;
-  const bytes = state.packageBytes.get(entry.partUri);
-  if (!bytes)
-    return null;
-  const offsetMap = buildParagraphOffsetMap(bytes, entry.byteStart, entry.byteEnd);
   const startByte = offsetMap.charToByte(startOffset);
   const endByte = offsetMap.charToByte(endOffset);
   if (startByte == null || endByte == null)
@@ -224336,6 +225399,54 @@ function resolveParagraphSliceRange(state, storyId, blockId, startOffset, endOff
     sourceAddress: { blockId, range: { start: startOffset, end: endOffset } }
   };
 }
+function resolveParagraphSliceRange(state, storyId, blockId, startOffset, endOffset) {
+  const entry = getStoryParagraphIndexFromState(state, storyId)?.byParaId(blockId) ?? null;
+  if (!entry)
+    return null;
+  const bytes = state.packageBytes.get(entry.partUri);
+  if (!bytes)
+    return null;
+  const offsetMap = buildParagraphOffsetMap(bytes, entry.byteStart, entry.byteEnd);
+  return sliceParagraphRangeFromOffsetMap(entry, offsetMap, blockId, startOffset, endOffset);
+}
+function tryLocalizedCompareEditTextOp(state, storyId, blockId, previousText, text, txId) {
+  if (necessarilyExceedsWordDiffRatio(previousText, text, WORD_DIFF_FALLBACK_RATIO))
+    return null;
+  const ops = getWordChanges(previousText, text);
+  if (ops.length === 0)
+    return null;
+  if (shouldFallBackFromWordDiff(ops, previousText.length, text.length))
+    return null;
+  const entry = getStoryParagraphIndexFromState(state, storyId)?.byParaId(blockId) ?? null;
+  if (!entry)
+    return null;
+  const bytes = state.packageBytes.get(entry.partUri);
+  if (!bytes)
+    return null;
+  const offsetMap = buildParagraphOffsetMap(bytes, entry.byteStart, entry.byteEnd);
+  const edits = [];
+  ops.forEach((op, ordinal) => {
+    const start = op.type === "insert" ? op.insertAt : op.oldFrom;
+    const end = op.type === "insert" ? op.insertAt : op.oldTo;
+    const range = sliceParagraphRangeFromOffsetMap(entry, offsetMap, blockId, start, end);
+    if (!range)
+      return;
+    edits.push({ on: range, newText: op.type === "delete" ? "" : op.newText, comparisonHunkGroupId: `${txId}:${blockId}:${ordinal}` });
+  });
+  if (edits.length !== ops.length)
+    return null;
+  const [first, ...rest] = edits;
+  if (!first)
+    return null;
+  return {
+    kind: "editText",
+    changeMode: "tracked",
+    on: first.on,
+    newText: first.newText,
+    rsid: allocateTxRsid(txId),
+    edits: [first, ...rest]
+  };
+}
 function deriveSimpleInlineFormatEdits(baseParagraphXml, targetRunXml) {
   const base2 = scanSimpleRunFormatting(extractCompareParagraphRunXml(baseParagraphXml));
   const target = scanSimpleRunFormatting(targetRunXml);
@@ -226201,7 +227312,7 @@ function committedNoOp2(txId, packageRevision) {
 function rejected14(txId, reason) {
   return { txId, status: "rejected", rejectedReason: reason };
 }
-var EXACT_ROW_UNSAFE_REVISION_LOCAL_NAMES, NOTE_LIFECYCLE_PROVENANCE_NS2 = "urn:superdoc:note-lifecycle", MARKUP_COMPATIBILITY_NS = "http://schemas.openxmlformats.org/markup-compatibility/2006", UNDERSTOOD_NOTE_LIFECYCLE_MCE_NAMESPACES, XML_NCNAME_TOKEN, EXACT_ROW_UNSAFE_W14_REVISION_LOCAL_NAMES, SIGNAL_LANES, TE31, TD59, XML_TD2, DOCUMENT_PART_URI4 = "/word/document.xml", DOCUMENT_RELS_PART_URI6 = "/word/_rels/document.xml.rels", CONTENT_TYPES_PART_URI7 = "/[Content_Types].xml", RELATIONSHIPS_CONTENT_TYPE = "application/vnd.openxmlformats-package.relationships+xml", RELATIONSHIP_BACKED_SAVE_NOISE_PART_URIS, W_NS4 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", REL_FOOTNOTES = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes", REL_ENDNOTES = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/endnotes", CT_FOOTNOTES = "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml", CT_ENDNOTES = "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml", PACKAGE_RELATIONSHIPS_NS2 = "http://schemas.openxmlformats.org/package/2006/relationships", CONTENT_TYPES_NS4 = "http://schemas.openxmlformats.org/package/2006/content-types", DRAWINGML_NS = "http://schemas.openxmlformats.org/drawingml/2006/main", CORE_PROPERTIES_NS = "http://schemas.openxmlformats.org/package/2006/metadata/core-properties", DCTERMS_NS = "http://purl.org/dc/terms/", EXTENDED_PROPERTIES_NS = "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties", IMAGE_RELATIONSHIP_TYPES, HEADER_RELATIONSHIP_TYPES, FOOTER_RELATIONSHIP_TYPES, COMPARE_NOTE_MARKER = "", SIMPLE_INLINE_RUN_PROPERTY_ATTRIBUTES;
+var EXACT_ROW_UNSAFE_REVISION_LOCAL_NAMES, NOTE_LIFECYCLE_PROVENANCE_NS2 = "urn:superdoc:note-lifecycle", MARKUP_COMPATIBILITY_NS = "http://schemas.openxmlformats.org/markup-compatibility/2006", UNDERSTOOD_NOTE_LIFECYCLE_MCE_NAMESPACES, XML_NCNAME_TOKEN, EXACT_ROW_UNSAFE_W14_REVISION_LOCAL_NAMES, SIGNAL_LANES, TE31, TD59, XML_TD2, DOCUMENT_PART_URI4 = "/word/document.xml", DOCUMENT_RELS_PART_URI6 = "/word/_rels/document.xml.rels", CONTENT_TYPES_PART_URI7 = "/[Content_Types].xml", RELATIONSHIPS_CONTENT_TYPE = "application/vnd.openxmlformats-package.relationships+xml", RELATIONSHIP_BACKED_SAVE_NOISE_PART_URIS, W_NS4 = "http://schemas.openxmlformats.org/wordprocessingml/2006/main", REL_FOOTNOTES = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes", REL_ENDNOTES = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/endnotes", CT_FOOTNOTES = "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml", CT_ENDNOTES = "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml", PACKAGE_RELATIONSHIPS_NS2 = "http://schemas.openxmlformats.org/package/2006/relationships", CONTENT_TYPES_NS4 = "http://schemas.openxmlformats.org/package/2006/content-types", DRAWINGML_NS = "http://schemas.openxmlformats.org/drawingml/2006/main", CORE_PROPERTIES_NS = "http://schemas.openxmlformats.org/package/2006/metadata/core-properties", DCTERMS_NS = "http://purl.org/dc/terms/", EXTENDED_PROPERTIES_NS = "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties", IMAGE_RELATIONSHIP_TYPES, HEADER_RELATIONSHIP_TYPES, FOOTER_RELATIONSHIP_TYPES, WORD_DIFF_FALLBACK_RATIO = 0.6, MAX_WORD_DIFF_HUNKS = 1000, DENSE_WORD_DIFF_RATIO = 0.3, COMPARE_NOTE_MARKER = "", SIMPLE_INLINE_RUN_PROPERTY_ATTRIBUTES;
 var init_compile_compare_apply = __esm(() => {
   init_tracked_table_properties();
   init_sd_document_state();
@@ -226209,6 +227320,7 @@ var init_compile_compare_apply = __esm(() => {
   init_src2();
   init_xml_text();
   init_text_offset_mapping();
+  init_comparison_hunk_groups();
   init_commit_prepared_mutation();
   init_apply_patch_group();
   init_compile_format_run_range();
@@ -261400,7 +262512,7 @@ function refConfigSchemas2() {
     failure: refFailureSchema2
   };
 }
-var trackChangeTypeValues2, sourcePathSchema2, diagnosticPathSchema2, conversionSourceRangeSchema2, conversionSourceSchema2, diagnosticProperties2, sdDiagnosticSchema2, sdConversionDiagnosticSchema2, conversionReportSchema2, receiptSuccessMetadataProperties2, nodeTypeValues2, blockNodeTypeValues2, deletableBlockNodeTypeValues2, inlineNodeTypeValues2, knownTargetKindValues2, SHARED_DEFS2, rangeSchema2, positionSchema2, inlineAnchorSchema2, targetKindSchema2, textAddressSchema2, textTargetSchema2, commentTrackedChangeTargetSchema2, textSearchCommentTargetSchema2, blockNodeAddressSchema2, deletableBlockNodeAddressSchema2, tableAddressSchema2, tableRowAddressSchema2, tableCellAddressSchema2, tableOrCellAddressSchema2, paragraphAddressSchema2, headingAddressSchema2, listItemAddressSchema2, listsV2BlockTargetSchema2, paragraphTargetSchema2, sectionAddressSchema2, watermarkSlotTargetSchema2, watermarkTargetSchema2, watermarkAddressSchema2, watermarkHorizontalPlacementSchema2, watermarkVerticalPlacementSchema2, watermarkPlacementSchema2, textWatermarkSchema2, pictureWatermarkInputSchema2, retainedPictureWatermarkInputSchema2, watermarksApplyTargetSchema2, pictureWatermarkInfoSchema2, watermarkInfoSchema2, watermarksApplySuccessSchema2, watermarksApplyFailureSchema2, inlineNodeAddressSchema2, nodeAddressSchema2, commentAddressSchema2, trackedChangeAddressSchema2, entityAddressSchema2, selectionTargetSchema2, commentTrackedChangeLinkSchema2, targetLocatorSchema2, deleteBehaviorSchema2, resolvedHandleSchema2, pageInfoSchema2, receiptSuccessSchema2, commentsCreateSuccessSchema2, textMutationRangeSchema2, textMutationResolutionSchema2, textMutationSuccessSchema2, matchRunSchema2, matchBlockSchema2, storyLocatorSchema2, bodyStoryLocatorSchema2, markRunColorRefSchema2, markRunFontsSchema2, markRunLanguagesSchema2, markRunUnderlineSchema2, markRunShadingSchema2, markRunBorderSchema2, markRunPropsSchema2, trackChangeRefSchema2, createParagraphSuccessSchema2, createHeadingSuccessSchema2, createHeadingLevelSchema2, semanticHeadingLevelSchema2, listsInsertSuccessSchema2, listsMutateItemSuccessSchema2, listsExitSuccessSchema2, nodeSummarySchema2, nodeInfoSchema2, matchContextSchema2, unknownNodeDiagnosticSchema2, textSelectorSchema2, planTextSelectorSchema2, nodeSelectorSchema2, selectorShorthandSchema2, sdTextSelectorSchema2, sdNodeSelectorSchema2, sdSelectorSchema2, sdReadOptionsSchema2, sdFindInputSchema2, sdNodeResultSchema2, sdFindResultSchema2, sdMutationResolutionSchema2, evaluatedRevisionSchema2, sdMutationSuccessSchema2, documentInfoCountsSchema2, documentInfoOutlineItemSchema2, documentInfoCapabilitiesSchema2, documentStyleInfoSchema2, documentStylesSchema2, documentDefaultsSchema2, documentInfoSchema2, listKindSchema2, listInsertPositionSchema2, listItemInfoSchema2, listItemDomainItemSchema2, listsListResultSchema2, sectionBreakTypeSchema2, sectionOrientationSchema2, sectionVerticalAlignSchema2, sectionDirectionSchema2, sectionHeaderFooterKindSchema2, sectionHeaderFooterVariantSchema2, sectionLineNumberRestartSchema2, sectionPageNumberFormatSchema2, sectionRangeDomainSchema2, sectionPageMarginsSchema2, sectionHeaderFooterMarginsSchema2, sectionPageSetupSchema2, sectionColumnsSchema2, sectionLineNumberingSchema2, sectionPageNumberingSchema2, sectionHeaderFooterRefsSchema2, sectionBorderSpecSchema2, sectionPageBordersSchema2, sectionInfoSchema2, sectionResolvedHandleSchema2, sectionDomainItemSchema2, sectionsListResultSchema2, sectionMutationSuccessSchema2, documentMutationSuccessSchema2, paragraphMutationTargetSchema2, paragraphMutationSuccessSchema2, createSectionBreakSuccessSchema2, commentMetadataSchema2, commentInfoSchema2, commentDomainItemSchema2, commentsListResultSchema2, trackChangeWordRevisionIdsSchema2, trackChangeSourceIdsSchema2, trackChangeBroadTypeEnum2, trackChangeGroupingEnum2, trackChangeCanonicalizationKindEnum2, trackChangeAddressKindEnum2, trackChangeSourcePlatformEnum2, trackChangeReplacementSideSchema2, trackChangeReplacementSchema2, trackChangeOverlapRelationshipSchema2, trackChangeOverlapLayerSchema2, trackChangeOverlapInfoSchema2, trackChangeFormattingSnapshotSchema2, trackChangeListDeltaKindEnum2, trackChangeListDeltaSideSchema2, trackChangeListMemberDeltaSchema2, trackChangeListDeltaSummarySchema2, trackChangeTargetSchema2, trackChangeSnapshotSchema2, trackChangeCustomAttributeSchema2, trackChangeRewriteReviewGroupSchema2, trackChangeInfoSchema2, trackChangeDomainItemSchema2, trackChangesListResultSchema2, reviewDecideRangeTargetOptions2, historyActionCollaborationSchema2, capabilityReasonCodeSchema2, capabilityReasonsSchema2, capabilitySupportDecisionSchema2, capabilityFlagSchema2, operationRuntimeCapabilitySchema2, operationCapabilitiesSchema2, inlinePropertyCapabilitySchema2, inlinePropertyCapabilitiesByKeySchema2, formatCapabilitiesSchema2, planEngineCapabilitiesSchema2, capabilitiesOutputSchema2, strictEmptyObjectSchema2, tableBorderColorPattern2, tableBorderSpecSchema2, nullableTableBorderSpecSchema2, sdFragmentSchema2, conversionFragmentSchema2, placementSchema2, nestingPolicySchema2, insertInputSchema2, supportCheckRichInsertInputSchema2, supportCheckRichReplaceInputSchema2, supportCheckProjectionInputSchema2, supportCheckInputSchema2, supportCheckFailureSchema2, supportCheckGuardSchema2, supportCheckCommonProperties2, supportCheckOutputSchema2, tableLocatorSchema2, cellLocatorSchema2, cellOrTableScopedCellLocatorSchema2, tableOrCellLocatorSchema2, mergeRangeLocatorSchema2, tableAnchorLocationMembers2, tableAnchorLocationSchema2, tableCreateLocationSchema2, tableMutationSuccessSchema2, createTableSuccessSchema2, tableMutationFailureCodes2, tableMutationFailureSchema2, tableMutationResultSchema2, createTableResultSchema2, historyActionSuccessSchema2, historyActionFailureSchema2, formatInlineAliasOperationSchemas2, tocMutationFailureCodes2, tocMutationFailureSchema2, tocMutationSuccessSchema2, tocEntryMutationFailureCodes2, tocEntryMutationFailureSchema2, tocEntryMutationSuccessSchema2, hyperlinkTargetSchema2, hyperlinkReadPropertiesSchema2, hyperlinkDestinationSchema2, hyperlinkSpecSchema2, hyperlinkPatchSchema2, hyperlinkDomainSchema2, hyperlinkMutationSuccessSchema2, hyperlinkMutationFailureCodes2, hyperlinkMutationFailureSchema2, hyperlinkInfoSchema2, contentControlTargetSchema2, contentControlMoveDestinationSchema2, contentControlMutationSuccessSchema2, contentControlMutationFailureSchema2, ccInfoSchema2, ccListResultSchema2, refListQueryProperties2, refListQuerySchema2, discoveryOutputSchema2, receiptFailureSchema2, refFailureSchema2, bookmarkAddressSchema2, bookmarkMutation2, customXmlPartTargetSchema2, customXmlPartMutation2, customXmlPartCreateMutation2, anchoredMetadataAttachMutation2, anchoredMetadataMutation2, footnoteAddressSchema2, footnoteConfigScopeSchema2, footnoteNumberingSchema2, footnoteMutation2, footnoteConfig2, crossRefAddressSchema2, crossRefTargetSchema2, crossRefDisplaySchema2, crossRefMutation2, indexAddressSchema2, indexEntryAddressSchema2, indexConfigSchema2, indexEntryDataSchema2, indexEntryPatchSchema2, indexMutation2, indexEntryMutation2, captionAddressSchema2, captionMutation2, captionConfig2, fieldAddressSchema2, fieldMutation2, citationAddressSchema2, citationSourceAddressSchema2, bibliographyAddressSchema2, citationMutation2, citationSourceMutation2, bibliographyMutation2, citationPersonSchema2, citationSourceFieldsSchema2, tocCreateLocationSchema2, authoritiesAddressSchema2, authorityEntryAddressSchema2, authoritiesConfigSchema2, authorityEntryDataSchema2, authorityEntryPatchSchema2, authoritiesMutation2, authorityEntryMutation2, diffCoverageSchema2, diffSummarySchema2, diffSnapshotSchema2, diffApplyEligibilityBlockerSchema2, diffApplyModeEligibilitySchema2, diffApplyEligibilitySchema2, diffPayloadSchema2, diffApplyResultSchema2, operationSchemas2;
+var trackChangeTypeValues2, sourcePathSchema2, diagnosticPathSchema2, conversionSourceRangeSchema2, conversionSourceSchema2, diagnosticProperties2, sdDiagnosticSchema2, sdConversionDiagnosticSchema2, conversionReportSchema2, receiptSuccessMetadataProperties2, nodeTypeValues2, blockNodeTypeValues2, deletableBlockNodeTypeValues2, inlineNodeTypeValues2, knownTargetKindValues2, SHARED_DEFS2, rangeSchema2, positionSchema2, inlineAnchorSchema2, targetKindSchema2, textAddressSchema2, textTargetSchema2, commentTrackedChangeTargetSchema2, textSearchCommentTargetSchema2, blockNodeAddressSchema2, deletableBlockNodeAddressSchema2, tableAddressSchema2, tableRowAddressSchema2, tableCellAddressSchema2, tableOrCellAddressSchema2, paragraphAddressSchema2, headingAddressSchema2, listItemAddressSchema2, listsV2BlockTargetSchema2, paragraphTargetSchema2, sectionAddressSchema2, watermarkSlotTargetSchema2, watermarkTargetSchema2, watermarkAddressSchema2, watermarkHorizontalPlacementSchema2, watermarkVerticalPlacementSchema2, watermarkPlacementSchema2, textWatermarkSchema2, pictureWatermarkInputSchema2, retainedPictureWatermarkInputSchema2, watermarksApplyTargetSchema2, pictureWatermarkInfoSchema2, watermarkInfoSchema2, watermarksApplySuccessSchema2, watermarksApplyFailureSchema2, inlineNodeAddressSchema2, nodeAddressSchema2, commentAddressSchema2, trackedChangeAddressSchema2, entityAddressSchema2, selectionTargetSchema2, commentTrackedChangeLinkSchema2, targetLocatorSchema2, deleteBehaviorSchema2, resolvedHandleSchema2, pageInfoSchema2, receiptSuccessSchema2, commentsCreateSuccessSchema2, textMutationRangeSchema2, textMutationResolutionSchema2, textMutationSuccessSchema2, matchRunSchema2, matchBlockSchema2, storyLocatorSchema2, bodyStoryLocatorSchema2, markRunColorRefSchema2, markRunFontsSchema2, markRunLanguagesSchema2, markRunUnderlineSchema2, markRunShadingSchema2, markRunBorderSchema2, markRunPropsSchema2, trackChangeRefSchema2, createParagraphSuccessSchema2, createHeadingSuccessSchema2, createHeadingLevelSchema2, semanticHeadingLevelSchema2, listsInsertSuccessSchema2, listsMutateItemSuccessSchema2, listsExitSuccessSchema2, nodeSummarySchema2, nodeInfoSchema2, matchContextSchema2, unknownNodeDiagnosticSchema2, textSelectorSchema2, planTextSelectorSchema2, nodeSelectorSchema2, selectorShorthandSchema2, sdTextSelectorSchema2, sdNodeSelectorSchema2, sdSelectorSchema2, sdReadOptionsSchema2, sdFindInputSchema2, sdNodeResultSchema2, sdFindResultSchema2, sdMutationResolutionSchema2, evaluatedRevisionSchema2, sdMutationSuccessSchema2, documentInfoCountsSchema2, documentInfoOutlineItemSchema2, documentInfoCapabilitiesSchema2, documentStyleInfoSchema2, documentStylesSchema2, documentDefaultsSchema2, documentInfoSchema2, listKindSchema2, listInsertPositionSchema2, listItemInfoSchema2, listItemDomainItemSchema2, listsListResultSchema2, sectionBreakTypeSchema2, sectionOrientationSchema2, sectionVerticalAlignSchema2, sectionDirectionSchema2, sectionHeaderFooterKindSchema2, sectionHeaderFooterVariantSchema2, sectionLineNumberRestartSchema2, sectionPageNumberFormatSchema2, sectionRangeDomainSchema2, sectionPageMarginsSchema2, sectionHeaderFooterMarginsSchema2, sectionPageSetupSchema2, sectionColumnsSchema2, sectionLineNumberingSchema2, sectionPageNumberingSchema2, sectionHeaderFooterRefsSchema2, sectionBorderSpecSchema2, sectionPageBordersSchema2, sectionInfoSchema2, sectionResolvedHandleSchema2, sectionDomainItemSchema2, sectionsListResultSchema2, sectionMutationSuccessSchema2, documentMutationSuccessSchema2, paragraphMutationTargetSchema2, paragraphMutationSuccessSchema2, createSectionBreakSuccessSchema2, commentMetadataSchema2, commentInfoSchema2, commentDomainItemSchema2, commentsListResultSchema2, trackChangeWordRevisionIdsSchema2, trackChangeSourceIdsSchema2, trackChangeBroadTypeEnum2, trackChangeGroupingEnum2, trackChangeCanonicalizationKindEnum2, trackChangeAddressKindEnum2, trackChangeSourcePlatformEnum2, trackChangeReplacementSideSchema2, trackChangeReplacementSchema2, trackChangeOverlapRelationshipSchema2, trackChangeOverlapLayerSchema2, trackChangeOverlapInfoSchema2, trackChangeFormattingSnapshotSchema2, trackChangeListDeltaKindEnum2, trackChangeListDeltaSideSchema2, trackChangeListMemberDeltaSchema2, trackChangeListDeltaSummarySchema2, trackChangeTargetSchema2, trackChangeSnapshotSchema2, trackChangeCustomAttributeSchema2, trackChangeRewriteReviewGroupSchema2, trackChangeComparisonHunkReviewGroupSchema2, trackChangeReviewGroupSchema2, trackChangeInfoSchema2, trackChangeDomainItemSchema2, trackChangesListResultSchema2, reviewDecideRangeTargetOptions2, historyActionCollaborationSchema2, capabilityReasonCodeSchema2, capabilityReasonsSchema2, capabilitySupportDecisionSchema2, capabilityFlagSchema2, operationRuntimeCapabilitySchema2, operationCapabilitiesSchema2, inlinePropertyCapabilitySchema2, inlinePropertyCapabilitiesByKeySchema2, formatCapabilitiesSchema2, planEngineCapabilitiesSchema2, capabilitiesOutputSchema2, strictEmptyObjectSchema2, tableBorderColorPattern2, tableBorderSpecSchema2, nullableTableBorderSpecSchema2, sdFragmentSchema2, conversionFragmentSchema2, placementSchema2, nestingPolicySchema2, insertInputSchema2, supportCheckRichInsertInputSchema2, supportCheckRichReplaceInputSchema2, supportCheckProjectionInputSchema2, supportCheckInputSchema2, supportCheckFailureSchema2, supportCheckGuardSchema2, supportCheckCommonProperties2, supportCheckOutputSchema2, tableLocatorSchema2, cellLocatorSchema2, cellOrTableScopedCellLocatorSchema2, tableOrCellLocatorSchema2, mergeRangeLocatorSchema2, tableAnchorLocationMembers2, tableAnchorLocationSchema2, tableCreateLocationSchema2, tableMutationSuccessSchema2, createTableSuccessSchema2, tableMutationFailureCodes2, tableMutationFailureSchema2, tableMutationResultSchema2, createTableResultSchema2, historyActionSuccessSchema2, historyActionFailureSchema2, formatInlineAliasOperationSchemas2, tocMutationFailureCodes2, tocMutationFailureSchema2, tocMutationSuccessSchema2, tocEntryMutationFailureCodes2, tocEntryMutationFailureSchema2, tocEntryMutationSuccessSchema2, hyperlinkTargetSchema2, hyperlinkReadPropertiesSchema2, hyperlinkDestinationSchema2, hyperlinkSpecSchema2, hyperlinkPatchSchema2, hyperlinkDomainSchema2, hyperlinkMutationSuccessSchema2, hyperlinkMutationFailureCodes2, hyperlinkMutationFailureSchema2, hyperlinkInfoSchema2, contentControlTargetSchema2, contentControlMoveDestinationSchema2, contentControlMutationSuccessSchema2, contentControlMutationFailureSchema2, ccInfoSchema2, ccListResultSchema2, refListQueryProperties2, refListQuerySchema2, discoveryOutputSchema2, receiptFailureSchema2, refFailureSchema2, bookmarkAddressSchema2, bookmarkMutation2, customXmlPartTargetSchema2, customXmlPartMutation2, customXmlPartCreateMutation2, anchoredMetadataAttachMutation2, anchoredMetadataMutation2, footnoteAddressSchema2, footnoteConfigScopeSchema2, footnoteNumberingSchema2, footnoteMutation2, footnoteConfig2, crossRefAddressSchema2, crossRefTargetSchema2, crossRefDisplaySchema2, crossRefMutation2, indexAddressSchema2, indexEntryAddressSchema2, indexConfigSchema2, indexEntryDataSchema2, indexEntryPatchSchema2, indexMutation2, indexEntryMutation2, captionAddressSchema2, captionMutation2, captionConfig2, fieldAddressSchema2, fieldMutation2, citationAddressSchema2, citationSourceAddressSchema2, bibliographyAddressSchema2, citationMutation2, citationSourceMutation2, bibliographyMutation2, citationPersonSchema2, citationSourceFieldsSchema2, tocCreateLocationSchema2, authoritiesAddressSchema2, authorityEntryAddressSchema2, authoritiesConfigSchema2, authorityEntryDataSchema2, authorityEntryPatchSchema2, authoritiesMutation2, authorityEntryMutation2, diffCoverageSchema2, diffSummarySchema2, diffSnapshotSchema2, diffApplyEligibilityBlockerSchema2, diffApplyModeEligibilitySchema2, diffApplyEligibilitySchema2, diffPayloadSchema2, diffApplyResultSchema2, operationSchemas2;
 var init_schemas5 = __esm(() => {
   init_command_catalog2();
   init_types8();
@@ -262946,6 +264058,23 @@ var init_schemas5 = __esm(() => {
   }, ["name", "namespaceUri", "localName", "value"]);
   trackChangeRewriteReviewGroupSchema2 = objectSchema4({
     kind: { const: "text-rewrite" },
+    groupOrigin: { const: "authored-operation" },
+    role: { enum: ["parent", "child"] },
+    parentId: { type: "string" },
+    childChangeIds: { type: "array", items: { type: "string" } },
+    members: {
+      type: "array",
+      items: objectSchema4({
+        id: { type: "string" },
+        type: { enum: [...trackChangeBroadTypeEnum2] },
+        subtype: { type: "string" },
+        sourceIds: trackChangeSourceIdsSchema2
+      }, ["id", "type", "subtype", "sourceIds"])
+    }
+  }, ["kind", "groupOrigin", "role", "childChangeIds", "members"]);
+  trackChangeComparisonHunkReviewGroupSchema2 = objectSchema4({
+    kind: { const: "comparison-hunk" },
+    groupOrigin: { const: "comparison-hunk" },
     role: { enum: ["parent", "child"] },
     parentId: { type: "string" },
     childChangeIds: { type: "array", items: { type: "string" } },
@@ -262958,7 +264087,10 @@ var init_schemas5 = __esm(() => {
         sourceIds: trackChangeSourceIdsSchema2
       }, ["id", "type", "subtype", "sourceIds"])
     }
-  }, ["kind", "role", "childChangeIds", "members"]);
+  }, ["kind", "groupOrigin", "role", "childChangeIds", "members"]);
+  trackChangeReviewGroupSchema2 = {
+    oneOf: [trackChangeRewriteReviewGroupSchema2, trackChangeComparisonHunkReviewGroupSchema2]
+  };
   trackChangeInfoSchema2 = objectSchema4({
     address: trackedChangeAddressSchema2,
     id: { type: "string" },
@@ -262971,7 +264103,7 @@ var init_schemas5 = __esm(() => {
     sourceIds: trackChangeSourceIdsSchema2,
     wordRevisionIds: trackChangeWordRevisionIdsSchema2,
     revisionGroupId: { type: "string" },
-    reviewGroup: trackChangeRewriteReviewGroupSchema2,
+    reviewGroup: trackChangeReviewGroupSchema2,
     splitFromId: { oneOf: [{ type: "string" }, { type: "null" }] },
     replacement: trackChangeReplacementSchema2,
     author: { type: "string" },
@@ -263022,7 +264154,7 @@ var init_schemas5 = __esm(() => {
     sourceIds: trackChangeSourceIdsSchema2,
     wordRevisionIds: trackChangeWordRevisionIdsSchema2,
     revisionGroupId: { type: "string" },
-    reviewGroup: trackChangeRewriteReviewGroupSchema2,
+    reviewGroup: trackChangeReviewGroupSchema2,
     author: { type: "string" },
     authorEmail: { type: "string" },
     authorImage: { type: "string" },
@@ -289719,6 +290851,7 @@ function normalizeTarget(target) {
 // ../../../v2/editor-core/dist/review-read-model.js
 var init_review_read_model = __esm(() => {
   init_rewrite_groups();
+  init_comparison_hunk_groups();
 });
 
 // ../../../v2/document-api-v2-adapter/dist/interaction-trace.js
@@ -358901,8 +360034,9 @@ class V2TrackedChangesAdapter {
         continue;
       }
       if (entry.reviewGroup?.role === "parent") {
-        if (entry.reviewGroup.kind === "text-rewrite")
+        if (entry.reviewGroup.kind === "text-rewrite" || entry.reviewGroup.kind === "comparison-hunk") {
           cascadeChildRefs.push({ kind: "trackedChange", entityId: entry.id, storyId: entry.storyId });
+        }
         for (const fragment3 of entry.structuralFragments) {
           if (seenStructuralKeys.has(fragment3.entityKey))
             continue;
@@ -359169,7 +360303,7 @@ class V2TrackedChangesAdapter {
           continue;
         const id = logical.rsidToLogicalId.get(ref5.entityId) ?? ref5.entityId;
         const group = logical.byId.get(id)?.reviewGroup;
-        if (group?.kind === "text-rewrite")
+        if (group?.kind === "text-rewrite" || group?.kind === "comparison-hunk")
           touchedGroups.add(group.parentId ?? id);
       }
       const survivingGroups = [...touchedGroups].filter((id) => getPostLogical().byId.has(id));
@@ -359207,7 +360341,7 @@ class V2TrackedChangesAdapter {
     if (!entry) {
       return failure17("TARGET_NOT_FOUND", `No tracked change with id "${target.range.anchor}".`);
     }
-    if (entry.reviewGroup && !(entry.reviewGroup.kind === "text-rewrite" && entry.reviewGroup.role === "child")) {
+    if (entry.reviewGroup && !((entry.reviewGroup.kind === "text-rewrite" || entry.reviewGroup.kind === "comparison-hunk") && entry.reviewGroup.role === "child")) {
       return failure17("INVALID_INPUT", `trackChanges.decide range: tracked change "${entry.id}" is part of a grouped Word revision; ` + "decide it atomically by id.");
     }
     if (entry.type === "structural" || entry.type === "move") {
@@ -359374,7 +360508,7 @@ class V2TrackedChangesAdapter {
       if (!overlap.logical) {
         return failure17("INTERNAL_ERROR", `trackChanges.decide range: overlapped fragment "${overlap.fragment.rsid}" was not mapped to a logical tracked change.`);
       }
-      if (overlap.logical.reviewGroup && overlap.logical.reviewGroup.kind !== "text-rewrite") {
+      if (overlap.logical.reviewGroup && overlap.logical.reviewGroup.kind !== "text-rewrite" && overlap.logical.reviewGroup.kind !== "comparison-hunk") {
         return failure17("INVALID_INPUT", `trackChanges.decide range: tracked change "${overlap.logical.id}" is part of a grouped multi-paragraph ` + "insertion; decide it atomically by id.");
       }
     }
@@ -359539,7 +360673,7 @@ function isTextCoordinateSpace(value2) {
   return value2 === undefined || value2 === "visible" || value2 === "tracked";
 }
 function selectFragmentForLogicalRange(entry, side) {
-  if (entry.reviewGroup?.kind === "text-rewrite" && entry.reviewGroup.role === "parent") {
+  if (entry.reviewGroup?.role === "parent" && (entry.reviewGroup.kind === "text-rewrite" || entry.reviewGroup.kind === "comparison-hunk")) {
     const kind = side === "delete" || side === "deleted" || side === "source" ? "del" : "ins";
     return entry.fragments.find((fragment3) => fragment3.kind === kind) ?? entry.fragments[0] ?? null;
   }
@@ -359886,7 +361020,7 @@ function isVisibleLogicalChange(entry) {
   return isVisibleLogicalTrackedChange(entry);
 }
 function resolveSubsumedLogicalChange(logical, entry) {
-  if (entry.reviewGroup?.kind === "text-rewrite")
+  if (entry.reviewGroup?.kind === "text-rewrite" || entry.reviewGroup?.kind === "comparison-hunk")
     return entry;
   if (entry.reviewGroup?.role === "child" && entry.reviewGroup.parentId) {
     return logical.byId.get(entry.reviewGroup.parentId) ?? entry;
@@ -359931,6 +361065,7 @@ function buildDiscoveryItem2(entry, context, logical, linkedCommentIds, resolveS
     ...structuralDescriptor ? { structuralDescriptor } : {},
     revisionGroupId: entry.revisionGroupId,
     ...entry.reviewGroup?.kind === "text-rewrite" && logical ? { reviewGroup: projectTextRewriteReviewGroup(entry, logical) } : {},
+    ...entry.reviewGroup?.kind === "comparison-hunk" && logical ? { reviewGroup: projectComparisonHunkReviewGroup(entry, logical) } : {},
     splitFromId: entry.splitFromId,
     sourceIds: projectSourceIds(entry),
     wordRevisionIds: projectWordRevisionIdsAlias(entry),
@@ -360068,6 +361203,7 @@ function buildInfo(entry, context, logical, linkedCommentIds, resolveSession) {
     wordRevisionIds: projectWordRevisionIdsAlias(entry),
     revisionGroupId: entry.revisionGroupId,
     ...entry.reviewGroup?.kind === "text-rewrite" && logical ? { reviewGroup: projectTextRewriteReviewGroup(entry, logical) } : {},
+    ...entry.reviewGroup?.kind === "comparison-hunk" && logical ? { reviewGroup: projectComparisonHunkReviewGroup(entry, logical) } : {},
     splitFromId: entry.splitFromId,
     ...structuralDescriptor ? { structuralDescriptor } : {},
     ...replacement ? { replacement } : {},
@@ -360175,8 +361311,9 @@ function isGoogleDocsLikePackage(session) {
   return getSDDocumentSessionInternalPartBytes(session, "/docProps/app.xml") == null && getSDDocumentSessionInternalPartBytes(session, "/docProps/core.xml") == null && getSDDocumentSessionInternalPartBytes(session, "/docProps/custom.xml") == null && getSDDocumentSessionInternalPartBytes(session, "/word/settings.xml") != null;
 }
 function projectGrouping(entry) {
-  if (entry.reviewGroup && !(entry.reviewGroup.kind === "text-rewrite" && entry.reviewGroup.role === "child"))
+  if (entry.reviewGroup && !((entry.reviewGroup.kind === "text-rewrite" || entry.reviewGroup.kind === "comparison-hunk") && entry.reviewGroup.role === "child")) {
     return "unknown";
+  }
   return entry.type === "replacement" || entry.sides ? "replacement-pair" : "standalone";
 }
 function projectInsertedText(entry, logical) {
@@ -364685,6 +365822,23 @@ var init_relationship_backed_body_replay = __esm(() => {
 });
 
 // ../../../v2/document-api-v2-adapter/dist/diff/sections-references-replay.js
+function hasUntrackableFieldReplayStep(steps) {
+  return steps.some((step3) => (step3.kind === "field-topology" || step3.kind === "complex-field") && (!step3.beforeFragmentXml || !step3.afterFragmentXml || !isRunOnlyFieldFragment(step3.beforeFragmentXml, step3.beforeNamespaceBindings) || !isRunOnlyFieldFragment(step3.afterFragmentXml, step3.afterNamespaceBindings)));
+}
+function isRunOnlyFieldFragment(xml, namespaceBindings) {
+  const parsed = collectXmlElementRanges(xml, { fragment: true, additionalNamespaces: namespaceBindings });
+  if (parsed.errors.length > 0)
+    return false;
+  let end = 0;
+  for (const range of parsed.ranges.sort((a, b) => a.start - b.start || b.end - a.end)) {
+    if (range.start < end)
+      continue;
+    if (range.start !== end || range.tag.namespaceUri !== WORDPROCESSINGML_NS6 || range.tag.localName !== "r")
+      return false;
+    end = range.end;
+  }
+  return end === xml.length;
+}
 function buildSectionsReferencesReplayPlan(base3, target) {
   const unsafeReasons = [];
   const sectionSteps = buildSectionSteps(base3.xml, target.xml, unsafeReasons);
@@ -364886,7 +366040,10 @@ function buildReferenceSteps(baseXml, targetXml, unsafeReasons) {
   const baseFields = collectWordElements(baseXml, "fldSimple");
   const targetFields = collectWordElements(targetXml, "fldSimple");
   if (baseFields.length !== targetFields.length) {
-    unsafeReasons.push("simple-field topology changed");
+    const topologySteps = buildFieldTopologySteps(baseXml, targetXml, unsafeReasons);
+    if (topologySteps.length === 0)
+      unsafeReasons.push("simple-field topology changed");
+    steps.push(...topologySteps);
     return steps;
   }
   for (let index2 = 0;index2 < baseFields.length; index2 += 1) {
@@ -364913,8 +366070,87 @@ function buildReferenceSteps(baseXml, targetXml, unsafeReasons) {
     });
   }
   steps.push(...buildAddedComplexFieldSteps(baseXml, targetXml, unsafeReasons));
+  steps.push(...buildFieldTopologySteps(baseXml, targetXml, unsafeReasons).filter((candidate2) => !steps.some((step3) => step3.beforeXml === candidate2.beforeXml)));
+  return steps;
+}
+function buildFieldTopologySteps(baseXml, targetXml, unsafeReasons) {
+  const baseParagraphs = collectWordElements(baseXml, "p");
+  const targetParagraphs = collectWordElements(targetXml, "p");
+  if (baseParagraphs.length !== targetParagraphs.length)
+    return [];
+  const steps = [];
+  for (let index2 = 0;index2 < baseParagraphs.length; index2 += 1) {
+    const before = baseParagraphs[index2];
+    const after = targetParagraphs[index2];
+    if (before.xml === after.xml)
+      continue;
+    const simple = simpleFieldTopologyFragment(before, after) ?? simpleFieldTopologyFragment(after, before);
+    const complex = addedComplexRefField(before, after.xml) ?? addedComplexRefField(after, before.xml);
+    const candidate2 = simple ? { fieldXml: simple.fieldXml, resultXml: simple.resultXml } : complex;
+    if (!candidate2)
+      continue;
+    const addition = after.xml.includes(candidate2.fieldXml);
+    const beforeFragmentXml = addition ? candidate2.resultXml : candidate2.fieldXml;
+    const afterFragmentXml = addition ? candidate2.fieldXml : candidate2.resultXml;
+    if (replaceUnique(before.xml, beforeFragmentXml, afterFragmentXml) !== after.xml)
+      continue;
+    const name = simple ? parseRefInstruction(simple.instruction)?.name : complex?.referenceName;
+    const source = addition ? targetXml : baseXml;
+    const matchingBookmarks = collectWordElements(source, "bookmarkStart", true).filter((bookmark) => readAttribute2(bookmark, "name") === name);
+    if (!name || matchingBookmarks.length !== 1) {
+      unsafeReasons.push(`field topology ${index2} has a missing or ambiguous REF target`);
+      continue;
+    }
+    steps.push({
+      kind: "field-topology",
+      beforeXml: before.xml,
+      afterXml: after.xml,
+      beforeFragmentXml,
+      afterFragmentXml,
+      beforeNamespaceBindings: { ...before.range.namespaceBindings },
+      afterNamespaceBindings: { ...after.range.namespaceBindings }
+    });
+  }
   return steps;
 }
+function simpleFieldTopologyFragment(fieldParagraph, resultParagraph) {
+  const fields = collectWordElements(fieldParagraph.xml, "fldSimple", false, fieldParagraph.range.namespaceBindings);
+  if (fields.length !== 1 || collectWordElements(fieldParagraph.xml, "fldChar", true, fieldParagraph.range.namespaceBindings).length > 0)
+    return null;
+  const field = fields[0];
+  const instruction = readAttribute2(field, "instr");
+  if (!instruction || !parseRefInstruction(instruction))
+    return null;
+  const resultXml = fieldParagraph.xml.slice(field.range.openEnd, field.range.closeStart);
+  if (!resultXml || replaceUnique(fieldParagraph.xml, field.xml, resultXml) !== resultParagraph.xml)
+    return null;
+  const parsed = collectXmlElementRanges(field.xml, {
+    fragment: true,
+    additionalNamespaces: { ...fieldParagraph.range.namespaceBindings }
+  });
+  const disallowed = new Set([
+    "fldSimple",
+    "fldChar",
+    "hyperlink",
+    "drawing",
+    "object",
+    "pict",
+    "sdt",
+    "customXml",
+    "ins",
+    "del",
+    "footnoteReference",
+    "endnoteReference",
+    "commentReference",
+    "bookmarkStart",
+    "bookmarkEnd"
+  ]);
+  if (parsed.errors.length > 0 || parsed.ranges.some((range) => range.start > 0 && (range.tag.namespaceUri !== WORDPROCESSINGML_NS6 || disallowed.has(range.tag.localName))))
+    return null;
+  if (collectWordElements(resultXml, "r", false, fieldParagraph.range.namespaceBindings).length === 0)
+    return null;
+  return { fieldXml: field.xml, resultXml, instruction };
+}
 function buildChangedBookmarkSteps(baseXml, targetXml, baseBookmarks, targetBookmarks, unsafeReasons) {
   const baseByName = bookmarkStartsByName(baseBookmarks);
   const targetByName = bookmarkStartsByName(targetBookmarks);
@@ -365751,6 +366987,9 @@ class V2DiffAdapter {
         unsupportedReason: "section-reference-replay-unsafe"
       });
     }
+    if (reviewMarkup && hasUntrackableFieldReplayStep(sectionsReferencesPlan.referenceSteps)) {
+      throw diffValidationError("CAPABILITY_UNSUPPORTED", "diff.apply: tracked field replay requires run-only fragments for a schema-valid review and exact target representation. No mutation was performed.", { changedFamilies: ["fields-references"], unsupportedReason: "section-reference-replay-unsafe" });
+    }
     const usesLocalizedMainDocumentReplay = sectionsReferencesChanged && (sectionsReferencesPlan.sectionSteps.length > 0 || sectionsReferencesPlan.referenceSteps.length > 0);
     const localizedBodyOperations = usesLocalizedMainDocumentReplay ? buildLocalizedBodyOperations(payload.base.body, payload.target.body, sectionsReferencesPlan.sectionSteps, sectionsReferencesPlan.referenceSteps, { base: payload.base.definitions, target: payload.target.definitions }, canonicalBodyOperations) : [];
     if (usesLocalizedMainDocumentReplay) {
@@ -366243,6 +367482,13 @@ function buildCompareApplyEligibility(context, payload, plans) {
   }
   const sectionReferenceFamilies = payload.familyPolicy.filter((policy) => policy.applyRequired && (policy.family === "sections" || policy.family === "fields-references")).map((policy) => policy.family);
   addPlanHazards(hazards, plans.sectionsReferencesPlan.unsafeReasons, "section-reference-replay-unsafe", sectionReferenceFamilies, "Section/reference replay");
+  if (hasUntrackableFieldReplayStep(plans.sectionsReferencesPlan.referenceSteps)) {
+    hazards.tracked.push({
+      code: "section-reference-replay-unsafe",
+      message: "Tracked field replay requires run-only fragments for a schema-valid review and exact target representation.",
+      families: ["fields-references"]
+    });
+  }
   addPlanHazards(hazards, plans.physicalPlan.unsafeReasons, "header-footer-physical-lifecycle-unsafe", ["header-footer-parts"], "Header/footer physical lifecycle");
   const headerFooterSlotsChanged = payload.familyPolicy.some((policy) => policy.family === "header-footer-slots" && policy.applyRequired);
   if (plans.physicalPlan.hasTopologyChanges || headerFooterSlotsChanged) {
@@ -366895,7 +368141,7 @@ function reverseReferenceAttribute(xml, step3) {
     const afterInner = step3.afterXml.slice(afterParagraph.openEnd, afterParagraph.closeStart);
     return stripReplayNamespaceDeclarations(xml) === stripReplayNamespaceDeclarations(afterInner) ? beforeInner : xml;
   }
-  if (step3.kind === "bookmark-range" || step3.kind === "complex-field") {
+  if (step3.kind === "bookmark-range" || step3.kind === "complex-field" || step3.kind === "field-topology") {
     if (step3.beforeFragmentXml === undefined || step3.afterFragmentXml === undefined)
       return xml;
     const normalizedXml = stripReplayNamespaceDeclarations(xml);
@@ -367202,7 +368448,7 @@ function findUniqueReplayCarrier(xml, step3) {
     const start = xml.indexOf(marker);
     return start >= 0 && xml.indexOf(marker, start + marker.length) < 0 ? { start, end: start + marker.length } : null;
   }
-  if (step3.kind === "bookmark-range" || step3.kind === "complex-field") {
+  if (step3.kind === "bookmark-range" || step3.kind === "complex-field" || step3.kind === "field-topology") {
     const fragment3 = step3.afterFragmentXml;
     if (!fragment3)
       return null;