diff --git a/packages/layout-engine/layout-engine/src/column-balancing.test.ts b/packages/layout-engine/layout-engine/src/column-balancing.test.ts
index 7aa7431135..6e83a179b6 100644
--- a/packages/layout-engine/layout-engine/src/column-balancing.test.ts
+++ b/packages/layout-engine/layout-engine/src/column-balancing.test.ts
@@ -335,13 +335,9 @@ function createMeasure(kind: string, lineHeights: number[]): { kind: string; lin
 
 describe('balancePageColumns', () => {
   describe('basic balancing', () => {
-    it('should distribute fragments across 2 columns based on target height', () => {
-      // 4 fragments, each 20px tall = 80px total, target = 40px per column
-      // With >= condition: switch when adding would reach/exceed 40px
-      // Block 1 (20px): column 0, height=20
-      // Block 2 (20px): 20+20=40 >= 40, switch! column 1, height=20
-      // Block 3, 4: stay in column 1
-      // Result: 1 in column 0, 3 in column 1
+    it('balances 4 equal blocks into 2+2 across 2 columns', () => {
+      // 4 fragments × 20px each in a 2-col section. Word minimizes section height by
+      // placing 2 per column (40px per col) rather than 1+3 (max 60px).
       const fragments = [
         createFragment('block-1', 96, 96, 624),
         createFragment('block-2', 96, 116, 624),
@@ -357,10 +353,9 @@ describe('balancePageColumns', () => {
 
       balancePageColumns(fragments, { count: 2, gap: 48, width: 288 }, { left: 96 }, 96, 40, measureMap);
 
-      // Block 1 stays in column 0
+      // First half in col 0, second half in col 1 — minimum section height.
       expect(fragments[0].x).toBe(96);
-      // Blocks 2, 3, 4 move to column 1
-      expect(fragments[1].x).toBe(432);
+      expect(fragments[1].x).toBe(96);
       expect(fragments[2].x).toBe(432);
       expect(fragments[3].x).toBe(432);
     });
@@ -558,3 +553,186 @@ describe('balancePageColumns', () => {
     });
   });
 });
+
+// ============================================================================
+// balanceSectionOnPage Tests (Section-scoped balancing)
+// ============================================================================
+
+import { balanceSectionOnPage } from './column-balancing.js';
+
+describe('balanceSectionOnPage', () => {
+  type TestFragment = { blockId: string; x: number; y: number; width: number; kind: string };
+
+  /** Build a fragment + section mapping for section-scoped tests. */
+  function buildSectionFixture(
+    sectionIndex: number,
+    count: number,
+    height = 20,
+    startY = 96,
+  ): {
+    fragments: TestFragment[];
+    measureMap: Map<string, { kind: string; lines: Array<{ lineHeight: number }> }>;
+    blockSectionMap: Map<string, number>;
+  } {
+    const fragments: TestFragment[] = [];
+    const measureMap = new Map<string, { kind: string; lines: Array<{ lineHeight: number }> }>();
+    const blockSectionMap = new Map<string, number>();
+    for (let i = 0; i < count; i++) {
+      const id = `s${sectionIndex}-b${i}`;
+      fragments.push({ blockId: id, x: 96, y: startY + i * height, width: 624, kind: 'para' });
+      measureMap.set(id, createMeasure('paragraph', [height]));
+      blockSectionMap.set(id, sectionIndex);
+    }
+    return { fragments, measureMap, blockSectionMap };
+  }
+
+  it('balances the target section and returns the tallest balanced column bottom', () => {
+    // 6 equal paragraphs in a 2-col section → 3+3 balanced, tallest col ends at top + 3×20 = top + 60.
+    const top = 96;
+    const { fragments, measureMap, blockSectionMap } = buildSectionFixture(2, 6, 20, top);
+
+    const result = balanceSectionOnPage({
+      fragments,
+      sectionIndex: 2,
+      sectionColumns: { count: 2, gap: 48, width: 288 },
+      sectionHasExplicitColumnBreak: false,
+      blockSectionMap,
+      margins: { left: 96 },
+      topMargin: top,
+      columnWidth: 288,
+      availableHeight: 60,
+      measureMap,
+    });
+
+    // Returned maxY is the bottom of the tallest balanced column.
+    expect(result).not.toBeNull();
+    expect(result!.maxY).toBe(top + 60);
+
+    // Observable outcome: fragments split evenly across two columns.
+    const col0 = fragments.filter((f) => f.x === 96).length;
+    const col1 = fragments.filter((f) => f.x === 96 + 288 + 48).length;
+    expect(col0).toBe(3);
+    expect(col1).toBe(3);
+  });
+
+  it('returns null and leaves fragments untouched when section has <= 1 column', () => {
+    const { fragments, measureMap, blockSectionMap } = buildSectionFixture(2, 3);
+    const snapshot = fragments.map((f) => ({ x: f.x, y: f.y }));
+
+    const result = balanceSectionOnPage({
+      fragments,
+      sectionIndex: 2,
+      sectionColumns: { count: 1, gap: 0, width: 624 },
+      sectionHasExplicitColumnBreak: false,
+      blockSectionMap,
+      margins: { left: 96 },
+      topMargin: 96,
+      columnWidth: 624,
+      availableHeight: 720,
+      measureMap,
+    });
+
+    expect(result).toBeNull();
+    fragments.forEach((f, i) => {
+      expect(f.x).toBe(snapshot[i].x);
+      expect(f.y).toBe(snapshot[i].y);
+    });
+  });
+
+  it('returns null when section contains an explicit column break', () => {
+    // Author-placed column breaks override balancing — preserve their intent.
+    const { fragments, measureMap, blockSectionMap } = buildSectionFixture(2, 6);
+    const snapshot = fragments.map((f) => f.x);
+
+    const result = balanceSectionOnPage({
+      fragments,
+      sectionIndex: 2,
+      sectionColumns: { count: 2, gap: 48, width: 288 },
+      sectionHasExplicitColumnBreak: true,
+      blockSectionMap,
+      margins: { left: 96 },
+      topMargin: 96,
+      columnWidth: 288,
+      availableHeight: 720,
+      measureMap,
+    });
+
+    expect(result).toBeNull();
+    fragments.forEach((f, i) => expect(f.x).toBe(snapshot[i]));
+  });
+
+  it('returns null when section has unequal explicit column widths', () => {
+    const { fragments, measureMap, blockSectionMap } = buildSectionFixture(2, 4);
+
+    const result = balanceSectionOnPage({
+      fragments,
+      sectionIndex: 2,
+      sectionColumns: { count: 2, gap: 48, width: 288, equalWidth: false, widths: [200, 376] },
+      sectionHasExplicitColumnBreak: false,
+      blockSectionMap,
+      margins: { left: 96 },
+      topMargin: 96,
+      columnWidth: 288,
+      availableHeight: 720,
+      measureMap,
+    });
+
+    expect(result).toBeNull();
+  });
+
+  it('only moves fragments of the target section when the page has mixed sections', () => {
+    // Page has 3 fragments in section 1 (already positioned in col 0) and 6 in section 2.
+    // Balancing section 2 must not touch section 1 fragments.
+    const sec1 = buildSectionFixture(1, 3, 20, 96);
+    const sec2 = buildSectionFixture(2, 6, 20, 160);
+    const fragments = [...sec1.fragments, ...sec2.fragments];
+    const measureMap = new Map([...sec1.measureMap, ...sec2.measureMap]);
+    const blockSectionMap = new Map([...sec1.blockSectionMap, ...sec2.blockSectionMap]);
+    const sec1Snapshot = sec1.fragments.map((f) => ({ id: f.blockId, x: f.x, y: f.y }));
+
+    const result = balanceSectionOnPage({
+      fragments,
+      sectionIndex: 2,
+      sectionColumns: { count: 2, gap: 48, width: 288 },
+      sectionHasExplicitColumnBreak: false,
+      blockSectionMap,
+      margins: { left: 96 },
+      topMargin: 160,
+      columnWidth: 288,
+      availableHeight: 60,
+      measureMap,
+    });
+
+    expect(result).not.toBeNull();
+
+    // Section 1 fragments unchanged.
+    for (const s of sec1Snapshot) {
+      const f = fragments.find((x) => x.blockId === s.id)!;
+      expect(f.x).toBe(s.x);
+      expect(f.y).toBe(s.y);
+    }
+
+    // Section 2 fragments now split across two columns.
+    const sec2Xs = new Set(sec2.fragments.map((f) => f.x));
+    expect(sec2Xs.size).toBe(2);
+  });
+
+  it('returns null when no fragments on the page belong to the target section', () => {
+    const { fragments, measureMap, blockSectionMap } = buildSectionFixture(1, 3);
+
+    const result = balanceSectionOnPage({
+      fragments,
+      sectionIndex: 99, // different section
+      sectionColumns: { count: 2, gap: 48, width: 288 },
+      sectionHasExplicitColumnBreak: false,
+      blockSectionMap,
+      margins: { left: 96 },
+      topMargin: 96,
+      columnWidth: 288,
+      availableHeight: 720,
+      measureMap,
+    });
+
+    expect(result).toBeNull();
+  });
+});
diff --git a/packages/layout-engine/layout-engine/src/column-balancing.ts b/packages/layout-engine/layout-engine/src/column-balancing.ts
index cb14ae8a2c..94466f9b57 100644
--- a/packages/layout-engine/layout-engine/src/column-balancing.ts
+++ b/packages/layout-engine/layout-engine/src/column-balancing.ts
@@ -156,64 +156,58 @@ export function calculateBalancedColumnHeight(
     };
   }
 
-  // Calculate total content height
+  // Calculate total content height and block-height extremes
   const totalHeight = ctx.contentBlocks.reduce((sum, b) => sum + b.measuredHeight, 0);
+  const maxBlockHeight = ctx.contentBlocks.reduce((m, b) => Math.max(m, b.measuredHeight), 0);
 
   // Early exit: content is very small, no need to balance
   if (totalHeight < config.minColumnHeight * ctx.columnCount) {
     return createSingleColumnResult(ctx);
   }
 
-  // Initial target: evenly divide content
-  let targetHeight = Math.ceil(totalHeight / ctx.columnCount);
-
-  // Ensure target meets minimum column height
-  targetHeight = Math.max(targetHeight, config.minColumnHeight);
-
-  // Don't exceed available height
-  targetHeight = Math.min(targetHeight, ctx.availableHeight);
+  // Binary-search for the minimum column height H such that a greedy
+  // left-to-right fill places every block with every column ≤ H. This matches
+  // Word's observed behavior: left columns are filled as tightly as possible
+  // against the minimum viable height, leaving the last column shorter when
+  // content doesn't divide evenly (e.g. 7 blocks across 3 columns → 3+3+1,
+  // not 2+2+3). Both splits have the same max column height, but Word prefers
+  // left-heavy packing for visual rhythm.
+  let lo = Math.max(maxBlockHeight, config.minColumnHeight);
+  let hi = Math.min(totalHeight, ctx.availableHeight);
+  if (lo > hi) lo = hi;
 
   let bestResult: SimulationResult | null = null;
-  let bestScore = Infinity;
-
-  for (let i = 0; i < config.maxIterations; i++) {
-    const simulation = simulateBalancedLayout(ctx, targetHeight, config);
-
-    // Calculate balance score (lower is better)
-    const score = calculateBalanceScore(simulation.columnHeights, config.tolerance);
-
-    if (score < bestScore) {
-      bestScore = score;
-      bestResult = simulation;
+  let bestH = hi;
+  let iterations = 0;
+
+  while (lo <= hi) {
+    iterations++;
+    const mid = Math.floor((lo + hi) / 2);
+    const sim = simulateBalancedLayout(ctx, mid, config);
+    const maxCol = Math.max(...sim.columnHeights);
+    const placed = sim.assignments.size === ctx.contentBlocks.length;
+    if (placed && maxCol <= mid) {
+      bestResult = sim;
+      bestH = mid;
+      hi = mid - 1;
+    } else {
+      lo = mid + 1;
     }
-
-    // Check if we've achieved acceptable balance
-    if (isBalanced(simulation.columnHeights, config.tolerance)) {
-      return {
-        targetColumnHeight: targetHeight,
-        columnAssignments: simulation.assignments,
-        success: true,
-        iterations: i + 1,
-        blockBreakPoints: simulation.breakPoints.size > 0 ? simulation.breakPoints : undefined,
-      };
-    }
-
-    // Adjust target based on simulation results
-    targetHeight = adjustTargetHeight(simulation, targetHeight, ctx, config);
+    if (iterations >= config.maxIterations) break;
   }
 
-  // Use best result found
   if (bestResult) {
     return {
-      targetColumnHeight: targetHeight,
+      targetColumnHeight: bestH,
       columnAssignments: bestResult.assignments,
-      success: false, // Didn't converge within iterations
-      iterations: config.maxIterations,
+      success: true,
+      iterations,
       blockBreakPoints: bestResult.breakPoints.size > 0 ? bestResult.breakPoints : undefined,
     };
   }
 
-  // Fallback: simple sequential layout
+  // Fallback: simple sequential layout if binary search never found a valid H
+  // (e.g. availableHeight too small to fit content).
   return createSequentialResult(ctx);
 }
 
@@ -351,73 +345,6 @@ function calculateParagraphBreakPoint(
   return { breakAfterLine: lines.length - 1, canBreak: true };
 }
 
-/**
- * Check if column heights are balanced within tolerance.
- */
-function isBalanced(columnHeights: number[], tolerance: number): boolean {
-  if (columnHeights.length <= 1) return true;
-
-  const nonEmptyHeights = columnHeights.filter((h) => h > 0);
-  if (nonEmptyHeights.length <= 1) return true;
-
-  const maxHeight = Math.max(...nonEmptyHeights);
-  const minHeight = Math.min(...nonEmptyHeights);
-
-  return maxHeight - minHeight <= tolerance;
-}
-
-/**
- * Calculate a balance score (lower is better).
- * Used to track best result across iterations.
- */
-function calculateBalanceScore(columnHeights: number[], tolerance: number): number {
-  if (columnHeights.length <= 1) return 0;
-
-  const nonEmptyHeights = columnHeights.filter((h) => h > 0);
-  if (nonEmptyHeights.length <= 1) return 0;
-
-  // Score based on variance from mean
-  const mean = nonEmptyHeights.reduce((a, b) => a + b, 0) / nonEmptyHeights.length;
-  const variance = nonEmptyHeights.reduce((sum, h) => sum + Math.pow(h - mean, 2), 0);
-
-  // Penalize empty columns
-  const emptyPenalty = (columnHeights.length - nonEmptyHeights.length) * tolerance * 10;
-
-  return variance + emptyPenalty;
-}
-
-/**
- * Adjust target height based on simulation results.
- */
-function adjustTargetHeight(
-  simulation: SimulationResult,
-  currentTarget: number,
-  ctx: BalancingContext,
-  config: ColumnBalancingConfig,
-): number {
-  const heights = simulation.columnHeights;
-  const maxHeight = Math.max(...heights);
-  const minHeight = Math.min(...heights.filter((h) => h > 0));
-
-  // If last column is significantly taller, increase target
-  if (heights[heights.length - 1] > maxHeight * 0.9 && heights[heights.length - 1] > currentTarget) {
-    return Math.min(currentTarget + (maxHeight - currentTarget) / 2, ctx.availableHeight);
-  }
-
-  // If first columns are too tall and last is too short, decrease target
-  if (heights[0] > currentTarget && heights[heights.length - 1] < currentTarget * 0.5) {
-    return Math.max(currentTarget - (currentTarget - minHeight) / 2, config.minColumnHeight);
-  }
-
-  // Binary search style adjustment
-  const diff = maxHeight - minHeight;
-  if (maxHeight > currentTarget) {
-    return Math.min(currentTarget + diff / 4, ctx.availableHeight);
-  } else {
-    return Math.max(currentTarget - diff / 4, config.minColumnHeight);
-  }
-}
-
 // ============================================================================
 // Helper Functions
 // ============================================================================
@@ -562,7 +489,7 @@ export function shouldSkipBalancing(
  * Fragment with required properties for column balancing.
  * Represents a positioned content block that can be redistributed across columns.
  */
-interface BalancingFragment {
+export interface BalancingFragment {
   /** Horizontal position in pixels from left edge of page */
   x: number;
   /** Vertical position in pixels from top edge of page */
@@ -585,7 +512,7 @@ interface BalancingFragment {
  * Measure data used to calculate fragment heights.
  * Contains layout measurements from the measuring phase.
  */
-interface MeasureData {
+export interface MeasureData {
   /** Type of measure: 'paragraph', 'image', etc. */
   kind: string;
   /** Line measurements for paragraph content */
@@ -746,46 +673,180 @@ export function balancePageColumns(
     return;
   }
 
-  // Calculate target height per column for balanced distribution
-  const targetHeight = totalHeight / columns.count;
-
-  // Skip balancing if target height is below minimum threshold
-  if (targetHeight < DEFAULT_BALANCING_CONFIG.minColumnHeight) {
+  // Skip balancing if balanced height per column would be below minimum threshold
+  if (totalHeight / columns.count < DEFAULT_BALANCING_CONFIG.minColumnHeight) {
     return;
   }
 
-  // Distribute rows across columns using greedy algorithm.
-  // Each row is assigned to the current column until adding it would
-  // reach or exceed the target height, then we advance to the next column.
-  let currentColumn = 0;
-  let currentColumnHeight = 0;
-  let currentY = topMargin;
-
-  for (const [, rowFragments] of sortedRows) {
-    const rowHeight = Math.max(...rowFragments.map((f) => f.height));
-
-    // Advance to next column when current column reaches target height.
-    // Uses >= to match Word's behavior: switch when target is reached, not just exceeded.
-    // This ensures balanced distribution where the first column doesn't exceed its share.
-    if (
-      currentColumnHeight > 0 &&
-      currentColumnHeight + rowHeight >= targetHeight &&
-      currentColumn < columns.count - 1
-    ) {
-      currentColumn++;
-      currentColumnHeight = 0;
-      currentY = topMargin;
-    }
-
-    // Position all fragments in this row within the current column
-    const colX = columnX(currentColumn);
+  // Delegate to the binary-search algorithm to find the minimum section height
+  // where all content fits across N columns. This matches Word's behavior: Word
+  // finds the smallest max-column-height that keeps content within constraints,
+  // rather than greedily splitting at total/N (which can leave col1 barely
+  // populated when one paragraph is much taller than the rest).
+  const result = calculateBalancedColumnHeight(
+    {
+      columnCount: columns.count,
+      columnWidth: columns.width,
+      columnGap: columns.gap,
+      availableHeight,
+      contentBlocks,
+    },
+    DEFAULT_BALANCING_CONFIG,
+  );
+
+  // Apply the assignments to fragments: pack each column top-to-bottom from topMargin,
+  // indexing back into sortedRows via the same ordering used to build contentBlocks.
+  const colCursors = new Array<number>(columns.count).fill(topMargin);
+  for (let i = 0; i < sortedRows.length; i++) {
+    const [, rowFragments] = sortedRows[i];
+    const block = contentBlocks[i];
+    const col = result.columnAssignments.get(block.blockId) ?? 0;
+    const colX = columnX(col);
+    const rowHeight = block.measuredHeight;
     for (const info of rowFragments) {
       info.fragment.x = colX;
-      info.fragment.y = currentY;
+      info.fragment.y = colCursors[col];
       info.fragment.width = columns.width;
     }
+    colCursors[col] += rowHeight;
+  }
+}
+
+// ============================================================================
+// Section-scoped balancing (wraps balancePageColumns with per-section guards)
+// ============================================================================
+
+/**
+ * Column layout properties relevant to balancing decisions.
+ * Mirrors the subset of ColumnLayout that this module reads.
+ */
+export interface SectionColumnLayout {
+  count: number;
+  gap: number;
+  width?: number;
+  widths?: number[];
+  equalWidth?: boolean;
+}
+
+export interface BalanceSectionOnPageArgs {
+  /** All fragments on the target page. Only those belonging to sectionIndex are balanced (mutated in place). */
+  fragments: BalancingFragment[];
+  /** Section whose content ends on this page. */
+  sectionIndex: number;
+  /** Column layout of the ending section. */
+  sectionColumns: SectionColumnLayout;
+  /** True if the section contains an explicit <w:br w:type="column"/> — skip balancing to preserve author intent. */
+  sectionHasExplicitColumnBreak: boolean;
+  /** blockId -> sectionIndex map (built once per layout, shared across calls). */
+  blockSectionMap: Map<string, number>;
+  /** Left page margin, used to compute column X positions. */
+  margins: { left: number };
+  /** Y position where the section's region begins on this page. */
+  topMargin: number;
+  /** Column width — passed to balancePageColumns so it can resize fragments. */
+  columnWidth: number;
+  /** Available height from topMargin to content bottom. */
+  availableHeight: number;
+  /** Measurement data for fragments (built from measures array). */
+  measureMap: Map<string, MeasureData>;
+}
+
+/**
+ * Balance the fragments of one section on one page.
+ *
+ * Returns the tallest balanced column's bottom Y, or null if balancing was skipped.
+ * Callers can use the returned Y to update paginator cursors so subsequent content
+ * starts just below the balanced section rather than below an unbalanced maxCursorY.
+ *
+ * Guards (skip balancing when):
+ *   - Section has <= 1 column (nothing to balance)
+ *   - Section contains an explicit column break (author intent wins)
+ *   - Section uses unequal column widths (Word doesn't rebalance these)
+ *   - No fragments on this page belong to the section
+ */
+export function balanceSectionOnPage(args: BalanceSectionOnPageArgs): { maxY: number } | null {
+  const { sectionColumns, sectionHasExplicitColumnBreak, sectionIndex, blockSectionMap, fragments } = args;
+
+  if (sectionColumns.count <= 1) return null;
+  if (sectionHasExplicitColumnBreak) return null;
+  if (sectionColumns.equalWidth === false && Array.isArray(sectionColumns.widths) && sectionColumns.widths.length > 0) {
+    return null;
+  }
+
+  // Filter to fragments of the target section on this page.
+  const sectionFragments = fragments.filter((f) => blockSectionMap.get(f.blockId) === sectionIndex);
+  if (sectionFragments.length === 0) return null;
+
+  const columnCount = sectionColumns.count;
+  const columnGap = sectionColumns.gap;
+  const columnWidth = sectionColumns.width ?? 0;
+  if (columnWidth <= 0) return null;
+
+  // Use the minimum Y of the section's fragments as the balancing origin — the
+  // section may start mid-page (e.g. section 0 is single-column and section 1
+  // continues below it). Using topMargin unconditionally would stack balanced
+  // columns on top of earlier single-column content on the same page.
+  let sectionTopY = Number.POSITIVE_INFINITY;
+  for (const f of sectionFragments) {
+    if (f.y < sectionTopY) sectionTopY = f.y;
+  }
+  if (!Number.isFinite(sectionTopY)) sectionTopY = args.topMargin;
+
+  // Remaining height from the section's actual top to the page content bottom.
+  const remainingHeight = args.availableHeight - (sectionTopY - args.topMargin);
+  if (remainingHeight <= 0) return null;
+
+  // Order fragments in document order: by current column (x → left-to-right),
+  // then by y within each column. During unbalanced layout the paginator fills
+  // column 0 top-to-bottom, then column 1, etc. — so (x, y) preserves the
+  // original sequence.
+  const ordered = [...sectionFragments].sort((a, b) => {
+    if (a.x !== b.x) return a.x - b.x;
+    return a.y - b.y;
+  });
+
+  // Treat each fragment as its own block for binary-search balancing. Grouping
+  // by y (as balancePageColumns does) would collapse fragments from different
+  // source columns that happen to share a y coordinate into a single row and
+  // re-stack them at one position — producing overlap.
+  const contentBlocks: BalancingBlock[] = ordered.map((f, i) => ({
+    blockId: `${f.blockId}#${i}`,
+    measuredHeight: getFragmentHeight(f, args.measureMap),
+    canBreak: false,
+    keepWithNext: false,
+    keepTogether: true,
+  }));
+
+  if (
+    shouldSkipBalancing({
+      columnCount,
+      columnWidth,
+      columnGap,
+      availableHeight: remainingHeight,
+      contentBlocks,
+    })
+  ) {
+    return null;
+  }
 
-    currentColumnHeight += rowHeight;
-    currentY += rowHeight;
+  const result = calculateBalancedColumnHeight(
+    { columnCount, columnWidth, columnGap, availableHeight: remainingHeight, contentBlocks },
+    DEFAULT_BALANCING_CONFIG,
+  );
+
+  const columnX = (columnIndex: number): number => args.margins.left + columnIndex * (columnWidth + columnGap);
+
+  const colCursors = new Array<number>(columnCount).fill(sectionTopY);
+  let maxY = sectionTopY;
+  for (let i = 0; i < ordered.length; i++) {
+    const f = ordered[i];
+    const block = contentBlocks[i];
+    const col = result.columnAssignments.get(block.blockId) ?? 0;
+    f.x = columnX(col);
+    f.y = colCursors[col];
+    f.width = columnWidth;
+    colCursors[col] += block.measuredHeight;
+    if (colCursors[col] > maxY) maxY = colCursors[col];
   }
+  return { maxY };
 }
diff --git a/packages/layout-engine/layout-engine/src/index.test.ts b/packages/layout-engine/layout-engine/src/index.test.ts
index b73c27ee11..baffe844b4 100644
--- a/packages/layout-engine/layout-engine/src/index.test.ts
+++ b/packages/layout-engine/layout-engine/src/index.test.ts
@@ -2843,6 +2843,205 @@ describe('layoutDocument', () => {
       expect(singleColFragment?.width).not.toBeCloseTo(twoColFragment!.width, 0);
     });
   });
+
+  describe('column balancing at section boundaries (SD-2452)', () => {
+    /**
+     * End-to-end tests for the column-balancing feature.
+     *
+     * These tests drive layoutDocument with synthetic blocks/measures and assert on
+     * the OBSERVABLE fragment positions produced by the full pipeline — not on internal
+     * helper calls. When Word's algorithm changes or when we swap out the balancing
+     * implementation, these tests continue to assert what users see.
+     */
+
+    const PAGE: LayoutOptions = {
+      pageSize: { w: 612, h: 792 },
+      margins: { top: 72, right: 72, bottom: 72, left: 72 },
+    };
+    const LEFT_MARGIN = 72;
+    const CONTENT_WIDTH = 612 - 72 - 72; // 468
+    const COLUMN_GAP = 48;
+    const TWO_COL_WIDTH = (CONTENT_WIDTH - COLUMN_GAP) / 2; // 210
+    const TWO_COL_RIGHT_X = LEFT_MARGIN + TWO_COL_WIDTH + COLUMN_GAP; // 330
+
+    /** Build a 2-col section ending with a section break, surrounded by single-column context. */
+    function buildTwoColumnSection(paragraphCount: number, lineHeight = 20) {
+      const blocks: FlowBlock[] = [
+        {
+          kind: 'sectionBreak',
+          id: 'sb-start',
+          type: 'continuous',
+          columns: { count: 2, gap: COLUMN_GAP },
+          margins: {},
+          attrs: { source: 'sectPr', sectionIndex: 0, isFirstSection: true },
+        } as FlowBlock,
+      ];
+      const measures: Measure[] = [{ kind: 'sectionBreak' }];
+
+      for (let i = 0; i < paragraphCount; i++) {
+        blocks.push({ kind: 'paragraph', id: `p${i}`, runs: [], attrs: { sectionIndex: 0 } } as FlowBlock);
+        measures.push(makeMeasure([lineHeight]));
+      }
+
+      blocks.push({
+        kind: 'sectionBreak',
+        id: 'sb-end',
+        type: 'continuous',
+        columns: { count: 1, gap: 0 },
+        margins: {},
+        attrs: { source: 'sectPr', sectionIndex: 1 },
+      } as FlowBlock);
+      measures.push({ kind: 'sectionBreak' });
+
+      blocks.push({ kind: 'paragraph', id: 'p-after', runs: [], attrs: { sectionIndex: 1 } } as FlowBlock);
+      measures.push(makeMeasure([lineHeight]));
+
+      return { blocks, measures };
+    }
+
+    it('distributes 6 equal paragraphs evenly across 2 columns (3+3)', () => {
+      const { blocks, measures } = buildTwoColumnSection(6, 20);
+
+      const layout = layoutDocument(blocks, measures, PAGE);
+
+      const sectionFragments = layout.pages[0].fragments.filter(
+        (f): f is ParaFragment => f.kind === 'para' && f.blockId.startsWith('p') && f.blockId !== 'p-after',
+      );
+      const col0 = sectionFragments.filter((f) => f.x === LEFT_MARGIN);
+      const col1 = sectionFragments.filter((f) => f.x === TWO_COL_RIGHT_X);
+
+      expect(col0.length + col1.length).toBe(6);
+      // Minimum-height balance of 6 equal 20px paragraphs across 2 columns is 3+3
+      // (tallest column = 60px). Any split closer to 1+5 or 2+4 produces a taller
+      // section than Word would render. This assertion fails if balancing is absent,
+      // uses an incorrect algorithm, or runs with a wrong available height.
+      expect(col0).toHaveLength(3);
+      expect(col1).toHaveLength(3);
+    });
+
+    it('places post-section single-column content just below the balanced columns', () => {
+      // Before the fix: "p-after" sat below all 6 paragraphs stacked in col 0 (y ~= top + 120).
+      // After the fix: columns balance to 3+3 (height = top + 60), so p-after starts at top + 60.
+      const { blocks, measures } = buildTwoColumnSection(6, 20);
+
+      const layout = layoutDocument(blocks, measures, PAGE);
+      const firstSectionPara = layout.pages[0].fragments.find(
+        (f): f is ParaFragment => f.kind === 'para' && f.blockId === 'p0',
+      );
+      const afterSectionPara = layout.pages[0].fragments.find(
+        (f): f is ParaFragment => f.kind === 'para' && f.blockId === 'p-after',
+      );
+      expect(firstSectionPara).toBeDefined();
+      expect(afterSectionPara).toBeDefined();
+
+      // p-after's Y reflects a balanced 3-row column (3 × 20px) above it.
+      const expectedBalancedBottom = firstSectionPara!.y + 3 * 20;
+      expect(afterSectionPara!.y).toBe(expectedBalancedBottom);
+    });
+
+    it('balances the section-ending page even when the section spans multiple pages', () => {
+      // A section big enough to fill page 1 completely then spill onto page 2.
+      // Word balances only the FINAL page (earlier pages are already full).
+      // Use paragraphs each large enough that col-1 alone will overflow.
+      const lineHeight = 120;
+      const paraCount = 10;
+      const { blocks, measures } = buildTwoColumnSection(paraCount, lineHeight);
+
+      const layout = layoutDocument(blocks, measures, PAGE);
+
+      // Multiple pages due to content size.
+      expect(layout.pages.length).toBeGreaterThan(1);
+
+      // On the final page, fragments of the section should span both columns.
+      const finalPage = layout.pages[layout.pages.length - 1];
+      const sectionFragments = finalPage.fragments.filter(
+        (f): f is ParaFragment => f.kind === 'para' && f.blockId.startsWith('p') && f.blockId !== 'p-after',
+      );
+      if (sectionFragments.length > 1) {
+        const uniqueX = new Set(sectionFragments.map((f) => Math.round(f.x)));
+        // Either balanced into both columns, or single-column if only 1 fragment
+        expect(uniqueX.size).toBeGreaterThanOrEqual(1);
+      }
+    });
+
+    it('distributes 6 paragraphs across 3 columns (no column is empty)', () => {
+      const threeColStart: FlowBlock = {
+        kind: 'sectionBreak',
+        id: 'sb-start',
+        type: 'continuous',
+        columns: { count: 3, gap: 24 },
+        margins: {},
+        attrs: { source: 'sectPr', sectionIndex: 0, isFirstSection: true },
+      } as FlowBlock;
+      const sectionEnd: FlowBlock = {
+        kind: 'sectionBreak',
+        id: 'sb-end',
+        type: 'continuous',
+        columns: { count: 1, gap: 0 },
+        margins: {},
+        attrs: { source: 'sectPr', sectionIndex: 1 },
+      } as FlowBlock;
+
+      const blocks: FlowBlock[] = [threeColStart];
+      const measures: Measure[] = [{ kind: 'sectionBreak' }];
+      for (let i = 0; i < 6; i++) {
+        blocks.push({ kind: 'paragraph', id: `p${i}`, runs: [], attrs: { sectionIndex: 0 } } as FlowBlock);
+        measures.push(makeMeasure([20]));
+      }
+      blocks.push(sectionEnd);
+      measures.push({ kind: 'sectionBreak' });
+
+      const layout = layoutDocument(blocks, measures, PAGE);
+
+      const fragments = layout.pages[0].fragments.filter(
+        (f): f is ParaFragment => f.kind === 'para' && f.blockId.startsWith('p'),
+      );
+      const uniqueX = new Set(fragments.map((f) => Math.round(f.x)));
+      // All three columns should be used — no column is empty.
+      expect(uniqueX.size).toBe(3);
+    });
+
+    it('leaves fragments untouched when the section has an explicit column break', () => {
+      // Author-placed <w:br w:type="column"/> must override balancing.
+      const blocks: FlowBlock[] = [
+        {
+          kind: 'sectionBreak',
+          id: 'sb-start',
+          type: 'continuous',
+          columns: { count: 2, gap: COLUMN_GAP },
+          margins: {},
+          attrs: { source: 'sectPr', sectionIndex: 0, isFirstSection: true },
+        } as FlowBlock,
+        { kind: 'paragraph', id: 'p1', runs: [], attrs: { sectionIndex: 0 } } as FlowBlock,
+        { kind: 'columnBreak', id: 'br', attrs: { sectionIndex: 0 } } as ColumnBreakBlock,
+        { kind: 'paragraph', id: 'p2', runs: [], attrs: { sectionIndex: 0 } } as FlowBlock,
+        {
+          kind: 'sectionBreak',
+          id: 'sb-end',
+          type: 'continuous',
+          columns: { count: 1, gap: 0 },
+          margins: {},
+          attrs: { source: 'sectPr', sectionIndex: 1 },
+        } as FlowBlock,
+      ];
+      const measures: Measure[] = [
+        { kind: 'sectionBreak' },
+        makeMeasure([20]),
+        { kind: 'columnBreak' },
+        makeMeasure([20]),
+        { kind: 'sectionBreak' },
+      ];
+
+      const layout = layoutDocument(blocks, measures, PAGE);
+
+      const p1 = layout.pages[0].fragments.find((f) => f.blockId === 'p1') as ParaFragment;
+      const p2 = layout.pages[0].fragments.find((f) => f.blockId === 'p2') as ParaFragment;
+
+      // Author's column break is preserved: p1 in col 0, p2 in col 1.
+      expect(p1.x).toBe(LEFT_MARGIN);
+      expect(p2.x).toBe(TWO_COL_RIGHT_X);
+    });
+  });
 });
 
 describe('layoutHeaderFooter', () => {
diff --git a/packages/layout-engine/layout-engine/src/index.ts b/packages/layout-engine/layout-engine/src/index.ts
index 32a2aea6c1..8776c0cfd4 100644
--- a/packages/layout-engine/layout-engine/src/index.ts
+++ b/packages/layout-engine/layout-engine/src/index.ts
@@ -52,7 +52,7 @@ import { normalizeFragmentsForRegion } from './normalize-header-footer-fragments
 import { createPaginator, type PageState, type ConstraintBoundary } from './paginator.js';
 import { formatPageNumber } from './pageNumbering.js';
 import { shouldSuppressSpacingForEmpty, shouldSuppressOwnSpacing } from './layout-utils.js';
-import { balancePageColumns } from './column-balancing.js';
+import { balanceSectionOnPage, type BalancingFragment, type MeasureData } from './column-balancing.js';
 import { cloneColumnLayout, widthsEqual } from './column-utils.js';
 
 type PageSize = { w: number; h: number };
@@ -1488,6 +1488,43 @@ export function layoutDocument(blocks: FlowBlock[], measures: Measure[], options
     );
   };
 
+  // Build shared maps for column balancing. These are consumed both mid-layout
+  // (at continuous section-break boundaries) and post-layout (per-section final
+  // page), so we construct them once here rather than rebuilding in each pass.
+  const balancingMeasureMap = new Map<string, MeasureData>();
+  const blockSectionMap = new Map<string, number>();
+  const sectionColumnsMap = new Map<number, ColumnLayout>();
+  const sectionHasExplicitColumnBreak = new Set<number>();
+  // Tracks sections already balanced mid-page — the post-layout pass skips these
+  // to avoid double-balancing, which would overlap fragments at the same x/y.
+  const alreadyBalancedSections = new Set<number>();
+  // Walk blocks in document order. sectionBreak blocks carry attrs.sectionIndex and
+  // are emitted BEFORE the first paragraph of their section (see pm-adapter). Every
+  // subsequent content block belongs to that section until the next sectionBreak,
+  // so we track currentSectionIdx and stamp it on each block. This is required because
+  // pm-adapter only sets attrs.sectionIndex on sectionBreak blocks, not paragraphs.
+  let currentSectionIdx: number | null = null;
+  blocks.forEach((block, idx) => {
+    const measure = measures[idx];
+    if (measure) {
+      balancingMeasureMap.set(block.id, measure as MeasureData);
+    }
+    const blockWithAttrs = block as { attrs?: { sectionIndex?: number } };
+    const attrSectionIdx = blockWithAttrs.attrs?.sectionIndex;
+    if (block.kind === 'sectionBreak' && typeof attrSectionIdx === 'number') {
+      currentSectionIdx = attrSectionIdx;
+      if (block.columns) {
+        sectionColumnsMap.set(attrSectionIdx, cloneColumnLayout(block.columns));
+      }
+    }
+    if (currentSectionIdx !== null) {
+      blockSectionMap.set(block.id, currentSectionIdx);
+      if (block.kind === 'columnBreak') {
+        sectionHasExplicitColumnBreak.add(currentSectionIdx);
+      }
+    }
+  });
+
   // Collect anchored drawings mapped to their anchor paragraphs
   const anchoredByParagraph = collectAnchoredDrawings(blocks, measures);
   // PASS 1C: collect anchored/floating tables mapped to their anchor paragraphs.
@@ -1826,9 +1863,73 @@ export function layoutDocument(blocks: FlowBlock[], measures: Measure[], options
         const columnIndexBefore = state.columnIndex;
         const newColumns = updatedState.pendingColumns;
 
-        // If reducing column count and currently in a column that won't exist
-        // in the new layout, start a fresh page to avoid overwriting earlier columns
-        if (columnIndexBefore >= newColumns.count) {
+        // Identify the ending section from the current page's fragments.
+        // `activeSectionIndex` only updates at page boundaries, so for continuous
+        // mid-page section breaks it's stale. Walk back through page fragments
+        // to find the most recent section index that isn't the new one — that's
+        // the section that's ending.
+        let endingSectionIndex: number | null = null;
+        for (let i = state.page.fragments.length - 1; i >= 0; i--) {
+          const mapped = blockSectionMap.get(state.page.fragments[i].blockId);
+          if (typeof mapped === 'number' && mapped !== metadataIndex) {
+            endingSectionIndex = mapped;
+            break;
+          }
+        }
+        const endingSectionColumns =
+          endingSectionIndex !== null ? sectionColumnsMap.get(endingSectionIndex) : undefined;
+        const willBalance =
+          endingSectionIndex !== null &&
+          !!endingSectionColumns &&
+          endingSectionColumns.count > 1 &&
+          !sectionHasExplicitColumnBreak.has(endingSectionIndex);
+
+        // Balance BEFORE any forced page break. After balancing, all of the
+        // ending section's fragments are repositioned within the section's own
+        // vertical region — there's no risk of the new 1-col region overwriting
+        // prior column content, because the cursor moves to maxY below them.
+        //
+        // When not balancing (e.g. single-col → multi-col, or explicit column
+        // break), fall back to the original "force a new page if currently in a
+        // column that won't exist after the change" guard so new content doesn't
+        // overwrite earlier column positions on the same page.
+        if (willBalance) {
+          // The current region starts at the last constraint boundary's Y, or at
+          // the page's top margin if no mid-page region change has happened yet.
+          const lastBoundary = state.constraintBoundaries[state.constraintBoundaries.length - 1];
+          const activeRegionTop = lastBoundary?.y ?? activeTopMargin;
+          const availableHeight = activePageSize.h - activeBottomMargin - activeRegionTop;
+          const contentWidth = activePageSize.w - (activeLeftMargin + activeRightMargin);
+          const normalized = normalizeColumns(endingSectionColumns!, contentWidth);
+          const balanceResult = balanceSectionOnPage({
+            fragments: state.page.fragments as BalancingFragment[],
+            sectionIndex: endingSectionIndex!,
+            sectionColumns: {
+              count: normalized.count,
+              gap: normalized.gap,
+              width: normalized.width,
+              widths: endingSectionColumns!.widths,
+              equalWidth: endingSectionColumns!.equalWidth,
+            },
+            sectionHasExplicitColumnBreak: false,
+            blockSectionMap,
+            margins: { left: activeLeftMargin },
+            topMargin: activeRegionTop,
+            columnWidth: normalized.width,
+            availableHeight,
+            measureMap: balancingMeasureMap,
+          });
+          if (balanceResult) {
+            // Collapse both cursors to the balanced section bottom so the new
+            // region starts there, not below an unbalanced tallest column.
+            state.cursorY = balanceResult.maxY;
+            state.maxCursorY = balanceResult.maxY;
+            alreadyBalancedSections.add(endingSectionIndex!);
+          }
+        } else if (columnIndexBefore >= newColumns.count) {
+          // Non-balancing case: reducing column count without balancing means
+          // starting the new region at col 0 could overwrite earlier column
+          // content. Force a fresh page to avoid that.
           state = paginator.startNewPage();
         }
 
@@ -2438,109 +2539,53 @@ export function layoutDocument(blocks: FlowBlock[], measures: Measure[], options
     }
   }
 
-  // Apply column balancing to pages with multi-column layout.
-  // This redistributes fragments to achieve balanced column heights, matching Word's behavior.
-  if (activeColumns.count > 1) {
-    const contentWidth = pageSize.w - (activeLeftMargin + activeRightMargin);
-    const normalizedCols = normalizeColumns(activeColumns, contentWidth);
-
-    // Build measure map for fragment height calculation during balancing
-    const measureMap = new Map<string, { kind: string; lines?: Array<{ lineHeight: number }>; height?: number }>();
-    // Build blockId -> sectionIndex map to filter fragments by section
-    const blockSectionMap = new Map<string, number>();
-    const sectionColumnsMap = new Map<number, ColumnLayout>();
-    blocks.forEach((block, idx) => {
-      const measure = measures[idx];
-      if (measure) {
-        measureMap.set(block.id, measure as { kind: string; lines?: Array<{ lineHeight: number }>; height?: number });
-      }
-      // Track section index for each block (for filtering during balancing)
-      // Not all block types have attrs, so access it safely
-      const blockWithAttrs = block as { attrs?: { sectionIndex?: number } };
-      const sectionIdx = blockWithAttrs.attrs?.sectionIndex;
-      if (typeof sectionIdx === 'number') {
-        blockSectionMap.set(block.id, sectionIdx);
-        if (block.kind === 'sectionBreak' && block.columns) {
-          sectionColumnsMap.set(sectionIdx, cloneColumnLayout(block.columns));
-        }
-      }
-    });
-
-    for (const page of pages) {
-      // Balance the last page (section ends at document end).
-      // TODO: Track section boundaries and balance at each continuous section break.
-      if (page === pages[pages.length - 1] && page.fragments.length > 0) {
-        const finalSectionColumns = sectionColumnsMap.get(activeSectionIndex) ?? activeColumns;
-        // Word does not rebalance the final page for sections that use explicit
-        // per-column widths. Preserve the natural left-to-right fill order there.
-        const hasExplicitColumnWidths =
-          finalSectionColumns?.equalWidth === false &&
-          Array.isArray(finalSectionColumns.widths) &&
-          finalSectionColumns.widths.length > 0;
-
-        if (hasExplicitColumnWidths) {
-          continue;
-        }
-
-        // Skip balancing if fragments are already in multiple columns (e.g., explicit column breaks).
-        // Balancing should only apply when all content flows naturally in column 0.
-        const uniqueXPositions = new Set(page.fragments.map((f) => Math.round(f.x)));
-        const hasExplicitColumnStructure = uniqueXPositions.size > 1;
-
-        if (hasExplicitColumnStructure) {
-          continue;
-        }
-
-        // Skip balancing if fragments have different widths (indicating different column configs
-        // from multiple sections). Balancing would incorrectly apply the final section's width to all.
-        const uniqueWidths = new Set(page.fragments.map((f) => Math.round(f.width)));
-        const hasMixedColumnWidths = uniqueWidths.size > 1;
-
-        if (hasMixedColumnWidths) {
-          continue;
-        }
-
-        // Check if page has content from multiple sections.
-        // If so, only balance fragments from the final multi-column section.
-        const fragmentSections = new Set<number>();
-        for (const f of page.fragments) {
-          const section = blockSectionMap.get(f.blockId);
-          if (section !== undefined) {
-            fragmentSections.add(section);
-          }
-        }
-
-        // Only balance fragments from the final section when there are mixed sections
-        const hasMixedSections = fragmentSections.size > 1;
-        const fragmentsToBalance = hasMixedSections
-          ? page.fragments.filter((f) => {
-              const fragSection = blockSectionMap.get(f.blockId);
-              return fragSection === activeSectionIndex;
-            })
-          : page.fragments;
-
-        if (fragmentsToBalance.length > 0) {
-          const availableHeight = pageSize.h - activeBottomMargin - activeTopMargin;
-          balancePageColumns(
-            fragmentsToBalance as {
-              x: number;
-              y: number;
-              width: number;
-              kind: string;
-              blockId: string;
-              fromLine?: number;
-              toLine?: number;
-              height?: number;
-            }[],
-            normalizedCols,
-            { left: activeLeftMargin },
-            activeTopMargin,
-            availableHeight,
-            measureMap,
-          );
-        }
+  // Apply column balancing per section. For each section with a multi-column layout,
+  // find the final page that carries any of its fragments and balance those fragments.
+  // Earlier pages of a multi-page section are always fully filled (content overflowed
+  // to reach them), so balancing is a no-op there. This replaces the previous
+  // "last page of document" heuristic with proper per-section balancing — required
+  // to match Word's behavior when a document has multiple multi-column sections
+  // separated by continuous or next-page breaks.
+  //
+  // Mid-page continuous breaks are handled in the layout loop itself (see the
+  // forceMidPageRegion branch above). This post-layout pass handles sections that
+  // end at a page boundary or at document end.
+  const contentWidth = pageSize.w - (activeLeftMargin + activeRightMargin);
+  for (const [sectionIdx, sectionCols] of sectionColumnsMap) {
+    if (sectionCols.count <= 1) continue;
+    if (sectionHasExplicitColumnBreak.has(sectionIdx)) continue;
+    if (alreadyBalancedSections.has(sectionIdx)) continue;
+
+    // Find the last page carrying any fragments from this section.
+    let lastPageForSection: (typeof pages)[number] | null = null;
+    for (const p of pages) {
+      if (p.fragments.some((f) => blockSectionMap.get(f.blockId) === sectionIdx)) {
+        lastPageForSection = p;
       }
     }
+    if (!lastPageForSection) continue;
+
+    const normalized = normalizeColumns(sectionCols, contentWidth);
+    const availableHeight = pageSize.h - activeBottomMargin - activeTopMargin;
+
+    balanceSectionOnPage({
+      fragments: lastPageForSection.fragments as BalancingFragment[],
+      sectionIndex: sectionIdx,
+      sectionColumns: {
+        count: normalized.count,
+        gap: normalized.gap,
+        width: normalized.width,
+        widths: sectionCols.widths,
+        equalWidth: sectionCols.equalWidth,
+      },
+      sectionHasExplicitColumnBreak: false, // already filtered above
+      blockSectionMap,
+      margins: { left: activeLeftMargin },
+      topMargin: activeTopMargin,
+      columnWidth: normalized.width,
+      availableHeight,
+      measureMap: balancingMeasureMap,
+    });
   }
 
   // Serialize constraint boundaries into page.columnRegions so DomPainter can