@harbour-enterprises/superdoc 1.0.0-next.3 → 1.0.0-next.5

package/dist/chunks/{super-editor.es-S9Kp_7dy.es.js → super-editor.es-vynpc_1U.es.js}

@@ -42410,7 +42410,7 @@ const _SuperConverter = class _SuperConverter2 {
   static getStoredSuperdocVersion(docx) {
     return _SuperConverter2.getStoredCustomProperty(docx, "SuperdocVersion");
   }
-  static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.0.0-next.3") {
+  static setStoredSuperdocVersion(docx = this.convertedXml, version2 = "1.0.0-next.5") {
     return _SuperConverter2.setStoredCustomProperty(docx, "SuperdocVersion", version2, false);
   }
   /**
@@ -59638,7 +59638,7 @@ const isHeadless = (editor) => {
 const shouldSkipNodeView = (editor) => {
   return isHeadless(editor);
 };
-const summaryVersion = "1.0.0-next.3";
+const summaryVersion = "1.0.0-next.5";
 const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
 const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
 function mapAttributes(attrs) {
@@ -60427,7 +60427,7 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
       { default: remarkStringify },
       { default: remarkGfm }
     ] = await Promise.all([
-      import("./index-DLO-SgUP-c73otQJ5.es.js"),
+      import("./index-BUoOdDUj-CLmpIPsb.es.js"),
       import("./index-DRCvimau-Cw339678.es.js"),
       import("./index-C_x_N6Uh-DJn8hIEt.es.js"),
       import("./index-D_sWOSiG-DE96TaT5.es.js"),
@@ -60632,7 +60632,7 @@ const _Editor = class _Editor2 extends EventEmitter$1 {
    * Process collaboration migrations
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "1.0.0-next.3");
+    console.debug("[checkVersionMigrations] Current editor version", "1.0.0-next.5");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -66237,6 +66237,34 @@ function calculateTabWidth(params2) {
     tabStopPosUsed: nextStop.pos
   };
 }
+const SPACE_CHARS$1 = /* @__PURE__ */ new Set([" ", " "]);
+function shouldApplyJustify(params2) {
+  const { alignment: alignment2, hasExplicitPositioning, isLastLineOfParagraph, paragraphEndsWithLineBreak, skipJustifyOverride } = params2;
+  if (alignment2 !== "justify" && alignment2 !== "both") {
+    return false;
+  }
+  if (skipJustifyOverride === true) {
+    return false;
+  }
+  if (hasExplicitPositioning) {
+    return false;
+  }
+  if (isLastLineOfParagraph && !paragraphEndsWithLineBreak) {
+    return false;
+  }
+  return true;
+}
+function calculateJustifySpacing(params2) {
+  const { lineWidth, availableWidth, spaceCount, shouldJustify } = params2;
+  if (!shouldJustify) {
+    return 0;
+  }
+  if (spaceCount <= 0) {
+    return 0;
+  }
+  const slack = availableWidth - lineWidth;
+  return slack / spaceCount;
+}
 function resolveSpacingIndent$1(style2, numbering) {
   const spacing = {
     before: style2.spacing?.before ?? 0,
@@ -66503,13 +66531,14 @@ const hydrateParagraphStyleAttrs = (para, context, preResolved) => {
       };
     }
   }
+  const normalizedAlign = normalizeAlignment(resolvedExtended.justification);
   const hydrated = {
     resolved,
     spacing: resolvedSpacing,
     indent: resolvedIndent,
     borders: cloneIfObject(resolvedExtended.borders),
     shading: cloneIfObject(resolvedExtended.shading),
-    alignment: resolvedExtended.justification,
+    alignment: normalizedAlign,
     tabStops: cloneIfObject(resolvedExtended.tabStops),
     keepLines: resolvedExtended.keepLines,
     keepNext: resolvedExtended.keepNext,
@@ -67210,7 +67239,7 @@ const computeParagraphAttrs = (para, styleContext, listCounterContext, converter
   } else if (styleAlignment) {
     paragraphAttrs.alignment = styleAlignment;
   } else if (computed2.paragraph.alignment) {
-    paragraphAttrs.alignment = computed2.paragraph.alignment;
+    paragraphAttrs.alignment = normalizeAlignment(computed2.paragraph.alignment);
   }
   const spacingPx = spacingPtToPx(spacing, normalizedSpacing);
   if (spacingPx) paragraphAttrs.spacing = spacingPx;
@@ -70167,7 +70196,7 @@ function tableNodeToBlock(node, nextBlockId, positions, defaultFont, defaultSize
 let measurementCanvas = null;
 let measurementCtx = null;
 const TAB_CHAR_LENGTH = 1;
-const SPACE_CHARS = /* @__PURE__ */ new Set([" ", " "]);
+const SPACE_CHARS = SPACE_CHARS$1;
 const isTabRun$1 = (run2) => run2?.kind === "tab";
 function getMeasurementContext() {
   if (measurementCtx) return measurementCtx;
@@ -70193,29 +70222,50 @@ const countSpaces = (text) => {
   }
   return spaces;
 };
-const getJustifyAdjustment = (block, line, availableWidthOverride, alignmentOverride) => {
+const getJustifyAdjustment = (block, line, availableWidthOverride, alignmentOverride, isLastLineOfParagraph, paragraphEndsWithLineBreak, skipJustifyOverride) => {
   if (block.kind !== "paragraph") {
     return { extraPerSpace: 0, totalSpaces: 0 };
   }
-  const alignment2 = alignmentOverride ?? block.attrs?.alignment;
-  const hasExplicitPositioning = line.segments?.some((seg) => seg.x !== void 0);
-  const availableWidth = availableWidthOverride ?? line.maxWidth ?? line.width;
-  const slack = Math.max(0, availableWidth - line.width);
-  if (alignment2 !== "justify" || hasExplicitPositioning || slack <= 0) {
+  if (block.runs.length === 0) {
     return { extraPerSpace: 0, totalSpaces: 0 };
   }
-  const runs = sliceRunsForLine$1(block, line);
-  const totalSpaces = runs.reduce((sum, run2) => {
-    if (isTabRun$1(run2) || "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" || run2.kind === "fieldAnnotation") {
-      return sum;
-    }
-    return sum + countSpaces(run2.text ?? "");
-  }, 0);
-  if (totalSpaces <= 0) {
+  const alignment2 = alignmentOverride ?? block.attrs?.alignment;
+  const hasExplicitPositioning = line.segments?.some((seg) => seg.x !== void 0) ?? false;
+  const lastRunIndex = block.runs.length - 1;
+  const lastRun = block.runs[lastRunIndex];
+  const derivedIsLastLine = line.toRun >= lastRunIndex;
+  const derivedEndsWithLineBreak = lastRun ? lastRun.kind === "lineBreak" : false;
+  const shouldJustify = shouldApplyJustify({
+    alignment: alignment2,
+    hasExplicitPositioning,
+    isLastLineOfParagraph: derivedIsLastLine,
+    paragraphEndsWithLineBreak: derivedEndsWithLineBreak,
+    skipJustifyOverride
+  });
+  if (!shouldJustify) {
     return { extraPerSpace: 0, totalSpaces: 0 };
   }
+  let totalSpaces = line.spaceCount ?? 0;
+  if (totalSpaces === 0) {
+    const runs = sliceRunsForLine$1(block, line);
+    totalSpaces = runs.reduce((sum, run2) => {
+      if (isTabRun$1(run2) || "src" in run2 || run2.kind === "lineBreak" || run2.kind === "break" || run2.kind === "fieldAnnotation") {
+        return sum;
+      }
+      return sum + countSpaces(run2.text ?? "");
+    }, 0);
+  }
+  const availableWidth = availableWidthOverride ?? line.maxWidth ?? line.width;
+  const lineWidth = line.naturalWidth ?? line.width;
+  const extraPerSpace = calculateJustifySpacing({
+    lineWidth,
+    availableWidth,
+    spaceCount: totalSpaces,
+    shouldJustify: true
+    // Already checked above
+  });
   return {
-    extraPerSpace: slack / totalSpaces,
+    extraPerSpace,
     totalSpaces
   };
 };
@@ -70282,7 +70332,7 @@ function measureCharacterX(block, line, charOffset, availableWidthOverride, alig
   line.width;
   const justify = getJustifyAdjustment(block, line, availableWidth, alignmentOverride);
   const alignment2 = alignmentOverride ?? (block.kind === "paragraph" ? block.attrs?.alignment : void 0);
-  const renderedLineWidth = alignment2 === "justify" ? line.width + Math.max(0, availableWidth - line.width) : line.width;
+  const renderedLineWidth = alignment2 === "justify" && justify.extraPerSpace !== 0 ? availableWidth : line.width;
   const hasExplicitPositioning = line.segments?.some((seg) => seg.x !== void 0);
   const alignmentOffset = !hasExplicitPositioning && alignment2 === "center" ? Math.max(0, (availableWidth - renderedLineWidth) / 2) : !hasExplicitPositioning && alignment2 === "right" ? Math.max(0, availableWidth - renderedLineWidth) : 0;
   if (hasExplicitPositioning && line.segments && ctx2) {
@@ -70325,13 +70375,13 @@ function measureCharacterX(block, line, charOffset, availableWidthOverride, alig
       const textUpToTarget = text.slice(0, offsetInRun);
       const measured2 = ctx2.measureText(textUpToTarget);
       const spacingWidth = computeLetterSpacingWidth(run2, offsetInRun, runLength);
-      const spacesInPortion = justify.extraPerSpace > 0 ? countSpaces(textUpToTarget) : 0;
+      const spacesInPortion = justify.extraPerSpace !== 0 ? countSpaces(textUpToTarget) : 0;
       return alignmentOffset + currentX + measured2.width + spacingWidth + justify.extraPerSpace * (spaceTally + spacesInPortion);
     }
     ctx2.font = getRunFontString(run2);
     const measured = ctx2.measureText(text);
     const runLetterSpacing = computeLetterSpacingWidth(run2, runLength, runLength);
-    const spacesInRun = justify.extraPerSpace > 0 ? countSpaces(text) : 0;
+    const spacesInRun = justify.extraPerSpace !== 0 ? countSpaces(text) : 0;
     currentX += measured.width + runLetterSpacing + justify.extraPerSpace * spacesInRun;
     spaceTally += spacesInRun;
     currentCharOffset += runLength;
@@ -75483,9 +75533,66 @@ const _DomPainter = class _DomPainter2 {
       const firstLineOffset = suppressFirstLineIndent ? 0 : (paraIndent?.firstLine ?? 0) - (paraIndent?.hanging ?? 0);
       const lastRun = block.runs.length > 0 ? block.runs[block.runs.length - 1] : null;
       const paragraphEndsWithLineBreak = lastRun?.kind === "lineBreak";
+      let listFirstLineMarkerTabWidth;
+      if (!fragment.continuesFromPrev && fragment.markerWidth && wordLayout?.marker) {
+        const markerBoxWidth = fragment.markerWidth;
+        const markerTextWidth = fragment.markerTextWidth != null && isFinite(fragment.markerTextWidth) && fragment.markerTextWidth >= 0 ? fragment.markerTextWidth : markerBoxWidth;
+        const suffix2 = wordLayout.marker.suffix ?? "tab";
+        if (suffix2 === "tab") {
+          const markerJustification = wordLayout.marker.justification ?? "left";
+          const isFirstLineIndentMode = wordLayout.firstLineIndentMode === true;
+          let markerStartPos;
+          if (isFirstLineIndentMode && wordLayout.marker.markerX !== void 0 && Number.isFinite(wordLayout.marker.markerX)) {
+            markerStartPos = wordLayout.marker.markerX;
+          } else {
+            const hanging = paraIndent?.hanging ?? 0;
+            const firstLine = paraIndent?.firstLine ?? 0;
+            markerStartPos = paraIndentLeft - hanging + firstLine;
+          }
+          const validMarkerStartPos = Number.isFinite(markerStartPos) ? markerStartPos : 0;
+          let tabWidth;
+          if (markerJustification === "left") {
+            const currentPos = validMarkerStartPos + markerTextWidth;
+            if (isFirstLineIndentMode) {
+              const textStartTarget = wordLayout.marker.textStartX !== void 0 && Number.isFinite(wordLayout.marker.textStartX) ? wordLayout.marker.textStartX : wordLayout.textStartPx;
+              if (textStartTarget !== void 0 && Number.isFinite(textStartTarget) && textStartTarget > currentPos) {
+                tabWidth = textStartTarget - currentPos;
+              } else {
+                tabWidth = LIST_MARKER_GAP$1;
+              }
+            } else {
+              const firstLine = paraIndent?.firstLine ?? 0;
+              const textStart = paraIndentLeft + firstLine;
+              tabWidth = textStart - currentPos;
+              if (tabWidth <= 0) {
+                tabWidth = DEFAULT_TAB_INTERVAL_PX$1 - currentPos % DEFAULT_TAB_INTERVAL_PX$1;
+              } else if (tabWidth < LIST_MARKER_GAP$1) {
+                tabWidth = LIST_MARKER_GAP$1;
+              }
+            }
+          } else {
+            const gutterWidth = fragment.markerGutter ?? wordLayout.marker.gutterWidthPx;
+            tabWidth = gutterWidth !== void 0 && Number.isFinite(gutterWidth) && gutterWidth > 0 ? gutterWidth : LIST_MARKER_GAP$1;
+          }
+          if (tabWidth < LIST_MARKER_GAP$1) {
+            tabWidth = LIST_MARKER_GAP$1;
+          }
+          listFirstLineMarkerTabWidth = validMarkerStartPos + markerTextWidth + tabWidth;
+        } else if (suffix2 === "space") {
+          const hanging = paraIndent?.hanging ?? 0;
+          const firstLine = paraIndent?.firstLine ?? 0;
+          const markerStartPos = paraIndentLeft - hanging + firstLine;
+          const validMarkerStartPos = Number.isFinite(markerStartPos) ? markerStartPos : 0;
+          listFirstLineMarkerTabWidth = validMarkerStartPos + markerTextWidth + 4;
+        }
+      }
       lines.forEach((line, index2) => {
-        const fallbackAvailableWidth = Math.max(0, fragment.width - (paraIndentLeft + paraIndentRight));
-        const availableWidthOverride = line.maxWidth ?? fallbackAvailableWidth;
+        const positiveIndentReduction = Math.max(0, paraIndentLeft) + Math.max(0, paraIndentRight);
+        const fallbackAvailableWidth = Math.max(0, fragment.width - positiveIndentReduction);
+        let availableWidthOverride = line.maxWidth != null ? Math.min(line.maxWidth, fallbackAvailableWidth) : fallbackAvailableWidth;
+        if (index2 === 0 && listFirstLineMarkerTabWidth != null) {
+          availableWidthOverride = fragment.width - listFirstLineMarkerTabWidth - Math.max(0, paraIndentRight);
+        }
         const isLastLineOfFragment = index2 === lines.length - 1;
         const isLastLineOfParagraph = isLastLineOfFragment && !fragment.continuesOnNext;
         const shouldSkipJustifyForLastLine = isLastLineOfParagraph && !paragraphEndsWithLineBreak;
@@ -75511,7 +75618,10 @@ const _DomPainter = class _DomPainter2 {
             }
           } else if (paraIndentLeft && paraIndentLeft > 0) {
             lineEl.style.paddingLeft = `${paraIndentLeft}px`;
-          } else if (!isFirstLine && paraIndent?.hanging && paraIndent.hanging > 0) {
+          } else if (!isFirstLine && paraIndent?.hanging && paraIndent.hanging > 0 && // Only apply hanging padding when left indent is NOT negative.
+          // When left indent is negative, the fragment position already accounts for it.
+          // Adding padding here would shift body lines right, causing right-side overflow.
+          !(paraIndentLeft != null && paraIndentLeft < 0)) {
             lineEl.style.paddingLeft = `${paraIndent.hanging}px`;
           }
         }
@@ -75540,6 +75650,7 @@ const _DomPainter = class _DomPainter2 {
           lineEl.style.paddingLeft = `${validMarkerStartPos}px`;
           const markerContainer = this.doc.createElement("span");
           markerContainer.style.display = "inline-block";
+          markerContainer.style.wordSpacing = "0px";
           const markerEl = this.doc.createElement("span");
           markerEl.classList.add("superdoc-paragraph-marker");
           markerEl.textContent = wordLayout.marker.markerText ?? "";
@@ -75625,10 +75736,15 @@ const _DomPainter = class _DomPainter2 {
               }
             }
             tabEl.style.display = "inline-block";
+            tabEl.style.wordSpacing = "0px";
             tabEl.style.width = `${tabWidth}px`;
             lineEl.prepend(tabEl);
           } else if (suffix2 === "space") {
-            lineEl.prepend(this.doc.createTextNode(" "));
+            const spaceEl = this.doc.createElement("span");
+            spaceEl.classList.add("superdoc-marker-suffix-space");
+            spaceEl.style.wordSpacing = "0px";
+            spaceEl.textContent = " ";
+            lineEl.prepend(spaceEl);
           }
           lineEl.prepend(markerContainer);
         }
@@ -76920,11 +77036,8 @@ const _DomPainter = class _DomPainter2 {
       el.setAttribute("styleid", styleId);
     }
     const alignment2 = block.attrs?.alignment;
-    const effectiveAlignment = alignment2;
-    if (effectiveAlignment === "center" || effectiveAlignment === "right") {
-      el.style.textAlign = effectiveAlignment;
-    } else if (effectiveAlignment === "justify") {
-      el.style.textAlign = "left";
+    if (alignment2 === "center" || alignment2 === "right") {
+      el.style.textAlign = alignment2;
     } else {
       el.style.textAlign = "left";
     }
@@ -76935,9 +77048,8 @@ const _DomPainter = class _DomPainter2 {
     if (lineRange.pmEnd != null) {
       el.dataset.pmEnd = String(lineRange.pmEnd);
     }
-    const runsForLine = sliceRunsForLine(block, line);
+    let runsForLine = sliceRunsForLine(block, line);
     const trackedConfig = this.resolveTrackedChangesConfig(block);
-    runsForLine.length > 0 ? runsForLine.filter((r2) => (r2.kind === "text" || r2.kind === void 0) && "text" in r2 && r2.text != null).map((r2) => r2.text) : gatherTextSlicesForLine(block, line);
     if (runsForLine.length === 0) {
       const span = this.doc.createElement("span");
       span.innerHTML = "&nbsp;";
@@ -76984,7 +77096,156 @@ const _DomPainter = class _DomPainter2 {
       });
     }
     const hasExplicitPositioning = line.segments?.some((seg) => seg.x !== void 0);
-    availableWidthOverride ?? line.maxWidth ?? line.width;
+    const availableWidth = availableWidthOverride ?? line.maxWidth ?? line.width;
+    const justifyShouldApply = shouldApplyJustify({
+      alignment: block.attrs?.alignment,
+      hasExplicitPositioning: hasExplicitPositioning ?? false,
+      // Caller already folds last-line + trailing lineBreak behavior into skipJustify.
+      isLastLineOfParagraph: false,
+      paragraphEndsWithLineBreak: false,
+      skipJustifyOverride: skipJustify
+    });
+    const countSpaces2 = (text) => {
+      let count = 0;
+      for (let i = 0; i < text.length; i += 1) {
+        if (SPACE_CHARS$1.has(text[i])) count += 1;
+      }
+      return count;
+    };
+    if (justifyShouldApply) {
+      const stableDataAttrs = (attrs) => {
+        if (!attrs) return void 0;
+        const keys2 = Object.keys(attrs).sort();
+        const out = {};
+        keys2.forEach((key2) => {
+          out[key2] = attrs[key2];
+        });
+        return out;
+      };
+      const mergeSignature = (run2) => JSON.stringify({
+        kind: run2.kind ?? "text",
+        fontFamily: run2.fontFamily,
+        fontSize: run2.fontSize,
+        bold: run2.bold ?? false,
+        italic: run2.italic ?? false,
+        letterSpacing: run2.letterSpacing ?? null,
+        color: run2.color ?? null,
+        underline: run2.underline ?? null,
+        strike: run2.strike ?? false,
+        highlight: run2.highlight ?? null,
+        textTransform: run2.textTransform ?? null,
+        token: run2.token ?? null,
+        pageRefMetadata: run2.pageRefMetadata ?? null,
+        trackedChange: run2.trackedChange ?? null,
+        sdt: run2.sdt ?? null,
+        link: run2.link ?? null,
+        comments: run2.comments ?? null,
+        dataAttrs: stableDataAttrs(run2.dataAttrs) ?? null
+      });
+      const isWhitespaceOnly = (text) => {
+        if (text.length === 0) return false;
+        for (let i = 0; i < text.length; i += 1) {
+          if (!SPACE_CHARS$1.has(text[i])) return false;
+        }
+        return true;
+      };
+      const cloneTextRun = (run2) => ({
+        ...run2,
+        comments: run2.comments ? [...run2.comments] : void 0,
+        dataAttrs: run2.dataAttrs ? { ...run2.dataAttrs } : void 0,
+        underline: run2.underline ? { ...run2.underline } : void 0,
+        pageRefMetadata: run2.pageRefMetadata ? { ...run2.pageRefMetadata } : void 0
+      });
+      const normalized = runsForLine.map((run2) => {
+        if (run2.kind !== "text" && run2.kind !== void 0 || !("text" in run2)) return run2;
+        return cloneTextRun(run2);
+      });
+      const merged = [];
+      for (let i = 0; i < normalized.length; i += 1) {
+        const run2 = normalized[i];
+        if (run2.kind !== "text" && run2.kind !== void 0 || !("text" in run2)) {
+          merged.push(run2);
+          continue;
+        }
+        const textRun = run2;
+        if (!isWhitespaceOnly(textRun.text ?? "")) {
+          merged.push(textRun);
+          continue;
+        }
+        const prev = merged[merged.length - 1];
+        if (prev && (prev.kind === "text" || prev.kind === void 0) && "text" in prev) {
+          const prevTextRun = prev;
+          if (mergeSignature(prevTextRun) === mergeSignature(textRun)) {
+            const extra = textRun.text ?? "";
+            prevTextRun.text = (prevTextRun.text ?? "") + extra;
+            if (prevTextRun.pmStart != null) {
+              prevTextRun.pmEnd = prevTextRun.pmStart + prevTextRun.text.length;
+            } else if (prevTextRun.pmEnd != null) {
+              prevTextRun.pmEnd = prevTextRun.pmEnd + extra.length;
+            }
+            continue;
+          }
+        }
+        const next = normalized[i + 1];
+        if (next && (next.kind === "text" || next.kind === void 0) && "text" in next) {
+          const nextTextRun = next;
+          if (mergeSignature(nextTextRun) === mergeSignature(textRun)) {
+            const extra = textRun.text ?? "";
+            nextTextRun.text = extra + (nextTextRun.text ?? "");
+            if (textRun.pmStart != null) {
+              nextTextRun.pmStart = textRun.pmStart;
+            } else if (nextTextRun.pmStart != null) {
+              nextTextRun.pmStart = nextTextRun.pmStart - extra.length;
+            }
+            if (nextTextRun.pmStart != null && nextTextRun.pmEnd == null) {
+              nextTextRun.pmEnd = nextTextRun.pmStart + nextTextRun.text.length;
+            }
+            continue;
+          }
+        }
+        merged.push(textRun);
+      }
+      runsForLine = merged;
+      const hasNonSpaceText = runsForLine.some(
+        (run2) => (run2.kind === "text" || run2.kind === void 0) && "text" in run2 && (run2.text ?? "").trim().length > 0
+      );
+      if (hasNonSpaceText) {
+        for (let i = runsForLine.length - 1; i >= 0; i -= 1) {
+          const run2 = runsForLine[i];
+          if (run2.kind !== "text" && run2.kind !== void 0 || !("text" in run2)) continue;
+          const text = run2.text ?? "";
+          let trimCount = 0;
+          for (let j2 = text.length - 1; j2 >= 0 && text[j2] === " "; j2 -= 1) {
+            trimCount += 1;
+          }
+          if (trimCount === 0) break;
+          const nextText = text.slice(0, Math.max(0, text.length - trimCount));
+          if (nextText.length === 0) {
+            runsForLine.splice(i, 1);
+            continue;
+          }
+          run2.text = nextText;
+          if (run2.pmEnd != null) {
+            run2.pmEnd = run2.pmEnd - trimCount;
+          }
+          break;
+        }
+      }
+    }
+    const spaceCount = line.spaceCount ?? runsForLine.reduce((sum, run2) => {
+      if (run2.kind !== "text" && run2.kind !== void 0 || !("text" in run2) || run2.text == null) return sum;
+      return sum + countSpaces2(run2.text);
+    }, 0);
+    const lineWidth = line.naturalWidth ?? line.width;
+    const spacingPerSpace = calculateJustifySpacing({
+      lineWidth,
+      availableWidth,
+      spaceCount,
+      shouldJustify: justifyShouldApply
+    });
+    if (spacingPerSpace !== 0) {
+      el.style.wordSpacing = `${spacingPerSpace}px`;
+    }
     if (hasExplicitPositioning && line.segments) {
       const paraIndent = block.attrs?.indent;
       const indentLeft = paraIndent?.left ?? 0;
@@ -77856,7 +78117,7 @@ const applyParagraphBlockStyles = (element, attrs) => {
     element.setAttribute("styleid", attrs.styleId);
   }
   if (attrs.alignment) {
-    element.style.textAlign = attrs.alignment;
+    element.style.textAlign = attrs.alignment === "justify" || attrs.alignment === "both" ? "left" : attrs.alignment;
   }
   if (attrs.dropCap) {
     element.classList.add("sd-editor-dropcap");
@@ -77921,23 +78182,6 @@ const applyParagraphShadingStyles = (element, shading) => {
   if (!shading?.fill) return;
   element.style.backgroundColor = shading.fill;
 };
-const gatherTextSlicesForLine = (block, line) => {
-  const slices = [];
-  const startRun = line.fromRun ?? 0;
-  const endRun = line.toRun ?? startRun;
-  for (let runIndex = startRun; runIndex <= endRun; runIndex += 1) {
-    const run2 = block.runs[runIndex];
-    if (!run2 || run2.kind !== "text" && run2.kind !== void 0 || !("text" in run2) || !run2.text) continue;
-    const isFirst = runIndex === startRun;
-    const isLast = runIndex === endRun;
-    const start2 = isFirst ? line.fromChar ?? 0 : 0;
-    const end2 = isLast ? line.toChar ?? run2.text.length : run2.text.length;
-    if (start2 >= end2) continue;
-    const slice2 = run2.text.slice(start2, end2);
-    if (slice2) slices.push(slice2);
-  }
-  return slices;
-};
 const sliceRunsForLine = (block, line) => {
   const result = [];
   for (let runIndex = line.fromRun; runIndex <= line.toRun; runIndex += 1) {
@@ -78559,7 +78803,8 @@ function calculateTextStartIndent(params2) {
   let indentAdjust = paraIndentLeft;
   if (isListItem2 && isFirstLine && isFirstLineIndentMode) {
     const textStartFallback = paraIndentLeft + Math.max(firstLineIndent, 0) + markerWidth;
-    indentAdjust = typeof wordLayout?.textStartPx === "number" && Number.isFinite(wordLayout.textStartPx) ? wordLayout.textStartPx : textStartFallback;
+    const markerTextStartX = wordLayout?.marker?.textStartX;
+    indentAdjust = typeof markerTextStartX === "number" && Number.isFinite(markerTextStartX) ? markerTextStartX : typeof wordLayout?.textStartPx === "number" && Number.isFinite(wordLayout.textStartPx) ? wordLayout.textStartPx : textStartFallback;
   } else if (isFirstLine && !isListItem2) {
     indentAdjust += firstLineOffset;
   }
@@ -79249,6 +79494,20 @@ const asSafeNumber = (value) => {
   }
   return value;
 };
+function calculateFirstLineIndent(block, measure) {
+  const wordLayout = block.attrs?.wordLayout;
+  if (!wordLayout?.firstLineIndentMode) {
+    return 0;
+  }
+  if (!wordLayout.marker || !measure.marker) {
+    return 0;
+  }
+  const markerWidthRaw = measure.marker.markerWidth ?? wordLayout.marker.markerBoxWidthPx ?? 0;
+  const markerWidth = Number.isFinite(markerWidthRaw) && markerWidthRaw >= 0 ? markerWidthRaw : 0;
+  const gutterWidthRaw = measure.marker.gutterWidth ?? 0;
+  const gutterWidth = Number.isFinite(gutterWidthRaw) && gutterWidthRaw >= 0 ? gutterWidthRaw : 0;
+  return markerWidth + gutterWidth;
+}
 function layoutParagraphBlock(ctx2, anchors) {
   const { block, measure, columnWidth, ensurePage, advanceColumn, columnX, floatManager } = ctx2;
   const remeasureParagraph2 = ctx2.remeasureParagraph;
@@ -79378,17 +79637,8 @@ function layoutParagraphBlock(ctx2, anchors) {
   const remeasureWidth = Math.max(1, columnWidth - indentLeft - indentRight);
   let didRemeasureForColumnWidth = false;
   if (typeof remeasureParagraph2 === "function" && typeof measurementWidth === "number" && measurementWidth > remeasureWidth) {
-    let firstLineIndent = 0;
-    const wordLayout = block.attrs?.wordLayout;
-    if (wordLayout?.marker && measure.marker) {
-      const markerJustification = wordLayout.marker.justification ?? "left";
-      if (markerJustification === "left") {
-        const markerWidth = measure.marker.markerWidth ?? 0;
-        const gutterWidth = measure.marker.gutterWidth ?? wordLayout.marker.gutterWidthPx ?? 0;
-        firstLineIndent = markerWidth + gutterWidth;
-      }
-    }
-    const newMeasure = remeasureParagraph2(block, remeasureWidth, firstLineIndent);
+    const firstLineIndent = calculateFirstLineIndent(block, measure);
+    const newMeasure = remeasureParagraph2(block, columnWidth, firstLineIndent);
     lines = normalizeLines(newMeasure);
     didRemeasureForColumnWidth = true;
   }
@@ -79469,16 +79719,7 @@ function layoutParagraphBlock(ctx2, anchors) {
     }
     const narrowestRemeasureWidth = Math.max(1, narrowestWidth - indentLeft - indentRight);
     if (narrowestRemeasureWidth < remeasureWidth) {
-      let firstLineIndent = 0;
-      const wordLayout = block.attrs?.wordLayout;
-      if (wordLayout?.marker && measure.marker) {
-        const markerJustification = wordLayout.marker.justification ?? "left";
-        if (markerJustification === "left") {
-          const markerWidth = measure.marker.markerWidth ?? 0;
-          const gutterWidth = measure.marker.gutterWidth ?? wordLayout.marker.gutterWidthPx ?? 0;
-          firstLineIndent = markerWidth + gutterWidth;
-        }
-      }
+      const firstLineIndent = calculateFirstLineIndent(block, measure);
       const newMeasure = remeasureParagraph2(block, narrowestRemeasureWidth, firstLineIndent);
       lines = normalizeLines(newMeasure);
       didRemeasureForFloats = true;
@@ -82625,7 +82866,8 @@ function remeasureParagraph(block, maxWidth, firstLineIndent = 0) {
   const indentHanging = Math.max(0, indent?.hanging ?? 0);
   const rawFirstLineOffset = Math.max(0, firstLineIndent || indentFirstLine - indentHanging);
   const contentWidth = Math.max(1, maxWidth - indentLeft - indentRight);
-  const textStartPx = wordLayout?.textStartPx;
+  const markerTextStartX = wordLayout?.marker?.textStartX;
+  const textStartPx = typeof markerTextStartX === "number" && Number.isFinite(markerTextStartX) ? markerTextStartX : typeof wordLayout?.textStartPx === "number" && Number.isFinite(wordLayout.textStartPx) ? wordLayout.textStartPx : void 0;
   const treatAsHanging = textStartPx && indentLeft === 0 && indentHanging === 0;
   const firstLineWidth = typeof textStartPx === "number" && textStartPx > indentLeft && !treatAsHanging ? Math.max(1, maxWidth - textStartPx - indentRight) : Math.max(1, contentWidth - rawFirstLineOffset);
   const tabStops = buildTabStopsPx$1(indent, attrs?.tabs, attrs?.tabIntervalTwips);
@@ -82637,6 +82879,7 @@ function remeasureParagraph(block, maxWidth, firstLineIndent = 0) {
     const startRun = currentRun;
     const startChar = currentChar;
     let width = 0;
+    let widthAtLastBreak = -1;
     let lastBreakRun = -1;
     let lastBreakChar = -1;
     let endRun = currentRun;
@@ -82654,6 +82897,7 @@ function remeasureParagraph(block, maxWidth, firstLineIndent = 0) {
         endChar = 1;
         lastBreakRun = r2;
         lastBreakChar = 1;
+        widthAtLastBreak = width;
         continue;
       }
       const text = runText(run2);
@@ -82664,6 +82908,7 @@ function remeasureParagraph(block, maxWidth, firstLineIndent = 0) {
           if (lastBreakRun >= 0) {
             endRun = lastBreakRun;
             endChar = lastBreakChar;
+            width = widthAtLastBreak >= 0 ? widthAtLastBreak : width;
           } else {
             endRun = r2;
             endChar = c2;
@@ -82678,6 +82923,7 @@ function remeasureParagraph(block, maxWidth, firstLineIndent = 0) {
         if (ch === " " || ch === "	" || ch === "-") {
           lastBreakRun = r2;
           lastBreakChar = c2 + 1;
+          widthAtLastBreak = width;
         }
       }
       if (didBreakInThisLine) break;
@@ -84388,7 +84634,9 @@ function clickToPosition(layout, blocks, measures, containerPoint, domContainer,
       }
       const markerWidth = fragment.markerWidth ?? measure.marker?.markerWidth ?? 0;
       const isListItem3 = markerWidth > 0;
-      const alignmentOverride = isListItem3 ? "left" : void 0;
+      const paraAlignment = block.attrs?.alignment;
+      const isJustified = paraAlignment === "justify" || paraAlignment === "both";
+      const alignmentOverride = isListItem3 && !isJustified ? "left" : void 0;
       const pos = mapPointToPm(block, line, pageRelativePoint.x - fragment.x, isRTL, availableWidth, alignmentOverride);
       if (pos == null) {
         logClickStage("warn", "no-position", {
@@ -84455,7 +84703,9 @@ function clickToPosition(layout, blocks, measures, containerPoint, domContainer,
       }
       const cellMarkerWidth = cellMeasure.marker?.markerWidth ?? 0;
       const isListItem3 = cellMarkerWidth > 0;
-      const alignmentOverride = isListItem3 ? "left" : void 0;
+      const cellAlignment = cellBlock.attrs?.alignment;
+      const isJustified = cellAlignment === "justify" || cellAlignment === "both";
+      const alignmentOverride = isListItem3 && !isJustified ? "left" : void 0;
       const pos = mapPointToPm(cellBlock, line, localX, isRTL, availableWidth, alignmentOverride);
       if (pos != null) {
         logClickStage("log", "success", {
@@ -84624,7 +84874,9 @@ function selectionToRects(layout, blocks, measures, from2, to, geometryHelper) {
           const charOffsetTo = pmPosToCharOffset(block, line, sliceTo);
           const markerWidth = fragment.markerWidth ?? measure.marker?.markerWidth ?? 0;
           const isListItemFlag = isListItem(markerWidth, block);
-          const alignmentOverride = isListItemFlag ? "left" : void 0;
+          const blockAlignment = block.attrs?.alignment;
+          const isJustified = blockAlignment === "justify" || blockAlignment === "both";
+          const alignmentOverride = isListItemFlag && !isJustified ? "left" : void 0;
           const startX = mapPmToX(block, line, charOffsetFrom, fragment.width, alignmentOverride);
           const endX = mapPmToX(block, line, charOffsetTo, fragment.width, alignmentOverride);
           const indent = extractParagraphIndent(block.attrs?.indent);
@@ -85366,7 +85618,9 @@ async function measureParagraphBlock(block, maxWidth) {
   const contentWidth = Math.max(1, maxWidth - indentLeft - indentRight);
   const bodyContentWidth = contentWidth;
   let initialAvailableWidth;
-  const textStartPx = wordLayout?.textStartPx;
+  const rawTextStartPx = wordLayout?.textStartPx;
+  const markerTextStartX = wordLayout?.marker?.textStartX;
+  const textStartPx = typeof markerTextStartX === "number" && Number.isFinite(markerTextStartX) ? markerTextStartX : typeof rawTextStartPx === "number" && Number.isFinite(rawTextStartPx) ? rawTextStartPx : void 0;
   if (typeof textStartPx === "number" && textStartPx > indentLeft) {
     initialAvailableWidth = Math.max(1, maxWidth - textStartPx - indentRight);
   } else {
@@ -85501,12 +85755,40 @@ async function measureParagraphBlock(block, maxWidth) {
       runsToProcess.push(run2);
     }
   }
+  const trimTrailingWrapSpaces = (lineToTrim) => {
+    const lastRun = runsToProcess[lineToTrim.toRun];
+    if (!lastRun || !("text" in lastRun) || typeof lastRun.text !== "string") return;
+    const sliceStart = lineToTrim.toRun === lineToTrim.fromRun ? lineToTrim.fromChar : 0;
+    const sliceEnd = lineToTrim.toChar;
+    if (sliceEnd <= sliceStart) return;
+    const sliceText = lastRun.text.slice(sliceStart, sliceEnd);
+    let trimCount = 0;
+    for (let i = sliceText.length - 1; i >= 0 && sliceText[i] === " "; i -= 1) {
+      trimCount += 1;
+    }
+    if (trimCount === 0) return;
+    if (lineToTrim.fromRun === lineToTrim.toRun && sliceText.trim().length === 0) {
+      return;
+    }
+    const keptText = sliceText.slice(0, Math.max(0, sliceText.length - trimCount));
+    const { font } = buildFontString(
+      lastRun
+    );
+    const fullWidth = measureRunWidth(sliceText, font, ctx2, lastRun);
+    const keptWidth = keptText.length > 0 ? measureRunWidth(keptText, font, ctx2, lastRun) : 0;
+    const delta = Math.max(0, fullWidth - keptWidth);
+    lineToTrim.width = roundValue(Math.max(0, lineToTrim.width - delta));
+    lineToTrim.spaceCount = Math.max(0, lineToTrim.spaceCount - trimCount);
+    if (lineToTrim.naturalWidth != null && typeof lineToTrim.naturalWidth === "number") {
+      lineToTrim.naturalWidth = roundValue(Math.max(0, lineToTrim.naturalWidth - delta));
+    }
+  };
   for (let runIndex = 0; runIndex < runsToProcess.length; runIndex++) {
     const run2 = runsToProcess[runIndex];
     if (run2.kind === "break") {
       if (currentLine) {
         const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-        const { spaceCount: _sc, ...lineBase } = currentLine;
+        const lineBase = currentLine;
         const completedLine = { ...lineBase, ...metrics };
         addBarTabsToLine(completedLine);
         lines.push(completedLine);
@@ -85551,7 +85833,7 @@ async function measureParagraphBlock(block, maxWidth) {
           toRun: runIndex,
           toChar: 0,
           width: 0,
-          maxWidth: getEffectiveWidth(initialAvailableWidth),
+          maxWidth: getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : bodyContentWidth),
           segments: [],
           ...metrics
         };
@@ -85586,7 +85868,7 @@ async function measureParagraphBlock(block, maxWidth) {
           width: 0,
           maxFontSize: 12,
           // Default font size for tabs
-          maxWidth: getEffectiveWidth(initialAvailableWidth),
+          maxWidth: getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : bodyContentWidth),
           segments: [],
           spaceCount: 0
         };
@@ -85636,7 +85918,7 @@ async function measureParagraphBlock(block, maxWidth) {
           width: imageWidth,
           maxFontSize: imageHeight,
           // Use image height for line height calculation
-          maxWidth: getEffectiveWidth(initialAvailableWidth),
+          maxWidth: getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : bodyContentWidth),
           spaceCount: 0,
           segments: [
             {
@@ -85652,8 +85934,9 @@ async function measureParagraphBlock(block, maxWidth) {
       }
       const appliedTabAlign = lastAppliedTabAlign;
       if (currentLine.width + imageWidth > currentLine.maxWidth && currentLine.width > 0) {
+        trimTrailingWrapSpaces(currentLine);
         const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-        const { spaceCount: _sc, ...lineBase } = currentLine;
+        const lineBase = currentLine;
         const completedLine = {
           ...lineBase,
           ...metrics
@@ -85726,7 +86009,7 @@ async function measureParagraphBlock(block, maxWidth) {
           // Field annotations are atomic units
           width: annotationWidth,
           maxFontSize: annotationHeight,
-          maxWidth: getEffectiveWidth(initialAvailableWidth),
+          maxWidth: getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : bodyContentWidth),
           spaceCount: 0,
           segments: [
             {
@@ -85741,8 +86024,9 @@ async function measureParagraphBlock(block, maxWidth) {
         continue;
       }
       if (currentLine.width + annotationWidth > currentLine.maxWidth && currentLine.width > 0) {
+        trimTrailingWrapSpaces(currentLine);
         const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-        const { spaceCount: _sc, ...lineBase } = currentLine;
+        const lineBase = currentLine;
         const completedLine = {
           ...lineBase,
           ...metrics
@@ -85815,15 +86099,16 @@ async function measureParagraphBlock(block, maxWidth) {
             width: spacesWidth,
             maxFontSize: run2.fontSize,
             maxFontInfo: getFontInfoFromRun(run2),
-            maxWidth: getEffectiveWidth(initialAvailableWidth),
+            maxWidth: getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : bodyContentWidth),
             segments: [{ runIndex, fromChar: spacesStartChar, toChar: spacesEndChar, width: spacesWidth }],
             spaceCount: spacesLength
           };
         } else {
           const boundarySpacing = currentLine.width > 0 ? run2.letterSpacing ?? 0 : 0;
           if (currentLine.width + boundarySpacing + spacesWidth > currentLine.maxWidth - WIDTH_FUDGE_PX2 && currentLine.width > 0) {
+            trimTrailingWrapSpaces(currentLine);
             const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-            const { spaceCount: _sc, ...lineBase } = currentLine;
+            const lineBase = currentLine;
             const completedLine = {
               ...lineBase,
               ...metrics
@@ -85859,6 +86144,13 @@ async function measureParagraphBlock(block, maxWidth) {
         continue;
       }
       const words = segment.split(" ");
+      let lastNonEmptyWordIndex = -1;
+      for (let i = words.length - 1; i >= 0; i -= 1) {
+        if (words[i] !== "") {
+          lastNonEmptyWordIndex = i;
+          break;
+        }
+      }
       let segmentStartX;
       if (currentLine && pendingTabAlignment) {
         segmentStartX = alignSegmentAtTab(segment, font, run2);
@@ -85881,15 +86173,16 @@ async function measureParagraphBlock(block, maxWidth) {
               width: singleSpaceWidth,
               maxFontSize: run2.fontSize,
               maxFontInfo: getFontInfoFromRun(run2),
-              maxWidth: getEffectiveWidth(initialAvailableWidth),
+              maxWidth: getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : bodyContentWidth),
               segments: [{ runIndex, fromChar: spaceStartChar, toChar: spaceEndChar, width: singleSpaceWidth }],
               spaceCount: 1
             };
           } else {
             const boundarySpacing2 = currentLine.width > 0 ? run2.letterSpacing ?? 0 : 0;
             if (currentLine.width + boundarySpacing2 + singleSpaceWidth > currentLine.maxWidth - WIDTH_FUDGE_PX2 && currentLine.width > 0) {
+              trimTrailingWrapSpaces(currentLine);
               const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-              const { spaceCount: _sc, ...lineBase } = currentLine;
+              const lineBase = currentLine;
               const completedLine = { ...lineBase, ...metrics };
               addBarTabsToLine(completedLine);
               lines.push(completedLine);
@@ -85921,19 +86214,19 @@ async function measureParagraphBlock(block, maxWidth) {
           charPosInRun = spaceEndChar;
           continue;
         }
-        const isLastWordInSegment = wordIndex === words.length - 1;
-        const isLastWord = isLastWordInSegment && isLastSegment;
         const wordOnlyWidth = measureRunWidth(word, font, ctx2, run2);
-        const spaceWidth = isLastWord ? 0 : measureRunWidth(" ", font, ctx2, run2);
-        const wordCommitWidth = isLastWord ? wordOnlyWidth : wordOnlyWidth + spaceWidth;
+        const shouldIncludeDelimiterSpace = wordIndex < lastNonEmptyWordIndex;
+        const spaceWidth = shouldIncludeDelimiterSpace ? measureRunWidth(" ", font, ctx2, run2) : 0;
+        const wordCommitWidth = wordOnlyWidth + spaceWidth;
         const wordStartChar = charPosInRun;
         const wordEndNoSpace = charPosInRun + word.length;
-        const wordEndWithSpace = charPosInRun + (isLastWord ? word.length : word.length + 1);
+        const wordEndWithSpace = wordEndNoSpace + (shouldIncludeDelimiterSpace ? 1 : 0);
         const effectiveMaxWidth = currentLine ? currentLine.maxWidth : getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : contentWidth);
         if (wordOnlyWidth > effectiveMaxWidth && word.length > 1) {
           if (currentLine && currentLine.width > 0 && currentLine.segments && currentLine.segments.length > 0) {
+            trimTrailingWrapSpaces(currentLine);
             const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-            const { spaceCount: _sc, ...lineBase } = currentLine;
+            const lineBase = currentLine;
             const completedLine = { ...lineBase, ...metrics };
             addBarTabsToLine(completedLine);
             lines.push(completedLine);
@@ -85967,7 +86260,7 @@ async function measureParagraphBlock(block, maxWidth) {
               });
               if (isLastChunk) {
                 const ls = run2.letterSpacing ?? 0;
-                if (!isLastWord && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX2) {
+                if (shouldIncludeDelimiterSpace && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX2) {
                   currentLine.toChar = wordEndWithSpace;
                   currentLine.width = roundValue(currentLine.width + spaceWidth + ls);
                   charPosInRun = wordEndWithSpace;
@@ -85976,8 +86269,9 @@ async function measureParagraphBlock(block, maxWidth) {
                   charPosInRun = wordEndWithSpace;
                 }
               } else {
+                trimTrailingWrapSpaces(currentLine);
                 const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-                const { spaceCount: _sc, ...lineBase } = currentLine;
+                const lineBase = currentLine;
                 const completedLine = { ...lineBase, ...metrics };
                 addBarTabsToLine(completedLine);
                 lines.push(completedLine);
@@ -85999,7 +86293,7 @@ async function measureParagraphBlock(block, maxWidth) {
                 spaceCount: 0
               };
               const ls = run2.letterSpacing ?? 0;
-              if (!isLastWord && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX2) {
+              if (shouldIncludeDelimiterSpace && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX2) {
                 currentLine.toChar = wordEndWithSpace;
                 currentLine.width = roundValue(currentLine.width + spaceWidth + ls);
                 charPosInRun = wordEndWithSpace;
@@ -86036,12 +86330,12 @@ async function measureParagraphBlock(block, maxWidth) {
             width: wordOnlyWidth,
             maxFontSize: run2.fontSize,
             maxFontInfo: getFontInfoFromRun(run2),
-            maxWidth: getEffectiveWidth(initialAvailableWidth),
+            maxWidth: getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : bodyContentWidth),
             segments: [{ runIndex, fromChar: wordStartChar, toChar: wordEndNoSpace, width: wordOnlyWidth }],
             spaceCount: 0
           };
           const ls = run2.letterSpacing ?? 0;
-          if (!isLastWord && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX2) {
+          if (shouldIncludeDelimiterSpace && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX2) {
             currentLine.toChar = wordEndWithSpace;
             currentLine.width = roundValue(currentLine.width + spaceWidth + ls);
             charPosInRun = wordEndWithSpace;
@@ -86055,15 +86349,16 @@ async function measureParagraphBlock(block, maxWidth) {
         const boundarySpacing = currentLine.width > 0 ? run2.letterSpacing ?? 0 : 0;
         const justifyAlignment = block.attrs?.alignment === "justify";
         const totalWidthWithWord = currentLine.width + boundarySpacing + wordCommitWidth + // Safe cast: only TextRuns produce word segments from split(), other run types are handled earlier
-        (isLastWord ? 0 : run2.letterSpacing ?? 0);
+        (shouldIncludeDelimiterSpace ? run2.letterSpacing ?? 0 : 0);
         const availableWidth = currentLine.maxWidth - WIDTH_FUDGE_PX2;
         let shouldBreak = currentLine.width + boundarySpacing + wordOnlyWidth > availableWidth && currentLine.width > 0 && !isTocEntry;
         let compressedWidth = null;
         if (shouldBreak && justifyAlignment) {
-          const isParagraphLastWord = isLastWord && runIndex === runsToProcess.length - 1;
+          const isLastNonEmptyWordInSegment = wordIndex === lastNonEmptyWordIndex;
+          const isParagraphLastWord = isLastSegment && isLastNonEmptyWordInSegment && runIndex === runsToProcess.length - 1;
           if (!isParagraphLastWord) {
             const existingSpaces = currentLine.spaceCount ?? 0;
-            const candidateSpaces = existingSpaces + (isLastWord ? 0 : 1);
+            const candidateSpaces = existingSpaces + (shouldIncludeDelimiterSpace ? 1 : 0);
             if (candidateSpaces > 0) {
               const overflow = totalWidthWithWord - availableWidth;
               if (overflow > 0) {
@@ -86079,8 +86374,9 @@ async function measureParagraphBlock(block, maxWidth) {
           }
         }
         if (shouldBreak) {
+          trimTrailingWrapSpaces(currentLine);
           const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-          const { spaceCount: _sc, ...lineBase } = currentLine;
+          const lineBase = currentLine;
           const completedLine = {
             ...lineBase,
             ...metrics
@@ -86101,7 +86397,7 @@ async function measureParagraphBlock(block, maxWidth) {
             segments: [{ runIndex, fromChar: wordStartChar, toChar: wordEndNoSpace, width: wordOnlyWidth }],
             spaceCount: 0
           };
-          if (!isLastWord && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX2) {
+          if (shouldIncludeDelimiterSpace && currentLine.width + spaceWidth <= currentLine.maxWidth - WIDTH_FUDGE_PX2) {
             currentLine.toChar = wordEndWithSpace;
             currentLine.width = roundValue(currentLine.width + spaceWidth + (run2.letterSpacing ?? 0));
             charPosInRun = wordEndWithSpace;
@@ -86111,7 +86407,7 @@ async function measureParagraphBlock(block, maxWidth) {
           }
         } else {
           currentLine.toRun = runIndex;
-          if (!isLastWord && currentLine.width + boundarySpacing + wordOnlyWidth + spaceWidth > currentLine.maxWidth - WIDTH_FUDGE_PX2) {
+          if (shouldIncludeDelimiterSpace && currentLine.width + boundarySpacing + wordOnlyWidth + spaceWidth > currentLine.maxWidth - WIDTH_FUDGE_PX2) {
             currentLine.toChar = wordEndNoSpace;
             currentLine.width = roundValue(currentLine.width + boundarySpacing + wordOnlyWidth);
             currentLine.maxFontInfo = updateMaxFontInfo(currentLine.maxFontSize, currentLine.maxFontInfo, run2);
@@ -86125,8 +86421,9 @@ async function measureParagraphBlock(block, maxWidth) {
               wordOnlyWidth,
               useExplicitXHere ? segmentStartX : void 0
             );
+            trimTrailingWrapSpaces(currentLine);
             const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-            const { spaceCount: _sc, ...lineBase } = currentLine;
+            const lineBase = currentLine;
             const completedLine = { ...lineBase, ...metrics };
             addBarTabsToLine(completedLine);
             lines.push(completedLine);
@@ -86136,20 +86433,23 @@ async function measureParagraphBlock(block, maxWidth) {
             charPosInRun = wordEndNoSpace + 1;
             continue;
           }
-          const newToChar = isLastWord ? wordEndNoSpace : wordEndWithSpace;
+          const newToChar = shouldIncludeDelimiterSpace ? wordEndWithSpace : wordEndNoSpace;
           currentLine.toChar = newToChar;
           const useExplicitX = wordIndex === 0 && segmentStartX !== void 0;
           const explicitX = useExplicitX ? segmentStartX : void 0;
-          const targetWidth = compressedWidth != null ? compressedWidth : currentLine.width + boundarySpacing + wordCommitWidth + (isLastWord ? 0 : run2.letterSpacing ?? 0);
+          const targetWidth = compressedWidth != null ? compressedWidth : currentLine.width + boundarySpacing + wordCommitWidth + (shouldIncludeDelimiterSpace ? run2.letterSpacing ?? 0 : 0);
+          if (compressedWidth != null) {
+            currentLine.naturalWidth = roundValue(totalWidthWithWord);
+          }
           currentLine.width = roundValue(targetWidth);
           currentLine.maxFontInfo = updateMaxFontInfo(currentLine.maxFontSize, currentLine.maxFontInfo, run2);
           currentLine.maxFontSize = Math.max(currentLine.maxFontSize, run2.fontSize);
           appendSegment(currentLine.segments, runIndex, wordStartChar, newToChar, wordCommitWidth, explicitX);
-          if (!isLastWord) {
+          if (shouldIncludeDelimiterSpace) {
             currentLine.spaceCount += 1;
           }
         }
-        charPosInRun = isLastWord ? wordEndNoSpace : wordEndWithSpace;
+        charPosInRun = shouldIncludeDelimiterSpace ? wordEndWithSpace : wordEndNoSpace;
       }
       if (lastAppliedTabAlign && currentLine) {
         const appliedTab = lastAppliedTabAlign;
@@ -86169,7 +86469,7 @@ async function measureParagraphBlock(block, maxWidth) {
             width: 0,
             maxFontSize: run2.fontSize,
             maxFontInfo: getFontInfoFromRun(run2),
-            maxWidth: getEffectiveWidth(initialAvailableWidth),
+            maxWidth: getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : bodyContentWidth),
             segments: [],
             spaceCount: 0
           };
@@ -86217,7 +86517,7 @@ async function measureParagraphBlock(block, maxWidth) {
   }
   if (currentLine) {
     const metrics = calculateTypographyMetrics(currentLine.maxFontSize, spacing, currentLine.maxFontInfo);
-    const { spaceCount: _sc, ...lineBase } = currentLine;
+    const lineBase = currentLine;
     const finalLine = {
       ...lineBase,
       ...metrics