mixdog 0.9.173 → 0.9.174

package/src/runtime/office/portable/text-metrics.mjs

@@ -2,6 +2,12 @@ import { createCanvas, GlobalFonts } from '@napi-rs/canvas';
 import { warmupInstalledOfficeFonts } from './font-provisioner.mjs';
 import { bySlide, rectangleGap, reviewDeclaredRelations } from './pptx-relations.mjs';
 
+// PowerPoint's single line spacing is 1.2 em for every face — probe 2026-09-04
+// read BoundHeight / lines / size = 1.200 for Noto Sans KR, Noto Serif KR,
+// Malgun Gothic, Noto Sans, Arial, and Calibri at 18 and 36 pt. The canvas's
+// font bounding box (1.33 for Malgun, 1.44 for Noto Serif KR) is the face's own
+// metric, not the pitch PowerPoint lays out, so it is not used. A percentage
+// line spacing multiplies the 1.2.
 const LINE_HEIGHT_RATIO = 1.2;
 const CJK = /[\u1100-\u115F\u2E80-\uA4CF\uAC00-\uD7A3\uF900-\uFAFF\uFE30-\uFE6F\uFF00-\uFF60\uFFE0-\uFFE6]/;
 // Families that carry their own Hangul / CJK glyphs. Any other face (Arial, Calibri, Noto Sans) hands
@@ -125,7 +131,7 @@ function fontAvailable(name) {
   // Weight-suffixed families (Malgun Gothic Semilight, Segoe UI Semibold)
   // often enumerate only under their base family; measure with that base
   // instead of reporting the whole font missing.
-  const base = family.replace(/\s+(?:semilight|light|semibold|medium|black|thin|extrabold)$/u, '');
+  const base = family.replace(WEIGHT_SUFFIX, '');
   return base !== family && (installedFonts.has(base) || Boolean(installedEquivalent(base)));
 }
 
@@ -270,14 +276,34 @@ export function wrapParagraph(text, width, font = {}) {
   return lines.length ? lines : [''];
 }
 
-// PowerPoint's single line spacing is 1.2 em for every face — probe 2026-09-04
-// read BoundHeight / lines / size = 1.200 for Noto Sans KR, Noto Serif KR,
-// Malgun Gothic, Noto Sans, Arial, and Calibri at 18 and 36 pt. The canvas's
-// font bounding box (1.33 for Malgun, 1.44 for Noto Serif KR) is the face's own
-// metric, not the pitch PowerPoint lays out, so it is not used. A percentage
-// line spacing multiplies the 1.2.
-function naturalLineRatio() {
-  return LINE_HEIGHT_RATIO;
+// A paragraph whose text carries soft breaks ('\n') is laid out as one line group per break, each at the
+// size of its own runs: "GPT-5.6 Sol" at 14 pt over "Codex CLI 대비" at 10 pt is two lines, not one
+// unbroken word wrapped three times. Space before and after stay with the paragraph's first and last line.
+function softBreakLines(paragraph) {
+  const text = String(paragraph.text ?? '');
+  if (!text.includes('\n')) return [paragraph];
+  const runs = Array.isArray(paragraph.runs) ? paragraph.runs : [{ text, fontSize: paragraph.fontSize }];
+  const lines = [[]];
+  for (const run of runs) {
+    String(run.text ?? '')
+      .split('\n')
+      .forEach((part, index) => {
+        if (index > 0) lines.push([]);
+        if (part) lines[lines.length - 1].push({ ...run, text: part });
+      });
+  }
+  const { runs: _runs, spaceBefore, spaceAfter, ...rest } = paragraph;
+  return lines.map((lineRuns, index) => {
+    const sizes = lineRuns.map((run) => Number(run.fontSize) || 0).filter(Boolean);
+    return {
+      ...rest,
+      text: lineRuns.map((run) => run.text).join(''),
+      fontSize: sizes.length ? Math.max(...sizes) : paragraph.fontSize,
+      ...(new Set(sizes).size > 1 ? { runs: lineRuns } : {}),
+      ...(index === 0 && spaceBefore ? { spaceBefore } : {}),
+      ...(index === lines.length - 1 && spaceAfter ? { spaceAfter } : {}),
+    };
+  });
 }
 
 // lineSpacing: the PowerPoint multiple (1.0 = single); a paragraph's own
@@ -291,7 +317,7 @@ export function measureTextBlock(paragraphs = [], { width = 0, lineSpacing = 1,
   // wrap breaks such a run between characters, the laid-out width no longer
   // shows that the measure is narrower than the text it has to carry.
   let longestRun = 0;
-  for (const paragraph of paragraphs) {
+  for (const paragraph of paragraphs.flatMap(softBreakLines)) {
     const font = {
       fontName: paragraph.fontName,
       fontSize: paragraph.fontSize,
@@ -299,6 +325,26 @@ export function measureTextBlock(paragraphs = [], { width = 0, lineSpacing = 1,
       italic: paragraph.italic,
     };
     const size = Math.max(1, Number(paragraph.fontSize) || 18);
+    const multipleEarly =
+      Number(paragraph.lineSpacing) > 0 ? Number(paragraph.lineSpacing) : Math.max(0.5, Number(lineSpacing) || 1);
+    // Runs of different sizes ("+4.3" at 47 pt, "%p" at 19 pt) are measured each at its own size: read at the first
+    // run's size, a figure with its small unit was reported as breaking mid-word and overflowing its box. When the
+    // whole paragraph fits one line that way, it is one line.
+    const runs =
+      Array.isArray(paragraph.runs) && new Set(paragraph.runs.map((run) => run.fontSize)).size > 1
+        ? paragraph.runs
+        : null;
+    if (runs) {
+      const total = runs.reduce((sum, run) => sum + measureTextWidth(run.text, { ...font, fontSize: run.fontSize }), 0);
+      if (!(width > 0) || total <= width) {
+        widest = Math.max(widest, total);
+        longestRun = Math.max(longestRun, total);
+        lines += 1;
+        height += size * (lineHeightRatio > 0 ? lineHeightRatio : LINE_HEIGHT_RATIO * multipleEarly);
+        height += Math.max(0, Number(paragraph.spaceBefore) || 0) + Math.max(0, Number(paragraph.spaceAfter) || 0);
+        continue;
+      }
+    }
     const wrapped = width > 0 ? wrapParagraph(paragraph.text, width, font) : [String(paragraph.text ?? '')];
     for (const line of wrapped) widest = Math.max(widest, measureTextWidth(line, font));
     for (const part of segments(paragraph.text)) {
@@ -307,7 +353,7 @@ export function measureTextBlock(paragraphs = [], { width = 0, lineSpacing = 1,
     lines += wrapped.length;
     const multiple =
       Number(paragraph.lineSpacing) > 0 ? Number(paragraph.lineSpacing) : Math.max(0.5, Number(lineSpacing) || 1);
-    const pitch = lineHeightRatio > 0 ? lineHeightRatio : naturalLineRatio() * multiple;
+    const pitch = lineHeightRatio > 0 ? lineHeightRatio : LINE_HEIGHT_RATIO * multiple;
     height += wrapped.length * size * pitch;
     height += Math.max(0, Number(paragraph.spaceBefore) || 0);
     height += Math.max(0, Number(paragraph.spaceAfter) || 0);
@@ -450,13 +496,18 @@ export function reviewCjkTracking(boxes = []) {
   return issues;
 }
 
+// The largest type size a block of paragraphs sets, 0 when none states one.
+function largestFontSize(paragraphs) {
+  return Math.max(0, ...paragraphs.map((paragraph) => Number(paragraph.fontSize) || 0));
+}
+
 // Two readings of the same fault: a box narrower than its longest word
 // breaks mid-word, and a box only a little wider still leaves a ragged
 // column of one or two words a line. Both are answered by widening the
 // measure, so they share one code and report once.
 function narrowBoxIssue(box, paragraphs, measured, usableWidth, path) {
   if (box.wrap === false) return null;
-  const bodySize = Math.max(0, ...paragraphs.map((paragraph) => Number(paragraph.fontSize) || 0));
+  const bodySize = largestFontSize(paragraphs);
   const longestRun = Number(measured.longestRun) || measured.width;
   if (longestRun > usableWidth * 1.02) {
     return {
@@ -574,7 +625,7 @@ function statementSlides(boxes = []) {
     if (!text) continue;
     const entry = perSlide.get(box.slide) || { count: 0, sizes: [], chars: 0 };
     entry.count += 1;
-    entry.sizes.push(Math.max(0, ...paragraphs.map((paragraph) => Number(paragraph.fontSize) || 0)));
+    entry.sizes.push(largestFontSize(paragraphs));
     entry.chars += text.length;
     perSlide.set(box.slide, entry);
   }
@@ -629,6 +680,24 @@ function hollowBand(content = []) {
   return { depth, top };
 }
 
+// A page the statement exemption covers that is no statement: a title in the top quarter, nothing at poster size,
+// and a line of 14 pt or more (the takeaway) with a hollow band between them. A statement is one claim set large in
+// its air; a title over an empty middle and a sentence at the foot is a content page whose content never came.
+// The author may mean it, so it is information, not a target.
+function titleLineHollow(slideBoxes, content, slideHeight) {
+  const texts = slideBoxes
+    .map((box) => ({ box, size: largestFontSize(Array.isArray(box.paragraphs) ? box.paragraphs : []) }))
+    .filter(({ box }) => (box.paragraphs || []).some((paragraph) => String(paragraph.text || '').trim()));
+  if (texts.length < 2) return null;
+  const title = texts.reduce((largest, entry) => (entry.size > largest.size ? entry : largest));
+  if (title.size < 24 || title.size >= 34 || !(Number(title.box.top) < slideHeight * 0.25)) return null;
+  const hollow = hollowBand(content);
+  if (hollow.depth <= HOLLOW_BAND || hollow.top < Number(title.box.top) + Number(title.box.height) - 1) return null;
+  const below = hollow.top + hollow.depth - 1;
+  if (!texts.some((entry) => entry !== title && entry.size >= 14 && Number(entry.box.top) >= below)) return null;
+  return hollow;
+}
+
 export function reviewVerticalBalance(bounds = [], { slideWidth = 0, slideHeight = 0, boxes = [] } = {}) {
   if (!(slideHeight > 0) || !(slideWidth > 0)) return [];
   const issues = [];
@@ -638,7 +707,24 @@ export function reviewVerticalBalance(bounds = [], { slideWidth = 0, slideHeight
       (shape) => Math.max(0, shape.width) * Math.max(0, shape.height) < slideWidth * slideHeight * 0.8
     );
     if (!content.length) continue;
-    if (statements.has(slide) && !carriesObject(content)) continue;
+    if (statements.has(slide) && !carriesObject(content)) {
+      const hollow = titleLineHollow(
+        boxes.filter((box) => box.slide === slide),
+        content,
+        slideHeight
+      );
+      if (hollow) {
+        issues.push({
+          severity: 'info',
+          code: 'title_line_hollow',
+          path: `/slide[${slide}]`,
+          message: `Only a title and a line under it, with an empty band ${Math.round(hollow.depth)}pt deep between them. A statement page sets its claim large in the air; a content page brings its evidence into the band, or moves the line up under the title.`,
+          hollowBand: Math.round(hollow.depth),
+          hollowTop: Math.round(hollow.top),
+        });
+      }
+      continue;
+    }
     const top = Math.min(...content.map((shape) => shape.top));
     const bottom = Math.max(...content.map((shape) => shape.top + shape.height));
     const topEmpty = Math.max(0, top);
@@ -685,21 +771,13 @@ export function reviewStatLabelProximity(boxes = [], { maximumGap = 36 } = {}) {
         .map((paragraph) => String(paragraph.text ?? ''))
         .join(' ')
         .trim();
-      const size = Math.max(...paragraphs.map((paragraph) => Number(paragraph.fontSize) || 0), 0);
+      const size = largestFontSize(paragraphs);
       if (size < 28 || !text || text.length > 16 || !/\d/.test(text)) continue;
       const letters = (text.match(/\p{L}/gu) || []).length;
       if (letters > text.replace(/\s/g, '').length * 0.5) continue;
       const nearest = shapes
         .filter((candidate) => candidate !== box)
-        .filter(
-          (candidate) =>
-            Math.max(
-              ...(Array.isArray(candidate.paragraphs) ? candidate.paragraphs : []).map(
-                (paragraph) => Number(paragraph.fontSize) || 0
-              ),
-              0
-            ) <= 20
-        )
+        .filter((candidate) => largestFontSize(Array.isArray(candidate.paragraphs) ? candidate.paragraphs : []) <= 20)
         .filter((candidate) => candidate.paragraphs?.some((paragraph) => String(paragraph.text || '').trim()))
         .sort((first, second) => rectangleGap(box, first) - rectangleGap(box, second))[0];
       if (!nearest) continue;

package/src/runtime/office/portable/xlsx-assertions.mjs

@@ -111,6 +111,144 @@ function issue(index, code, message, path = '/') {
   };
 }
 
+// Each check reads one assertion against the workbook, records its issues, and
+// answers whether the assertion held.
+function checkCellValue({ assertion, assertionIndex, sheet, target, issues }) {
+  // A formula written without Excel carries no cached result until the
+  // workbook is recalculated. Compared anyway it reads as a wrong model —
+  // and against a zero expectation it used to read as a right one.
+  if (uncalculated(target)) {
+    issues.push(
+      issue(
+        assertionIndex,
+        'assertion_value_uncalculated',
+        `${sheet}!${assertion.cell} holds ${JSON.stringify(formulaText(target))} with no calculated result, so it cannot be compared with ${JSON.stringify(assertion.equals)}: ${UNCALCULATED_ROUTE}.`,
+        target?.path || `/sheet[${sheet}]/cell[${assertion.cell}]`
+      )
+    );
+    return false;
+  }
+  const passed = Boolean(target) && sameValue(target.value, assertion.equals, assertion.tolerance);
+  if (!passed) {
+    issues.push(
+      issue(
+        assertionIndex,
+        'assertion_value_mismatch',
+        `Expected ${sheet}!${assertion.cell} to equal ${JSON.stringify(assertion.equals)}; actual value is ${JSON.stringify(target?.value ?? null)}.`,
+        target?.path || `/sheet[${sheet}]/cell[${assertion.cell}]`
+      )
+    );
+  }
+  return passed;
+}
+
+function checkCellFormula({ assertion, assertionIndex, sheet, target, issues }) {
+  const actual = String(target?.formula || '');
+  const comparableActual = actual.replace(/^=/, '');
+  const comparableExpected = String(assertion.equals ?? '').replace(/^=/, '');
+  const passed =
+    Boolean(target) &&
+    (assertion.equals !== undefined
+      ? comparableActual === comparableExpected
+      : new RegExp(String(assertion.matches || '')).test(actual));
+  if (!passed)
+    issues.push(
+      issue(
+        assertionIndex,
+        'assertion_formula_mismatch',
+        `Formula assertion failed for ${sheet}!${assertion.cell}; actual formula is ${JSON.stringify(actual)}.`,
+        target?.path || `/sheet[${sheet}]/cell[${assertion.cell}]`
+      )
+    );
+  return passed;
+}
+
+function checkTieOut({ assertion, assertionIndex, sheet, get, issues }) {
+  const left = get(assertion.left, sheet);
+  const right = get(assertion.right, sheet);
+  // Two sides that have not been calculated are both empty, and an empty
+  // pair used to tie out: the strictest check in the model answered "agreed"
+  // without a single number behind it.
+  const pending = [
+    [assertion.left, left],
+    [assertion.right, right],
+  ].filter(([, cell]) => uncalculated(cell));
+  if (pending.length) {
+    issues.push(
+      issue(
+        assertionIndex,
+        'assertion_value_uncalculated',
+        `Tie-out cannot be read yet: ${pending.map(([reference, cell]) => `${JSON.stringify(reference)} holds ${JSON.stringify(formulaText(cell))} with no calculated result`).join(' and ')}; ${UNCALCULATED_ROUTE}.`,
+        pending[0][1]?.path || left?.path || right?.path || '/'
+      )
+    );
+    return false;
+  }
+  const passed = Boolean(left && right) && sameValue(left.value, right.value, assertion.tolerance);
+  if (!passed)
+    issues.push(
+      issue(
+        assertionIndex,
+        'assertion_tie_out_failed',
+        `Tie-out failed: ${JSON.stringify(assertion.left)}=${JSON.stringify(left?.value ?? null)} and ${JSON.stringify(assertion.right)}=${JSON.stringify(right?.value ?? null)}.`,
+        left?.path || right?.path || '/'
+      )
+    );
+  return passed;
+}
+
+function checkNoErrors({ document, assertion, assertionIndex, issues }) {
+  const failures = cellsForAssertion(document, assertion).filter((cell) => ERROR_VALUE.test(String(cell.value || '')));
+  for (const cell of failures.slice(0, 100))
+    issues.push(
+      issue(
+        assertionIndex,
+        'assertion_formula_error',
+        `Formula error ${cell.value} violates no-errors assertion.`,
+        cell.path
+      )
+    );
+  return failures.length === 0;
+}
+
+function checkFormulaConsistency({ document, assertion, assertionIndex, sheet, issues }) {
+  const formulas = cellsForAssertion(document, assertion).filter((cell) => cell.formula);
+  const patterns = new Map();
+  for (const cell of formulas) {
+    const pattern = relativeFormulaSignature(cell.formula, cell.ref);
+    patterns.set(pattern, (patterns.get(pattern) || 0) + 1);
+  }
+  const expected = [...patterns.entries()].sort((left, right) => right[1] - left[1])[0]?.[0] || '';
+  const inconsistent = formulas.filter((cell) => relativeFormulaSignature(cell.formula, cell.ref) !== expected);
+  if (!formulas.length)
+    issues.push(
+      issue(
+        assertionIndex,
+        'assertion_formula_missing',
+        'Formula-consistency assertion found no formulas.',
+        `/sheet[${assertion.sheet || sheet}]`
+      )
+    );
+  for (const cell of inconsistent.slice(0, 100))
+    issues.push(
+      issue(
+        assertionIndex,
+        'assertion_formula_inconsistent',
+        'Formula differs from the dominant pattern in the asserted region.',
+        cell.path
+      )
+    );
+  return formulas.length > 0 && inconsistent.length === 0;
+}
+
+const ASSERTION_CHECKS = new Map([
+  ['cell-value', checkCellValue],
+  ['cell-formula', checkCellFormula],
+  ['tie-out', checkTieOut],
+  ['no-errors', checkNoErrors],
+  ['formula-consistency', checkFormulaConsistency],
+]);
+
 export function evaluateXlsxAssertions(document, assertions = []) {
   const index = cellIndex(document);
   const issues = [];
@@ -125,128 +263,11 @@ export function evaluateXlsxAssertions(document, assertions = []) {
     const kind = String(assertion?.kind || '').toLowerCase();
     const sheet = String(assertion?.sheet || document?.sheets?.[0]?.name || '');
     const target = assertion?.cell ? get({ sheet, cell: assertion.cell }) : null;
-    let passed = true;
-    if (kind === 'cell-value') {
-      // A formula written without Excel carries no cached result until the
-      // workbook is recalculated. Compared anyway it reads as a wrong model —
-      // and against a zero expectation it used to read as a right one.
-      if (uncalculated(target)) {
-        passed = false;
-        issues.push(
-          issue(
-            assertionIndex,
-            'assertion_value_uncalculated',
-            `${sheet}!${assertion.cell} holds ${JSON.stringify(formulaText(target))} with no calculated result, so it cannot be compared with ${JSON.stringify(assertion.equals)}: ${UNCALCULATED_ROUTE}.`,
-            target?.path || `/sheet[${sheet}]/cell[${assertion.cell}]`
-          )
-        );
-      } else {
-        passed = Boolean(target) && sameValue(target.value, assertion.equals, assertion.tolerance);
-        if (!passed) {
-          issues.push(
-            issue(
-              assertionIndex,
-              'assertion_value_mismatch',
-              `Expected ${sheet}!${assertion.cell} to equal ${JSON.stringify(assertion.equals)}; actual value is ${JSON.stringify(target?.value ?? null)}.`,
-              target?.path || `/sheet[${sheet}]/cell[${assertion.cell}]`
-            )
-          );
-        }
-      }
-    } else if (kind === 'cell-formula') {
-      const actual = String(target?.formula || '');
-      const comparableActual = actual.replace(/^=/, '');
-      const comparableExpected = String(assertion.equals ?? '').replace(/^=/, '');
-      passed =
-        Boolean(target) &&
-        (assertion.equals !== undefined
-          ? comparableActual === comparableExpected
-          : new RegExp(String(assertion.matches || '')).test(actual));
-      if (!passed)
-        issues.push(
-          issue(
-            assertionIndex,
-            'assertion_formula_mismatch',
-            `Formula assertion failed for ${sheet}!${assertion.cell}; actual formula is ${JSON.stringify(actual)}.`,
-            target?.path || `/sheet[${sheet}]/cell[${assertion.cell}]`
-          )
-        );
-    } else if (kind === 'tie-out') {
-      const left = get(assertion.left, sheet);
-      const right = get(assertion.right, sheet);
-      // Two sides that have not been calculated are both empty, and an empty
-      // pair used to tie out: the strictest check in the model answered "agreed"
-      // without a single number behind it.
-      const pending = [
-        [assertion.left, left],
-        [assertion.right, right],
-      ].filter(([, cell]) => uncalculated(cell));
-      if (pending.length) {
-        passed = false;
-        issues.push(
-          issue(
-            assertionIndex,
-            'assertion_value_uncalculated',
-            `Tie-out cannot be read yet: ${pending.map(([reference, cell]) => `${JSON.stringify(reference)} holds ${JSON.stringify(formulaText(cell))} with no calculated result`).join(' and ')}; ${UNCALCULATED_ROUTE}.`,
-            pending[0][1]?.path || left?.path || right?.path || '/'
-          )
-        );
-      } else {
-        passed = Boolean(left && right) && sameValue(left.value, right.value, assertion.tolerance);
-        if (!passed)
-          issues.push(
-            issue(
-              assertionIndex,
-              'assertion_tie_out_failed',
-              `Tie-out failed: ${JSON.stringify(assertion.left)}=${JSON.stringify(left?.value ?? null)} and ${JSON.stringify(assertion.right)}=${JSON.stringify(right?.value ?? null)}.`,
-              left?.path || right?.path || '/'
-            )
-          );
-      }
-    } else if (kind === 'no-errors') {
-      const failures = cellsForAssertion(document, assertion).filter((cell) =>
-        ERROR_VALUE.test(String(cell.value || ''))
-      );
-      passed = failures.length === 0;
-      for (const cell of failures.slice(0, 100))
-        issues.push(
-          issue(
-            assertionIndex,
-            'assertion_formula_error',
-            `Formula error ${cell.value} violates no-errors assertion.`,
-            cell.path
-          )
-        );
-    } else if (kind === 'formula-consistency') {
-      const formulas = cellsForAssertion(document, assertion).filter((cell) => cell.formula);
-      const patterns = new Map();
-      for (const cell of formulas) {
-        const pattern = relativeFormulaSignature(cell.formula, cell.ref);
-        patterns.set(pattern, (patterns.get(pattern) || 0) + 1);
-      }
-      const expected = [...patterns.entries()].sort((left, right) => right[1] - left[1])[0]?.[0] || '';
-      const inconsistent = formulas.filter((cell) => relativeFormulaSignature(cell.formula, cell.ref) !== expected);
-      passed = formulas.length > 0 && inconsistent.length === 0;
-      if (!formulas.length)
-        issues.push(
-          issue(
-            assertionIndex,
-            'assertion_formula_missing',
-            'Formula-consistency assertion found no formulas.',
-            `/sheet[${assertion.sheet || sheet}]`
-          )
-        );
-      for (const cell of inconsistent.slice(0, 100))
-        issues.push(
-          issue(
-            assertionIndex,
-            'assertion_formula_inconsistent',
-            'Formula differs from the dominant pattern in the asserted region.',
-            cell.path
-          )
-        );
+    const check = ASSERTION_CHECKS.get(kind);
+    let passed = false;
+    if (check) {
+      passed = check({ document, assertion, assertionIndex, sheet, target, get, issues });
     } else {
-      passed = false;
       issues.push(
         issue(assertionIndex, 'assertion_kind_unknown', `Unknown XLSX assertion kind: ${kind || '(missing)'}`)
       );

package/src/runtime/office/portable/xlsx-audit-support.mjs

@@ -93,17 +93,24 @@ export function hasVisibleStyle(style) {
   return Number.isFinite(size) && size > 0 && size !== 11;
 }
 
+// A range as an area bounded by both rows and columns, or null: a malformed
+// range, or a whole-row or whole-column one, excludes nothing.
+function boundedArea(range) {
+  try {
+    const area = parseAreaRange(String(range || '').replace(/\$/g, ''));
+    return area.startRow && area.startCol ? area : null;
+  } catch {
+    return null;
+  }
+}
+
 // The Excel tables a sheet lists (both readers: `tables` [{ range }]), as
 // areas; the body rows are records the table sources, not assumptions.
 export function tableAreas(sheet) {
   const areas = [];
   for (const table of sheet?.tables || []) {
-    try {
-      const area = parseAreaRange(String(table?.range || '').replace(/\$/g, ''));
-      if (area.startRow && area.startCol) areas.push({ ...area, table });
-    } catch {
-      // A malformed range excludes nothing.
-    }
+    const area = boundedArea(table?.range);
+    if (area) areas.push({ ...area, table });
   }
   return areas;
 }
@@ -113,12 +120,8 @@ export function tableAreas(sheet) {
 export function mergedAreas(sheet) {
   const areas = [];
   for (const range of sheet?.mergedRanges || []) {
-    try {
-      const area = parseAreaRange(String(range || '').replace(/\$/g, ''));
-      if (area.startRow && area.startCol) areas.push(area);
-    } catch {
-      // A malformed range excludes nothing.
-    }
+    const area = boundedArea(range);
+    if (area) areas.push(area);
   }
   return areas;
 }

package/src/runtime/office/portable/xlsx-contract.mjs

@@ -1,5 +1,5 @@
 import { columnNumber } from './portable-cells.mjs';
-import { quoteSheetName } from './portable-sheet-xml.mjs';
+import { quoteSheetName, sheetQualifiedAreas } from './portable-sheet-xml.mjs';
 import { escapeRegExp } from './xlsx-audit-support.mjs';
 
 const XLSX_MAX_ROWS = 1_048_576;
@@ -293,6 +293,12 @@ function validateFreezePanes(operation) {
   if (!Number.isInteger(column) || column < 0 || column > XLSX_MAX_COLUMNS) {
     throw new Error(`XLSX freeze_panes column must be between 0 and ${XLSX_MAX_COLUMNS}`);
   }
+  // row:1 read as "freeze one row" came back as a batch that changed nothing; it names the first row that scrolls.
+  if (row <= 1 && column <= 1) {
+    throw new Error(
+      'XLSX freeze_panes row and column name the first row and column that scroll, so this freezes nothing: row:2 keeps the header row (row 1) in view, column:2 keeps column A.'
+    );
+  }
 }
 
 function validateSortRange(operation) {
@@ -322,17 +328,50 @@ function validateConditionalFormat(operation) {
 }
 
 // A chart's source may be several areas joined by commas, the way Excel's
-// Range("A7:A12,D7:D12") reads them; each one is a bounded range.
+// Range("A7:A12,D7:D12") reads them; each one is a bounded range. The source
+// may stand on another sheet ('월별 계산'!A1:A7,'월별 계산'!D1:D7), the way a
+// summary sheet charts the calculation behind it — one sheet for every area.
 function validateRangeOperation(operation, op) {
-  const parts =
-    op === 'add_chart'
-      ? String(operation.range)
-          .split(',')
-          .map((part) => part.trim())
-      : [operation.range];
+  const parts = op === 'add_chart' ? chartSourceAreas(operation.range) : [operation.range];
   const area = parseXlsxRange(parts[0]);
-  for (const part of parts.slice(1)) parseXlsxRange(part);
+  const areas = [area, ...parts.slice(1).map((part) => parseXlsxRange(part))];
   if (op === 'set_range') validateRangeMatrix(operation, area);
+  if (op === 'add_chart') assertChartReadsItsData(operation, areas);
+}
+
+function chartSourceAreas(range) {
+  const areas = sheetQualifiedAreas(range);
+  const named = new Set(areas.map((entry) => entry.sheet.toLowerCase()));
+  if (named.size > 1) {
+    throw new Error(
+      `XLSX add_chart ${range} names ${named.has('') ? 'a sheet on some areas and none on others' : 'more than one sheet'}; a chart reads one sheet, so name it on every area or on none`
+    );
+  }
+  return areas.map((entry) => entry.area);
+}
+
+// A chart read by columns takes its categories down the first column and a series from every other column. Given
+// a row of periods (years across, one measure under them) it drew one category and a series per year — five bars
+// in five colours over a single label, with no legend to say which year is which. That shape is refused with the
+// reading it wanted named, before either backend draws it.
+function assertChartReadsItsData(operation, areas) {
+  if (String(operation.plotBy || '').toLowerCase() === 'rows') {
+    // plotBy:'rows' turns one block a quarter: its first row the categories, its first column the series names.
+    // Given two areas joined by a comma, Excel drew a chart with no series while the portable writer refused them.
+    if (areas.length !== 1 || areas[0].rows < 2 || areas[0].columns < 2) {
+      throw new Error(
+        `XLSX add_chart ${operation.range}: plotBy:'rows' requires one bounded range whose first row holds the categories and whose first column names each series`
+      );
+    }
+    return;
+  }
+  const rows = Math.max(...areas.map((part) => part.rows));
+  const columns = areas.reduce((total, part) => total + part.columns, 0);
+  if (rows === 2 && columns - 1 >= 3) {
+    throw new Error(
+      `XLSX add_chart ${operation.range} reads as ${columns - 1} series of one value each over a single category; a row of periods across the top wants plotBy:'rows' (the first row the categories, each row under it a series)`
+    );
+  }
 }
 
 function validateSpan(op, start, count, { field, limit, unit }) {
@@ -375,6 +414,10 @@ function validateXlsxOperation(operation) {
     validateSpan(op, operation.row, operation.count ?? 1, { field: 'row', limit: XLSX_MAX_ROWS, unit: 'row' });
   }
   if (['insert_columns', 'delete_columns'].includes(op)) {
+    // A letter, as set_column_width and set_column_visibility take it, becomes the number both backends shift by.
+    if (typeof operation.column === 'string' && /^[A-Za-z]{1,3}$/.test(operation.column.trim())) {
+      operation.column = columnNumber(operation.column.trim().toUpperCase());
+    }
     validateSpan(op, operation.column, operation.count ?? 1, {
       field: 'column',
       limit: XLSX_MAX_COLUMNS,