@extend-ai/react-docx 0.7.5 → 0.8.0

package/dist/index.cjs

@@ -821,6 +821,102 @@ var init_types = __esm({
   }
 });
 
+// ../doc-model/src/block-id.ts
+function allocateBlockId() {
+  const value = nextBlockIdValue;
+  nextBlockIdValue += 1;
+  return `b${value}`;
+}
+function ensureNodeBlockIds(node) {
+  if (!node.blockId) {
+    node.blockId = allocateBlockId();
+  }
+  if (node.type !== "table") {
+    return;
+  }
+  for (const row of node.rows) {
+    for (const cell of row.cells) {
+      for (const child of cell.nodes) {
+        ensureNodeBlockIds(child);
+      }
+    }
+  }
+}
+function ensureDocModelBlockIds(model) {
+  model.nodes.forEach(ensureNodeBlockIds);
+  for (const section of model.metadata.headerSections ?? []) {
+    section.nodes.forEach(ensureNodeBlockIds);
+  }
+  for (const section of model.metadata.footerSections ?? []) {
+    section.nodes.forEach(ensureNodeBlockIds);
+  }
+  for (const section of model.metadata.sections ?? []) {
+    for (const headerSection of section.headerSections ?? []) {
+      headerSection.nodes.forEach(ensureNodeBlockIds);
+    }
+    for (const footerSection of section.footerSections ?? []) {
+      footerSection.nodes.forEach(ensureNodeBlockIds);
+    }
+  }
+  for (const note of model.metadata.footnotes ?? []) {
+    note.nodes?.forEach(ensureNodeBlockIds);
+  }
+  for (const note of model.metadata.endnotes ?? []) {
+    note.nodes?.forEach(ensureNodeBlockIds);
+  }
+  return model;
+}
+function collectNodeBlockIds(node, seen, duplicates) {
+  if (node.blockId) {
+    if (seen.has(node.blockId)) {
+      duplicates.add(node.blockId);
+    }
+    seen.add(node.blockId);
+  }
+  if (node.type !== "table") {
+    return;
+  }
+  for (const row of node.rows) {
+    for (const cell of row.cells) {
+      for (const child of cell.nodes) {
+        collectNodeBlockIds(child, seen, duplicates);
+      }
+    }
+  }
+}
+function collectDuplicateDocModelBlockIds(model) {
+  const duplicates = /* @__PURE__ */ new Set();
+  const visitContainer = (nodes) => {
+    if (!nodes) {
+      return;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    nodes.forEach((node) => collectNodeBlockIds(node, seen, duplicates));
+  };
+  visitContainer(model.nodes);
+  for (const section of model.metadata.headerSections ?? []) {
+    visitContainer(section.nodes);
+  }
+  for (const section of model.metadata.footerSections ?? []) {
+    visitContainer(section.nodes);
+  }
+  for (const note of model.metadata.footnotes ?? []) {
+    visitContainer(note.nodes);
+  }
+  for (const note of model.metadata.endnotes ?? []) {
+    visitContainer(note.nodes);
+  }
+  return Array.from(duplicates);
+}
+var nextBlockIdValue;
+var init_block_id = __esm({
+  "../doc-model/src/block-id.ts"() {
+    "use strict";
+    init_cjs_shims();
+    nextBlockIdValue = 1;
+  }
+});
+
 // ../doc-model/src/clone.ts
 function isParagraphCellContent(node) {
   return node.type === "paragraph";
@@ -879,9 +975,16 @@ function cloneParagraphStyle(style) {
     } : void 0
   };
 }
+function cloneParagraphNode(paragraph) {
+  return cloneParagraph(paragraph);
+}
+function cloneTableNode(table) {
+  return cloneTable(table);
+}
 function cloneParagraph(paragraph) {
   return {
     type: "paragraph",
+    blockId: paragraph.blockId,
     style: cloneParagraphStyle(paragraph.style),
     paragraphMarkDeleted: paragraph.paragraphMarkDeleted,
     sourceXml: paragraph.sourceXml,
@@ -1011,6 +1114,7 @@ function cloneTableFloatingStyle(floating) {
 function cloneTable(table) {
   return {
     type: "table",
+    blockId: table.blockId,
     sourceXml: table.sourceXml,
     style: table.style ? {
       widthTwips: table.style.widthTwips,
@@ -1131,12 +1235,51 @@ var init_clone = __esm({
   }
 });
 
+// ../doc-model/src/freeze.ts
+function deepFreezeValue(value) {
+  if (typeof value !== "object" || value === null) {
+    return;
+  }
+  if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
+    return;
+  }
+  if (Object.isFrozen(value)) {
+    return;
+  }
+  Object.freeze(value);
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      deepFreezeValue(entry);
+    }
+    return;
+  }
+  for (const key of Object.keys(value)) {
+    deepFreezeValue(value[key]);
+  }
+}
+function deepFreezeDocModel(model) {
+  deepFreezeValue(model);
+  return model;
+}
+var init_freeze = __esm({
+  "../doc-model/src/freeze.ts"() {
+    "use strict";
+    init_cjs_shims();
+  }
+});
+
 // ../doc-model/src/index.ts
 var src_exports2 = {};
 __export(src_exports2, {
+  allocateBlockId: () => allocateBlockId,
   buildDocModel: () => buildDocModel,
   buildDocModelFromBytes: () => buildDocModelFromBytes,
   cloneDocModel: () => cloneDocModel,
+  cloneParagraphNode: () => cloneParagraphNode,
+  cloneTableNode: () => cloneTableNode,
+  collectDuplicateDocModelBlockIds: () => collectDuplicateDocModelBlockIds,
+  deepFreezeDocModel: () => deepFreezeDocModel,
+  ensureDocModelBlockIds: () => ensureDocModelBlockIds,
   normalizeDocModel: () => normalizeDocModel
 });
 async function buildDocModel(pkg) {
@@ -1162,7 +1305,9 @@ var init_src3 = __esm({
     init_src();
     init_normalize();
     init_types();
+    init_block_id();
     init_clone();
+    init_freeze();
     init_normalize();
   }
 });
@@ -1174,6 +1319,7 @@ __export(index_exports, {
   DEFAULT_PAGE_OVERFLOW_TOLERANCE_PX: () => DEFAULT_PAGE_OVERFLOW_TOLERANCE_PX,
   DocxEditorViewer: () => DocxEditorViewer,
   ReactDocxViewer: () => ReactDocxViewer,
+  allocateBlockId: () => allocateBlockId,
   applyRunStyle: () => applyRunStyle,
   buildDocModel: () => buildDocModel,
   buildDocModelFromBytes: () => buildDocModelFromBytes,
@@ -1181,15 +1327,20 @@ __export(index_exports, {
   buildDocumentPageRanges: () => buildDocumentPageRanges,
   buildLayoutSnapshot: () => buildLayoutSnapshot,
   cloneDocModel: () => cloneDocModel,
+  cloneParagraphNode: () => cloneParagraphNode,
+  cloneTableNode: () => cloneTableNode,
   collectDocxEstimatedOverflowBreakStartNodeIndexes: () => collectDocxEstimatedOverflowBreakStartNodeIndexes,
   collectDocxHardPageBreakStartNodeIndexes: () => collectDocxHardPageBreakStartNodeIndexes2,
   collectDocxLastRenderedPageBreakStartNodeIndexes: () => collectDocxLastRenderedPageBreakStartNodeIndexes,
+  collectDuplicateDocModelBlockIds: () => collectDuplicateDocModelBlockIds,
   collectTableExplicitPageBreakInfo: () => collectTableExplicitPageBreakInfo2,
   collectTopLevelExplicitPageBreakStartNodeIndexes: () => collectTopLevelExplicitPageBreakStartNodeIndexes2,
   copyParagraphs: () => copyParagraphs,
   createMinimalDocxPackage: () => createMinimalDocxPackage,
+  deepFreezeDocModel: () => deepFreezeDocModel,
   defaultStarterModel: () => defaultStarterModel,
   duplicateParagraph: () => duplicateParagraph,
+  ensureDocModelBlockIds: () => ensureDocModelBlockIds,
   getPart: () => getPart,
   initWasm: () => initWasm2,
   insertParagraph: () => insertParagraph,
@@ -1570,7 +1721,7 @@ async function importDocxOnMainThread(buffer, signal) {
     throw createAbortError();
   }
   const startedAt = performanceNow();
-  const [{ parseDocx: parseDocx2 }, { buildDocModel: buildDocModel2 }] = await Promise.all([
+  const [{ parseDocx: parseDocx2 }, { buildDocModel: buildDocModel2, ensureDocModelBlockIds: ensureDocModelBlockIds2 }] = await Promise.all([
     Promise.resolve().then(() => (init_src2(), src_exports)),
     Promise.resolve().then(() => (init_src3(), src_exports2))
   ]);
@@ -1579,7 +1730,7 @@ async function importDocxOnMainThread(buffer, signal) {
   if (signal?.aborted) {
     throw createAbortError();
   }
-  const model = await buildDocModel2(pkg);
+  const model = ensureDocModelBlockIds2(await buildDocModel2(pkg));
   const finishedAt = performanceNow();
   if (signal?.aborted) {
     throw createAbortError();
@@ -1613,7 +1764,7 @@ async function importDocxBuffer(buffer, options = {}) {
   }
   const requestId = nextImportWorkerRequestId;
   nextImportWorkerRequestId += 1;
-  return new Promise((resolve, reject) => {
+  const workerResult = new Promise((resolve, reject) => {
     let settled = false;
     const cleanup = () => {
       worker.removeEventListener("message", handleMessage);
@@ -1677,6 +1828,10 @@ async function importDocxBuffer(buffer, options = {}) {
       );
     }
   });
+  const result = await workerResult;
+  const { ensureDocModelBlockIds: ensureDocModelBlockIds2 } = await Promise.resolve().then(() => (init_src3(), src_exports2));
+  ensureDocModelBlockIds2(result.model);
+  return result;
 }
 
 // src/section-layout.ts
@@ -2074,6 +2229,7 @@ init_src3();
 function paragraphFromText(text, options) {
   return {
     type: "paragraph",
+    blockId: allocateBlockId(),
     style: options?.paragraphStyle,
     children: [{ type: "text", text, style: options?.runStyle }]
   };
@@ -2659,6 +2815,7 @@ function splitParagraphChildrenAtTextOffsets(paragraph, text, startOffset, endOf
 function cloneParagraph2(paragraph) {
   return {
     type: "paragraph",
+    blockId: allocateBlockId(),
     style: paragraph.style ? { ...paragraph.style } : void 0,
     sourceXml: paragraph.sourceXml,
     children: paragraph.children.map(cloneParagraphChildRun)
@@ -2692,26 +2849,31 @@ function duplicateParagraph(model, index) {
   return next;
 }
 function updateParagraphText(model, index, text, options) {
-  const next = cloneDocModel(model);
-  const paragraph = getParagraph(next, index);
-  if (!paragraph) {
-    return next;
+  const source = getParagraph(model, index);
+  if (!source) {
+    return { ...model, nodes: [...model.nodes] };
   }
-  paragraph.children = distributeTextAcrossParagraphChildren(paragraph, text, options);
+  const paragraph = cloneParagraphNode(source);
+  paragraph.children = distributeTextAcrossParagraphChildren(source, text, options);
   paragraph.sourceXml = void 0;
-  return next;
+  const nextNodes = [...model.nodes];
+  nextNodes[index] = paragraph;
+  return { ...model, nodes: nextNodes };
 }
 function updateTableCellText(model, tableIndex, rowIndex, cellIndex, text, options) {
-  const next = cloneDocModel(model);
-  const tableNode = next.nodes[tableIndex];
-  if (!tableNode || tableNode.type !== "table") {
-    return next;
+  const sourceTable = model.nodes[tableIndex];
+  if (!sourceTable || sourceTable.type !== "table") {
+    return { ...model, nodes: [...model.nodes] };
   }
+  const tableNode = cloneTableNode(sourceTable);
   const row = tableNode.rows[rowIndex];
   const cell = row?.cells[cellIndex];
   if (!cell) {
-    return next;
+    return { ...model, nodes: [...model.nodes] };
   }
+  const nextNodes = [...model.nodes];
+  nextNodes[tableIndex] = tableNode;
+  const next = { ...model, nodes: nextNodes };
   const paragraphs = cell.nodes.filter((node) => node.type === "paragraph");
   const incomingParagraphTexts = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
   if (incomingParagraphTexts.length === 0) {
@@ -2740,21 +2902,23 @@ function updateTableCellText(model, tableIndex, rowIndex, cellIndex, text, optio
   return next;
 }
 function updateTableCellParagraphText(model, tableIndex, rowIndex, cellIndex, paragraphIndex, text, options) {
-  const next = cloneDocModel(model);
-  const tableNode = next.nodes[tableIndex];
-  if (!tableNode || tableNode.type !== "table") {
-    return next;
+  const sourceTable = model.nodes[tableIndex];
+  if (!sourceTable || sourceTable.type !== "table") {
+    return { ...model, nodes: [...model.nodes] };
   }
+  const tableNode = cloneTableNode(sourceTable);
   const row = tableNode.rows[rowIndex];
   const cell = row?.cells[cellIndex];
   const paragraph = cell?.nodes.filter((node) => node.type === "paragraph")[paragraphIndex];
   if (!cell || !paragraph) {
-    return next;
+    return { ...model, nodes: [...model.nodes] };
   }
   paragraph.children = distributeTextAcrossParagraphChildren(paragraph, text, options);
   paragraph.sourceXml = void 0;
   tableNode.sourceXml = void 0;
-  return next;
+  const nextNodes = [...model.nodes];
+  nextNodes[tableIndex] = tableNode;
+  return { ...model, nodes: nextNodes };
 }
 function updateTableCellParagraphTextRecursive(model, tableIndex, rowIndex, cellIndex, paragraphIndex, text, options) {
   const next = cloneDocModel(model);
@@ -3074,6 +3238,222 @@ async function serializeDocx(model, basePackage) {
   return wasmSerializeDocx(model, basePackage ? mapsToWasmPackage(basePackage) : void 0);
 }
 
+// src/editing-intents.ts
+init_cjs_shims();
+function resolveEditingIntent(source) {
+  const insertedText = source.data ?? source.dataTransferText ?? "";
+  const transferredText = source.dataTransferText ?? source.data ?? "";
+  switch (source.inputType) {
+    case "insertCompositionText":
+    case "deleteCompositionText":
+      return void 0;
+    case "insertText":
+    case "insertFromYank":
+    case "insertFromPasteAsQuotation":
+      return { kind: "insertText", text: insertedText };
+    case "insertFromPaste":
+    case "insertFromDrop":
+      return { kind: "insertText", text: transferredText };
+    case "insertReplacementText":
+    case "insertTranspose":
+      return { kind: "replaceText", text: insertedText };
+    case "insertParagraph":
+      return { kind: "insertParagraph" };
+    case "insertLineBreak":
+      return { kind: "insertLineBreak" };
+    case "deleteContentBackward":
+      return { kind: "deleteContent", direction: "backward", unit: "character" };
+    case "deleteContentForward":
+      return { kind: "deleteContent", direction: "forward", unit: "character" };
+    case "deleteWordBackward":
+      return { kind: "deleteContent", direction: "backward", unit: "word" };
+    case "deleteWordForward":
+      return { kind: "deleteContent", direction: "forward", unit: "word" };
+    case "deleteSoftLineBackward":
+    case "deleteHardLineBackward":
+      return { kind: "deleteContent", direction: "backward", unit: "line" };
+    case "deleteSoftLineForward":
+    case "deleteHardLineForward":
+      return { kind: "deleteContent", direction: "forward", unit: "line" };
+    case "deleteEntireSoftLine":
+      return {
+        kind: "deleteContent",
+        direction: "backward",
+        unit: "entire-line"
+      };
+    case "deleteContent":
+    case "deleteByCut":
+    case "deleteByDrag":
+      return { kind: "deleteRange" };
+    case "historyUndo":
+      return { kind: "historyUndo" };
+    case "historyRedo":
+      return { kind: "historyRedo" };
+    default:
+      return { kind: "blocked" };
+  }
+}
+function editingIntentCoalesceClass(intent) {
+  switch (intent.kind) {
+    case "insertText":
+    case "insertLineBreak":
+    case "replaceText":
+      return "insert";
+    case "deleteContent":
+    case "deleteRange":
+      return "delete";
+    default:
+      return void 0;
+  }
+}
+function isWhitespaceChar(char) {
+  return /\s/.test(char);
+}
+function codePointLengthBefore(text, offset) {
+  if (offset >= 2) {
+    const codePoint = text.codePointAt(offset - 2);
+    if (codePoint !== void 0 && codePoint > 65535) {
+      return 2;
+    }
+  }
+  return offset > 0 ? 1 : 0;
+}
+function codePointLengthAt(text, offset) {
+  if (offset >= text.length) {
+    return 0;
+  }
+  const codePoint = text.codePointAt(offset);
+  return codePoint !== void 0 && codePoint > 65535 ? 2 : 1;
+}
+function wordDeleteStartBefore(text, offset) {
+  let index = offset;
+  while (index > 0 && isWhitespaceChar(text[index - 1])) {
+    index -= 1;
+  }
+  while (index > 0 && !isWhitespaceChar(text[index - 1])) {
+    index -= 1;
+  }
+  return index;
+}
+function wordDeleteEndAfter(text, offset) {
+  let index = offset;
+  while (index < text.length && isWhitespaceChar(text[index])) {
+    index += 1;
+  }
+  while (index < text.length && !isWhitespaceChar(text[index])) {
+    index += 1;
+  }
+  return index;
+}
+function lineStartBefore(text, offset) {
+  const newlineIndex = text.lastIndexOf("\n", Math.max(0, offset - 1));
+  return newlineIndex < 0 ? 0 : newlineIndex + 1;
+}
+function lineEndAfter(text, offset) {
+  const newlineIndex = text.indexOf("\n", offset);
+  if (newlineIndex < 0) {
+    return text.length;
+  }
+  return newlineIndex === offset ? offset + 1 : newlineIndex;
+}
+function replaceRange(text, start, end, replacement) {
+  return {
+    text: `${text.slice(0, start)}${replacement}${text.slice(end)}`,
+    caret: start + replacement.length
+  };
+}
+function applyTextEditingIntent(text, selectionStart, selectionEnd, intent) {
+  const start = Math.max(0, Math.min(Math.round(selectionStart), text.length));
+  const end = Math.max(
+    start,
+    Math.min(Math.round(selectionEnd), text.length)
+  );
+  switch (intent.kind) {
+    case "insertText":
+    case "replaceText": {
+      const replacement = intent.text.replace(/\r\n?/g, "\n");
+      if (replacement.length === 0 && start === end) {
+        return void 0;
+      }
+      return replaceRange(text, start, end, replacement);
+    }
+    case "insertLineBreak":
+      return replaceRange(text, start, end, "\n");
+    case "deleteRange":
+      if (start === end) {
+        return void 0;
+      }
+      return replaceRange(text, start, end, "");
+    case "deleteContent": {
+      if (start !== end) {
+        return replaceRange(text, start, end, "");
+      }
+      if (intent.direction === "backward") {
+        if (intent.unit === "entire-line") {
+          const lineStart = lineStartBefore(text, start);
+          const newlineIndex = text.indexOf("\n", start);
+          const lineEnd = newlineIndex < 0 ? text.length : newlineIndex;
+          if (lineStart === lineEnd) {
+            return void 0;
+          }
+          return replaceRange(text, lineStart, lineEnd, "");
+        }
+        if (start === 0) {
+          return void 0;
+        }
+        const deleteFrom = intent.unit === "character" ? start - codePointLengthBefore(text, start) : intent.unit === "word" ? wordDeleteStartBefore(text, start) : lineStartBefore(text, start);
+        if (deleteFrom >= start) {
+          return void 0;
+        }
+        return replaceRange(text, deleteFrom, start, "");
+      }
+      if (start >= text.length) {
+        return void 0;
+      }
+      const deleteTo = intent.unit === "character" ? start + codePointLengthAt(text, start) : intent.unit === "word" ? wordDeleteEndAfter(text, start) : lineEndAfter(text, start);
+      if (deleteTo <= start) {
+        return void 0;
+      }
+      return replaceRange(text, start, deleteTo, "");
+    }
+    default:
+      return void 0;
+  }
+}
+function shouldCoalesceTextCommit(previous, next, windowMs = 1e3) {
+  return Boolean(
+    previous && previous.key === next.key && next.at >= previous.at && next.at - previous.at <= windowMs && previous.caretAfter === next.caretBefore
+  );
+}
+function mergeCellParagraphTexts(paragraphTexts, boundaryParagraphIndex) {
+  if (boundaryParagraphIndex <= 0 || boundaryParagraphIndex >= paragraphTexts.length) {
+    return void 0;
+  }
+  const mergedTexts = [
+    ...paragraphTexts.slice(0, boundaryParagraphIndex - 1),
+    `${paragraphTexts[boundaryParagraphIndex - 1]}${paragraphTexts[boundaryParagraphIndex]}`,
+    ...paragraphTexts.slice(boundaryParagraphIndex + 1)
+  ];
+  const cellText = mergedTexts.join("\n");
+  let caretGlobalOffset = 0;
+  for (let index = 0; index < boundaryParagraphIndex - 1; index += 1) {
+    caretGlobalOffset += paragraphTexts[index].length + 1;
+  }
+  caretGlobalOffset += paragraphTexts[boundaryParagraphIndex - 1].length;
+  const parts = cellText.split("\n");
+  let remaining = caretGlobalOffset;
+  let caretParagraphIndex = 0;
+  while (caretParagraphIndex < parts.length - 1 && remaining > parts[caretParagraphIndex].length) {
+    remaining -= parts[caretParagraphIndex].length + 1;
+    caretParagraphIndex += 1;
+  }
+  return {
+    cellText,
+    caretParagraphIndex,
+    caretOffset: Math.max(0, Math.min(remaining, parts[caretParagraphIndex].length))
+  };
+}
+
 // src/pagination-breaks.ts
 init_cjs_shims();
 var PAGE_BREAK_XML_PATTERN = /<w:br\b[^>]*w:type="page"[^>]*\/?>/i;
@@ -3286,6 +3666,55 @@ function resolveMeasuredBodyFooterOverlapLatchState(options) {
     shouldLatch: consecutivePasses >= stabilityThreshold
   };
 }
+function createEstimatedPagesBuildMemo(build) {
+  const entries = [];
+  return (measuredTableRowHeightsByNodeIndex, measuredPageContentHeightsPxByPageIndex, strictLastRenderedParagraphStartBreaks) => {
+    const cached = entries.find(
+      (entry) => entry.measuredTableRowHeightsByNodeIndex === measuredTableRowHeightsByNodeIndex && entry.measuredPageContentHeightsPxByPageIndex === measuredPageContentHeightsPxByPageIndex && entry.strictLastRenderedParagraphStartBreaks === strictLastRenderedParagraphStartBreaks
+    );
+    if (cached) {
+      return cached.pages;
+    }
+    const pages = build(
+      measuredTableRowHeightsByNodeIndex,
+      measuredPageContentHeightsPxByPageIndex,
+      strictLastRenderedParagraphStartBreaks
+    );
+    entries.push({
+      measuredTableRowHeightsByNodeIndex,
+      measuredPageContentHeightsPxByPageIndex,
+      strictLastRenderedParagraphStartBreaks,
+      pages
+    });
+    return pages;
+  };
+}
+function resolveMeasuredSplitParagraphPageComparison(options) {
+  if (options.canUndo || options.canRedo || !options.hasMeasuredPageContentHeights) {
+    return {
+      pages: options.measuredEstimatedPages,
+      usedPureEstimatedPages: false
+    };
+  }
+  const measuredPagesAreOnlySplitParagraphs = options.measuredEstimatedPages.length > 0 && options.measuredEstimatedPages.every(
+    options.pageContainsOnlySplitParagraphSegments
+  );
+  if (!measuredPagesAreOnlySplitParagraphs) {
+    return {
+      pages: options.measuredEstimatedPages,
+      usedPureEstimatedPages: false
+    };
+  }
+  const pureEstimatedPages = options.buildPureEstimatedPages();
+  const purePagesAreOnlySplitParagraphs = pureEstimatedPages.length > 0 && pureEstimatedPages.every(options.pageContainsOnlySplitParagraphSegments);
+  if (purePagesAreOnlySplitParagraphs && pureEstimatedPages.length < options.measuredEstimatedPages.length) {
+    return { pages: pureEstimatedPages, usedPureEstimatedPages: true };
+  }
+  return {
+    pages: options.measuredEstimatedPages,
+    usedPureEstimatedPages: false
+  };
+}
 function isBetterCandidate(candidate, incumbent, targetPageCount) {
   const candidateDifference = Math.abs(candidate.pageCount - targetPageCount);
   const incumbentDifference = Math.abs(incumbent.pageCount - targetPageCount);
@@ -5437,7 +5866,6 @@ var TABLE_ROW_HEIGHT_PAGINATION_ESTIMATE_PADDING_RATIO = 1.08;
 var TABLE_ROW_HEIGHT_PAGINATION_ESTIMATE_PADDING_MIN_ROWS = 15;
 var MIN_TABLE_ROW_SLICE_REMAINING_HEIGHT_PX = MIN_PARAGRAPH_LINE_HEIGHT_PX * 2;
 var TABLE_ROW_SLICE_BOUNDARY_TOLERANCE_PX = 2;
-var TOP_AND_BOTTOM_VERTICAL_DRAG_SNAP_PX = 10;
 var HEADER_FOOTER_INACTIVE_OPACITY = 0.5;
 var LETTERHEAD_INDENT_MIN_TWIPS = 900;
 var LETTERHEAD_INDENT_MAX_TWIPS = 4200;
@@ -5910,7 +6338,7 @@ function reconcileMeasuredTableRowHeightsForImportPagination(table, measuredRowH
     );
   });
 }
-function resolveTableMeasuredRowHeightsForPagination(nodes, tableMeasuredRowHeights, options) {
+function resolveTableMeasuredRowHeightsForPagination(nodes, tableMeasuredRowHeightsByBlockId, options) {
   const activeTableIndexes = /* @__PURE__ */ new Set();
   (options?.activeDraftKeys ?? []).forEach((draftKey) => {
     const [tableIndexText] = draftKey.split(":");
@@ -5920,37 +6348,114 @@ function resolveTableMeasuredRowHeightsForPagination(nodes, tableMeasuredRowHeig
     }
   });
   const includeOnlyActiveTables = activeTableIndexes.size > 0;
-  if (includeOnlyActiveTables === false && options?.allowMeasuredImportPagination !== true) {
+  if (includeOnlyActiveTables === false && options?.allowMeasuredImportPagination !== true && options?.allowContentSignatureValidatedTables !== true) {
     return void 0;
   }
   const next = {};
-  Object.entries(tableMeasuredRowHeights).forEach(
-    ([tableIndexText, measuredRowHeights]) => {
-      const tableIndex = Number.parseInt(tableIndexText, 10);
-      const tableNode = nodes[tableIndex];
-      if (!Number.isFinite(tableIndex) || !tableNode || tableNode.type !== "table" || !Array.isArray(measuredRowHeights) || measuredRowHeights.length !== tableNode.rows.length) {
-        return;
-      }
-      if (includeOnlyActiveTables && !activeTableIndexes.has(tableIndex)) {
+  nodes.forEach((tableNode, tableIndex) => {
+    if (tableNode.type !== "table" || !tableNode.blockId) {
+      return;
+    }
+    const entry = tableMeasuredRowHeightsByBlockId[tableNode.blockId];
+    if (!entry || !Array.isArray(entry.rowHeightsPx) || entry.rowHeightsPx.length !== tableNode.rows.length) {
+      return;
+    }
+    const measuredRowHeights = entry.rowHeightsPx;
+    if (includeOnlyActiveTables) {
+      if (!activeTableIndexes.has(tableIndex)) {
         return;
       }
-      const nextHeights = includeOnlyActiveTables ? measuredRowHeights.map(
-        (heightPx) => normalizeMeasuredTableRowHeightPx(heightPx)
-      ) : reconcileMeasuredTableRowHeightsForImportPagination(
-        tableNode,
-        measuredRowHeights,
-        options?.pageContentWidthPxByNodeIndex?.get(tableIndex),
-        options?.pageContentHeightPxByNodeIndex?.get(tableIndex),
-        options?.numberingDefinitions,
-        options?.docGridLinePitchPxByNodeIndex?.get(tableIndex)
-      ) ?? measuredRowHeights.map(
+      next[tableIndex] = measuredRowHeights.map(
         (heightPx) => normalizeMeasuredTableRowHeightPx(heightPx)
       );
-      next[tableIndex] = nextHeights;
+      return;
     }
-  );
+    if (options?.allowMeasuredImportPagination !== true && entry.contentSignature !== docNodeContentSignature(tableNode)) {
+      return;
+    }
+    next[tableIndex] = reconcileMeasuredTableRowHeightsForImportPagination(
+      tableNode,
+      measuredRowHeights,
+      options?.pageContentWidthPxByNodeIndex?.get(tableIndex),
+      options?.pageContentHeightPxByNodeIndex?.get(tableIndex),
+      options?.numberingDefinitions,
+      options?.docGridLinePitchPxByNodeIndex?.get(tableIndex)
+    ) ?? measuredRowHeights.map(
+      (heightPx) => normalizeMeasuredTableRowHeightPx(heightPx)
+    );
+  });
   return Object.keys(next).length > 0 ? next : void 0;
 }
+function buildMeasuredPageContentValidationForPageSegments(pageSegments, nodes, contextSignature) {
+  const blocks = [];
+  let previousNodeIndex;
+  for (const segment of pageSegments) {
+    if (segment.nodeIndex === previousNodeIndex) {
+      continue;
+    }
+    previousNodeIndex = segment.nodeIndex;
+    const node = nodes[segment.nodeIndex];
+    blocks.push({
+      blockId: node?.blockId,
+      contentSignature: node ? docNodeContentSignature(node) : ""
+    });
+  }
+  return { contextSignature, blocks };
+}
+function measuredPageContentValidationsEqual(left, right) {
+  if (left === right) {
+    return true;
+  }
+  if (!left || !right) {
+    return false;
+  }
+  if (left.contextSignature !== right.contextSignature || left.blocks.length !== right.blocks.length) {
+    return false;
+  }
+  for (let index = 0; index < left.blocks.length; index += 1) {
+    if (left.blocks[index].blockId !== right.blocks[index].blockId || left.blocks[index].contentSignature !== right.blocks[index].contentSignature) {
+      return false;
+    }
+  }
+  return true;
+}
+function resolveMeasuredPageContentHeightsPxForEditedModel(nodes, measuredPageContentHeightsPxByPageIndex, validationByPageIndex, contextSignature) {
+  let cursor = 0;
+  let previousPageLastBlockId;
+  let validPageCount = 0;
+  for (let pageIndex = 0; pageIndex < measuredPageContentHeightsPxByPageIndex.length; pageIndex += 1) {
+    const validation = validationByPageIndex[pageIndex];
+    if (!validation || validation.contextSignature !== contextSignature || validation.blocks.length === 0) {
+      break;
+    }
+    let pageIsValid = true;
+    for (let blockIndex = 0; blockIndex < validation.blocks.length; blockIndex += 1) {
+      const block = validation.blocks[blockIndex];
+      if (!block.blockId) {
+        pageIsValid = false;
+        break;
+      }
+      if (blockIndex === 0 && block.blockId === previousPageLastBlockId) {
+        continue;
+      }
+      const node = nodes[cursor];
+      if (!node || node.blockId !== block.blockId || docNodeContentSignature(node) !== block.contentSignature) {
+        pageIsValid = false;
+        break;
+      }
+      cursor += 1;
+    }
+    if (!pageIsValid) {
+      break;
+    }
+    previousPageLastBlockId = validation.blocks[validation.blocks.length - 1]?.blockId;
+    validPageCount += 1;
+  }
+  if (validPageCount === 0) {
+    return void 0;
+  }
+  return validPageCount >= measuredPageContentHeightsPxByPageIndex.length ? measuredPageContentHeightsPxByPageIndex : measuredPageContentHeightsPxByPageIndex.slice(0, validPageCount);
+}
 function placeCaretInsideElementDom(element) {
   const selection = window.getSelection();
   if (!selection) {
@@ -5995,6 +6500,34 @@ function selectionOffsetsWithinElementDom(element) {
     return void 0;
   }
 }
+function staticRangeOffsetsWithinElementDom(element, staticRange) {
+  if (!element.contains(staticRange.startContainer) || !element.contains(staticRange.endContainer)) {
+    return void 0;
+  }
+  try {
+    const textLengthWithoutNumberingLabels = (range) => {
+      const fragment = range.cloneContents();
+      fragment.querySelectorAll("[data-docx-numbering-label='true']").forEach((label) => {
+        label.remove();
+      });
+      return fragment.textContent?.length ?? 0;
+    };
+    const startRange = document.createRange();
+    startRange.setStart(element, 0);
+    startRange.setEnd(staticRange.startContainer, staticRange.startOffset);
+    const endRange = document.createRange();
+    endRange.setStart(element, 0);
+    endRange.setEnd(staticRange.endContainer, staticRange.endOffset);
+    const startOffset = textLengthWithoutNumberingLabels(startRange);
+    const endOffset = textLengthWithoutNumberingLabels(endRange);
+    return {
+      start: Math.min(startOffset, endOffset),
+      end: Math.max(startOffset, endOffset)
+    };
+  } catch {
+    return void 0;
+  }
+}
 function setSelectionWithinElementByTextOffsetsDom(element, startOffset, endOffset) {
   const selection = window.getSelection();
   if (!selection) {
@@ -7448,8 +7981,11 @@ var defaultStarterModel = {
     defaultParagraphStyleId: "Normal"
   }
 };
+function cloneDocModelWithBlockIds(model) {
+  return ensureDocModelBlockIds(cloneDocModel(model));
+}
 function createBlankDocumentModel() {
-  return cloneDocModel(defaultStarterModel);
+  return cloneDocModelWithBlockIds(defaultStarterModel);
 }
 function textRuns2(paragraph) {
   return paragraph.children.filter(
@@ -8115,6 +8651,8 @@ function paragraphLooksLikeCheckboxChoiceRow(paragraph) {
 }
 var KEEP_ALL_SCRIPT_RE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
 var MIN_DUAL_WRAPPED_INTERIOR_BAND_PX = 72;
+var WRAP_BAND_RECONCILE_TOLERANCE_PX = 2;
+var WRAP_BAND_RECONCILE_MAX_PASSES = 24;
 function resolveDualWrapParagraphRenderBlockHeightPx(layout, geometries) {
   const fullHeightPx = wrappedPretextParagraphBlockHeightPx(layout);
   const textBottomPx = pretextLayoutContentBottomPx(layout);
@@ -8131,10 +8669,27 @@ function resolveDualWrapParagraphRenderBlockHeightPx(layout, geometries) {
   }
   return fullHeightPx;
 }
+function resolveDragPreviewAwareWrapBlockHeightPx(layout, geometries, foreignExclusions) {
+  const baseHeightPx = resolveDualWrapParagraphRenderBlockHeightPx(
+    layout,
+    geometries
+  );
+  if (!foreignExclusions?.some((exclusion) => exclusion.fromDragPreview)) {
+    return baseHeightPx;
+  }
+  const lineHeightPx = Math.max(1, Math.round(layout.lineHeightPx ?? 1));
+  const staticBottomPx = Math.max(
+    lineHeightPx,
+    pretextLayoutContentBottomPx(layout),
+    ...geometries.map((geometry) => geometry.exclusion.bottom),
+    ...foreignExclusions.filter((exclusion) => !exclusion.fromDragPreview).map((exclusion) => exclusion.bottom)
+  );
+  return Math.min(baseHeightPx, Math.max(1, Math.round(staticBottomPx)));
+}
 function resolveForeignWrapExclusionsForFlowRange(obstacles, sourceNodeIndex, pageFlowTopPx, pageFlowBottomPx) {
   const foreignExclusions = [];
   for (const obstacle of obstacles) {
-    if (obstacle.sourceNodeIndex === sourceNodeIndex) {
+    if (obstacle.sourceNodeIndex === sourceNodeIndex && !obstacle.appliesToSourceNode) {
       continue;
     }
     if (obstacle.bottom <= pageFlowTopPx || obstacle.top >= pageFlowBottomPx) {
@@ -8190,7 +8745,8 @@ function collectPageFlowWrapObstaclesForParagraph(paragraph, nodeIndex, pageFlow
       paragraphTopPx: options?.paragraphTopPx,
       pageMarginTopPx: options?.pageMarginTopPx,
       movePreviewByImageIndex,
-      allowNegativeImageTop: movePreviewByImageIndex.size > 0
+      allowNegativeImageTop: movePreviewByImageIndex.size > 0,
+      foreignExclusions: options?.foreignExclusions
     }
   );
   const coveredImageIndexes = /* @__PURE__ */ new Set();
@@ -8268,18 +8824,28 @@ function resolveParagraphForeignOnlyWrappedTextLayout(paragraph, containerWidthP
   };
 }
 function precomputePageSegmentForeignWrapExclusions(segments, model, availableWidthPx, numberingDefinitions, docGridLinePitchPxByNodeIndex, pageContentWidthPxByNodeIndex, pageLayout, interaction) {
-  const flowTopPxBySegmentIndex = [];
-  const flowHeightPxBySegmentIndex = [];
-  let pageFlowTopPx = 0;
-  for (const segment of segments) {
-    flowTopPxBySegmentIndex.push(pageFlowTopPx);
+  const segmentWidthPxAt = (nodeIndex) => pageContentWidthPxByNodeIndex.get(nodeIndex) ?? availableWidthPx;
+  const measuredWrapBands = interaction?.measuredWrapBands;
+  const measuredBandAt = (key) => {
+    const band = measuredWrapBands?.get(key);
+    return band && band.bottomPx > band.topPx && band.rightPx > band.leftPx ? band : void 0;
+  };
+  const flowTopsFromHeights = (heights) => {
+    const flowTops = [];
+    let pageFlowTopPx = 0;
+    for (const heightPx of heights) {
+      flowTops.push(pageFlowTopPx);
+      pageFlowTopPx += heightPx;
+    }
+    return flowTops;
+  };
+  const baseFlowHeightPxBySegmentIndex = segments.map((segment) => {
     const node = model.nodes[segment.nodeIndex];
-    const segmentWidthPx = pageContentWidthPxByNodeIndex.get(segment.nodeIndex) ?? availableWidthPx;
-    const segmentHeightPx = estimateRenderedPageSegmentHeightPx(
+    return estimateRenderedPageSegmentHeightPx(
       node,
       segment,
       model,
-      segmentWidthPx,
+      segmentWidthPxAt(segment.nodeIndex),
       numberingDefinitions,
       docGridLinePitchPxByNodeIndex.get(segment.nodeIndex),
       // For the wrap-exclusion flow simulation, a square/tight-wrapped float
@@ -8289,54 +8855,313 @@ function precomputePageSegmentForeignWrapExclusions(segments, model, availableWi
       // the float's exclusion rect to overlap and indent them.
       { excludeWrappedFloatingImageFootprint: true }
     );
-    flowHeightPxBySegmentIndex.push(segmentHeightPx);
-    pageFlowTopPx += segmentHeightPx;
-  }
-  const obstacles = [];
-  for (let segmentIndex = 0; segmentIndex < segments.length; segmentIndex += 1) {
-    const segment = segments[segmentIndex];
-    const node = model.nodes[segment.nodeIndex];
-    if (node?.type !== "paragraph") {
-      continue;
-    }
-    const segmentWidthPx = pageContentWidthPxByNodeIndex.get(segment.nodeIndex) ?? availableWidthPx;
-    const paragraphRenderTextWidthPx = paragraphAvailableTextWidthPx(
-      node,
-      segmentWidthPx,
-      numberingDefinitions
-    );
-    obstacles.push(
-      ...collectPageFlowWrapObstaclesForParagraph(
+  });
+  const collectObstacles = (flowTopPxBySegmentIndex2, flowHeightPxBySegmentIndex2, previousObstacles) => {
+    const obstacles2 = [];
+    for (let segmentIndex = 0; segmentIndex < segments.length; segmentIndex += 1) {
+      const segment = segments[segmentIndex];
+      const node = model.nodes[segment.nodeIndex];
+      if (node?.type === "table" && node.style?.floating && !segment.tableRowRange) {
+        const tableContainerWidthPx = segmentWidthPxAt(segment.nodeIndex);
+        const tableFlowTopPx = flowTopPxBySegmentIndex2[segmentIndex] ?? 0;
+        const measuredTableBand = measuredBandAt(`tbl:${segment.nodeIndex}`);
+        if (measuredTableBand) {
+          const floating = node.style.floating;
+          const distLPx = twipsToPixels(floating.leftFromTextTwips) ?? 0;
+          const distRPx = twipsToPixels(floating.rightFromTextTwips) ?? 0;
+          const distTPx = twipsToPixels(floating.topFromTextTwips) ?? 0;
+          const distBPx = twipsToPixels(floating.bottomFromTextTwips) ?? 0;
+          let exclusionLeftPx = Math.max(0, measuredTableBand.leftPx - distLPx);
+          let exclusionRightPx = Math.min(
+            tableContainerWidthPx,
+            measuredTableBand.rightPx + distRPx
+          );
+          if (exclusionLeftPx > 0 && exclusionLeftPx < MIN_DUAL_WRAPPED_INTERIOR_BAND_PX) {
+            exclusionLeftPx = 0;
+          }
+          if (exclusionRightPx < tableContainerWidthPx && tableContainerWidthPx - exclusionRightPx < MIN_DUAL_WRAPPED_INTERIOR_BAND_PX) {
+            exclusionRightPx = tableContainerWidthPx;
+          }
+          obstacles2.push({
+            sourceNodeIndex: segment.nodeIndex,
+            left: exclusionLeftPx,
+            right: exclusionRightPx,
+            top: measuredTableBand.topPx - distTPx,
+            bottom: measuredTableBand.bottomPx + distBPx
+          });
+          continue;
+        }
+        const geometry = resolveFloatingTableGeometry(
+          node,
+          tableContainerWidthPx,
+          {
+            tableWidthPx: estimateFloatingTableWidthPx(
+              node,
+              tableContainerWidthPx
+            ),
+            tableHeightPx: estimateTableHeightPx(
+              node,
+              tableContainerWidthPx,
+              numberingDefinitions,
+              docGridLinePitchPxByNodeIndex.get(segment.nodeIndex)
+            ),
+            indentPx: twipsToSignedPixels(node.style?.indentTwips) ?? 0,
+            flowTopPx: tableFlowTopPx,
+            pageMarginTopPx: pageLayout.marginsPx.top,
+            pageMarginLeftPx: pageLayout.marginsPx.left
+          }
+        );
+        if (geometry) {
+          obstacles2.push({
+            sourceNodeIndex: segment.nodeIndex,
+            left: geometry.exclusion.left,
+            right: geometry.exclusion.right,
+            top: tableFlowTopPx + geometry.exclusion.top,
+            bottom: tableFlowTopPx + geometry.exclusion.bottom
+          });
+        }
+        continue;
+      }
+      if (node?.type !== "paragraph") {
+        continue;
+      }
+      const paragraphRenderTextWidthPx = paragraphAvailableTextWidthPx(
         node,
-        segment.nodeIndex,
-        flowTopPxBySegmentIndex[segmentIndex] ?? 0,
-        paragraphRenderTextWidthPx,
-        estimateParagraphLineHeightPx(
+        segmentWidthPxAt(segment.nodeIndex),
+        numberingDefinitions
+      );
+      node.children.forEach((child, childIndex) => {
+        if (child.type !== "image" || !child.floating?.wrapType || child.floating.wrapType === "none" || child.floating.behindDocument === true || shouldRenderWrappedFloatingImage(child)) {
+          return;
+        }
+        const band = measuredBandAt(
+          `img:p:${segment.nodeIndex}:${childIndex}`
+        );
+        if (!band) {
+          return;
+        }
+        const floating = child.floating;
+        const containerWidthPx = segmentWidthPxAt(segment.nodeIndex);
+        const fullWidthWrap = floating.wrapType === "topAndBottom";
+        let exclusionLeftPx = fullWidthWrap ? 0 : Math.max(0, band.leftPx - (floating.distLPx ?? 0));
+        let exclusionRightPx = fullWidthWrap ? containerWidthPx : Math.min(containerWidthPx, band.rightPx + (floating.distRPx ?? 0));
+        if (exclusionLeftPx > 0 && exclusionLeftPx < MIN_DUAL_WRAPPED_INTERIOR_BAND_PX) {
+          exclusionLeftPx = 0;
+        }
+        if (exclusionRightPx < containerWidthPx && containerWidthPx - exclusionRightPx < MIN_DUAL_WRAPPED_INTERIOR_BAND_PX) {
+          exclusionRightPx = containerWidthPx;
+        }
+        if (exclusionRightPx <= exclusionLeftPx) {
+          return;
+        }
+        obstacles2.push({
+          sourceNodeIndex: segment.nodeIndex,
+          appliesToSourceNode: true,
+          left: exclusionLeftPx,
+          right: exclusionRightPx,
+          top: band.topPx - (floating.distTPx ?? 0),
+          bottom: band.bottomPx + (floating.distBPx ?? 0)
+        });
+      });
+      const flowTopPx = measuredBandAt(`para:${segment.nodeIndex}`)?.topPx ?? flowTopPxBySegmentIndex2[segmentIndex] ?? 0;
+      obstacles2.push(
+        ...collectPageFlowWrapObstaclesForParagraph(
           node,
-          docGridLinePitchPxByNodeIndex.get(segment.nodeIndex)
-        ),
-        {
-          paragraphTopPx: flowTopPxBySegmentIndex[segmentIndex] ?? 0,
-          pageMarginTopPx: pageLayout.marginsPx.top,
-          location: {
-            kind: "paragraph",
-            nodeIndex: segment.nodeIndex
-          },
-          floatingMovePreview: interaction?.floatingMovePreview,
-          resizePreview: interaction?.resizePreview
+          segment.nodeIndex,
+          flowTopPx,
+          paragraphRenderTextWidthPx,
+          estimateParagraphLineHeightPx(
+            node,
+            docGridLinePitchPxByNodeIndex.get(segment.nodeIndex)
+          ),
+          {
+            paragraphTopPx: flowTopPx,
+            pageMarginTopPx: pageLayout.marginsPx.top,
+            location: {
+              kind: "paragraph",
+              nodeIndex: segment.nodeIndex
+            },
+            floatingMovePreview: interaction?.floatingMovePreview,
+            resizePreview: interaction?.resizePreview,
+            foreignExclusions: previousObstacles ? resolveForeignWrapExclusionsForFlowRange(
+              previousObstacles,
+              segment.nodeIndex,
+              flowTopPx,
+              flowTopPx + (flowHeightPxBySegmentIndex2[segmentIndex] ?? 0)
+            ) : void 0
+          }
+        )
+      );
+    }
+    return obstacles2;
+  };
+  const baseFlowTopPxBySegmentIndex = flowTopsFromHeights(
+    baseFlowHeightPxBySegmentIndex
+  );
+  const firstPassObstacles = collectObstacles(
+    baseFlowTopPxBySegmentIndex,
+    baseFlowHeightPxBySegmentIndex
+  );
+  let flowTopPxBySegmentIndex = baseFlowTopPxBySegmentIndex;
+  let flowHeightPxBySegmentIndex = baseFlowHeightPxBySegmentIndex;
+  let obstacles = firstPassObstacles;
+  const hasInteractionPreview = Boolean(
+    interaction?.floatingMovePreview || interaction?.resizePreview
+  );
+  const hasFloatingTableObstacle = segments.some((segment) => {
+    const node = model.nodes[segment.nodeIndex];
+    return node?.type === "table" && Boolean(node.style?.floating) && !segment.tableRowRange;
+  });
+  if ((hasInteractionPreview || hasFloatingTableObstacle) && firstPassObstacles.length > 0) {
+    const reflowHeightPxBySegmentIndex = segments.map(
+      (segment, segmentIndex) => {
+        const baseHeightPx = baseFlowHeightPxBySegmentIndex[segmentIndex] ?? 0;
+        const node = model.nodes[segment.nodeIndex];
+        if (node?.type !== "paragraph" || segment.tableRowRange || segment.tableRowSlice || segment.paragraphLineRange) {
+          return baseHeightPx;
+        }
+        if (node.children.some(
+          (child) => child.type === "image" && shouldRenderWrappedFloatingImage(child)
+        )) {
+          return baseHeightPx;
+        }
+        const flowTopPx = baseFlowTopPxBySegmentIndex[segmentIndex] ?? 0;
+        const foreignExclusions = resolveForeignWrapExclusionsForFlowRange(
+          firstPassObstacles,
+          segment.nodeIndex,
+          flowTopPx,
+          flowTopPx + baseHeightPx
+        );
+        if (foreignExclusions.length === 0) {
+          return baseHeightPx;
         }
-      )
+        const source = buildParagraphPretextLayoutSource(node);
+        if (!source) {
+          return baseHeightPx;
+        }
+        const textWidthPx = paragraphAvailableTextWidthPx(
+          node,
+          segmentWidthPxAt(segment.nodeIndex),
+          numberingDefinitions
+        );
+        const lineHeightPx = Math.max(
+          1,
+          Math.round(
+            estimateParagraphLineHeightPx(
+              node,
+              docGridLinePitchPxByNodeIndex.get(segment.nodeIndex)
+            )
+          )
+        );
+        const unexcludedLayout = layoutParagraphPretextSource(
+          node,
+          source,
+          textWidthPx,
+          lineHeightPx,
+          []
+        );
+        const excludedLayout = layoutParagraphPretextSource(
+          node,
+          source,
+          textWidthPx,
+          lineHeightPx,
+          foreignExclusions
+        );
+        if (!unexcludedLayout || !excludedLayout) {
+          return baseHeightPx;
+        }
+        const lineExtentPx = (layout) => layout.lines.length > 0 ? (layout.lines[layout.lines.length - 1]?.y ?? 0) + lineHeightPx : 0;
+        return baseHeightPx + Math.max(
+          0,
+          lineExtentPx(excludedLayout) - lineExtentPx(unexcludedLayout)
+        );
+      }
+    );
+    flowHeightPxBySegmentIndex = reflowHeightPxBySegmentIndex;
+    flowTopPxBySegmentIndex = flowTopsFromHeights(reflowHeightPxBySegmentIndex);
+    obstacles = collectObstacles(
+      flowTopPxBySegmentIndex,
+      flowHeightPxBySegmentIndex,
+      firstPassObstacles
     );
   }
-  const result = segments.map(
-    (segment, segmentIndex) => resolveForeignWrapExclusionsForFlowRange(
+  const result = segments.map((segment, segmentIndex) => {
+    const segmentLineRange = segment.paragraphLineRange;
+    const segmentCoversWholeParagraph = !segmentLineRange || segmentLineRange.startLineIndex === 0 && segmentLineRange.endLineIndex >= segmentLineRange.totalLineCount;
+    const measuredParagraphBand = segmentCoversWholeParagraph ? measuredBandAt(`para:${segment.nodeIndex}`) : void 0;
+    const flowTopPx = measuredParagraphBand?.topPx ?? flowTopPxBySegmentIndex[segmentIndex] ?? 0;
+    const flowBottomPx = measuredParagraphBand?.bottomPx ?? flowTopPx + (flowHeightPxBySegmentIndex[segmentIndex] ?? 0);
+    return resolveForeignWrapExclusionsForFlowRange(
       obstacles,
       segment.nodeIndex,
-      flowTopPxBySegmentIndex[segmentIndex] ?? 0,
-      (flowTopPxBySegmentIndex[segmentIndex] ?? 0) + (flowHeightPxBySegmentIndex[segmentIndex] ?? 0)
-    )
+      flowTopPx,
+      flowBottomPx
+    );
+  });
+  const measuredBands = interaction?.floatingMovePreview?.measuredBands;
+  const draggedAnchorNodeIndex = (() => {
+    const key = interaction?.floatingMovePreview?.imageKey;
+    const match = key ? /^p:(\d+):/.exec(key) : null;
+    return match ? Number.parseInt(match[1], 10) : void 0;
+  })();
+  if (!measuredBands || draggedAnchorNodeIndex === void 0) {
+    return result;
+  }
+  const measuredFlowBandAt = (nodeIndex) => {
+    const band = measuredBands.hostByNodeIndex[nodeIndex];
+    if (!band) {
+      return void 0;
+    }
+    return {
+      top: band.topPx - pageLayout.marginsPx.top,
+      bottom: band.bottomPx - pageLayout.marginsPx.top
+    };
+  };
+  const anchorSegmentIndex = segments.findIndex(
+    (segment) => segment.nodeIndex === draggedAnchorNodeIndex
   );
-  return result;
+  const anchorMeasuredBand = measuredFlowBandAt(draggedAnchorNodeIndex);
+  if (anchorSegmentIndex < 0 || !anchorMeasuredBand) {
+    return result;
+  }
+  const anchorEstimatedFlowTopPx = flowTopPxBySegmentIndex[anchorSegmentIndex] ?? 0;
+  const draggedObstacles = [];
+  const otherObstacles = [];
+  for (const obstacle of obstacles) {
+    if (obstacle.sourceNodeIndex === draggedAnchorNodeIndex) {
+      draggedObstacles.push({
+        ...obstacle,
+        top: obstacle.top - anchorEstimatedFlowTopPx + anchorMeasuredBand.top,
+        bottom: obstacle.bottom - anchorEstimatedFlowTopPx + anchorMeasuredBand.top
+      });
+    } else {
+      otherObstacles.push(obstacle);
+    }
+  }
+  if (draggedObstacles.length === 0) {
+    return result;
+  }
+  return segments.map((segment, segmentIndex) => {
+    const node = model.nodes[segment.nodeIndex];
+    const measuredBand = measuredFlowBandAt(segment.nodeIndex);
+    if (node?.type !== "paragraph" || segment.nodeIndex === draggedAnchorNodeIndex || !measuredBand) {
+      return result[segmentIndex] ?? [];
+    }
+    return [
+      ...resolveForeignWrapExclusionsForFlowRange(
+        otherObstacles,
+        segment.nodeIndex,
+        flowTopPxBySegmentIndex[segmentIndex] ?? 0,
+        (flowTopPxBySegmentIndex[segmentIndex] ?? 0) + (flowHeightPxBySegmentIndex[segmentIndex] ?? 0)
+      ),
+      ...resolveForeignWrapExclusionsForFlowRange(
+        draggedObstacles,
+        segment.nodeIndex,
+        measuredBand.top,
+        measuredBand.bottom
+      ).map((exclusion) => ({ ...exclusion, fromDragPreview: true }))
+    ];
+  });
 }
 function applyWrappedFloatingInteractionPreviewToParagraph(paragraph, location, paragraphRenderTextWidthPx, options) {
   const hasInteractionPreview = Boolean(
@@ -8955,12 +9780,27 @@ function layoutParagraphPretextSource(paragraph, source, containerWidthPx, lineH
   );
   const wordBreak = pretextWordBreakModeForText(source.text);
   const items = buildParagraphPretextLayoutItems(paragraph, source);
+  const firstLineIndentPx = twipsToSignedPixels(
+    paragraph.style?.indent?.firstLineTwips
+  );
+  const layoutExclusions = Number.isFinite(firstLineIndentPx) && firstLineIndentPx > 0 ? [
+    ...exclusions ?? [],
+    {
+      left: 0,
+      right: Math.min(
+        Math.max(1, Math.round(containerWidthPx)),
+        Math.round(firstLineIndentPx)
+      ),
+      top: 0,
+      bottom: 1
+    }
+  ] : exclusions;
   const richLayout = items.length > 0 ? layoutItemsWithPretextAroundExclusions(
     source.text,
     items,
     containerWidthPx,
     lineHeightPx,
-    exclusions,
+    layoutExclusions,
     fallbackFont
   ) : void 0;
   if (richLayout) {
@@ -8971,7 +9811,7 @@ function layoutParagraphPretextSource(paragraph, source, containerWidthPx, lineH
     fallbackFont,
     containerWidthPx,
     lineHeightPx,
-    exclusions,
+    layoutExclusions,
     {
       wordBreak
     }
@@ -9098,6 +9938,7 @@ function resolveDualWrappedFloatingImageGeometry(image, containerWidthPx, option
   const rawImageTopPx = (hasExplicitBaseTopPx ? baseTopPx : paragraphLocalBaseTopPx + (isInlinePreview ? 0 : distTPx)) + deltaY;
   const modelAllowsNegativeTop = Number.isFinite(floating?.yPx) && floating?.yPx < 0;
   const imageTopPx = options?.allowNegativeImageTop || modelAllowsNegativeTop ? Math.round(rawImageTopPx) : Math.max(0, Math.round(rawImageTopPx));
+  const horizontalAlignIsOperative = !hasExplicitBaseLeftPx && !Number.isFinite(floating?.xPx);
   let exclusionLeftPx = Math.max(0, imageLeftPx - distLPx);
   let exclusionRightPx = Math.min(
     safeContainerWidthPx,
@@ -9106,9 +9947,9 @@ function resolveDualWrappedFloatingImageGeometry(image, containerWidthPx, option
   if (wrapType === "topAndBottom") {
     exclusionLeftPx = 0;
     exclusionRightPx = safeContainerWidthPx;
-  } else if (horizontalAlign === "left" || horizontalAlign === "inside") {
+  } else if (horizontalAlignIsOperative && (horizontalAlign === "left" || horizontalAlign === "inside")) {
     exclusionLeftPx = 0;
-  } else if (horizontalAlign === "right" || horizontalAlign === "outside") {
+  } else if (horizontalAlignIsOperative && (horizontalAlign === "right" || horizontalAlign === "outside")) {
     exclusionRightPx = safeContainerWidthPx;
   }
   if (!isInlinePreview && wrapType !== "topAndBottom") {
@@ -12010,6 +12851,9 @@ function estimateRenderedPageSegmentHeightPx(node, segment, model, availableWidt
       )
     );
   }
+  if (node.type === "table" && node.style?.floating) {
+    return 0;
+  }
   return Math.max(
     MIN_PARAGRAPH_LINE_HEIGHT_PX,
     estimateTableHeightPx(
@@ -12338,7 +13182,7 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
   const preferLastRenderedParagraphStartBreaks = options?.preferLastRenderedParagraphStartBreaks ?? false;
   const strictLastRenderedParagraphStartBreaks = options?.strictLastRenderedParagraphStartBreaks ?? false;
   const hardBreakStartNodeIndexes = collectDocxHardPageBreakStartNodeIndexes(model);
-  const paginationNumberingLabels = buildParagraphNumberingLabels(model);
+  const paginationNumberingLabels = options?.precomputedNumberingLabels ?? buildParagraphNumberingLabels(model);
   const sectionStartPageBreakNodeIndexes = collectDocxSectionStartPageBreakNodeIndexes(model);
   const nextHardBreakStartNodeIndexByNodeIndex = buildNextHardBreakStartNodeIndexLookup(
     model.nodes.length,
@@ -12910,6 +13754,11 @@ function buildDocumentPageNodeSegments(model, pageContentHeightPx, pageContentWi
       previousParagraphAfterPx = afterSpacingPx;
       continue;
     }
+    if (node.style?.floating) {
+      currentPageSegments.push({ nodeIndex });
+      previousParagraphAfterPx = 0;
+      continue;
+    }
     const measuredRowHeightsPxRaw = options?.measuredTableRowHeightsByNodeIndex?.[nodeIndex];
     const measuredRowHeightsPx = measuredRowHeightsPxRaw && measuredRowHeightsPxRaw.length === node.rows.length ? measuredRowHeightsPxRaw.map(
       (heightPx) => Math.max(
@@ -13444,6 +14293,22 @@ function absoluteFloatingImageStyle(image, options) {
   }
   return style;
 }
+function normalizeFloatingDragDeltaForZoom(screenDeltaPx, zoomScale) {
+  const safeScale = Number.isFinite(zoomScale) && zoomScale > 0 ? zoomScale : 1;
+  return screenDeltaPx / safeScale;
+}
+function normalizeFloatingDropRectForZoom(rect, zoomScale) {
+  const safeScale = Number.isFinite(zoomScale) && zoomScale > 0 ? zoomScale : 1;
+  if (safeScale === 1) {
+    return rect;
+  }
+  return {
+    left: rect.left / safeScale,
+    top: rect.top / safeScale,
+    ...Number.isFinite(rect.width) ? { width: rect.width / safeScale } : void 0,
+    ...Number.isFinite(rect.height) ? { height: rect.height / safeScale } : void 0
+  };
+}
 function resolveAbsoluteFloatingImageDropPatch(floating, layout, options) {
   const nextLeftPx = options.wrapperRect.left + Math.round(options.deltaX);
   const nextTopPx = options.wrapperRect.top + Math.round(options.deltaY);
@@ -13515,11 +14380,9 @@ function resolveWrappedFloatingImageDropPatch(image, hostWidth, movedLeft, moved
     }
   );
   const previewUsesSideFloat = previewGeometry === void 0 || previewGeometry.exclusion.left <= 0 || previewGeometry.exclusion.right >= hostWidth;
-  const rawExplicitTopPx = Math.round(
+  const explicitTopPx = Math.round(
     movedTop - Math.round(baseFloating.distTPx ?? 0)
   );
-  const currentTopPx = Math.round(baseFloating.yPx ?? 0);
-  const explicitTopPx = wrapType.trim().toLowerCase() === "topandbottom" && Math.abs(rawExplicitTopPx - currentTopPx) < TOP_AND_BOTTOM_VERTICAL_DRAG_SNAP_PX ? currentTopPx : rawExplicitTopPx;
   return {
     wrapType,
     wrapText,
@@ -13535,6 +14398,47 @@ function resolveWrappedFloatingImageDropPatch(image, hostWidth, movedLeft, moved
     behindDocument: false
   };
 }
+function resolveWrappedDropAnchorParagraphHost(wrapperElement, droppedTopScreenPx, droppedLeftScreenPx) {
+  const viewerRoot = wrapperElement.closest("[data-testid='docx-editor-viewer']") ?? wrapperElement.ownerDocument;
+  if (!viewerRoot) {
+    return void 0;
+  }
+  const hosts = Array.from(
+    viewerRoot.querySelectorAll(
+      "[data-docx-paragraph-host='true'][data-docx-paragraph-kind='paragraph'][data-docx-paragraph-node-index]"
+    )
+  );
+  let best;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (const host of hosts) {
+    const nodeIndex = Number.parseInt(
+      host.getAttribute("data-docx-paragraph-node-index") ?? "",
+      10
+    );
+    if (!Number.isFinite(nodeIndex)) {
+      continue;
+    }
+    const rect = host.getBoundingClientRect();
+    if (rect.width <= 0 && rect.height <= 0) {
+      continue;
+    }
+    const verticalDistance = droppedTopScreenPx < rect.top ? rect.top - droppedTopScreenPx : droppedTopScreenPx >= rect.bottom ? droppedTopScreenPx - rect.bottom : 0;
+    const horizontalDistance = droppedLeftScreenPx < rect.left ? rect.left - droppedLeftScreenPx : droppedLeftScreenPx > rect.right ? droppedLeftScreenPx - rect.right : 0;
+    const distance = verticalDistance * 4 + horizontalDistance;
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      best = { host, nodeIndex, rect };
+    }
+  }
+  return best;
+}
+function wrappedDragCanReanchorToParagraph(floating) {
+  if (!floatingImageMovesWithText(floating)) {
+    return true;
+  }
+  const verticalRelativeTo = floating.verticalRelativeTo?.trim().toLowerCase() ?? "";
+  return verticalRelativeTo === "" || verticalRelativeTo === "paragraph" || verticalRelativeTo === "line";
+}
 function resolvePageSpanningAbsoluteFloatingDimensions(image, widthPx, heightPx, floatingPageOriginPx) {
   const floating = image.floating;
   const pageWidthPx = Number.isFinite(floatingPageOriginPx?.pageWidth) ? Math.max(1, Math.round(floatingPageOriginPx?.pageWidth)) : void 0;
@@ -17498,6 +18402,7 @@ function createEmptyParagraphFromTemplate(template) {
   const nextTextStyle = cloneTextStyle2(firstRunStyle(template));
   return {
     type: "paragraph",
+    blockId: allocateBlockId(),
     style: cloneParagraphStyle2(template?.style),
     children: [
       {
@@ -17648,6 +18553,65 @@ function resolveFloatingTableSide(table) {
   }
   return "left";
 }
+function estimateFloatingTableWidthPx(table, containerWidthPx) {
+  const explicitWidthPx = twipsToPixels(table.style?.widthTwips);
+  const columnWidthsTwips = table.style?.columnWidthsTwips;
+  const columnsWidthPx = columnWidthsTwips && columnWidthsTwips.length > 0 ? columnWidthsTwips.reduce(
+    (total, widthTwips) => total + (twipsToPixels(widthTwips) ?? 0),
+    0
+  ) : void 0;
+  return Math.max(
+    24,
+    Math.min(
+      Math.max(1, Math.round(containerWidthPx)),
+      Math.round(explicitWidthPx ?? columnsWidthPx ?? containerWidthPx)
+    )
+  );
+}
+function resolveFloatingTableGeometry(table, containerWidthPx, options) {
+  const floating = table.style?.floating;
+  if (!floating) {
+    return void 0;
+  }
+  const safeContainerWidthPx = Math.max(1, Math.round(containerWidthPx));
+  const tableWidthPx = Math.max(1, Math.round(options.tableWidthPx));
+  const tableHeightPx = Math.max(0, Math.round(options.tableHeightPx));
+  const distLPx = twipsToPixels(floating.leftFromTextTwips) ?? 0;
+  const distRPx = twipsToPixels(floating.rightFromTextTwips) ?? 0;
+  const distTPx = twipsToPixels(floating.topFromTextTwips) ?? 0;
+  const distBPx = twipsToPixels(floating.bottomFromTextTwips) ?? 0;
+  const xPx = twipsToSignedPixels(floating.xTwips);
+  const yPx = twipsToSignedPixels(floating.yTwips);
+  const horizontalAnchor = floating.horizontalAnchor?.trim().toLowerCase();
+  const verticalAnchor = floating.verticalAnchor?.trim().toLowerCase();
+  const horizontalAlign = floating.horizontalAlign?.trim().toLowerCase();
+  const flowTopPx = Math.round(options.flowTopPx ?? 0);
+  const deltaX = Math.round(options.deltaX ?? 0);
+  const deltaY = Math.round(options.deltaY ?? 0);
+  const leftPx = (xPx !== void 0 ? horizontalAnchor === "page" ? xPx - Math.round(options.pageMarginLeftPx ?? 0) : xPx : horizontalAlign === "right" || horizontalAlign === "outside" ? safeContainerWidthPx - tableWidthPx - distRPx : horizontalAlign === "center" ? Math.round((safeContainerWidthPx - tableWidthPx) / 2) : horizontalAlign === "left" || horizontalAlign === "inside" ? distLPx : Math.round(options.indentPx ?? 0)) + deltaX;
+  const topPx = (yPx !== void 0 ? verticalAnchor === "margin" ? yPx - flowTopPx : verticalAnchor === "page" ? yPx - Math.round(options.pageMarginTopPx ?? 0) - flowTopPx : yPx : 0) + deltaY;
+  let exclusionLeftPx = Math.max(0, leftPx - distLPx);
+  let exclusionRightPx = Math.min(
+    safeContainerWidthPx,
+    leftPx + tableWidthPx + distRPx
+  );
+  if (exclusionLeftPx > 0 && exclusionLeftPx < MIN_DUAL_WRAPPED_INTERIOR_BAND_PX) {
+    exclusionLeftPx = 0;
+  }
+  if (exclusionRightPx < safeContainerWidthPx && safeContainerWidthPx - exclusionRightPx < MIN_DUAL_WRAPPED_INTERIOR_BAND_PX) {
+    exclusionRightPx = safeContainerWidthPx;
+  }
+  return {
+    leftPx,
+    topPx,
+    exclusion: {
+      left: exclusionLeftPx,
+      right: exclusionRightPx,
+      top: topPx - distTPx,
+      bottom: topPx + tableHeightPx + distBPx
+    }
+  };
+}
 function tableWrapperStyle(table, indentPx) {
   const floating = table.style?.floating;
   if (!floating) {
@@ -20182,6 +21146,22 @@ function shouldReissueDomSelectionRestore(options) {
   }
   return options.modelChanged;
 }
+function stableInnerHtmlProp(cache, key, html) {
+  const cached = cache.get(key);
+  if (cached && cached.__html === html) {
+    return cached;
+  }
+  const next = { __html: html };
+  cache.set(key, next);
+  return next;
+}
+function isCompositionKeyboardEvent(event) {
+  const nativeKeyboardEvent = event.nativeEvent;
+  if (nativeKeyboardEvent?.isComposing) {
+    return true;
+  }
+  return event.keyCode === 229;
+}
 function shouldSyncActiveRangeOnKeyUp(event) {
   const nativeKeyboardEvent = event.nativeEvent;
   if (nativeKeyboardEvent?.isComposing) {
@@ -20726,12 +21706,14 @@ function updateSectionImageFloatingAtLocation(model, location, patch) {
   });
   return changed ? next : model;
 }
+var NO_TRACKED_CHANGES = [];
+var NO_COMMENTS = [];
 function useDocxEditor(options = {}) {
   const starterTemplateRef = React.useRef(
-    cloneDocModel(options.starterModel ?? defaultStarterModel)
+    cloneDocModelWithBlockIds(options.starterModel ?? defaultStarterModel)
   );
   const [model, setModel] = React.useState(
-    () => cloneDocModel(starterTemplateRef.current)
+    () => cloneDocModelWithBlockIds(starterTemplateRef.current)
   );
   const [basePackage, setBasePackage] = React.useState();
   const [documentLoadNonce, setDocumentLoadNonce] = React.useState(0);
@@ -20775,6 +21757,9 @@ function useDocxEditor(options = {}) {
     pendingRunStyle
   );
   const suppressNextDomSelectionRestoreRef = React.useRef(false);
+  const textCommitBurstRef = React.useRef(
+    void 0
+  );
   const domSelectionRestoreModelRef = React.useRef(model);
   const selectionSessionRef = React.useRef("idle");
   const selectionSessionTimeoutRef = React.useRef(null);
@@ -20786,6 +21771,17 @@ function useDocxEditor(options = {}) {
   React.useEffect(() => {
     modelRef.current = model;
   }, [model]);
+  React.useEffect(() => {
+    if (typeof process === "undefined" || process.env?.NODE_ENV === "production") {
+      return;
+    }
+    const duplicateBlockIds = collectDuplicateDocModelBlockIds(model);
+    if (duplicateBlockIds.length > 0) {
+      console.error(
+        `Duplicate doc-model block ids detected (an op copied a node without allocating a fresh id): ${duplicateBlockIds.join(", ")}`
+      );
+    }
+  }, [model]);
   React.useEffect(() => {
     selectionRef.current = selection;
   }, [selection]);
@@ -21067,12 +22063,13 @@ function useDocxEditor(options = {}) {
   }, [activeTextRange, selectedParagraph, selectedParagraphLocation]);
   const selectedListType = selectedParagraph ? paragraphListType(selectedParagraph, model.metadata.numberingDefinitions) : void 0;
   const trackedChanges = React.useMemo(
-    () => collectTrackedChangesFromModel(model),
-    [model]
+    () => showTrackedChanges ? collectTrackedChangesFromModel(model) : NO_TRACKED_CHANGES,
+    [model, showTrackedChanges]
+  );
+  const comments = React.useMemo(
+    () => showComments ? collectCommentsFromModel(model) : NO_COMMENTS,
+    [model, showComments]
   );
-  const comments = React.useMemo(() => collectCommentsFromModel(model), [
-    model
-  ]);
   const hasUnorderedList = selectedListType === "unordered";
   const hasOrderedList = selectedListType === "ordered";
   const canUndo = history.past.length > 0;
@@ -21395,7 +22392,7 @@ function useDocxEditor(options = {}) {
     activeImportAbortControllerRef.current?.abort();
     activeImportAbortControllerRef.current = void 0;
     unloadEmbeddedFonts();
-    setModel(cloneDocModel(starterTemplateRef.current));
+    setModel(cloneDocModelWithBlockIds(starterTemplateRef.current));
     setDocumentLoadNonce((current) => current + 1);
     setBasePackage(void 0);
     setFileName("(new document)");
@@ -21432,6 +22429,7 @@ function useDocxEditor(options = {}) {
     setStatus("Exported DOCX");
   }, [basePackage, fileName]);
   const undo = React.useCallback(() => {
+    textCommitBurstRef.current = void 0;
     setHistory((currentHistory) => {
       const previousSnapshot = currentHistory.past[currentHistory.past.length - 1];
       const previous = previousSnapshot?.model;
@@ -21471,6 +22469,7 @@ function useDocxEditor(options = {}) {
     });
   }, []);
   const redo = React.useCallback(() => {
+    textCommitBurstRef.current = void 0;
     setHistory((currentHistory) => {
       const nextSnapshot = currentHistory.future[0];
       const next = nextSnapshot?.model;
@@ -22023,6 +23022,7 @@ function useDocxEditor(options = {}) {
             next.nodes = [
               {
                 type: "paragraph",
+                blockId: allocateBlockId(),
                 children: [
                   {
                     type: "text",
@@ -22222,6 +23222,7 @@ function useDocxEditor(options = {}) {
                   next.nodes = [
                     {
                       type: "paragraph",
+                      blockId: allocateBlockId(),
                       children: [{ type: "text", text: "" }]
                     }
                   ];
@@ -22261,6 +23262,7 @@ function useDocxEditor(options = {}) {
               next.nodes = [
                 {
                   type: "paragraph",
+                  blockId: allocateBlockId(),
                   children: [{ type: "text", text: "" }]
                 }
               ];
@@ -23000,6 +24002,7 @@ function useDocxEditor(options = {}) {
         paragraphNode.sourceXml = void 0;
         next.nodes.splice(insertionIndex, 0, {
           type: "paragraph",
+          blockId: allocateBlockId(),
           style: cloneParagraphStyle2(paragraphNode.style),
           children: [
             {
@@ -23096,6 +24099,7 @@ function useDocxEditor(options = {}) {
         paragraphNode.sourceXml = void 0;
         next.nodes.splice(insertionIndex, 0, {
           type: "paragraph",
+          blockId: allocateBlockId(),
           style: cloneParagraphStyle2(splitParagraphStyle),
           children: splitChildren.afterChildren
         });
@@ -23142,6 +24146,7 @@ function useDocxEditor(options = {}) {
         0,
         {
           type: "table",
+          blockId: allocateBlockId(),
           style: {
             borders: createDefaultEditorTableBorders()
           },
@@ -23155,6 +24160,7 @@ function useDocxEditor(options = {}) {
                   nodes: [
                     {
                       type: "paragraph",
+                      blockId: allocateBlockId(),
                       children: [
                         {
                           type: "text",
@@ -23170,6 +24176,7 @@ function useDocxEditor(options = {}) {
                   nodes: [
                     {
                       type: "paragraph",
+                      blockId: allocateBlockId(),
                       children: [
                         {
                           type: "text",
@@ -23190,6 +24197,7 @@ function useDocxEditor(options = {}) {
                   nodes: [
                     {
                       type: "paragraph",
+                      blockId: allocateBlockId(),
                       children: [{ type: "text", text: "Value 1" }]
                     }
                   ]
@@ -23199,6 +24207,7 @@ function useDocxEditor(options = {}) {
                   nodes: [
                     {
                       type: "paragraph",
+                      blockId: allocateBlockId(),
                       children: [{ type: "text", text: "Value 2" }]
                     }
                   ]
@@ -23268,6 +24277,7 @@ function useDocxEditor(options = {}) {
         const next = cloneDocModel(current);
         next.nodes.push({
           type: "paragraph",
+          blockId: allocateBlockId(),
           children: [{ type: "text", text }]
         });
         return next;
@@ -23383,7 +24393,7 @@ function useDocxEditor(options = {}) {
     [applyModelChange]
   );
   const moveFloatingImage = React.useCallback(
-    (location, patch) => {
+    (location, patch, options2) => {
       applyModelChange((current) => {
         const next = cloneDocModel(current);
         const { paragraph, tableNode } = getParagraphAtLocation(
@@ -23401,6 +24411,16 @@ function useDocxEditor(options = {}) {
           ...child.floating ?? {},
           ...patch
         };
+        const reparentNodeIndex = options2?.reparentToParagraphNodeIndex;
+        const reparentTarget = reparentNodeIndex !== void 0 ? next.nodes[reparentNodeIndex] : void 0;
+        if (reparentTarget && reparentTarget.type === "paragraph" && reparentTarget !== paragraph) {
+          paragraph.children.splice(location.childIndex, 1);
+          if (paragraph.children.length === 0) {
+            paragraph.children.push({ type: "text", text: "" });
+          }
+          reparentTarget.children.unshift(child);
+          reparentTarget.sourceXml = void 0;
+        }
         paragraph.sourceXml = void 0;
         if (tableNode) {
           tableNode.sourceXml = void 0;
@@ -23660,6 +24680,7 @@ function useDocxEditor(options = {}) {
           const firstParagraph = paragraphs[0];
           const nextParagraph = {
             type: "paragraph",
+            blockId: allocateBlockId(),
             style: cloneParagraphStyle2(firstParagraph?.style),
             children: [
               {
@@ -23751,6 +24772,7 @@ function useDocxEditor(options = {}) {
         if (next.nodes.length === 0) {
           next.nodes.push({
             type: "paragraph",
+            blockId: allocateBlockId(),
             children: [{ type: "text", text: "" }]
           });
           nextSelection = { kind: "paragraph", nodeIndex: 0 };
@@ -23822,6 +24844,51 @@ function useDocxEditor(options = {}) {
     },
     [applyModelChange]
   );
+  const setTableFloating = React.useCallback(
+    (tableIndex, patch, options2) => {
+      applyModelChange((current) => {
+        const tableNode = current.nodes[tableIndex];
+        if (!tableNode || tableNode.type !== "table") {
+          return current;
+        }
+        const next = cloneDocModel(current);
+        const nextTable = next.nodes[tableIndex];
+        if (!nextTable || nextTable.type !== "table") {
+          return current;
+        }
+        nextTable.style = {
+          ...nextTable.style ?? {},
+          floating: {
+            ...nextTable.style?.floating ?? {},
+            ...patch
+          }
+        };
+        nextTable.sourceXml = void 0;
+        const moveToNodeIndex = options2?.moveToNodeIndex;
+        if (moveToNodeIndex !== void 0 && moveToNodeIndex !== tableIndex && moveToNodeIndex !== tableIndex + 1) {
+          const clampedTarget = clampNumber(
+            moveToNodeIndex,
+            0,
+            next.nodes.length
+          );
+          const extracted = next.nodes.splice(tableIndex, 1)[0];
+          if (extracted) {
+            next.nodes.splice(
+              clampNumber(
+                clampedTarget > tableIndex ? clampedTarget - 1 : clampedTarget,
+                0,
+                next.nodes.length
+              ),
+              0,
+              extracted
+            );
+          }
+        }
+        return next;
+      }, "Moved table");
+    },
+    [applyModelChange]
+  );
   const moveEmbeddedTableToBody = React.useCallback(
     (tableRuntimeKey, targetNodeIndex) => {
       const runtimeLocation = parseEmbeddedTableRuntimeKey(tableRuntimeKey);
@@ -24275,6 +25342,100 @@ function useDocxEditor(options = {}) {
     },
     [applyModelChange]
   );
+  const commitParagraphTextAtRange = React.useCallback(
+    (location, text, caret, options2) => {
+      const now = Date.now();
+      return dispatchEditorTransaction((current) => {
+        const paragraph = getParagraphAtLocation(
+          current.model,
+          location
+        ).paragraph;
+        if (!paragraph) {
+          return void 0;
+        }
+        const insertionOffset = options2?.insertionOffset ?? caret.start;
+        const insertedStyle = cloneTextStyle2(current.pendingRunStyle) ?? firstTextStyleAtOffset(paragraph, insertionOffset, false);
+        const nextModel = paragraphText(paragraph) === text ? current.model : updateParagraphTextAtLocation(current.model, location, text, {
+          insertedStyle
+        });
+        const coalesce = options2?.coalesceKey !== void 0 && shouldCoalesceTextCommit(textCommitBurstRef.current, {
+          key: options2.coalesceKey,
+          caretBefore: insertionOffset,
+          at: now
+        });
+        textCommitBurstRef.current = options2?.coalesceKey !== void 0 ? { key: options2.coalesceKey, caretAfter: caret.end, at: now } : void 0;
+        return {
+          model: nextModel,
+          selection: selectionFromTextRangeLocation(location),
+          activeTextRange: {
+            start: {
+              location: cloneTextRangeLocation(location),
+              offset: caret.start
+            },
+            end: {
+              location: cloneTextRangeLocation(location),
+              offset: caret.end
+            }
+          },
+          pushHistory: !coalesce,
+          clearSelectedFormField: true
+        };
+      });
+    },
+    [dispatchEditorTransaction]
+  );
+  const commitTableCellTextAtRange = React.useCallback(
+    (tableIndex, rowIndex, cellIndex, text, caret) => {
+      textCommitBurstRef.current = void 0;
+      return dispatchEditorTransaction((current) => {
+        const tableNode = current.model.nodes[tableIndex];
+        if (!tableNode || tableNode.type !== "table") {
+          return void 0;
+        }
+        if (!tableNode.rows[rowIndex]?.cells[cellIndex]) {
+          return void 0;
+        }
+        const caretLocation = {
+          kind: "table-cell",
+          tableIndex,
+          rowIndex,
+          cellIndex,
+          paragraphIndex: caret.paragraphIndex
+        };
+        const caretParagraph = getParagraphAtLocation(
+          current.model,
+          caretLocation
+        ).paragraph;
+        const insertedStyle = cloneTextStyle2(current.pendingRunStyle) ?? (caretParagraph ? firstTextStyleAtOffset(caretParagraph, caret.start, false) : void 0);
+        const nextModel = updateTableCellText(
+          current.model,
+          tableIndex,
+          rowIndex,
+          cellIndex,
+          text,
+          {
+            insertedStyle
+          }
+        );
+        return {
+          model: nextModel,
+          selection: selectionFromTextRangeLocation(caretLocation),
+          activeTextRange: {
+            start: {
+              location: cloneTextRangeLocation(caretLocation),
+              offset: caret.start
+            },
+            end: {
+              location: cloneTextRangeLocation(caretLocation),
+              offset: caret.end
+            }
+          },
+          clearSelectedFormField: true
+        };
+      });
+    },
+    [dispatchEditorTransaction]
+  );
   const commitSectionParagraphText = React.useCallback(
     (location, text) => {
       applyModelChange(
@@ -24403,12 +25564,15 @@ function useDocxEditor(options = {}) {
     deleteTableColumn,
     deleteTable,
     moveTable,
+    setTableFloating,
     moveEmbeddedTableToBody,
     replaceExpandedSelection,
     deleteExpandedSelection,
     commitParagraphText,
     commitTableCellText,
     commitTableCellParagraphTextRecursive,
+    commitParagraphTextAtRange,
+    commitTableCellTextAtRange,
     commitSectionParagraphText
   };
 }
@@ -26836,8 +28000,9 @@ function DocxEditorViewer({
     ]
   );
   const viewerRootRef = React.useRef(null);
-  const paragraphDraftsRef = React.useRef(/* @__PURE__ */ new Map());
   const tableCellDraftsRef = React.useRef(/* @__PURE__ */ new Map());
+  const editableParagraphHtmlPropsRef = React.useRef(/* @__PURE__ */ new Map());
+  const editableTableCellHtmlPropsRef = React.useRef(/* @__PURE__ */ new Map());
   const tableCellParagraphDraftsRef = React.useRef(
     /* @__PURE__ */ new Map()
   );
@@ -26850,9 +28015,27 @@ function DocxEditorViewer({
     /* @__PURE__ */ new Map()
   );
   const [
-    measuredParagraphOuterHeightsPxByNodeIndex,
-    setMeasuredParagraphOuterHeightsPxByNodeIndex
+    measuredParagraphOuterHeightsPxByBlockId,
+    setMeasuredParagraphOuterHeightsPxByBlockId
   ] = React.useState(() => /* @__PURE__ */ new Map());
+  const measuredParagraphOuterHeightsPxByNodeIndex = React.useMemo(() => {
+    const byNodeIndex = /* @__PURE__ */ new Map();
+    if (measuredParagraphOuterHeightsPxByBlockId.size === 0) {
+      return byNodeIndex;
+    }
+    editor.model.nodes.forEach((node, nodeIndex) => {
+      if (node.type !== "paragraph" || !node.blockId) {
+        return;
+      }
+      const outerHeightPx = measuredParagraphOuterHeightsPxByBlockId.get(
+        node.blockId
+      );
+      if (outerHeightPx !== void 0) {
+        byNodeIndex.set(nodeIndex, outerHeightPx);
+      }
+    });
+    return byNodeIndex;
+  }, [editor.model.nodes, measuredParagraphOuterHeightsPxByBlockId]);
   const tableCellEditorElementsRef = React.useRef(
     /* @__PURE__ */ new Map()
   );
@@ -26891,6 +28074,8 @@ function DocxEditorViewer({
   const tableDraftLayoutRefreshRafRef = React.useRef(null);
   const activeRangeFlushFrameRef = React.useRef(null);
   const pendingEditableCaretRef = React.useRef(null);
+  const editingIntentContinuationRef = React.useRef(void 0);
+  const compositionActiveRef = React.useRef(false);
   const pointerSelectionDragRef = React.useRef({ down: false, moved: false });
   const deferredCollapsedSelectionSyncTimeoutRef = React.useRef(
     null
@@ -26975,6 +28160,10 @@ function DocxEditorViewer({
     measuredPageContentIdentityKeysByIndex,
     setMeasuredPageContentIdentityKeysByIndex
   ] = React.useState([]);
+  const [
+    measuredPageContentValidationByIndex,
+    setMeasuredPageContentValidationByIndex
+  ] = React.useState([]);
   const [hasMeasuredBodyFooterOverlap, setHasMeasuredBodyFooterOverlap] = React.useState(false);
   const measuredBodyFooterOverlapCandidateRef = React.useRef({
     signature: void 0,
@@ -27034,6 +28223,7 @@ function DocxEditorViewer({
   React.useEffect(() => {
     setMeasuredPageContentHeightByIndex([]);
     setMeasuredPageContentIdentityKeysByIndex([]);
+    setMeasuredPageContentValidationByIndex([]);
     setHasMeasuredBodyFooterOverlap(false);
     measuredBodyFooterOverlapCandidateRef.current = {
       signature: void 0,
@@ -27056,7 +28246,7 @@ function DocxEditorViewer({
     setActiveDropTarget(void 0);
     setIsDraggingImage(false);
     setActiveHeaderFooterEdit(void 0);
-    paragraphDraftsRef.current.clear();
+    editingIntentContinuationRef.current = void 0;
     tableCellDraftsRef.current.clear();
     tableCellParagraphDraftsRef.current.clear();
     sectionParagraphDraftsRef.current.clear();
@@ -27104,6 +28294,7 @@ function DocxEditorViewer({
   const suppressNextTableCellClickRef = React.useRef(false);
   const [tableCellSelectionRange, setTableCellSelectionRange] = React.useState();
   const [tableMoveDropPreview, setTableMoveDropPreview] = React.useState();
+  const [tableFloatingDragPreview, setTableFloatingDragPreview] = React.useState();
   const [tableContextMenuState, setTableContextMenuState] = React.useState();
   const [contextMenuState, setContextMenuState] = React.useState();
   const [activeHeaderFooterEdit, setActiveHeaderFooterEdit] = React.useState();
@@ -27113,13 +28304,36 @@ function DocxEditorViewer({
   );
   const [paragraphStructureEpoch, bumpParagraphStructureEpoch] = React.useReducer((value) => value + 1, 0);
   const [paginationMeasurementEpoch, bumpPaginationMeasurementEpoch] = React.useReducer((value) => value + 1, 0);
+  const [measuredWrapBands, setMeasuredWrapBands] = React.useState(() => /* @__PURE__ */ new Map());
+  const wrapBandReconcileModelRef = React.useRef(void 0);
+  const wrapBandReconcilePassCountRef = React.useRef(0);
   const paginationMeasurementSuspendUntilRef = React.useRef(0);
   const paginationMeasurementResumeTimeoutRef = React.useRef(
     null
   );
   React.useLayoutEffect(() => {
-    setMeasuredParagraphOuterHeightsPxByNodeIndex(/* @__PURE__ */ new Map());
-  }, [editor.documentLoadNonce, paragraphStructureEpoch]);
+    setMeasuredParagraphOuterHeightsPxByBlockId(/* @__PURE__ */ new Map());
+  }, [editor.documentLoadNonce]);
+  React.useEffect(() => {
+    setMeasuredParagraphOuterHeightsPxByBlockId((current) => {
+      if (current.size === 0) {
+        return current;
+      }
+      const liveBlockIds = /* @__PURE__ */ new Set();
+      for (const node of editor.model.nodes) {
+        if (node.blockId) {
+          liveBlockIds.add(node.blockId);
+        }
+      }
+      let next;
+      current.forEach((_, blockId) => {
+        if (!liveBlockIds.has(blockId)) {
+          (next ??= new Map(current)).delete(blockId);
+        }
+      });
+      return next ?? current;
+    });
+  }, [editor.model.nodes]);
   const schedulePaginationMeasurementResume = React.useCallback(
     (delayMs) => {
       if (typeof window === "undefined") {
@@ -27215,6 +28429,7 @@ function DocxEditorViewer({
     setHoveredEmbeddedTableKey(void 0);
     setFocusedEmbeddedTableKey(void 0);
     setTableMoveDropPreview(void 0);
+    setTableFloatingDragPreview(void 0);
     tableMoveDragRef.current = void 0;
     setTableContextMenuState(void 0);
     setContextMenuState(void 0);
@@ -27269,18 +28484,12 @@ function DocxEditorViewer({
     const nextNodeCount = editor.model.nodes.length;
     const structureChanged = previousNodeCount !== nextNodeCount;
     if (structureChanged) {
-      paragraphDraftsRef.current.clear();
+      editingIntentContinuationRef.current = void 0;
       tableCellDraftsRef.current.clear();
       tableCellParagraphDraftsRef.current.clear();
       pendingTableCellFocusRef.current = void 0;
       bumpParagraphStructureEpoch();
     }
-    paragraphDraftsRef.current.forEach((_, nodeIndex) => {
-      const node = editor.model.nodes[nodeIndex];
-      if (!node || node.type !== "paragraph") {
-        paragraphDraftsRef.current.delete(nodeIndex);
-      }
-    });
     tableCellDraftsRef.current.forEach((_, draftKey) => {
       const [tableIndexRaw, rowIndexRaw, cellIndexRaw] = draftKey.split(":");
       const tableIndex = Number.parseInt(tableIndexRaw ?? "", 10);
@@ -27332,6 +28541,27 @@ function DocxEditorViewer({
     () => buildPaginationSectionMetrics(documentSections, documentLayout),
     [documentLayout, documentSections]
   );
+  const paginationMeasurementContextSignature = React.useMemo(
+    () => [
+      Math.round(documentLayout.pageWidthPx),
+      Math.round(documentLayout.pageHeightPx),
+      Math.round(documentLayout.marginsPx.top),
+      Math.round(documentLayout.marginsPx.bottom),
+      Math.round(documentLayout.marginsPx.left),
+      Math.round(documentLayout.marginsPx.right),
+      trackedChangesEnabled ? "tc1" : "tc0",
+      docNodeContentSignature(paginationSectionMetrics)
+    ].join("|"),
+    [documentLayout, paginationSectionMetrics, trackedChangesEnabled]
+  );
+  React.useEffect(() => {
+    setMeasuredParagraphOuterHeightsPxByBlockId(
+      (current) => current.size === 0 ? current : /* @__PURE__ */ new Map()
+    );
+    setTableMeasuredRowHeights(
+      (current) => Object.keys(current).length === 0 ? current : {}
+    );
+  }, [paginationMeasurementContextSignature]);
   const {
     docGridLinePitchPxByNodeIndex,
     pageContentWidthPxByNodeIndex,
@@ -27429,6 +28659,7 @@ function DocxEditorViewer({
       tableMeasuredRowHeights,
       {
         allowMeasuredImportPagination,
+        allowContentSignatureValidatedTables: !disableMeasuredImportPagination,
         activeDraftKeys,
         numberingDefinitions: editor.model.metadata.numberingDefinitions,
         pageContentWidthPxByNodeIndex,
@@ -27459,36 +28690,52 @@ function DocxEditorViewer({
     );
     const suppressSpacingBeforeAfterPageBreak = editor.model.metadata.compatibility?.suppressSpacingBeforeAfterPageBreak === true;
     const preferLastRenderedParagraphStartBreaks = !editor.canUndo && !editor.canRedo;
-    const canUseMeasuredPageContentHeights = !editor.canUndo && !editor.canRedo && !disableMeasuredImportPagination && !floatingMovePreview && !dropCapMovePreview && (measuredPageContentHeightByIndex?.length ?? 0) > 0;
+    const measuredPageContentHeightsPxForPagination = (measuredPageContentHeightByIndex?.length ?? 0) === 0 ? void 0 : !editor.canUndo && !editor.canRedo ? measuredPageContentHeightByIndex : resolveMeasuredPageContentHeightsPxForEditedModel(
+      editor.model.nodes,
+      measuredPageContentHeightByIndex,
+      measuredPageContentValidationByIndex,
+      paginationMeasurementContextSignature
+    );
+    const canUseMeasuredPageContentHeights = !disableMeasuredImportPagination && !floatingMovePreview && !dropCapMovePreview && (measuredPageContentHeightsPxForPagination?.length ?? 0) > 0;
+    const buildEstimatedPagesForInputs = createEstimatedPagesBuildMemo(
+      (measuredTableRowHeightsByNodeIndex, measuredPageContentHeightsPx, strictLastRenderedParagraphStartBreaks) => {
+        const buildPagesWithHeights = (resolvedPageContentHeights) => buildDocumentPageNodeSegments(
+          editor.model,
+          pageContentHeightPx,
+          pageContentWidthPx,
+          editor.model.metadata.numberingDefinitions,
+          paginationSectionMetrics,
+          {
+            allowParagraphLineSplitting: true,
+            suppressSpacingBeforeAfterPageBreak,
+            preferLastRenderedParagraphStartBreaks,
+            strictLastRenderedParagraphStartBreaks,
+            measuredTableRowHeightsByNodeIndex,
+            measuredPageContentHeightsPxByPageIndex: resolvedPageContentHeights,
+            measuredParagraphOuterHeightsPxByNodeIndex,
+            precomputedNumberingLabels: paragraphNumberingLabels
+          }
+        );
+        const basePages = buildPagesWithHeights(measuredPageContentHeightsPx);
+        return applyEstimatedFootnoteReserveToPages(
+          editor.model,
+          basePages,
+          pageContentHeightPx,
+          pageContentWidthPx,
+          paginationSectionMetrics,
+          editor.model.metadata.numberingDefinitions,
+          editor.model.metadata.footnotes ?? [],
+          (pageContentHeightsOverride) => buildPagesWithHeights(pageContentHeightsOverride)
+        );
+      }
+    );
     const buildEstimatedPages = (measuredTableRowHeightsByNodeIndex, measuredPageContentHeightsOverride, paginationOptions) => {
-      const allowMeasuredPageContentHeights = !editor.canUndo && !editor.canRedo && !disableMeasuredImportPagination && !floatingMovePreview && !dropCapMovePreview;
-      const baseMeasuredHeights = !allowMeasuredPageContentHeights || measuredPageContentHeightsOverride === null ? void 0 : measuredPageContentHeightsOverride ?? measuredPageContentHeightByIndex;
-      const buildPagesWithHeights = (resolvedPageContentHeights) => buildDocumentPageNodeSegments(
-        editor.model,
-        pageContentHeightPx,
-        pageContentWidthPx,
-        editor.model.metadata.numberingDefinitions,
-        paginationSectionMetrics,
-        {
-          allowParagraphLineSplitting: true,
-          suppressSpacingBeforeAfterPageBreak,
-          preferLastRenderedParagraphStartBreaks,
-          strictLastRenderedParagraphStartBreaks: paginationOptions?.strictLastRenderedParagraphStartBreaks ?? false,
-          measuredTableRowHeightsByNodeIndex,
-          measuredPageContentHeightsPxByPageIndex: resolvedPageContentHeights,
-          measuredParagraphOuterHeightsPxByNodeIndex
-        }
-      );
-      const basePages = buildPagesWithHeights(baseMeasuredHeights);
-      return applyEstimatedFootnoteReserveToPages(
-        editor.model,
-        basePages,
-        pageContentHeightPx,
-        pageContentWidthPx,
-        paginationSectionMetrics,
-        editor.model.metadata.numberingDefinitions,
-        editor.model.metadata.footnotes ?? [],
-        (pageContentHeightsOverride) => buildPagesWithHeights(pageContentHeightsOverride)
+      const allowMeasuredPageContentHeights = !disableMeasuredImportPagination && !floatingMovePreview && !dropCapMovePreview;
+      const baseMeasuredHeights = !allowMeasuredPageContentHeights || measuredPageContentHeightsOverride === null ? void 0 : measuredPageContentHeightsOverride ?? measuredPageContentHeightsPxForPagination;
+      return buildEstimatedPagesForInputs(
+        measuredTableRowHeightsByNodeIndex,
+        baseMeasuredHeights,
+        paginationOptions?.strictLastRenderedParagraphStartBreaks ?? false
       );
     };
     const storedDocumentPageCount2 = editor.model.metadata.documentPageCount;
@@ -27527,7 +28774,7 @@ function DocxEditorViewer({
       tableMeasuredRowHeightsForPagination
     );
     let estimatedPagesUseMeasuredPageContentHeightsForRender = canUseMeasuredPageContentHeights;
-    let estimatedRenderMeasuredPageContentHeightsPxByPageIndex = canUseMeasuredPageContentHeights ? measuredPageContentHeightByIndex : void 0;
+    let estimatedRenderMeasuredPageContentHeightsPxByPageIndex = canUseMeasuredPageContentHeights ? measuredPageContentHeightsPxForPagination : void 0;
     let estimatedRenderPageContentHeightScale = void 0;
     const deferExpensiveInitialPaginationReconciliation = deferInitialPaginationPaint && !initialPaginationBackgroundRefinementUnlocked;
     if (deferExpensiveInitialPaginationReconciliation) {
@@ -27538,23 +28785,21 @@ function DocxEditorViewer({
         renderPageContentHeightScale: estimatedRenderPageContentHeightScale
       };
     }
-    if (measuredPageContentHeightByIndex && measuredPageContentHeightByIndex.length > 0) {
-      const pureEstimatedPages = buildEstimatedPages(
-        tableMeasuredRowHeightsForPagination,
-        null
-      );
-      const measuredPagesAreOnlySplitParagraphs = estimatedPages.length > 0 && estimatedPages.every(
-        (pageSegments) => documentPageContainsOnlySplitParagraphSegments(pageSegments)
-      );
-      const purePagesAreOnlySplitParagraphs = pureEstimatedPages.length > 0 && pureEstimatedPages.every(
-        (pageSegments) => documentPageContainsOnlySplitParagraphSegments(pageSegments)
-      );
-      if (measuredPagesAreOnlySplitParagraphs && purePagesAreOnlySplitParagraphs && pureEstimatedPages.length < estimatedPages.length) {
-        estimatedPages = pureEstimatedPages;
-        estimatedPagesUseMeasuredPageContentHeightsForRender = false;
-        estimatedRenderMeasuredPageContentHeightsPxByPageIndex = void 0;
-        estimatedRenderPageContentHeightScale = void 0;
+    const splitParagraphComparison = resolveMeasuredSplitParagraphPageComparison(
+      {
+        canUndo: editor.canUndo,
+        canRedo: editor.canRedo,
+        hasMeasuredPageContentHeights: (measuredPageContentHeightsPxForPagination?.length ?? 0) > 0,
+        measuredEstimatedPages: estimatedPages,
+        buildPureEstimatedPages: () => buildEstimatedPages(tableMeasuredRowHeightsForPagination, null),
+        pageContainsOnlySplitParagraphSegments: documentPageContainsOnlySplitParagraphSegments
       }
+    );
+    if (splitParagraphComparison.usedPureEstimatedPages) {
+      estimatedPages = splitParagraphComparison.pages;
+      estimatedPagesUseMeasuredPageContentHeightsForRender = false;
+      estimatedRenderMeasuredPageContentHeightsPxByPageIndex = void 0;
+      estimatedRenderPageContentHeightScale = void 0;
     }
     if (!editor.canUndo && !editor.canRedo && targetPageCount !== void 0 && tableMeasuredRowHeightsForPagination && !hasMultiColumnRenderedPageBreakHints) {
       const candidatePages = [
@@ -27567,7 +28812,7 @@ function DocxEditorViewer({
         {
           pages: buildEstimatedPages(void 0),
           useMeasuredPageContentHeightsForRender: canUseMeasuredPageContentHeights,
-          renderMeasuredPageContentHeightsPxByPageIndex: canUseMeasuredPageContentHeights ? measuredPageContentHeightByIndex : void 0,
+          renderMeasuredPageContentHeightsPxByPageIndex: canUseMeasuredPageContentHeights ? measuredPageContentHeightsPxForPagination : void 0,
           renderPageContentHeightScale: void 0
         },
         {
@@ -27598,7 +28843,7 @@ function DocxEditorViewer({
       }
     }
     const measuredPageHeightOverridesReduceContent = !editor.canUndo && !editor.canRedo && !floatingMovePreview && !dropCapMovePreview && estimatedPages.some((segments, pageIndex) => {
-      const measuredHeightPx = measuredPageContentHeightByIndex?.[pageIndex];
+      const measuredHeightPx = measuredPageContentHeightsPxForPagination?.[pageIndex];
       if (!Number.isFinite(measuredHeightPx)) {
         return false;
       }
@@ -27708,7 +28953,7 @@ function DocxEditorViewer({
         return {
           pages: hintAlignedPages,
           useMeasuredPageContentHeightsForRender: canUseMeasuredPageContentHeights,
-          renderMeasuredPageContentHeightsPxByPageIndex: canUseMeasuredPageContentHeights ? measuredPageContentHeightByIndex : void 0,
+          renderMeasuredPageContentHeightsPxByPageIndex: canUseMeasuredPageContentHeights ? measuredPageContentHeightsPxForPagination : void 0,
           renderPageContentHeightScale: void 0
         };
       }
@@ -27750,22 +28995,23 @@ function DocxEditorViewer({
           preferLastRenderedParagraphStartBreaks,
           measuredTableRowHeightsByNodeIndex,
           measuredPageContentHeightsPxByPageIndex: measuredPageContentHeightsOverride === null ? void 0 : scaleMeasuredPageContentHeights(
-            measuredPageContentHeightsOverride ?? measuredPageContentHeightByIndex,
+            measuredPageContentHeightsOverride ?? measuredPageContentHeightsPxForPagination,
             heightScale
           ),
-          measuredParagraphOuterHeightsPxByNodeIndex
+          measuredParagraphOuterHeightsPxByNodeIndex,
+          precomputedNumberingLabels: paragraphNumberingLabels
         }
       )
     });
     let reconciledCandidate = reconcileCandidatePages(
       estimatedPages,
       tableMeasuredRowHeightsForPagination,
-      estimatedPagesUseMeasuredPageContentHeightsForRender ? measuredPageContentHeightByIndex : null
+      estimatedPagesUseMeasuredPageContentHeightsForRender ? measuredPageContentHeightsPxForPagination : null
     );
     let reconciledPages = reconciledCandidate.pages;
     let reconciledPagesUseMeasuredPageContentHeightsForRender = estimatedPagesUseMeasuredPageContentHeightsForRender;
     let reconciledRenderMeasuredPageContentHeightsPxByPageIndex = reconciledPagesUseMeasuredPageContentHeightsForRender ? scaleMeasuredPageContentHeights(
-      measuredPageContentHeightByIndex,
+      measuredPageContentHeightsPxForPagination,
       reconciledCandidate.scale
     ) : void 0;
     let reconciledRenderPageContentHeightScale = void 0;
@@ -27826,7 +29072,10 @@ function DocxEditorViewer({
     hasMeasuredBodyFooterOverlap,
     initialPaginationBackgroundRefinementUnlocked,
     measuredPageContentHeightByIndex,
+    measuredPageContentValidationByIndex,
     measuredParagraphOuterHeightsPxByNodeIndex,
+    paginationMeasurementContextSignature,
+    paragraphNumberingLabels,
     tableMeasuredRowHeightsForPagination
   ]);
   const pageNodeSegmentsByPage = pageSegmentationPlan.pages;
@@ -28259,6 +29508,132 @@ function DocxEditorViewer({
     },
     [explicitPageVirtualizationZoomScale]
   );
+  React.useEffect(() => {
+    if (floatingMovePreview || resizePreview || tableFloatingDragPreview || tableMoveDragRef.current) {
+      return;
+    }
+    const modelChanged = wrapBandReconcileModelRef.current !== editor.model;
+    if (modelChanged) {
+      wrapBandReconcileModelRef.current = editor.model;
+      wrapBandReconcilePassCountRef.current = 0;
+    }
+    if (wrapBandReconcilePassCountRef.current >= WRAP_BAND_RECONCILE_MAX_PASSES) {
+      return;
+    }
+    const fresh = /* @__PURE__ */ new Map();
+    pageBodyElementsRef.current.forEach((bodyElement) => {
+      if (!bodyElement.isConnected) {
+        return;
+      }
+      const origin = bodyElement.getBoundingClientRect();
+      if (origin.width <= 0) {
+        return;
+      }
+      const zoomScale = resolveViewerMeasurementZoomScale(bodyElement, 1);
+      const toBand = (rect) => ({
+        topPx: (rect.top - origin.top) / zoomScale,
+        bottomPx: (rect.bottom - origin.top) / zoomScale,
+        leftPx: (rect.left - origin.left) / zoomScale,
+        rightPx: (rect.right - origin.left) / zoomScale
+      });
+      let pageHasFloatingObject = false;
+      tableElementsRef.current.forEach((element, nodeIndex) => {
+        if (!element.isConnected || !bodyElement.contains(element)) {
+          return;
+        }
+        const node = editor.model.nodes[nodeIndex];
+        if (node?.type !== "table" || !node.style?.floating) {
+          return;
+        }
+        pageHasFloatingObject = true;
+        fresh.set(`tbl:${nodeIndex}`, toBand(element.getBoundingClientRect()));
+      });
+      bodyElement.querySelectorAll("[data-docx-image-location]").forEach((span) => {
+        if (!(span instanceof HTMLElement)) {
+          return;
+        }
+        const location = span.getAttribute("data-docx-image-location") ?? "";
+        const match = /^p:(\d+):(\d+)$/.exec(location);
+        if (!match) {
+          return;
+        }
+        const nodeIndex = Number.parseInt(match[1] ?? "", 10);
+        const childIndex = Number.parseInt(match[2] ?? "", 10);
+        const node = editor.model.nodes[nodeIndex];
+        const child = node?.type === "paragraph" ? node.children[childIndex] : void 0;
+        if (!child || child.type !== "image" || !child.floating?.wrapType || child.floating.wrapType === "none" || child.floating.behindDocument === true || shouldRenderWrappedFloatingImage(child)) {
+          return;
+        }
+        if (getComputedStyle(span).position !== "absolute") {
+          return;
+        }
+        pageHasFloatingObject = true;
+        fresh.set(`img:${location}`, toBand(span.getBoundingClientRect()));
+      });
+      if (!pageHasFloatingObject) {
+        let hasInFlowWrappedFloat = false;
+        paragraphElementsRef.current.forEach((element, nodeIndex) => {
+          if (hasInFlowWrappedFloat || !element.isConnected || !bodyElement.contains(element)) {
+            return;
+          }
+          const candidate = editor.model.nodes[nodeIndex];
+          if (candidate?.type === "paragraph" && candidate.children.some(
+            (child) => child.type === "image" && shouldRenderWrappedFloatingImage(child)
+          )) {
+            hasInFlowWrappedFloat = true;
+          }
+        });
+        if (!hasInFlowWrappedFloat) {
+          return;
+        }
+      }
+      paragraphElementsRef.current.forEach((element, nodeIndex) => {
+        if (!element.isConnected || !bodyElement.contains(element)) {
+          return;
+        }
+        const rect = element.getBoundingClientRect();
+        if (rect.height <= 0) {
+          return;
+        }
+        fresh.set(`para:${nodeIndex}`, toBand(rect));
+      });
+    });
+    const withinTolerance = (previous, candidate) => Math.abs(previous.topPx - candidate.topPx) <= WRAP_BAND_RECONCILE_TOLERANCE_PX && Math.abs(previous.bottomPx - candidate.bottomPx) <= WRAP_BAND_RECONCILE_TOLERANCE_PX && Math.abs(previous.leftPx - candidate.leftPx) <= WRAP_BAND_RECONCILE_TOLERANCE_PX && Math.abs(previous.rightPx - candidate.rightPx) <= WRAP_BAND_RECONCILE_TOLERANCE_PX;
+    const next = /* @__PURE__ */ new Map();
+    if (!modelChanged) {
+      measuredWrapBands.forEach((band, key) => {
+        next.set(key, band);
+      });
+    }
+    let modifiedExistingBand = false;
+    fresh.forEach((band, key) => {
+      const previous = measuredWrapBands.get(key);
+      if (previous && withinTolerance(previous, band)) {
+        next.set(key, previous);
+        return;
+      }
+      if (previous && !modelChanged) {
+        modifiedExistingBand = true;
+      }
+      next.set(key, band);
+    });
+    let changed = next.size !== measuredWrapBands.size;
+    if (!changed) {
+      for (const [key, band] of next) {
+        if (measuredWrapBands.get(key) !== band) {
+          changed = true;
+          break;
+        }
+      }
+    }
+    if (!changed) {
+      return;
+    }
+    if (modifiedExistingBand) {
+      wrapBandReconcilePassCountRef.current += 1;
+    }
+    setMeasuredWrapBands(next);
+  });
   React.useEffect(() => {
     setDeferInternalPageVirtualization(!hasLargeTableLayoutSurface);
   }, [editor.documentLoadNonce, hasLargeTableLayoutSurface]);
@@ -28738,12 +30113,16 @@ function DocxEditorViewer({
     if (Date.now() < paginationMeasurementSuspendUntilRef.current) {
       return;
     }
-    setMeasuredParagraphOuterHeightsPxByNodeIndex((current) => {
+    setMeasuredParagraphOuterHeightsPxByBlockId((current) => {
       const next = new Map(current);
       let changed = false;
       const rootElement = viewerRootRef.current;
       const zoomScale = resolveViewerMeasurementZoomScale(rootElement, 1);
       paragraphElementsRef.current.forEach((element, nodeIndex) => {
+        const node = editor.model.nodes[nodeIndex];
+        if (node?.type !== "paragraph" || !node.blockId) {
+          return;
+        }
         if (!element.isConnected || element.dataset.docxParagraphPartialLineRange === "true" || element.closest('[data-docx-header-footer-region="footer"]') || element.closest('[data-docx-header-footer-region="header"]')) {
           return;
         }
@@ -28760,9 +30139,9 @@ function DocxEditorViewer({
             rect.height / zoomScale + (Number.isFinite(marginTop) ? marginTop : 0) + (Number.isFinite(marginBottom) ? marginBottom : 0)
           )
         );
-        const previousHeightPx = next.get(nodeIndex);
+        const previousHeightPx = next.get(node.blockId);
         if (previousHeightPx === void 0 || Math.abs(previousHeightPx - outerHeightPx) > 1) {
-          next.set(nodeIndex, outerHeightPx);
+          next.set(node.blockId, outerHeightPx);
           changed = true;
         }
       });
@@ -28770,7 +30149,9 @@ function DocxEditorViewer({
     });
   }, [
     editor.documentLoadNonce,
+    editor.model.nodes,
     pageNodeSegmentIdentityKeysByPage,
+    paginationMeasurementEpoch,
     resolveViewerMeasurementZoomScale,
     visiblePageEndIndex,
     visiblePageStartIndex
@@ -28833,7 +30214,7 @@ function DocxEditorViewer({
         if (segment.tableRowSlice) {
           continue;
         }
-        const measuredHeights = tableMeasuredRowHeights[segment.nodeIndex];
+        const measuredHeights = tableNode.blockId ? tableMeasuredRowHeights[tableNode.blockId]?.rowHeightsPx : void 0;
         if (!measuredHeights || measuredHeights.length !== tableNode.rows.length) {
           return true;
         }
@@ -29397,6 +30778,9 @@ function DocxEditorViewer({
       setMeasuredPageContentIdentityKeysByIndex(
         (current) => current.length === 0 ? current : []
       );
+      setMeasuredPageContentValidationByIndex(
+        (current) => current.length === 0 ? current : []
+      );
       return;
     }
     if (!paginationMeasurementEnabled) {
@@ -29410,6 +30794,9 @@ function DocxEditorViewer({
       setMeasuredPageContentIdentityKeysByIndex(
         (current) => current.length === 0 ? current : []
       );
+      setMeasuredPageContentValidationByIndex(
+        (current) => current.length === 0 ? current : []
+      );
       return;
     }
     if (Date.now() < paginationMeasurementSuspendUntilRef.current) {
@@ -29543,6 +30930,19 @@ function DocxEditorViewer({
     const nextMeasuredHeights = nextMeasuredPageDiagnostics.map(
       (diagnostics) => diagnostics.heightPx
     );
+    const nextMeasuredPageValidation = pageNodeSegmentsByPage.map(
+      (pageSegments, pageIndex) => {
+        const pageIsVisible = pageIndex >= visiblePageStartIndex && pageIndex <= visiblePageEndIndex;
+        if (!pageIsVisible || !pageElementsRef.current.get(pageIndex)) {
+          return void 0;
+        }
+        return buildMeasuredPageContentValidationForPageSegments(
+          pageSegments,
+          editor.model.nodes,
+          paginationMeasurementContextSignature
+        );
+      }
+    );
     const overlappingPageIndexes = nextMeasuredPageDiagnostics.reduce(
       (indexes, diagnostics, pageIndex) => {
         if (diagnostics.bodyOverrunsFooter) {
@@ -29613,6 +31013,27 @@ function DocxEditorViewer({
         }
         return nextMeasuredPageIdentityKeys;
       });
+      setMeasuredPageContentValidationByIndex((current) => {
+        const merged = nextMeasuredPageValidation.map(
+          (validation, pageIndex) => validation ?? current[pageIndex]
+        );
+        if (current.length === merged.length) {
+          let equal = true;
+          for (let pageIndex = 0; pageIndex < merged.length; pageIndex += 1) {
+            if (!measuredPageContentValidationsEqual(
+              current[pageIndex],
+              merged[pageIndex]
+            )) {
+              equal = false;
+              break;
+            }
+          }
+          if (equal) {
+            return current;
+          }
+        }
+        return merged;
+      });
     });
     return () => {
       window.cancelAnimationFrame(frameId);
@@ -29620,8 +31041,10 @@ function DocxEditorViewer({
   }, [
     disableMeasuredImportPagination,
     documentLayout,
+    editor.model.nodes,
     measuredPageContentHeightByIndex,
     measuredPageContentIdentityKeysByIndex,
+    paginationMeasurementContextSignature,
     paginationMeasurementEnabled,
     paginationMeasurementEpoch,
     pageCount,
@@ -29654,6 +31077,7 @@ function DocxEditorViewer({
     initialPaginationStableSignatureRef.current = void 0;
     setDisableMeasuredImportPagination(true);
     setMeasuredPageContentHeightByIndex([]);
+    setMeasuredPageContentValidationByIndex([]);
     setTableMeasuredRowHeights({});
   }, [
     deferInitialPaginationPaint,
@@ -29737,7 +31161,8 @@ function DocxEditorViewer({
       (pageIndex) => (pageNodeSegmentsByPage[pageIndex] ?? []).filter(
         (segment) => editor.model.nodes[segment.nodeIndex]?.type === "table"
       ).map((segment) => {
-        const measuredHeights = tableMeasuredRowHeights[segment.nodeIndex] ?? [];
+        const tableNode = editor.model.nodes[segment.nodeIndex];
+        const measuredHeights = (tableNode?.blockId ? tableMeasuredRowHeights[tableNode.blockId]?.rowHeightsPx : void 0) ?? [];
         return `${segment.nodeIndex}:${measuredHeights.join(",")}`;
       }).join(";")
     ).join("|");
@@ -29992,22 +31417,29 @@ function DocxEditorViewer({
         startY: event.clientY,
         hasMoved: false
       };
+      const zoomScale = resolveViewerMeasurementZoomScale(
+        viewerRootRef.current,
+        1
+      );
+      const tableElementAtStart = tableElementsRef.current.get(tableIndex);
+      const tableRectAtStart = tableElementAtStart?.getBoundingClientRect();
+      const floatingHostRectAtStart = tableElementAtStart?.closest("[data-docx-floating-table-host]")?.getBoundingClientRect();
       const onPointerMove = (pointerMoveEvent) => {
         const dragState = tableMoveDragRef.current;
         if (!dragState || pointerMoveEvent.pointerId !== dragState.pointerId) {
           return;
         }
-        const deltaX = Math.abs(pointerMoveEvent.clientX - dragState.startX);
-        const deltaY = Math.abs(pointerMoveEvent.clientY - dragState.startY);
-        if (deltaX + deltaY < TABLE_MOVE_DRAG_THRESHOLD_PX) {
+        const movedX = pointerMoveEvent.clientX - dragState.startX;
+        const movedY = pointerMoveEvent.clientY - dragState.startY;
+        if (!dragState.hasMoved && Math.abs(movedX) + Math.abs(movedY) < TABLE_MOVE_DRAG_THRESHOLD_PX) {
           return;
         }
         dragState.hasMoved = true;
-        const target = resolveTableMoveDropTarget(dragState.tableIndex, {
-          x: pointerMoveEvent.clientX,
-          y: pointerMoveEvent.clientY
+        setTableFloatingDragPreview({
+          tableIndex: dragState.tableIndex,
+          deltaX: normalizeFloatingDragDeltaForZoom(movedX, zoomScale),
+          deltaY: normalizeFloatingDragDeltaForZoom(movedY, zoomScale)
         });
-        setTableMoveDropPreview(target?.preview);
         pointerMoveEvent.preventDefault();
       };
       const onPointerUp = (pointerUpEvent) => {
@@ -30030,18 +31462,57 @@ function DocxEditorViewer({
         setHoveredTableHandleTableIndex(
           pointerStillOverTable ? dragState.tableIndex : void 0
         );
-        const target = resolveTableMoveDropTarget(dragState.tableIndex, {
-          x: pointerUpEvent.clientX,
-          y: pointerUpEvent.clientY
-        });
-        setTableMoveDropPreview(void 0);
-        if (!dragState.hasMoved) {
+        setTableFloatingDragPreview(void 0);
+        if (!dragState.hasMoved || !tableRectAtStart) {
           return;
         }
-        if (!target) {
+        const deltaX = normalizeFloatingDragDeltaForZoom(
+          pointerUpEvent.clientX - dragState.startX,
+          zoomScale
+        );
+        const deltaY = normalizeFloatingDragDeltaForZoom(
+          pointerUpEvent.clientY - dragState.startY,
+          zoomScale
+        );
+        const tableNode = editor.model.nodes[dragState.tableIndex];
+        if (!tableNode || tableNode.type !== "table") {
           return;
         }
-        editor.moveTable(dragState.tableIndex, target.targetNodeIndex);
+        const currentFloating = tableNode.style?.floating;
+        const baseLeftPx = floatingHostRectAtStart ? (tableRectAtStart.left - floatingHostRectAtStart.left) / zoomScale : twipsToSignedPixels(tableNode.style?.indentTwips) ?? 0;
+        const baseTopPx = floatingHostRectAtStart ? (tableRectAtStart.top - floatingHostRectAtStart.top) / zoomScale : 0;
+        const dropTarget = resolveTableMoveDropTarget(dragState.tableIndex, {
+          x: pointerUpEvent.clientX,
+          y: pointerUpEvent.clientY
+        });
+        const rootRect = viewerRootRef.current?.getBoundingClientRect();
+        const shouldReanchor = dropTarget !== void 0 && rootRect !== void 0 && dropTarget.targetNodeIndex !== dragState.tableIndex && dropTarget.targetNodeIndex !== dragState.tableIndex + 1;
+        let committedTopPx = baseTopPx + deltaY;
+        if (shouldReanchor && dropTarget && rootRect) {
+          let targetScreenTop = rootRect.top + dropTarget.preview.top;
+          if (!floatingHostRectAtStart && dropTarget.targetNodeIndex > dragState.tableIndex) {
+            targetScreenTop -= tableRectAtStart.height;
+          }
+          const droppedTopScreenPx = tableRectAtStart.top + (pointerUpEvent.clientY - dragState.startY);
+          committedTopPx = (droppedTopScreenPx - targetScreenTop) / zoomScale;
+        }
+        committedTopPx = Math.max(0, committedTopPx);
+        editor.setTableFloating(
+          dragState.tableIndex,
+          {
+            xTwips: pixelsToTwips(baseLeftPx + deltaX),
+            yTwips: pixelsToTwips(committedTopPx),
+            horizontalAnchor: "margin",
+            verticalAnchor: "text",
+            horizontalAlign: void 0,
+            verticalAlign: void 0,
+            leftFromTextTwips: currentFloating?.leftFromTextTwips ?? 187,
+            rightFromTextTwips: currentFloating?.rightFromTextTwips ?? 187,
+            topFromTextTwips: currentFloating?.topFromTextTwips ?? 0,
+            bottomFromTextTwips: currentFloating?.bottomFromTextTwips ?? 0
+          },
+          shouldReanchor && dropTarget ? { moveToNodeIndex: dropTarget.targetNodeIndex } : void 0
+        );
       };
       window.addEventListener("pointermove", onPointerMove);
       window.addEventListener("pointerup", onPointerUp, { once: true });
@@ -31190,7 +32661,7 @@ function DocxEditorViewer({
       editorHasFocus && (!liveSelection || liveSelection.rangeCount === 0)
     );
     if (collapsedElementAnchor || selectionDropped) {
-      if (session === "keyboard" || session === "composition") {
+      if (session === "keyboard" || session === "composition" || compositionActiveRef.current) {
         return;
       }
       const anchorElement = anchorNode instanceof Element ? anchorNode : anchorNode?.parentElement ?? null;
@@ -31249,7 +32720,7 @@ function DocxEditorViewer({
       return;
     }
     const session = editor.selectionSessionKind;
-    if (pointerSelectionDragRef.current.moved || session === "composition") {
+    if (pointerSelectionDragRef.current.moved || session === "composition" || compositionActiveRef.current) {
       return;
     }
     const rootElement = viewerRootRef.current;
@@ -31628,7 +33099,7 @@ function DocxEditorViewer({
     appliedHistoryRestoreNonceRef.current = restoreRequest.nonce;
     const selectionIntentNonce = beginSelectionIntent();
     editor.beginSelectionSession("history-restore", { settleAfterMs: 180 });
-    paragraphDraftsRef.current.clear();
+    editingIntentContinuationRef.current = void 0;
     tableCellDraftsRef.current.clear();
     tableCellParagraphDraftsRef.current.clear();
     sectionParagraphDraftsRef.current.clear();
@@ -32304,7 +33775,7 @@ function DocxEditorViewer({
               normalizedActiveRange
             );
             if (collapsedRange) {
-              paragraphDraftsRef.current.clear();
+              editingIntentContinuationRef.current = void 0;
               tableCellDraftsRef.current.clear();
               tableCellParagraphDraftsRef.current.clear();
               syncSelectionFromDocxRange(collapsedRange);
@@ -32405,7 +33876,7 @@ function DocxEditorViewer({
         normalizedActiveRange
       );
       if (collapsedRange) {
-        paragraphDraftsRef.current.clear();
+        editingIntentContinuationRef.current = void 0;
         tableCellDraftsRef.current.clear();
         tableCellParagraphDraftsRef.current.clear();
         syncSelectionFromDocxRange(collapsedRange);
@@ -32463,7 +33934,7 @@ function DocxEditorViewer({
       if (!collapsedRange) {
         return false;
       }
-      paragraphDraftsRef.current.clear();
+      editingIntentContinuationRef.current = void 0;
       tableCellDraftsRef.current.clear();
       tableCellParagraphDraftsRef.current.clear();
       syncSelectionFromDocxRange(collapsedRange);
@@ -32618,7 +34089,7 @@ function DocxEditorViewer({
         return true;
       };
       const clearDraftsAndSetSelection = (range) => {
-        paragraphDraftsRef.current.clear();
+        editingIntentContinuationRef.current = void 0;
         tableCellDraftsRef.current.clear();
         tableCellParagraphDraftsRef.current.clear();
         syncSelectionFromDocxRange(range);
@@ -33111,7 +34582,7 @@ function DocxEditorViewer({
       if (!collapsedRange) {
         return;
       }
-      paragraphDraftsRef.current.clear();
+      editingIntentContinuationRef.current = void 0;
       tableCellDraftsRef.current.clear();
       tableCellParagraphDraftsRef.current.clear();
       syncSelectionFromDocxRange(collapsedRange);
@@ -33552,20 +35023,6 @@ function DocxEditorViewer({
     },
     [clearTableCellSelection, editor, selectionOffsetsWithinElement]
   );
-  const commitParagraphDraftFromElement = React.useCallback(
-    (nodeIndex, paragraph, element) => {
-      const nextText = editableTextFromElement(element);
-      const nextHtml = element.innerHTML;
-      if (nextText === paragraphText(paragraph)) {
-        paragraphDraftsRef.current.delete(nodeIndex);
-        return;
-      }
-      paragraphDraftsRef.current.set(nodeIndex, nextHtml);
-      editor.suppressNextDomSelectionRestore();
-      editor.commitParagraphText(nodeIndex, nextText);
-    },
-    [editor]
-  );
   const commitTableCellDraftFromElement = React.useCallback(
     (tableIndex, rowIndex, cellIndex, cellParagraphs, draftKey, element) => {
       const nextText = editableTextFromTableCellElement(element);
@@ -33782,33 +35239,14 @@ function DocxEditorViewer({
   }
   React.useEffect(() => {
     const flushPendingDraftsForExport = (currentModel) => {
-      if (paragraphDraftsRef.current.size === 0 && tableCellDraftsRef.current.size === 0 && tableCellParagraphDraftsRef.current.size === 0 && sectionParagraphDraftsRef.current.size === 0) {
+      if (tableCellDraftsRef.current.size === 0 && tableCellParagraphDraftsRef.current.size === 0 && sectionParagraphDraftsRef.current.size === 0) {
         return currentModel;
       }
       let nextModel = currentModel;
       const insertedStyle = cloneTextStyle2(editor.pendingRunStyle);
-      const consumedParagraphDraftIndexes = [];
       const consumedTableDraftKeys = [];
       const consumedTableParagraphDraftKeys = [];
       const consumedSectionDraftKeys = [];
-      paragraphDraftsRef.current.forEach((draftHtml, nodeIndex) => {
-        const element = paragraphElementsRef.current.get(nodeIndex);
-        if (!element && typeof draftHtml !== "string") {
-          return;
-        }
-        consumedParagraphDraftIndexes.push(nodeIndex);
-        const paragraph = nextModel.nodes[nodeIndex];
-        if (!paragraph || paragraph.type !== "paragraph") {
-          return;
-        }
-        const nextText = element ? editableTextFromElement(element) : editableTextFromDraftHtml(draftHtml);
-        if (nextText === paragraphText(paragraph)) {
-          return;
-        }
-        nextModel = updateParagraphText(nextModel, nodeIndex, nextText, {
-          insertedStyle
-        });
-      });
       tableCellParagraphDraftsRef.current.forEach((draftHtml, draftKey) => {
         const element = tableCellParagraphElementsRef.current.get(draftKey);
         if (!element && typeof draftHtml !== "string") {
@@ -33905,9 +35343,6 @@ function DocxEditorViewer({
           }
         );
       });
-      consumedParagraphDraftIndexes.forEach((nodeIndex) => {
-        paragraphDraftsRef.current.delete(nodeIndex);
-      });
       consumedTableDraftKeys.forEach((draftKey) => {
         tableCellDraftsRef.current.delete(draftKey);
       });
@@ -33949,6 +35384,430 @@ function DocxEditorViewer({
     },
     [editor]
   );
+  const handleEditableHostBeforeInput = React.useCallback(
+    (event) => {
+      if (isReadOnly) {
+        return;
+      }
+      if (event.isComposing || compositionActiveRef.current) {
+        return;
+      }
+      const targetElement = event.target instanceof Element ? event.target : event.target instanceof Node ? event.target.parentElement : null;
+      if (!targetElement) {
+        return;
+      }
+      if (targetElement.closest("textarea, input") || targetElement.closest("[data-docx-header-footer-region]")) {
+        return;
+      }
+      const intent = resolveEditingIntent({
+        inputType: event.inputType,
+        data: event.data,
+        dataTransferText: event.dataTransfer?.getData("text/plain")
+      });
+      if (!intent) {
+        return;
+      }
+      const resolveTargetRangeOffsets = (element) => {
+        const targetRange = typeof event.getTargetRanges === "function" ? event.getTargetRanges()[0] : void 0;
+        return targetRange ? staticRangeOffsetsWithinElementDom(element, targetRange) : void 0;
+      };
+      const paragraphHost = targetElement.closest(
+        "[data-docx-paragraph-host='true'][data-docx-paragraph-kind='paragraph']"
+      );
+      if (paragraphHost) {
+        if (!paragraphHost.isContentEditable) {
+          return;
+        }
+        const nodeIndexAttr = paragraphHost.getAttribute(
+          "data-docx-paragraph-node-index"
+        );
+        const nodeIndex = nodeIndexAttr != null ? Number.parseInt(nodeIndexAttr, 10) : Number.NaN;
+        const node = Number.isFinite(nodeIndex) ? editor.model.nodes[nodeIndex] : void 0;
+        if (!node || node.type !== "paragraph") {
+          return;
+        }
+        event.preventDefault();
+        cancelPendingPointerSelectionReconcile();
+        if (intent.kind === "blocked") {
+          return;
+        }
+        if (intent.kind === "historyUndo") {
+          editor.undo();
+          return;
+        }
+        if (intent.kind === "historyRedo") {
+          editor.redo();
+          return;
+        }
+        const location = { kind: "paragraph", nodeIndex };
+        const continuationKey = `p:${nodeIndex}`;
+        const domText = editableTextFromElement(paragraphHost);
+        const continuation2 = editingIntentContinuationRef.current;
+        const continuationActive2 = Boolean(
+          continuation2 && continuation2.key === continuationKey && continuation2.text !== domText
+        );
+        const currentText2 = continuationActive2 && continuation2 ? continuation2.text : domText;
+        let selectionOffsets2 = continuationActive2 && continuation2 ? { start: continuation2.caret, end: continuation2.caret } : selectionOffsetsWithinElement(paragraphHost);
+        if (!selectionOffsets2) {
+          const activeRange = editor.activeTextRange ? normalizeTextRange(editor.activeTextRange) : void 0;
+          if (activeRange && sameParagraphLocation(activeRange.start.location, location) && sameParagraphLocation(activeRange.end.location, location)) {
+            const safeStart = Math.max(
+              0,
+              Math.min(
+                Math.round(activeRange.start.offset),
+                currentText2.length
+              )
+            );
+            selectionOffsets2 = {
+              start: safeStart,
+              end: Math.max(
+                safeStart,
+                Math.min(
+                  Math.round(activeRange.end.offset),
+                  currentText2.length
+                )
+              )
+            };
+          }
+        }
+        if (!selectionOffsets2) {
+          selectionOffsets2 = {
+            start: currentText2.length,
+            end: currentText2.length
+          };
+        }
+        if (intent.kind === "insertParagraph") {
+          editingIntentContinuationRef.current = void 0;
+          const start = Math.max(
+            0,
+            Math.min(selectionOffsets2.start, currentText2.length)
+          );
+          const end = Math.max(
+            start,
+            Math.min(selectionOffsets2.end, currentText2.length)
+          );
+          tableCellDraftsRef.current.clear();
+          tableCellParagraphDraftsRef.current.clear();
+          if (paragraphIsList(node, currentText2)) {
+            const insertedListItem = editor.insertListItemAfterSelection(
+              currentText2,
+              start,
+              end,
+              location
+            );
+            if (insertedListItem !== void 0) {
+              focusParagraphAtOffset(
+                insertedListItem.paragraphIndex,
+                insertedListItem.caretOffset
+              );
+            }
+            return;
+          }
+          const splitParagraph = editor.splitParagraphAtSelection(
+            currentText2,
+            start,
+            end,
+            location
+          );
+          if (splitParagraph !== void 0) {
+            focusParagraphAtOffset(
+              splitParagraph.paragraphIndex,
+              splitParagraph.caretOffset
+            );
+          }
+          return;
+        }
+        if (intent.kind === "deleteContent" || intent.kind === "deleteRange") {
+          const activeRange = editor.activeTextRange ? normalizeTextRange(editor.activeTextRange) : void 0;
+          const expandedBeyondParagraph = Boolean(
+            activeRange && compareTextRangeBoundaries(activeRange.start, activeRange.end) < 0 && !(sameParagraphLocation(activeRange.start.location, location) && sameParagraphLocation(activeRange.end.location, location))
+          );
+          if (expandedBeyondParagraph && activeRange) {
+            editingIntentContinuationRef.current = void 0;
+            const collapsedRange = editor.deleteExpandedSelection(activeRange);
+            if (collapsedRange) {
+              tableCellDraftsRef.current.clear();
+              tableCellParagraphDraftsRef.current.clear();
+              syncSelectionFromDocxRange(collapsedRange);
+            }
+            return;
+          }
+        }
+        const rangeOffsets2 = !continuationActive2 && (intent.kind === "insertText" || intent.kind === "replaceText" || intent.kind === "insertLineBreak" || intent.kind === "deleteContent" || intent.kind === "deleteRange") ? resolveTargetRangeOffsets(paragraphHost) ?? selectionOffsets2 : selectionOffsets2;
+        const applied2 = applyTextEditingIntent(
+          currentText2,
+          rangeOffsets2.start,
+          rangeOffsets2.end,
+          intent
+        );
+        if (!applied2) {
+          if (intent.kind === "deleteContent" && rangeOffsets2.start === rangeOffsets2.end) {
+            if (intent.direction === "backward" && rangeOffsets2.start === 0) {
+              editingIntentContinuationRef.current = void 0;
+              let previousLocation;
+              for (let scanNodeIndex = nodeIndex - 1; scanNodeIndex >= 0; scanNodeIndex -= 1) {
+                const candidate = lastParagraphLocationInNode(
+                  editor.model,
+                  scanNodeIndex
+                );
+                if (candidate) {
+                  previousLocation = candidate;
+                  break;
+                }
+              }
+              const previousParagraph = previousLocation ? getParagraphAtLocation(editor.model, previousLocation).paragraph : void 0;
+              if (previousLocation && previousParagraph) {
+                const collapsedRange = editor.deleteExpandedSelection({
+                  start: {
+                    location: cloneTextRangeLocation(previousLocation),
+                    offset: paragraphText(previousParagraph).length
+                  },
+                  end: {
+                    location: cloneTextRangeLocation(location),
+                    offset: 0
+                  }
+                });
+                if (collapsedRange) {
+                  syncSelectionFromDocxRange(collapsedRange);
+                }
+              }
+              return;
+            }
+            if (intent.direction === "forward" && rangeOffsets2.start >= currentText2.length) {
+              editingIntentContinuationRef.current = void 0;
+              const nextLocation = nextParagraphLocation(
+                editor.model,
+                location
+              );
+              const nextParagraph = nextLocation ? getParagraphAtLocation(editor.model, nextLocation).paragraph : void 0;
+              if (nextLocation && nextParagraph) {
+                const collapsedRange = editor.deleteExpandedSelection({
+                  start: {
+                    location: cloneTextRangeLocation(location),
+                    offset: currentText2.length
+                  },
+                  end: {
+                    location: cloneTextRangeLocation(nextLocation),
+                    offset: 0
+                  }
+                });
+                if (collapsedRange) {
+                  syncSelectionFromDocxRange(collapsedRange);
+                }
+              }
+              return;
+            }
+          }
+          return;
+        }
+        const coalesceClass2 = editingIntentCoalesceClass(intent);
+        editor.commitParagraphTextAtRange(
+          location,
+          applied2.text,
+          { start: applied2.caret, end: applied2.caret },
+          {
+            insertionOffset: rangeOffsets2.start,
+            ...coalesceClass2 ? { coalesceKey: `p:${nodeIndex}:${coalesceClass2}` } : void 0
+          }
+        );
+        editingIntentContinuationRef.current = {
+          key: continuationKey,
+          text: applied2.text,
+          caret: applied2.caret
+        };
+        pendingEditableCaretRef.current = {
+          nodeIndex,
+          start: applied2.caret,
+          end: applied2.caret
+        };
+        schedulePaginationMeasurementResume();
+        return;
+      }
+      const cellHost = targetElement.closest(
+        "[data-docx-cell-key]"
+      );
+      if (!cellHost || !cellHost.isContentEditable) {
+        return;
+      }
+      const cellKeyMatch = /^cell-(\d+)-(\d+)-(\d+)$/.exec(
+        cellHost.getAttribute("data-docx-cell-key") ?? ""
+      );
+      if (!cellKeyMatch) {
+        return;
+      }
+      const tableIndex = Number.parseInt(cellKeyMatch[1], 10);
+      const rowIndex = Number.parseInt(cellKeyMatch[2], 10);
+      const cellIndex = Number.parseInt(cellKeyMatch[3], 10);
+      const tableNode = editor.model.nodes[tableIndex];
+      if (!tableNode || tableNode.type !== "table") {
+        return;
+      }
+      const cell = tableNode.rows[rowIndex]?.cells[cellIndex];
+      if (!cell) {
+        return;
+      }
+      if (cell.nodes.some((cellContent) => cellContent.type === "table")) {
+        return;
+      }
+      event.preventDefault();
+      cancelPendingPointerSelectionReconcile();
+      if (intent.kind === "blocked") {
+        return;
+      }
+      if (intent.kind === "historyUndo") {
+        editor.undo();
+        return;
+      }
+      if (intent.kind === "historyRedo") {
+        editor.redo();
+        return;
+      }
+      const cellParagraphNodes = tableCellParagraphs(cell.nodes);
+      const context = activeTableCellParagraphContext(cellHost);
+      const continuation = editingIntentContinuationRef.current;
+      const continuationPrefix = `c:${tableIndex}:${rowIndex}:${cellIndex}:`;
+      let continuationActive = false;
+      let paragraphIndex = context?.paragraphIndex;
+      let paragraphElement = context?.paragraphElement;
+      if (continuation && continuation.key.startsWith(continuationPrefix)) {
+        const continuationParagraphIndex = Number.parseInt(
+          continuation.key.slice(continuationPrefix.length),
+          10
+        );
+        const continuationElement = Number.isFinite(continuationParagraphIndex) ? cellHost.querySelector(
+          `[data-docx-table-paragraph-index='${continuationParagraphIndex}']`
+        ) ?? void 0 : void 0;
+        if (continuationElement && continuation.text !== editableTextFromElement(continuationElement)) {
+          continuationActive = true;
+          paragraphIndex = continuationParagraphIndex;
+          paragraphElement = continuationElement;
+        }
+      }
+      let rangeSelectionOffsets;
+      if (paragraphIndex === void 0 || !paragraphElement) {
+        const activeRange = editor.activeTextRange ? normalizeTextRange(editor.activeTextRange) : void 0;
+        const startLocation = activeRange?.start.location;
+        if (activeRange && startLocation && startLocation.kind === "table-cell" && startLocation.tableIndex === tableIndex && startLocation.rowIndex === rowIndex && startLocation.cellIndex === cellIndex && sameParagraphLocation(startLocation, activeRange.end.location)) {
+          const rangeParagraphElement = cellHost.querySelector(
+            `[data-docx-table-paragraph-index='${startLocation.paragraphIndex}']`
+          ) ?? void 0;
+          if (rangeParagraphElement) {
+            paragraphIndex = startLocation.paragraphIndex;
+            paragraphElement = rangeParagraphElement;
+            rangeSelectionOffsets = {
+              start: Math.max(0, Math.round(activeRange.start.offset)),
+              end: Math.max(0, Math.round(activeRange.end.offset))
+            };
+          }
+        }
+      }
+      if (paragraphIndex === void 0 || !paragraphElement || !cellParagraphNodes[paragraphIndex]) {
+        return;
+      }
+      const cellLocation = {
+        kind: "table-cell",
+        tableIndex,
+        rowIndex,
+        cellIndex,
+        paragraphIndex
+      };
+      const currentText = continuationActive && continuation ? continuation.text : editableTextFromElement(paragraphElement);
+      const selectionOffsets = continuationActive && continuation ? { start: continuation.caret, end: continuation.caret } : rangeSelectionOffsets ?? selectionOffsetsWithinElement(paragraphElement) ?? {
+        start: currentText.length,
+        end: currentText.length
+      };
+      if (intent.kind === "deleteContent" || intent.kind === "deleteRange") {
+        const activeRange = editor.activeTextRange ? normalizeTextRange(editor.activeTextRange) : void 0;
+        const expandedBeyondParagraph = Boolean(
+          activeRange && compareTextRangeBoundaries(activeRange.start, activeRange.end) < 0 && !(sameParagraphLocation(activeRange.start.location, cellLocation) && sameParagraphLocation(activeRange.end.location, cellLocation))
+        );
+        if (expandedBeyondParagraph && activeRange) {
+          editingIntentContinuationRef.current = void 0;
+          const collapsedRange = editor.deleteExpandedSelection(activeRange);
+          if (collapsedRange) {
+            tableCellDraftsRef.current.clear();
+            tableCellParagraphDraftsRef.current.clear();
+            syncSelectionFromDocxRange(collapsedRange);
+          }
+          return;
+        }
+      }
+      const effectiveIntent = intent.kind === "insertParagraph" ? { kind: "insertLineBreak" } : intent;
+      const rangeOffsets = !continuationActive && (effectiveIntent.kind === "insertText" || effectiveIntent.kind === "replaceText" || effectiveIntent.kind === "insertLineBreak" || effectiveIntent.kind === "deleteContent" || effectiveIntent.kind === "deleteRange") ? resolveTargetRangeOffsets(paragraphElement) ?? selectionOffsets : selectionOffsets;
+      const applied = applyTextEditingIntent(
+        currentText,
+        rangeOffsets.start,
+        rangeOffsets.end,
+        effectiveIntent
+      );
+      if (!applied) {
+        if (effectiveIntent.kind === "deleteContent" && rangeOffsets.start === rangeOffsets.end) {
+          const paragraphTexts = cellParagraphNodes.map(
+            (cellParagraph, cellParagraphIndex) => cellParagraphIndex === paragraphIndex ? currentText : paragraphText(cellParagraph)
+          );
+          const mergeBoundaryIndex = effectiveIntent.direction === "backward" && rangeOffsets.start === 0 ? paragraphIndex : effectiveIntent.direction === "forward" && rangeOffsets.start >= currentText.length ? paragraphIndex + 1 : void 0;
+          const merged = mergeBoundaryIndex !== void 0 ? mergeCellParagraphTexts(paragraphTexts, mergeBoundaryIndex) : void 0;
+          if (merged) {
+            editingIntentContinuationRef.current = void 0;
+            editor.commitTableCellTextAtRange(
+              tableIndex,
+              rowIndex,
+              cellIndex,
+              merged.cellText,
+              {
+                paragraphIndex: merged.caretParagraphIndex,
+                start: merged.caretOffset,
+                end: merged.caretOffset
+              }
+            );
+            schedulePaginationMeasurementResume();
+          }
+        }
+        return;
+      }
+      const coalesceClass = editingIntentCoalesceClass(effectiveIntent);
+      editor.commitParagraphTextAtRange(
+        cellLocation,
+        applied.text,
+        { start: applied.caret, end: applied.caret },
+        {
+          insertionOffset: rangeOffsets.start,
+          ...coalesceClass ? {
+            coalesceKey: `${continuationPrefix}${paragraphIndex}:${coalesceClass}`
+          } : void 0
+        }
+      );
+      editingIntentContinuationRef.current = {
+        key: `${continuationPrefix}${paragraphIndex}`,
+        text: applied.text,
+        caret: applied.caret
+      };
+      schedulePaginationMeasurementResume();
+    },
+    [
+      activeTableCellParagraphContext,
+      cancelPendingPointerSelectionReconcile,
+      editor,
+      focusParagraphAtOffset,
+      isReadOnly,
+      schedulePaginationMeasurementResume,
+      selectionOffsetsWithinElement,
+      syncSelectionFromDocxRange
+    ]
+  );
+  React.useEffect(() => {
+    const rootElement = viewerRootRef.current;
+    if (!rootElement) {
+      return;
+    }
+    const handleBeforeInput = (event) => {
+      handleEditableHostBeforeInput(event);
+    };
+    rootElement.addEventListener("beforeinput", handleBeforeInput);
+    return () => {
+      rootElement.removeEventListener("beforeinput", handleBeforeInput);
+    };
+  }, [handleEditableHostBeforeInput]);
   const resolveTableColumnWidths = React.useCallback(
     (tableIndex, table, tableWidthPx) => {
       const columnCount = tableColumnCount(table);
@@ -34150,7 +36009,7 @@ function DocxEditorViewer({
         docGridLinePitchPxByNodeIndex.get(nodeIndex),
         pageContentHeightPxByNodeIndex.get(nodeIndex)
       );
-      const previousMeasuredRowHeights = tableMeasuredRowHeights[nodeIndex];
+      const previousMeasuredRowHeights = node.blockId ? tableMeasuredRowHeights[node.blockId]?.rowHeightsPx : void 0;
       const measuredHeights = node.rows.map((_, rowIndex) => {
         const measuredHeight = measuredByRowIndex.get(rowIndex);
         if (measuredHeight !== void 0) {
@@ -34169,35 +36028,46 @@ function DocxEditorViewer({
     setTableMeasuredRowHeights((current) => {
       let changed = false;
       const next = {};
-      Object.entries(current).forEach(([tableIndexText, heights]) => {
-        const tableIndex = Number.parseInt(tableIndexText, 10);
-        const tableNode = editor.model.nodes[tableIndex];
-        if (!tableNode || tableNode.type !== "table") {
-          changed = true;
-          return;
+      const tableNodesByBlockId = /* @__PURE__ */ new Map();
+      const tableBlockIdsByNodeIndex = /* @__PURE__ */ new Map();
+      editor.model.nodes.forEach((node, nodeIndex) => {
+        if (node.type === "table" && node.blockId) {
+          tableNodesByBlockId.set(node.blockId, node);
+          tableBlockIdsByNodeIndex.set(nodeIndex, node.blockId);
         }
-        if (!Array.isArray(heights) || heights.length !== tableNode.rows.length) {
+      });
+      Object.entries(current).forEach(([blockId, entry]) => {
+        const tableNode = tableNodesByBlockId.get(blockId);
+        if (!tableNode || !Array.isArray(entry.rowHeightsPx) || entry.rowHeightsPx.length !== tableNode.rows.length) {
           changed = true;
           return;
         }
-        next[tableIndex] = heights;
+        next[blockId] = entry;
       });
       Object.entries(nextMeasuredHeights).forEach(
         ([tableIndexText, measuredHeights]) => {
           const tableIndex = Number.parseInt(tableIndexText, 10);
-          const currentHeights = next[tableIndex] ?? [];
-          if (currentHeights.length !== measuredHeights.length) {
-            next[tableIndex] = measuredHeights;
-            changed = true;
+          const blockId = tableBlockIdsByNodeIndex.get(tableIndex);
+          const tableNode = blockId ? tableNodesByBlockId.get(blockId) : void 0;
+          if (!blockId || !tableNode) {
             return;
           }
-          for (let index = 0; index < measuredHeights.length; index += 1) {
-            if (currentHeights[index] !== measuredHeights[index]) {
-              next[tableIndex] = measuredHeights;
-              changed = true;
-              return;
+          const contentSignature = docNodeContentSignature(tableNode);
+          const currentEntry = next[blockId];
+          const currentHeights = currentEntry?.rowHeightsPx ?? [];
+          let heightsChanged = currentHeights.length !== measuredHeights.length;
+          if (!heightsChanged) {
+            for (let index = 0; index < measuredHeights.length; index += 1) {
+              if (currentHeights[index] !== measuredHeights[index]) {
+                heightsChanged = true;
+                break;
+              }
             }
           }
+          if (heightsChanged || currentEntry?.contentSignature !== contentSignature) {
+            next[blockId] = { rowHeightsPx: measuredHeights, contentSignature };
+            changed = true;
+          }
         }
       );
       return changed ? next : current;
@@ -34708,27 +36578,72 @@ function DocxEditorViewer({
         "[data-docx-paragraph-host='true']"
       );
       const paragraphRect = paragraphHost?.getBoundingClientRect();
+      const zoomScale = resolveViewerMeasurementZoomScale(wrapperElement, 1);
       const baseFloating = image.floating ? { ...image.floating } : {};
+      const dragStartAnchor = isWrappedFloatingImage && location.kind === "paragraph" ? resolveWrappedDropAnchorParagraphHost(
+        wrapperElement,
+        wrapperRect.top,
+        wrapperRect.left
+      ) : void 0;
       let latestDeltaX = 0;
       let latestDeltaY = 0;
       let frameId;
       let inlineDragActivated = false;
       let latestInlineDropTarget;
       let latestInlineDropTargetKey;
+      const measuredBands = (() => {
+        if (!isWrappedFloatingImage || !pageSurface || !pageSurfaceRect) {
+          return void 0;
+        }
+        const hostByNodeIndex = {};
+        for (const host of Array.from(
+          pageSurface.querySelectorAll(
+            "[data-docx-paragraph-host='true'][data-docx-paragraph-kind='paragraph'][data-docx-paragraph-node-index]"
+          )
+        )) {
+          const nodeIndex = Number.parseInt(
+            host.getAttribute("data-docx-paragraph-node-index") ?? "",
+            10
+          );
+          if (!Number.isFinite(nodeIndex)) {
+            continue;
+          }
+          const rect = host.getBoundingClientRect();
+          if (rect.height <= 0) {
+            continue;
+          }
+          hostByNodeIndex[nodeIndex] = {
+            topPx: (rect.top - pageSurfaceRect.top) / zoomScale,
+            bottomPx: (rect.bottom - pageSurfaceRect.top) / zoomScale
+          };
+        }
+        return Object.keys(hostByNodeIndex).length > 0 ? { hostByNodeIndex } : void 0;
+      })();
       const updatePreview = () => {
         setFloatingMovePreview({
           imageKey,
           deltaX: latestDeltaX,
           deltaY: latestDeltaY,
+          measuredBands,
           ...paragraphRect ? {
-            baseLeftPx: Math.round(wrapperRect.left - paragraphRect.left),
-            baseTopPx: Math.round(wrapperRect.top - paragraphRect.top)
+            baseLeftPx: Math.round(
+              (wrapperRect.left - paragraphRect.left) / zoomScale
+            ),
+            baseTopPx: Math.round(
+              (wrapperRect.top - paragraphRect.top) / zoomScale
+            )
           } : void 0
         });
       };
       const onPointerMove = (pointerEvent) => {
-        latestDeltaX = pointerEvent.clientX - startX;
-        latestDeltaY = pointerEvent.clientY - startY;
+        latestDeltaX = normalizeFloatingDragDeltaForZoom(
+          pointerEvent.clientX - startX,
+          zoomScale
+        );
+        latestDeltaY = normalizeFloatingDragDeltaForZoom(
+          pointerEvent.clientY - startY,
+          zoomScale
+        );
         if (isInlineImage) {
           if (!inlineDragActivated) {
             const movementDistancePx = Math.abs(latestDeltaX) + Math.abs(latestDeltaY);
@@ -34805,9 +36720,9 @@ function DocxEditorViewer({
           return;
         }
         if (isWrappedFloatingImage) {
-          const hostWidth = paragraphRect?.width ?? DEFAULT_DOC_PAGE_WIDTH;
-          const imageWidth = image.widthPx ?? Math.max(24, Math.round(wrapperRect.width));
-          const imageHeight = image.heightPx ?? Math.max(24, Math.round(wrapperRect.height));
+          const hostWidth = paragraphRect ? paragraphRect.width / zoomScale : DEFAULT_DOC_PAGE_WIDTH;
+          const imageWidth = image.widthPx ?? Math.max(24, Math.round(wrapperRect.width / zoomScale));
+          const imageHeight = image.heightPx ?? Math.max(24, Math.round(wrapperRect.height / zoomScale));
           const baseGeometry = resolveDualWrappedFloatingImageGeometry(
             image,
             hostWidth,
@@ -34816,9 +36731,11 @@ function DocxEditorViewer({
               heightPx: imageHeight,
               ...paragraphRect ? {
                 baseLeftPx: Math.round(
-                  wrapperRect.left - paragraphRect.left
+                  (wrapperRect.left - paragraphRect.left) / zoomScale
                 ),
-                baseTopPx: Math.round(wrapperRect.top - paragraphRect.top)
+                baseTopPx: Math.round(
+                  (wrapperRect.top - paragraphRect.top) / zoomScale
+                )
               } : void 0
             }
           );
@@ -34830,6 +36747,46 @@ function DocxEditorViewer({
           const movedTop = Math.round(
             (baseGeometry?.imageTopPx ?? 0) + latestDeltaY
           );
+          const droppedTopScreenPx = wrapperRect.top + latestDeltaY * zoomScale;
+          const droppedLeftScreenPx = wrapperRect.left + latestDeltaX * zoomScale;
+          const dropAnchor = location.kind === "paragraph" && wrappedDragCanReanchorToParagraph(baseFloating) ? resolveWrappedDropAnchorParagraphHost(
+            wrapperElement,
+            droppedTopScreenPx,
+            droppedLeftScreenPx
+          ) : void 0;
+          if (dropAnchor && location.kind === "paragraph" && dropAnchor.nodeIndex !== location.nodeIndex && dropAnchor.nodeIndex !== dragStartAnchor?.nodeIndex) {
+            const targetHostWidth = dropAnchor.rect.width / zoomScale;
+            const targetMovedLeft = clampNumber(
+              Math.round(
+                (droppedLeftScreenPx - dropAnchor.rect.left) / zoomScale
+              ),
+              0,
+              Math.max(0, targetHostWidth - imageWidth)
+            );
+            const targetMovedTop = Math.round(
+              (droppedTopScreenPx - dropAnchor.rect.top) / zoomScale
+            );
+            editor.moveFloatingImage(
+              location,
+              resolveWrappedFloatingImageDropPatch(
+                image,
+                targetHostWidth,
+                targetMovedLeft,
+                targetMovedTop,
+                {
+                  widthPx: imageWidth,
+                  heightPx: imageHeight
+                }
+              ),
+              { reparentToParagraphNodeIndex: dropAnchor.nodeIndex }
+            );
+            setSelectedImage({
+              kind: "paragraph",
+              nodeIndex: dropAnchor.nodeIndex,
+              childIndex: 0
+            });
+            return;
+          }
           editor.moveFloatingImage(
             location,
             resolveWrappedFloatingImageDropPatch(
@@ -34846,14 +36803,21 @@ function DocxEditorViewer({
           return;
         }
         if (isAbsoluteFloatingImage) {
+          const dropPageSurfaceRect = pageSurface && pageSurface.isConnected ? pageSurface.getBoundingClientRect() : pageSurfaceRect;
           editor.moveFloatingImage(
             location,
             resolveAbsoluteFloatingImageDropPatch(
               baseFloating,
               documentLayout,
               {
-                wrapperRect,
-                pageSurfaceRect,
+                wrapperRect: normalizeFloatingDropRectForZoom(
+                  wrapperRect,
+                  zoomScale
+                ),
+                pageSurfaceRect: dropPageSurfaceRect ? normalizeFloatingDropRectForZoom(
+                  dropPageSurfaceRect,
+                  zoomScale
+                ) : void 0,
                 deltaX: latestDeltaX,
                 deltaY: latestDeltaY
               }
@@ -34866,7 +36830,7 @@ function DocxEditorViewer({
       window.addEventListener("pointerup", onPointerUp, { once: true });
       window.addEventListener("pointercancel", onPointerUp, { once: true });
     },
-    [documentLayout, editor, isReadOnly]
+    [documentLayout, editor, isReadOnly, resolveViewerMeasurementZoomScale]
   );
   const beginDropCapMove = React.useCallback(
     (event, nodeIndex, dropCap) => {
@@ -35003,6 +36967,7 @@ function DocxEditorViewer({
         "[data-docx-section-paragraph-host='true']"
       );
       const paragraphRect = paragraphHost?.getBoundingClientRect();
+      const zoomScale = resolveViewerMeasurementZoomScale(wrapperElement, 1);
       const baseFloating = image.floating ? { ...image.floating } : {};
       let latestDeltaX = 0;
       let latestDeltaY = 0;
@@ -35013,14 +36978,24 @@ function DocxEditorViewer({
           deltaX: latestDeltaX,
           deltaY: latestDeltaY,
           ...paragraphRect ? {
-            baseLeftPx: Math.round(wrapperRect.left - paragraphRect.left),
-            baseTopPx: Math.round(wrapperRect.top - paragraphRect.top)
+            baseLeftPx: Math.round(
+              (wrapperRect.left - paragraphRect.left) / zoomScale
+            ),
+            baseTopPx: Math.round(
+              (wrapperRect.top - paragraphRect.top) / zoomScale
+            )
           } : void 0
         });
       };
       const onPointerMove = (pointerEvent) => {
-        latestDeltaX = pointerEvent.clientX - startX;
-        latestDeltaY = pointerEvent.clientY - startY;
+        latestDeltaX = normalizeFloatingDragDeltaForZoom(
+          pointerEvent.clientX - startX,
+          zoomScale
+        );
+        latestDeltaY = normalizeFloatingDragDeltaForZoom(
+          pointerEvent.clientY - startY,
+          zoomScale
+        );
         if (frameId !== void 0) {
           window.cancelAnimationFrame(frameId);
         }
@@ -35038,9 +37013,9 @@ function DocxEditorViewer({
           return;
         }
         if (isWrappedFloatingImage) {
-          const hostWidth = paragraphRect?.width ?? documentLayout.pageWidthPx;
-          const imageWidth = image.widthPx ?? Math.max(24, Math.round(wrapperRect.width));
-          const imageHeight = image.heightPx ?? Math.max(24, Math.round(wrapperRect.height));
+          const hostWidth = paragraphRect ? paragraphRect.width / zoomScale : documentLayout.pageWidthPx;
+          const imageWidth = image.widthPx ?? Math.max(24, Math.round(wrapperRect.width / zoomScale));
+          const imageHeight = image.heightPx ?? Math.max(24, Math.round(wrapperRect.height / zoomScale));
           const baseGeometry = resolveDualWrappedFloatingImageGeometry(
             image,
             hostWidth,
@@ -35049,9 +37024,11 @@ function DocxEditorViewer({
               heightPx: imageHeight,
               ...paragraphRect ? {
                 baseLeftPx: Math.round(
-                  wrapperRect.left - paragraphRect.left
+                  (wrapperRect.left - paragraphRect.left) / zoomScale
                 ),
-                baseTopPx: Math.round(wrapperRect.top - paragraphRect.top)
+                baseTopPx: Math.round(
+                  (wrapperRect.top - paragraphRect.top) / zoomScale
+                )
               } : void 0
             }
           );
@@ -35081,14 +37058,21 @@ function DocxEditorViewer({
           return;
         }
         if (isAbsoluteFloatingImage) {
+          const dropPageSurfaceRect = pageSurface && pageSurface.isConnected ? pageSurface.getBoundingClientRect() : pageSurfaceRect;
           editor.moveSectionFloatingImage(
             location,
             resolveAbsoluteFloatingImageDropPatch(
               baseFloating,
               documentLayout,
               {
-                wrapperRect,
-                pageSurfaceRect,
+                wrapperRect: normalizeFloatingDropRectForZoom(
+                  wrapperRect,
+                  zoomScale
+                ),
+                pageSurfaceRect: dropPageSurfaceRect ? normalizeFloatingDropRectForZoom(
+                  dropPageSurfaceRect,
+                  zoomScale
+                ) : void 0,
                 deltaX: latestDeltaX,
                 deltaY: latestDeltaY
               }
@@ -35100,7 +37084,13 @@ function DocxEditorViewer({
       window.addEventListener("pointerup", onPointerUp, { once: true });
       window.addEventListener("pointercancel", onPointerUp, { once: true });
     },
-    [activeHeaderFooterEdit, documentLayout, editor, isReadOnly]
+    [
+      activeHeaderFooterEdit,
+      documentLayout,
+      editor,
+      isReadOnly,
+      resolveViewerMeasurementZoomScale
+    ]
   );
   const onSectionImageClick = React.useCallback(
     (location) => {
@@ -35767,6 +37757,10 @@ function DocxEditorViewer({
             display: "inline-block",
             whiteSpace: "pre",
             lineHeight: `${lineHeightPx}px`,
+            // Each fragment is its own block, so an inherited paragraph
+            // text-indent would shift every fragment past its computed
+            // interval; the layout reserves first-line indent itself.
+            textIndent: 0,
             pointerEvents: activeSession ? "none" : void 0
           },
           children: pieces
@@ -36013,15 +38007,24 @@ function DocxEditorViewer({
                     "aria-label": "Wrapped paragraph text",
                     onChange: (event) => {
                       cancelPendingPointerSelectionReconcile();
-                      editor.beginSelectionSession("keyboard", {
-                        settleAfterMs: 220
-                      });
                       const nextText = event.currentTarget.value.replace(
                         /\r\n?/g,
                         "\n"
                       );
                       const nextStart = event.currentTarget.selectionStart ?? nextText.length;
                       const nextEnd = event.currentTarget.selectionEnd ?? nextStart;
+                      const nativeInputEvent = event.nativeEvent;
+                      if (nativeInputEvent?.isComposing || compositionActiveRef.current) {
+                        editor.beginSelectionSession("composition");
+                        syncWrappedParagraphRange(location, nextStart, nextEnd, {
+                          textOverride: nextText,
+                          textLength: nextText.length
+                        });
+                        return;
+                      }
+                      editor.beginSelectionSession("keyboard", {
+                        settleAfterMs: 220
+                      });
                       syncWrappedParagraphRange(location, nextStart, nextEnd, {
                         textOverride: nextText,
                         textLength: nextText.length
@@ -36039,12 +38042,14 @@ function DocxEditorViewer({
                       });
                     },
                     onCompositionStart: () => {
+                      compositionActiveRef.current = true;
                       editor.beginSelectionSession("composition");
                       setActiveWrappedParagraphSession(
                         (current) => current && current.locationKey === locationKey ? { ...current, isComposing: true } : current
                       );
                     },
                     onCompositionEnd: (event) => {
+                      compositionActiveRef.current = false;
                       editor.beginSelectionSession("keyboard", {
                         settleAfterMs: 260
                       });
@@ -36054,18 +38059,20 @@ function DocxEditorViewer({
                       );
                       const nextStart = event.currentTarget.selectionStart ?? nextText.length;
                       const nextEnd = event.currentTarget.selectionEnd ?? nextStart;
-                      setActiveWrappedParagraphSession(
-                        (current) => current && current.locationKey === locationKey ? {
-                          ...current,
-                          isComposing: false,
-                          text: nextText,
-                          selectionStart: nextStart,
-                          selectionEnd: nextEnd
-                        } : current
-                      );
+                      syncWrappedParagraphRange(location, nextStart, nextEnd, {
+                        textOverride: nextText,
+                        textLength: nextText.length,
+                        isComposing: false
+                      });
+                      commitWrappedParagraphTextAtLocation(location, nextText);
+                      schedulePaginationMeasurementResume();
                     },
                     onKeyDown: (event) => {
                       cancelPendingPointerSelectionReconcile();
+                      if (isCompositionKeyboardEvent(event)) {
+                        editor.beginSelectionSession("composition");
+                        return;
+                      }
                       editor.beginSelectionSession("keyboard", {
                         settleAfterMs: 220
                       });
@@ -36188,6 +38195,13 @@ function DocxEditorViewer({
                       }
                     },
                     onBlur: (event) => {
+                      if (compositionActiveRef.current) {
+                        compositionActiveRef.current = false;
+                        commitWrappedParagraphTextAtLocation(
+                          location,
+                          event.currentTarget.value.replace(/\r\n?/g, "\n")
+                        );
+                      }
                       const currentTarget = event.currentTarget;
                       const wrappedParagraphRoot = currentTarget.closest(
                         "[data-docx-wrapped-paragraph-root='true']"
@@ -36545,7 +38559,8 @@ function DocxEditorViewer({
                 top: activeDualWrappedLayout.layout.lines[lineIndex]?.y ?? 0,
                 display: "inline-block",
                 whiteSpace: "pre",
-                lineHeight: `${activeDualWrappedLayout.lineHeightPx}px`
+                lineHeight: `${activeDualWrappedLayout.lineHeightPx}px`,
+                textIndent: 0
               },
               children: pieces
             },
@@ -37267,9 +39282,10 @@ function DocxEditorViewer({
           source: activeWrappedSource,
           layout: activeWrappedLayout,
           lineHeightPx: activeDualWrappedLayout.lineHeightPx,
-          blockHeightPx: resolveDualWrapParagraphRenderBlockHeightPx(
+          blockHeightPx: resolveDragPreviewAwareWrapBlockHeightPx(
             activeWrappedLayout,
-            activeDualWrappedLayout.geometries
+            activeDualWrappedLayout.geometries,
+            options?.pageFlowForeignExclusions
           ),
           obstacleNodes: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
             activeDualWrappedLayout.geometries.map(
@@ -38883,6 +40899,9 @@ function DocxEditorViewer({
           ),
           top: 0,
           marginRight: 0,
+          // Left-align the glyph in its hanging box (see body-paragraph twin)
+          // so a split list item's marker doesn't overlap the body text.
+          justifyContent: "flex-start",
           zIndex: 1,
           pointerEvents: "none"
         },
@@ -38921,7 +40940,11 @@ function DocxEditorViewer({
       ...baseParagraphStyle,
       ...hasPartialLineRange ? {
         marginTop: paragraphSegmentStartLine === 0 ? baseParagraphStyle.marginTop : 0,
-        marginBottom: paragraphSegmentEndLine >= paragraphSegmentTotalLines ? baseParagraphStyle.marginBottom : 0
+        marginBottom: paragraphSegmentEndLine >= paragraphSegmentTotalLines ? baseParagraphStyle.marginBottom : 0,
+        // See body-paragraph twin: the pretext split path positions
+        // everything absolutely, so drop the block hanging text-indent that
+        // would otherwise shift the segment left by the hanging amount.
+        ...shouldRenderParagraphSegmentWithPretext ? { textIndent: 0 } : void 0
       } : void 0,
       outline: "none"
     };
@@ -39110,6 +41133,11 @@ function DocxEditorViewer({
             ),
             top: 0,
             marginRight: 0,
+            // Left-align the marker glyph within its hanging-indent box so it
+            // sits at the number position with a gap before the text, instead
+            // of flex-end pinning it against the body text (which starts at
+            // the box's right edge) and overlapping it on split paragraphs.
+            justifyContent: "flex-start",
             zIndex: 1,
             pointerEvents: "none"
           },
@@ -39212,7 +41240,14 @@ function DocxEditorViewer({
         ...baseParagraphStyle,
         ...hasPartialLineRange ? {
           marginTop: paragraphSegmentStartLine === 0 ? resolvedBeforeSpacingPx ?? beforeSpacingPx : 0,
-          marginBottom: paragraphSegmentEndLine >= paragraphSegmentTotalLines ? resolvedAfterSpacingPx ?? afterSpacingPx : 0
+          marginBottom: paragraphSegmentEndLine >= paragraphSegmentTotalLines ? resolvedAfterSpacingPx ?? afterSpacingPx : 0,
+          // The pretext split path positions the marker and every line
+          // fragment absolutely, so it does not want the block hanging
+          // `text-indent: -hanging` (which otherwise shifts the whole
+          // absolutely-positioned segment left by the hanging amount,
+          // dropping the paragraph's left indent). The clip-fallback path
+          // still renders inline and keeps the text-indent.
+          ...shouldRenderParagraphSegmentWithPretext ? { textIndent: 0 } : void 0
         } : resolvedBeforeSpacingPx !== void 0 || resolvedAfterSpacingPx !== void 0 ? {
           ...resolvedBeforeSpacingPx !== void 0 ? { marginTop: resolvedBeforeSpacingPx } : void 0,
           ...resolvedAfterSpacingPx !== void 0 ? { marginBottom: resolvedAfterSpacingPx } : void 0
@@ -39312,8 +41347,9 @@ function DocxEditorViewer({
           )
         }
       ) : getFallbackParagraphRuns();
-      const paragraphDraftHtml = paragraphDraftsRef.current.get(nodeIndex);
-      const renderedEditableParagraphHtml = typeof paragraphDraftHtml === "string" ? paragraphDraftHtml : renderStaticHtml(renderedInteractiveParagraphContent);
+      const renderedEditableParagraphHtml = renderStaticHtml(
+        renderedInteractiveParagraphContent
+      );
       return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
         "div",
         {
@@ -39324,9 +41360,11 @@ function DocxEditorViewer({
           "data-docx-paragraph-end-line": paragraphSegmentEndLine,
           "data-docx-paragraph-partial-line-range": hasPartialLineRange ? "true" : void 0,
           style: paragraphStyle,
-          dangerouslySetInnerHTML: editable ? {
-            __html: renderedEditableParagraphHtml
-          } : void 0,
+          dangerouslySetInnerHTML: editable ? stableInnerHtmlProp(
+            editableParagraphHtmlPropsRef.current,
+            nodeIndex,
+            renderedEditableParagraphHtml
+          ) : void 0,
           ref: (element) => {
             if (shouldTrackParagraphElement) {
               if (element) {
@@ -39356,49 +41394,6 @@ function DocxEditorViewer({
                 }
               });
             }
-            const draft = paragraphDraftsRef.current.get(nodeIndex);
-            if (typeof draft === "string") {
-              const draftHtml = draft;
-              scheduleDomWrite(() => {
-                if (!element.isConnected) {
-                  return;
-                }
-                const latestDraft = paragraphDraftsRef.current.get(nodeIndex);
-                if (latestDraft !== draftHtml) {
-                  return;
-                }
-                if (element.innerHTML !== draftHtml) {
-                  const activeElement = document.activeElement;
-                  const shouldRestoreSelection = activeElement === element || activeElement instanceof Element && element.contains(activeElement);
-                  const selectionOffsets = shouldRestoreSelection ? selectionOffsetsWithinElement(element) : void 0;
-                  element.innerHTML = draftHtml;
-                  if (shouldRestoreSelection) {
-                    if (selectionOffsets) {
-                      const textLength = editableTextFromElement(element).length;
-                      const safeStart = Math.max(
-                        0,
-                        Math.min(selectionOffsets.start, textLength)
-                      );
-                      const safeEnd = Math.max(
-                        safeStart,
-                        Math.min(selectionOffsets.end, textLength)
-                      );
-                      setSelectionWithinElementByTextOffsets(
-                        element,
-                        safeStart,
-                        safeEnd
-                      );
-                    } else {
-                      placeCaretInsideElement(element);
-                    }
-                  }
-                }
-                const latestParagraph = editor.model.nodes[nodeIndex];
-                if (latestParagraph && latestParagraph.type === "paragraph" && editableTextFromElement(element) === paragraphText(latestParagraph)) {
-                  paragraphDraftsRef.current.delete(nodeIndex);
-                }
-              });
-            }
           },
           onPointerDown: (event) => {
             if (eventTargetIsInteractiveControl(event.target) || !editable) {
@@ -39516,36 +41511,78 @@ function DocxEditorViewer({
               return;
             }
             cancelPendingPointerSelectionReconcile();
-            editor.beginSelectionSession("keyboard", { settleAfterMs: 220 });
-            if (hasPartialLineRange) {
-              activateEditableParagraphSegment(nodeIndex, paragraphLineRange);
+            const nativeInputEvent = event.nativeEvent;
+            if (nativeInputEvent?.isComposing || compositionActiveRef.current) {
+              editor.beginSelectionSession("composition");
+              return;
+            }
+            const domText = editableTextFromElement(event.currentTarget);
+            const latestParagraph = editor.model.nodes[nodeIndex];
+            if (!latestParagraph || latestParagraph.type !== "paragraph" || domText === paragraphText(latestParagraph)) {
+              return;
             }
+            const continuation = editingIntentContinuationRef.current;
+            if (continuation && continuation.key === `p:${nodeIndex}` && continuation.text !== domText) {
+              return;
+            }
+            editor.beginSelectionSession("keyboard", { settleAfterMs: 220 });
             schedulePaginationMeasurementResume();
-            paragraphDraftsRef.current.set(
-              nodeIndex,
-              event.currentTarget.innerHTML
-            );
             const typedOffsets = selectionOffsetsWithinElement(
               event.currentTarget
             );
-            pendingEditableCaretRef.current = typedOffsets ? {
-              nodeIndex,
-              start: typedOffsets.start,
-              end: typedOffsets.end
-            } : null;
+            const caretOffset = typedOffsets?.end ?? domText.length;
+            editor.commitParagraphTextAtRange(
+              { kind: "paragraph", nodeIndex },
+              domText,
+              {
+                start: typedOffsets?.start ?? caretOffset,
+                end: caretOffset
+              }
+            );
+            editingIntentContinuationRef.current = {
+              key: `p:${nodeIndex}`,
+              text: domText,
+              caret: caretOffset
+            };
           },
           onCompositionStart: () => {
             if (!editable) {
               return;
             }
             cancelPendingPointerSelectionReconcile();
+            compositionActiveRef.current = true;
             editor.beginSelectionSession("composition");
           },
-          onCompositionEnd: () => {
+          onCompositionEnd: (event) => {
             if (!editable) {
               return;
             }
+            compositionActiveRef.current = false;
             editor.beginSelectionSession("keyboard", { settleAfterMs: 260 });
+            schedulePaginationMeasurementResume();
+            const composedText = editableTextFromElement(event.currentTarget);
+            const composedOffsets = selectionOffsetsWithinElement(
+              event.currentTarget
+            );
+            const caretEnd = composedOffsets?.end ?? composedText.length;
+            editor.commitParagraphTextAtRange(
+              { kind: "paragraph", nodeIndex },
+              composedText,
+              {
+                start: composedOffsets?.start ?? caretEnd,
+                end: caretEnd
+              }
+            );
+            editingIntentContinuationRef.current = {
+              key: `p:${nodeIndex}`,
+              text: composedText,
+              caret: caretEnd
+            };
+            pendingEditableCaretRef.current = composedOffsets ? {
+              nodeIndex,
+              start: composedOffsets.start,
+              end: composedOffsets.end
+            } : null;
           },
           onPaste: (event) => {
             const pastedText = event.clipboardData.getData("text/plain");
@@ -39558,13 +41595,16 @@ function DocxEditorViewer({
             }
             event.preventDefault();
             event.stopPropagation();
-            paragraphDraftsRef.current.delete(nodeIndex);
           },
           onKeyDown: (event) => {
             if (!editable) {
               return;
             }
             cancelPendingPointerSelectionReconcile();
+            if (isCompositionKeyboardEvent(event)) {
+              editor.beginSelectionSession("composition");
+              return;
+            }
             editor.beginSelectionSession("keyboard", { settleAfterMs: 220 });
             if (hasPartialLineRange) {
               activateEditableParagraphSegment(nodeIndex, paragraphLineRange);
@@ -39578,11 +41618,6 @@ function DocxEditorViewer({
             const handledHistoryShortcut = handleEditorHistoryShortcut(
               event,
               () => {
-                commitParagraphDraftFromElement(
-                  nodeIndex,
-                  node,
-                  event.currentTarget
-                );
               }
             );
             if (handledHistoryShortcut) {
@@ -39594,7 +41629,6 @@ function DocxEditorViewer({
               if (replaced) {
                 event.preventDefault();
                 event.stopPropagation();
-                paragraphDraftsRef.current.delete(nodeIndex);
                 return;
               }
             }
@@ -39604,7 +41638,6 @@ function DocxEditorViewer({
               if (replaced) {
                 event.preventDefault();
                 event.stopPropagation();
-                paragraphDraftsRef.current.delete(nodeIndex);
                 return;
               }
             }
@@ -39666,7 +41699,7 @@ function DocxEditorViewer({
                 if (previousLocation && previousParagraph) {
                   event.preventDefault();
                   event.stopPropagation();
-                  paragraphDraftsRef.current.delete(nodeIndex);
+                  editingIntentContinuationRef.current = void 0;
                   const caretClientPoint = collapsedCaretClientPointWithinElement(event.currentTarget);
                   if (caretClientPoint && focusParagraphLocationAtClientPoint(
                     previousLocation,
@@ -39688,7 +41721,7 @@ function DocxEditorViewer({
                 if (nextLocation && nextParagraph) {
                   event.preventDefault();
                   event.stopPropagation();
-                  paragraphDraftsRef.current.delete(nodeIndex);
+                  editingIntentContinuationRef.current = void 0;
                   const caretClientPoint = collapsedCaretClientPointWithinElement(event.currentTarget);
                   const fallbackOffset = paragraphText(nextParagraph).length;
                   if (caretClientPoint && focusParagraphLocationAtClientPoint(
@@ -39723,7 +41756,7 @@ function DocxEditorViewer({
                 if (previousLocation && previousParagraph) {
                   event.preventDefault();
                   event.stopPropagation();
-                  paragraphDraftsRef.current.delete(nodeIndex);
+                  editingIntentContinuationRef.current = void 0;
                   const collapsedRange = editor.deleteExpandedSelection({
                     start: {
                       location: cloneTextRangeLocation(previousLocation),
@@ -39749,7 +41782,7 @@ function DocxEditorViewer({
                 if (nextLocation && nextParagraph) {
                   event.preventDefault();
                   event.stopPropagation();
-                  paragraphDraftsRef.current.delete(nodeIndex);
+                  editingIntentContinuationRef.current = void 0;
                   const collapsedRange = editor.deleteExpandedSelection({
                     start: {
                       location: cloneTextRangeLocation(currentLocation),
@@ -39786,7 +41819,7 @@ function DocxEditorViewer({
               if (handledBackspace) {
                 event.preventDefault();
                 event.stopPropagation();
-                paragraphDraftsRef.current.delete(nodeIndex);
+                editingIntentContinuationRef.current = void 0;
                 focusParagraphAtOffset(nodeIndex, 0);
                 return;
               }
@@ -39810,7 +41843,7 @@ function DocxEditorViewer({
                 start
               )}
 ${currentText.slice(end)}`;
-              paragraphDraftsRef.current.delete(nodeIndex);
+              editingIntentContinuationRef.current = void 0;
               editor.commitParagraphText(nodeIndex, nextText);
               focusParagraphAtOffset(nodeIndex, start + 1);
               return;
@@ -39822,7 +41855,7 @@ ${currentText.slice(end)}`;
                 currentText
               );
               if (listDepthChanged) {
-                paragraphDraftsRef.current.delete(nodeIndex);
+                editingIntentContinuationRef.current = void 0;
                 const targetOffset = selectionOffsets?.end ?? currentText.length;
                 focusParagraphAtOffset(nodeIndex, targetOffset);
               }
@@ -39833,7 +41866,7 @@ ${currentText.slice(end)}`;
               event.stopPropagation();
               const start = selectionOffsets?.start ?? currentText.length;
               const end = selectionOffsets?.end ?? start;
-              paragraphDraftsRef.current.clear();
+              editingIntentContinuationRef.current = void 0;
               tableCellDraftsRef.current.clear();
               tableCellParagraphDraftsRef.current.clear();
               const insertedListItem = editor.insertListItemAfterSelection(
@@ -39867,7 +41900,7 @@ ${currentText.slice(end)}`;
                 start,
                 Math.min(selectionOffsets?.end ?? start, currentText.length)
               );
-              paragraphDraftsRef.current.clear();
+              editingIntentContinuationRef.current = void 0;
               tableCellDraftsRef.current.clear();
               tableCellParagraphDraftsRef.current.clear();
               const splitParagraph = editor.splitParagraphAtSelection(
@@ -39892,14 +41925,16 @@ ${currentText.slice(end)}`;
             if (!editable) {
               return;
             }
-            if (!paragraphDraftsRef.current.has(nodeIndex)) {
-              return;
+            if (compositionActiveRef.current) {
+              compositionActiveRef.current = false;
+              const composedText = editableTextFromElement(
+                event.currentTarget
+              );
+              if (composedText !== paragraphText(node)) {
+                editor.suppressNextDomSelectionRestore();
+                editor.commitParagraphText(nodeIndex, composedText);
+              }
             }
-            commitParagraphDraftFromElement(
-              nodeIndex,
-              node,
-              event.currentTarget
-            );
           },
           children: !editable ? renderedInteractiveParagraphContent : null
         },
@@ -39909,7 +41944,19 @@ ${currentText.slice(end)}`;
     const tableRowSliceOffsetPxForWrapper = tableRowSlice ? Math.max(0, Math.round(tableRowSlice.startOffsetPx)) : 0;
     const tableRowSliceTopBleedPxForWrapper = tableRowSlice && tableRowSliceOffsetPxForWrapper > 0 ? TABLE_ROW_SLICE_VISUAL_BLEED_PX : 0;
     const tableRowSliceBottomBleedPxForWrapper = tableRowSlice ? TABLE_ROW_SLICE_VISUAL_BLEED_PX : 0;
-    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    const floatingTablePageLayout = options?.pageLayout ?? documentLayout;
+    const floatingTableGeometry = node.style?.floating && !tableRowRange && !tableRowSlice ? resolveFloatingTableGeometry(node, nodeContentWidthPx, {
+      tableWidthPx: estimateFloatingTableWidthPx(
+        node,
+        nodeContentWidthPx
+      ),
+      tableHeightPx: 0,
+      indentPx: twipsToSignedPixels(node.style?.indentTwips) ?? 0,
+      flowTopPx: options?.pageFlowTopPx ?? 0,
+      pageMarginTopPx: floatingTablePageLayout.marginsPx.top,
+      pageMarginLeftPx: floatingTablePageLayout.marginsPx.left
+    }) : void 0;
+    const renderedTableBlock = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
       "div",
       {
         ref: (element) => {
@@ -39924,10 +41971,21 @@ ${currentText.slice(end)}`;
           }
         },
         style: {
-          ...tableWrapperStyle(
+          ...floatingTableGeometry ? {
+            position: "absolute",
+            left: floatingTableGeometry.leftPx,
+            top: floatingTableGeometry.topPx,
+            maxWidth: nodeContentWidthPx,
+            zIndex: 2
+          } : tableWrapperStyle(
             node,
             twipsToSignedPixels(node.style?.indentTwips) ?? 0
           ),
+          ...tableFloatingDragPreview?.tableIndex === nodeIndex ? {
+            transform: `translate(${tableFloatingDragPreview.deltaX}px, ${tableFloatingDragPreview.deltaY}px)`,
+            zIndex: 30,
+            opacity: 0.9
+          } : void 0,
           ...tableRowSlice ? {
             height: Math.max(
               MIN_PARAGRAPH_LINE_HEIGHT_PX,
@@ -40035,7 +42093,7 @@ ${currentText.slice(end)}`;
           const normalizedRowHeightsPx = rowHeightsPx.map(
             (value) => Number.isFinite(value) && value > 0 ? Math.max(24, value) : 24
           );
-          const measuredRowHeightsPx = tableMeasuredRowHeights[nodeIndex];
+          const measuredRowHeightsPx = node.blockId ? tableMeasuredRowHeights[node.blockId]?.rowHeightsPx : void 0;
           const rowBoundarySourceHeightsPx = measuredRowHeightsPx && measuredRowHeightsPx.length === node.rows.length ? measuredRowHeightsPx.map(
             (value) => Number.isFinite(value) && value > 0 ? Math.max(24, value) : 24
           ) : normalizedRowHeightsPx;
@@ -40263,6 +42321,9 @@ ${currentText.slice(end)}`;
                           } : void 0;
                           const cellDraftKey = `${nodeIndex}:${rowIndex}:${cellIndex}`;
                           const cellElementKey = `cell-${nodeIndex}-${rowIndex}-${cellIndex}`;
+                          const cellUsesLegacyDraftEditing = cell.nodes.some(
+                            (cellContent) => cellContent.type === "table"
+                          );
                           const colSpanValue = cell.style?.gridSpan && cell.style.gridSpan > 1 ? cell.style.gridSpan : 1;
                           const rowSpanValue = cell.style?.rowSpan && cell.style.rowSpan > 1 ? cell.style.rowSpan : 1;
                           const colSpan = colSpanValue > 1 ? colSpanValue : void 0;
@@ -40771,9 +42832,11 @@ ${currentText.slice(end)}`;
                                     overflowWrap: "break-word",
                                     wordBreak: "break-word"
                                   },
-                                  dangerouslySetInnerHTML: renderedEditableCellHtml ? {
-                                    __html: renderedEditableCellHtml
-                                  } : void 0,
+                                  dangerouslySetInnerHTML: renderedEditableCellHtml ? stableInnerHtmlProp(
+                                    editableTableCellHtmlPropsRef.current,
+                                    cellDraftKey,
+                                    renderedEditableCellHtml
+                                  ) : void 0,
                                   ref: (element) => {
                                     if (element) {
                                       tableCellEditorElementsRef.current.set(
@@ -40791,10 +42854,10 @@ ${currentText.slice(end)}`;
                                     const draft = tableCellDraftsRef.current.get(
                                       cellDraftKey
                                     );
-                                    if (typeof draft === "string") {
+                                    if (!compositionActiveRef.current && typeof draft === "string") {
                                       const draftHtml = draft;
                                       scheduleDomWrite(() => {
-                                        if (!element.isConnected) {
+                                        if (!element.isConnected || compositionActiveRef.current) {
                                           return;
                                         }
                                         const latestDraft = tableCellDraftsRef.current.get(
@@ -40916,28 +42979,6 @@ ${currentText.slice(end)}`;
                                             boundary,
                                             boundary
                                           );
-                                          const verifyBoundaryRestore = (attempt) => {
-                                            window.requestAnimationFrame(() => {
-                                              if (!element.isConnected) {
-                                                return;
-                                              }
-                                              const selection = window.getSelection();
-                                              const range = selection && selection.rangeCount > 0 ? selection.getRangeAt(0) : null;
-                                              const degenerate = !range || selection?.isCollapsed === true && range.startContainer === element && range.startOffset === 0;
-                                              if (degenerate) {
-                                                setSelectionFromDocxBoundaries(
-                                                  boundary,
-                                                  boundary
-                                                );
-                                              }
-                                              if (attempt < 6) {
-                                                verifyBoundaryRestore(
-                                                  attempt + 1
-                                                );
-                                              }
-                                            });
-                                          };
-                                          verifyBoundaryRestore(0);
                                         } else if (paragraphElement) {
                                           placeCaretInsideElement(
                                             paragraphElement,
@@ -40963,24 +43004,130 @@ ${currentText.slice(end)}`;
                                   },
                                   onInput: (event) => {
                                     cancelPendingPointerSelectionReconcile();
+                                    const nativeInputEvent = event.nativeEvent;
+                                    if (nativeInputEvent?.isComposing || compositionActiveRef.current) {
+                                      editor.beginSelectionSession(
+                                        "composition"
+                                      );
+                                      return;
+                                    }
+                                    if (cellUsesLegacyDraftEditing) {
+                                      editor.beginSelectionSession("keyboard", {
+                                        settleAfterMs: 220
+                                      });
+                                      schedulePaginationMeasurementResume();
+                                      tableCellDraftsRef.current.set(
+                                        cellDraftKey,
+                                        event.currentTarget.innerHTML
+                                      );
+                                      requestTableDraftLayoutRefresh();
+                                      return;
+                                    }
+                                    const context = activeTableCellParagraphContext(
+                                      event.currentTarget
+                                    );
+                                    const contextParagraph = context ? cellParagraphs[context.paragraphIndex] : void 0;
+                                    if (!context || !contextParagraph) {
+                                      return;
+                                    }
+                                    const domText = editableTextFromElement(
+                                      context.paragraphElement
+                                    );
+                                    if (domText === paragraphText(contextParagraph)) {
+                                      return;
+                                    }
+                                    const continuationKey = `c:${nodeIndex}:${rowIndex}:${cellIndex}:${context.paragraphIndex}`;
+                                    const continuation = editingIntentContinuationRef.current;
+                                    if (continuation && continuation.key === continuationKey && continuation.text !== domText) {
+                                      return;
+                                    }
                                     editor.beginSelectionSession("keyboard", {
                                       settleAfterMs: 220
                                     });
                                     schedulePaginationMeasurementResume();
-                                    tableCellDraftsRef.current.set(
-                                      cellDraftKey,
-                                      event.currentTarget.innerHTML
+                                    const typedOffsets = selectionOffsetsWithinElement(
+                                      context.paragraphElement
                                     );
-                                    requestTableDraftLayoutRefresh();
+                                    const caretOffset = typedOffsets?.end ?? domText.length;
+                                    editor.commitParagraphTextAtRange(
+                                      {
+                                        kind: "table-cell",
+                                        tableIndex: nodeIndex,
+                                        rowIndex,
+                                        cellIndex,
+                                        paragraphIndex: context.paragraphIndex
+                                      },
+                                      domText,
+                                      {
+                                        start: typedOffsets?.start ?? caretOffset,
+                                        end: caretOffset
+                                      }
+                                    );
+                                    editingIntentContinuationRef.current = {
+                                      key: continuationKey,
+                                      text: domText,
+                                      caret: caretOffset
+                                    };
                                   },
                                   onCompositionStart: () => {
                                     cancelPendingPointerSelectionReconcile();
+                                    compositionActiveRef.current = true;
                                     editor.beginSelectionSession("composition");
                                   },
-                                  onCompositionEnd: () => {
+                                  onCompositionEnd: (event) => {
+                                    compositionActiveRef.current = false;
                                     editor.beginSelectionSession("keyboard", {
                                       settleAfterMs: 260
                                     });
+                                    schedulePaginationMeasurementResume();
+                                    if (cellUsesLegacyDraftEditing) {
+                                      tableCellDraftsRef.current.set(
+                                        cellDraftKey,
+                                        event.currentTarget.innerHTML
+                                      );
+                                      requestTableDraftLayoutRefresh();
+                                      return;
+                                    }
+                                    const context = activeTableCellParagraphContext(
+                                      event.currentTarget
+                                    );
+                                    if (context && cellParagraphs[context.paragraphIndex]) {
+                                      const composedText = editableTextFromElement(
+                                        context.paragraphElement
+                                      );
+                                      const composedOffsets = selectionOffsetsWithinElement(
+                                        context.paragraphElement
+                                      );
+                                      const caretEnd = composedOffsets?.end ?? composedText.length;
+                                      editor.commitParagraphTextAtRange(
+                                        {
+                                          kind: "table-cell",
+                                          tableIndex: nodeIndex,
+                                          rowIndex,
+                                          cellIndex,
+                                          paragraphIndex: context.paragraphIndex
+                                        },
+                                        composedText,
+                                        {
+                                          start: composedOffsets?.start ?? caretEnd,
+                                          end: caretEnd
+                                        }
+                                      );
+                                      editingIntentContinuationRef.current = {
+                                        key: `c:${nodeIndex}:${rowIndex}:${cellIndex}:${context.paragraphIndex}`,
+                                        text: composedText,
+                                        caret: caretEnd
+                                      };
+                                      return;
+                                    }
+                                    editor.commitTableCellText(
+                                      nodeIndex,
+                                      rowIndex,
+                                      cellIndex,
+                                      editableTextFromTableCellElement(
+                                        event.currentTarget
+                                      )
+                                    );
                                   },
                                   onClick: (event) => {
                                     if (eventTargetIsInteractiveControl(
@@ -41155,6 +43302,12 @@ ${currentText.slice(end)}`;
                                   },
                                   onKeyDown: (event) => {
                                     cancelPendingPointerSelectionReconcile();
+                                    if (isCompositionKeyboardEvent(event)) {
+                                      editor.beginSelectionSession(
+                                        "composition"
+                                      );
+                                      return;
+                                    }
                                     editor.beginSelectionSession("keyboard", {
                                       settleAfterMs: 220
                                     });
@@ -41167,6 +43320,9 @@ ${currentText.slice(end)}`;
                                       return;
                                     }
                                     const handledHistoryShortcut = handleEditorHistoryShortcut(event, () => {
+                                      if (!cellUsesLegacyDraftEditing) {
+                                        return;
+                                      }
                                       commitTableCellDraftFromElement(
                                         nodeIndex,
                                         rowIndex,
@@ -41246,6 +43402,7 @@ ${currentText.slice(end)}`;
                                         start
                                       )}
 ${currentText.slice(end)}`;
+                                      editingIntentContinuationRef.current = void 0;
                                       tableCellDraftsRef.current.delete(
                                         cellDraftKey
                                       );
@@ -41290,6 +43447,7 @@ ${currentText.slice(end)}`;
                                       if (handledBackspace) {
                                         event.preventDefault();
                                         event.stopPropagation();
+                                        editingIntentContinuationRef.current = void 0;
                                         tableCellDraftsRef.current.delete(
                                           cellDraftKey
                                         );
@@ -41308,6 +43466,7 @@ ${currentText.slice(end)}`;
                                         currentText
                                       );
                                       if (listDepthChanged) {
+                                        editingIntentContinuationRef.current = void 0;
                                         tableCellDraftsRef.current.delete(
                                           cellDraftKey
                                         );
@@ -41321,6 +43480,31 @@ ${currentText.slice(end)}`;
                                     }
                                   },
                                   onBlur: (event) => {
+                                    if (!cellUsesLegacyDraftEditing) {
+                                      if (compositionActiveRef.current) {
+                                        compositionActiveRef.current = false;
+                                        const composedText = editableTextFromTableCellElement(
+                                          event.currentTarget
+                                        );
+                                        if (composedText !== tableCellText(cellParagraphs)) {
+                                          editor.suppressNextDomSelectionRestore();
+                                          editor.commitTableCellText(
+                                            nodeIndex,
+                                            rowIndex,
+                                            cellIndex,
+                                            composedText
+                                          );
+                                        }
+                                      }
+                                      return;
+                                    }
+                                    if (compositionActiveRef.current) {
+                                      compositionActiveRef.current = false;
+                                      tableCellDraftsRef.current.set(
+                                        cellDraftKey,
+                                        event.currentTarget.innerHTML
+                                      );
+                                    }
                                     if (!tableCellDraftsRef.current.has(
                                       cellDraftKey
                                     )) {
@@ -41728,6 +43912,18 @@ ${currentText.slice(end)}`;
         Math.round(tableRowSlice.sliceHeightPx)
       )}` : ""}` : `node-${nodeIndex}`
     );
+    if (floatingTableGeometry) {
+      return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        "div",
+        {
+          "data-docx-floating-table-host": "true",
+          style: { height: 0, position: "relative", overflow: "visible" },
+          children: renderedTableBlock
+        },
+        `floating-table-host-${nodeIndex}`
+      );
+    }
+    return renderedTableBlock;
   };
   const renderNodeSegments = React.useCallback(
     (nodeSegments, options) => {
@@ -41744,7 +43940,8 @@ ${currentText.slice(end)}`;
         resolvedPageLayout,
         {
           floatingMovePreview,
-          resizePreview
+          resizePreview,
+          measuredWrapBands
         }
       );
       for (let offset = 0; offset < nodeSegments.length; offset += 1) {
@@ -42397,6 +44594,8 @@ ${currentText.slice(end)}`;
             continue;
           }
         }
+        const segmentParagraphLineRange = segment.paragraphLineRange;
+        const measuredSegmentFlowTopPx = node.type === "paragraph" && (!segmentParagraphLineRange || segmentParagraphLineRange.startLineIndex === 0 && segmentParagraphLineRange.endLineIndex >= segmentParagraphLineRange.totalLineCount) ? measuredWrapBands.get(`para:${nodeIndex}`)?.topPx : void 0;
         rendered.push(
           renderDocumentNode(
             node,
@@ -42406,7 +44605,7 @@ ${currentText.slice(end)}`;
             segment.paragraphLineRange,
             {
               pageLayout: options?.pageLayout,
-              pageFlowTopPx,
+              pageFlowTopPx: measuredSegmentFlowTopPx ?? pageFlowTopPx,
               pageFlowForeignExclusions: foreignWrapExclusionsBySegmentIndex[offset],
               suppressLikelyFullPageCoverImageKeys: options?.suppressLikelyFullPageCoverImageKeys
             }
@@ -42438,6 +44637,7 @@ ${currentText.slice(end)}`;
       focusDropCapWrappedParagraph,
       hoveredDropCapNodeIndex,
       isReadOnly,
+      measuredWrapBands,
       pageContentWidthPxByNodeIndex,
       renderDocumentNode,
       resizePreview,
@@ -46523,6 +48723,7 @@ function ReactDocxViewer({
   DEFAULT_PAGE_OVERFLOW_TOLERANCE_PX,
   DocxEditorViewer,
   ReactDocxViewer,
+  allocateBlockId,
   applyRunStyle,
   buildDocModel,
   buildDocModelFromBytes,
@@ -46530,15 +48731,20 @@ function ReactDocxViewer({
   buildDocumentPageRanges,
   buildLayoutSnapshot,
   cloneDocModel,
+  cloneParagraphNode,
+  cloneTableNode,
   collectDocxEstimatedOverflowBreakStartNodeIndexes,
   collectDocxHardPageBreakStartNodeIndexes,
   collectDocxLastRenderedPageBreakStartNodeIndexes,
+  collectDuplicateDocModelBlockIds,
   collectTableExplicitPageBreakInfo,
   collectTopLevelExplicitPageBreakStartNodeIndexes,
   copyParagraphs,
   createMinimalDocxPackage,
+  deepFreezeDocModel,
   defaultStarterModel,
   duplicateParagraph,
+  ensureDocModelBlockIds,
   getPart,
   initWasm,
   insertParagraph,