fix(spreadsheet): 칸 다루기 전수 점검 흠 11 고침 — 고름 테두리 · 채우기 손잡이 · 틀고정 빈 띠 · 입력 형식 · 잘라 붙이기 옮김

- 격자: 고름을 옮겨도 옛 활성 칸 파란 테두리가 남던 것 · 채우기 손잡이가 범위 오른아래가 아니라
  활성 칸 모서리에 있던 것(여러 범위 · 읽기 전용 카드에서는 손잡이 없음) · 틀 고정 뒤 본문 판
  아래 · 오른 끝(틀 고정 크기만큼)이 안 그려져 비던 것(보이는 행열을 틀 고정만큼 밀어 잼) ·
  오류 칸 글자색을 테마 토큰으로(어두운 테마 대비 2.7 → 5.0)
- 입력: `50%` → 0% 형식 · `1,234.5` → #,##0.0 형식을 함께 붙임(엑셀 · 되돌리기 한 번) · 식의
  함수 · 참조 · 참거짓을 대문자로 · 닫는 괄호만 모자라면 채움 · 「식이 덜 끝남」 알림 글
- 클립보드: 잘라낸 칸을 같은 문서에 처음 붙이면 `옮기기` 로 — 그 칸을 가리키던 식도 따라감
  (전에는 식이 0 · 빈 칸을 가리킴) · 그 사이 잘라낸 자리에 새로 쓰면 보통 붙여넣기
- 시험: test_spreadsheet_saved_values.py(면적 · 재료 저장본 102 권 서버 재계산 = 저장 계산값) ·
  d_input 에 형식 · 대문자 · 괄호 규칙 · ORCA M02 면적산출 편집 창 목록 38 항목 재실행 통과

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BYN9gMie8e6pXzSxJNb6Xt

A00_Common/spreadsheet/spreadsheet_clipboard.ts

@@ -3,10 +3,9 @@
  * 복사 · 잘라내기 · 붙여넣기 — `copy` · `cut` · `paste` 사건만(허락 창 없음 · navigator.clipboard 안 씀).
  * 형 · 수식 살리기 규칙은 `spreadsheet_types.ts` `ClipBlock` 머리. 잘라내기 = 복사 + `내용지움`(누른 순간
  * 바로 지움) · 붙여넣기 = `칸` 명령(식은 A `moveFormula` · 구글 R1C1 은 `r1c1ToA1`) + 서식 · 병합 명령
- * 묶음(칸 하나하나). ⚠ 잘라내기는 OS 클립보드를 거치는 비동기 사건(다른 창 · 다른 앱에 붙일 수 있음)이라
- * `옮기기` 명령(같은 문서 안에서 그 칸을 가리키던 다른 식도 따라감) 은 못 씀 — 잘라낸 칸을 가리키던
- * 다른 칸의 식은 안 따라옴(엑셀의 「점선 테두리 유지 · 붙일 때만 지움」 도 아님). 편집 중
- * (`ctx.editor.editing()`)이면 사건을 편집기에 맡김.
+ * 묶음(칸 하나하나). 잘라낸 것을 같은 문서에 처음 붙이면(클립보드 HTML 의 `aislo-cut` 표 · 그 사이 잘라낸
+ * 자리에 새로 안 씀) 지운 칸을 되살려 `옮기기` 명령으로 — 그 칸을 가리키던 다른 식도 따라감(엑셀).
+ * 다른 앱 · 두 번째 붙여넣기는 보통 붙여넣기. 편집 중(`ctx.editor.editing()`)이면 사건을 편집기에 맡김.
  *
  * 이음(D `spreadsheet.ts` 잇는 자리) — `attachClipboard(ctx)` 한 번 부름(반환 `root` 없음 · 안 붙여도 됨).
  * `ctx.root` 의 copy/cut/paste 사건을 직접 받으므로 그 요소가 포커스를 받을 수 있어야 함
@@ -14,7 +13,7 @@
  * ========================================================================== */
 
 import { showToast } from "@ui/ui_template_elements";
-import { colName, parseRange, toA1 } from "./spreadsheet_address";
+import { colName, parseA1, parseRange, toA1 } from "./spreadsheet_address";
 import { formatValue } from "./spreadsheet_numfmt";
 import { moveFormula, r1c1ToA1 } from "./spreadsheet_refshift";
 import { st } from "./spreadsheet_text";
@@ -514,23 +513,79 @@ function pasteBlock(ctx: SpreadsheetContext, block: ClipBlock, at: CellAddress):
   ctx.dispatch(commands.length === 1 ? commands[0] : { 종류: "묶음", 명령: commands });
 }
 
+/** A1 칸이 범위 안인가 */
+function inside(rg: CellRange, a1: string): boolean {
+  const p = parseA1(a1);
+  return !!p && p.r >= rg.r0 && p.r <= rg.r1 && p.c >= rg.c0 && p.c <= rg.c1;
+}
+
+interface PendingCut {
+  token: string;
+  sheet: string;
+  range: CellRange;
+  /** 지우기 전 칸 — 같은 문서에 붙일 때 되살려 `옮기기` 로 넘김 */
+  cells: Record<string, Cell>;
+}
+
+/** 병합을 가르는지(통째로 든 병합은 됨) — `옮기기` 명령과 같은 규칙 */
+function cutsMerge(sheet: Sheet, rg: CellRange): boolean {
+  return (sheet.병합 ?? [])
+    .map((m) => parseRange(m))
+    .some((m) => !!m && rangesOverlap(m, rg) && !rangeContains(rg, m));
+}
+
 /** `ctx.root` 의 copy · cut · paste 를 받음(root null) */
 export function attachClipboard(ctx: SpreadsheetContext): PartHandle {
-  function onCopy(ev: ClipboardEvent): void {
-    if (ctx.editor.editing()) return;
+  /** 마지막 잘라내기 — 같은 문서에 붙이면 칸을 옮김(그 칸을 가리키던 식도 따라감 · 엑셀) */
+  let cut: PendingCut | null = null;
+
+  function write(ev: ClipboardEvent, prefix = ""): void {
     const range = activeRange(ctx);
     const { html, text } = blockToClipboard(ctx.book, ctx.selection.시트, range, (r, c) =>
       ctx.engine.value(ctx.selection.시트, r, c),
     );
-    ev.clipboardData?.setData("text/html", html);
+    ev.clipboardData?.setData("text/html", prefix + html);
     ev.clipboardData?.setData("text/plain", text);
     ev.preventDefault();
   }
 
+  function onCopy(ev: ClipboardEvent): void {
+    if (ctx.editor.editing()) return;
+    cut = null;
+    write(ev);
+  }
+
   function onCut(ev: ClipboardEvent): void {
     if (ctx.editor.editing() || ctx.readOnly) return;
-    onCopy(ev);
-    ctx.dispatch({ 종류: "내용지움", 시트: ctx.selection.시트, 범위: [activeRange(ctx)] });
+    const range = activeRange(ctx);
+    const sheet = ctx.sheet();
+    const cells: Record<string, Cell> = {};
+    for (const [a1, cell] of Object.entries(sheet.칸))
+      if (inside(range, a1)) cells[a1] = structuredClone(cell);
+    const token = Math.random().toString(36).slice(2);
+    write(ev, `<!--aislo-cut:${token}-->`);
+    cut = { token, sheet: sheet.id, range, cells };
+    ctx.dispatch({ 종류: "내용지움", 시트: sheet.id, 범위: [range] });
+  }
+
+  /** 잘라낸 칸을 같은 문서 안으로 — 되살린 뒤 `옮기기`(한 번에 되돌림) · 못 하면 false(보통 붙여넣기) */
+  function pasteCut(pending: PendingCut, at: CellAddress): boolean {
+    const src = ctx.book.시트.find((s) => s.id === pending.sheet);
+    if (!src) return false;
+    const { r0, c0, r1, c1 } = pending.range;
+    for (const [a1, cell] of Object.entries(src.칸))
+      if (inside(pending.range, a1) && (cell.값 !== undefined || cell.식 !== undefined))
+        return false; // 잘라낸 뒤 그 자리에 새로 씀
+    const dst = { r0: at.r, c0: at.c, r1: at.r + r1 - r0, c1: at.c + c1 - c0 };
+    if (cutsMerge(src, pending.range) || cutsMerge(ctx.sheet(), dst)) return false;
+    ctx.dispatch({
+      종류: "묶음",
+      명령: [
+        { 종류: "칸", 시트: src.id, 칸: pending.cells },
+        { 종류: "옮기기", 시트: src.id, 범위: pending.range, 대상시트: ctx.selection.시트, ...at },
+      ],
+    });
+    return true;
   }
 
   function onPaste(ev: ClipboardEvent): void {
@@ -538,6 +593,11 @@ export function attachClipboard(ctx: SpreadsheetContext): PartHandle {
     const html = ev.clipboardData?.getData("text/html") ?? "";
     const text = ev.clipboardData?.getData("text/plain") ?? "";
     const at = ctx.selection.활성;
+    const pending = cut;
+    if (pending && html.includes(`<!--aislo-cut:${pending.token}-->`)) {
+      cut = null; // 엑셀처럼 한 번만 옮김 — 다음부터는 보통 붙여넣기
+      if (pasteCut(pending, at)) return void ev.preventDefault();
+    }
     const block = parseClipboard(html, text, at);
     if (!block) {
       showToast(st("ClipboardPasteFailed"), "error");

A00_Common/spreadsheet/spreadsheet_editor.ts

@@ -15,7 +15,8 @@ import type { FuncHelp } from "./spreadsheet_func_help";
 import { parseFormula, tokenize } from "./spreadsheet_parser";
 import { cellsOf, move, selectCell } from "./spreadsheet_selection";
 import { checkValue, findValidation } from "./spreadsheet_validation";
-import type { Cell, CellAddress, CellStyle, Sheet } from "./spreadsheet_types";
+import { cellStyleAt } from "./spreadsheet_cellstyle";
+import type { Cell, CellAddress, CellStyle, Command, Sheet } from "./spreadsheet_types";
 import type {
   CellBox,
   EditorHandle,
@@ -89,6 +90,39 @@ export function textToCell(text: string, old?: Cell): Cell | null {
   return { ...base, 값: text };
 }
 
+/** 친 모양대로 숫자 형식(엑셀) — `50%` → `0%` · `12.5%` → `0.0%` · `1,234.5` → `#,##0.0` · 아니면 null */
+export function typedFormat(text: string): string | null {
+  const t = text.trim();
+  if (parseNumber(t) === null || /e/i.test(t)) return null;
+  const dec = /\.(\d+)/.exec(t)?.[1].length ?? 0;
+  const frac = dec ? "." + "0".repeat(dec) : "";
+  if (t.endsWith("%")) return `0${frac}%`;
+  if (t.includes(",")) return `#,##0${frac}`;
+  return null;
+}
+
+/** 식 글(앞 `=` 뺌) — 함수 · 참조 · 참거짓을 대문자로(엑셀) · 시트 이름 · 글 · 정의된 이름은 그대로 */
+export function upperFormula(body: string): string {
+  return tokenize(body)
+    .map((t) => {
+      if (t.kind === "func" || t.kind === "bool") return t.text.toUpperCase();
+      if (t.kind !== "ref") return t.text;
+      const bang = t.text.lastIndexOf("!") + 1;
+      return t.text.slice(0, bang) + t.text.slice(bang).toUpperCase();
+    })
+    .join("");
+}
+
+/** 닫는 괄호만 모자란 식이면 채운 식(엑셀 자동 고침) · 아니면 null */
+export function closeParens(value: string): string | null {
+  let depth = 0;
+  for (const t of tokenize(value.slice(1)))
+    if (t.kind === "paren") depth += t.text === "(" ? 1 : -1;
+  if (depth <= 0) return null;
+  const fixed = value + ")".repeat(depth);
+  return parseFormula(fixed).ok ? fixed : null;
+}
+
 /** 칸 → 편집 글(식은 `=` 붙임 · 수처럼 읽힐 글은 `'` 붙임) */
 export function cellToText(cell: Cell | undefined): string {
   if (!cell) return "";
@@ -360,7 +394,10 @@ export function createEditor(ctx: SpreadsheetContext): Editor {
   /** 칸에 적음 — 식이 틀렸거나(인자 수 등) 유효성(sub4) 「막음」 을 어기면 안 적고 false(편집 그대로 · 엑셀처럼 다시 치게) */
   function write(cells: CellAddress[], value: string, from: CellAddress): boolean {
     if (!st) return true;
-    const parsed = value.length > 1 && value[0] === "=" ? parseFormula(value) : null;
+    const isFormula = value.length > 1 && value[0] === "=";
+    if (isFormula && !parseFormula(value).ok) value = closeParens(value) ?? value;
+    const parsed = isFormula ? parseFormula(value) : null;
+    if (parsed?.ok) value = "=" + upperFormula(value.slice(1));
     if (parsed && !parsed.ok) {
       showToast(parsed.message, "error");
       const node = src();
@@ -389,7 +426,33 @@ export function createEditor(ctx: SpreadsheetContext): Editor {
       out[key] = next;
     }
     for (const m of warn) showToast(m, "warning");
-    if (Object.keys(out).length) ctx.dispatch({ 종류: "칸", 시트: sheet.id, 칸: out });
+    if (!Object.keys(out).length) return true;
+    const cellCmd: Command = { 종류: "칸", 시트: sheet.id, 칸: out };
+    const fmt = isFormula ? null : typedFormat(value);
+    // `%` 는 글 형식(`@`) · 이미 % 형식만 빼고 바꿈 · 천 단위 쉼표는 일반 형식일 때만(엑셀)
+    const takes = (code?: string): boolean =>
+      !code ||
+      /^(general|g\/표준)$/i.test(code) ||
+      (fmt!.endsWith("%") && !code.includes("%") && code.trim() !== "@");
+    const fmtAt = fmt
+      ? cells.filter((a) => takes(cellStyleAt(ctx.book, sheet, a.r, a.c).형식))
+      : [];
+    ctx.dispatch(
+      fmtAt.length
+        ? {
+            종류: "묶음",
+            명령: [
+              cellCmd,
+              {
+                종류: "서식",
+                시트: sheet.id,
+                범위: fmtAt.map((a) => ({ r0: a.r, c0: a.c, r1: a.r, c1: a.c })),
+                바꿀: { 형식: fmt! },
+              },
+            ],
+          }
+        : cellCmd,
+    );
     return true;
   }
 

A00_Common/spreadsheet/spreadsheet_grid.css

@@ -185,7 +185,7 @@
 }
 
 .aislo-cell.is-error {
-  color: #c00;
+  color: var(--color-danger, #c00);
 }
 
 /* 오류 칸 — 엑셀 오류 검사 초록 세모(왼 위 · sub3 오류 까닭은 title 풍선). */

A00_Common/spreadsheet/spreadsheet_grid.ts

@@ -652,16 +652,19 @@ export function createGrid(ctx: SpreadsheetContext): GridHandle {
     const scrollW = Math.max(0, w - headColW() - frozenW);
     const scrollH = Math.max(0, h - headRowH() - frozenH);
     const frozenColsVisible = visibleIndices(colGeo, 0, frozenCols - 1);
-    const scrollColFrom = Math.max(frozenCols, colGeo.indexAt(paneBR.scrollLeft));
-    const scrollColTo = Math.min(extent.cols - 1, colGeo.indexAt(paneBR.scrollLeft + scrollW) + 1);
+    // 본문 판 스크롤 0 = 틀고정 바로 다음 칸(`offset(frozen)`) — 그만큼 더해 재야 오른 · 아래 끝이 안 빔.
+    const left = paneBR.scrollLeft + frozenW;
+    const top = paneBR.scrollTop + frozenH;
+    const scrollColFrom = Math.max(frozenCols, colGeo.indexAt(left));
+    const scrollColTo = Math.min(extent.cols - 1, colGeo.indexAt(left + scrollW) + 1);
     const scrollColsVisible = visibleIndices(
       colGeo,
       scrollColFrom,
       Math.max(scrollColFrom, scrollColTo),
     );
     const frozenRowsVisible = visibleIndices(rowGeo, 0, frozenRows - 1);
-    const scrollRowFrom = Math.max(frozenRows, rowGeo.indexAt(paneBR.scrollTop));
-    const scrollRowTo = Math.min(extent.rows - 1, rowGeo.indexAt(paneBR.scrollTop + scrollH) + 1);
+    const scrollRowFrom = Math.max(frozenRows, rowGeo.indexAt(top));
+    const scrollRowTo = Math.min(extent.rows - 1, rowGeo.indexAt(top + scrollH) + 1);
     const scrollRowsVisible = visibleIndices(
       rowGeo,
       scrollRowFrom,
@@ -821,14 +824,32 @@ export function createGrid(ctx: SpreadsheetContext): GridHandle {
       node.style.borderWidth = i === 0 ? "2px" : "1px";
       selLayer!.append(node);
     }
-    const active = overlayBoxOf(sel.활성.r, sel.활성.c);
+    // 활성 칸 테두리 — 칸 다시 그리기(`renderRowOfCells`) 없이 고름만 바뀌어도 옛 칸에 남지 않게.
+    const activeKey = `${sel.활성.r},${sel.활성.c}`;
+    const anchor = merges.get(activeKey);
+    const activeAddr = toA1(anchor?.r0 ?? sel.활성.r, anchor?.c0 ?? sel.활성.c);
+    for (const el of root.querySelectorAll<HTMLElement>(".aislo-cell.is-selected"))
+      if (el.dataset.addr !== activeAddr) el.classList.remove("is-selected");
+    for (const el of root.querySelectorAll<HTMLElement>(`.aislo-cell[data-addr="${activeAddr}"]`))
+      el.classList.add("is-selected");
+    const handleAt = fillHandleCell();
+    if (!handleAt) return;
+    const corner = overlayBoxOf(handleAt.r, handleAt.c);
     const handle = document.createElement("div");
     handle.className = "aislo-grid__fill-handle";
-    handle.style.left = `${active.x + active.w - 4}px`;
-    handle.style.top = `${active.y + active.h - 4}px`;
+    handle.style.left = `${corner.x + corner.w - 4}px`;
+    handle.style.top = `${corner.y + corner.h - 4}px`;
     selLayer!.append(handle);
   }
 
+  /** 채우기 손잡이 자리 — 고른 범위 오른아래 칸(엑셀) · 범위가 여럿이거나 읽기 전용이면 없음. */
+  function fillHandleCell(): { r: number; c: number } | null {
+    const sel = ctx.selection;
+    if (ctx.readOnly || !sel || sel.범위.length !== 1) return null;
+    const g = sel.범위[0];
+    return { r: g.r1, c: g.c1 };
+  }
+
   function setRefHighlights(list: RefHighlight[]): void {
     let refLayer = overlay.querySelector<HTMLElement>(".aislo-grid__ref-layer");
     if (!refLayer) {
@@ -883,12 +904,11 @@ export function createGrid(ctx: SpreadsheetContext): GridHandle {
     const c = colGeo.indexAt(contentX);
     const r = rowGeo.indexAt(contentY);
     const sel = ctx.selection;
-    if (sel && sel.시트 === ctx.sheet().id) {
-      const active = boxOf(sel.활성.r, sel.활성.c);
-      const screen = screenBoxOf(sel.활성.r, sel.활성.c);
-      void active;
+    const handleAt = sel && sel.시트 === ctx.sheet().id ? fillHandleCell() : null;
+    if (handleAt) {
+      const screen = screenBoxOf(handleAt.r, handleAt.c);
       if (Math.abs(x - (screen.x + screen.w)) <= 5 && Math.abs(y - (screen.y + screen.h)) <= 5) {
-        return { kind: "fillHandle", r: sel.활성.r, c: sel.활성.c };
+        return { kind: "fillHandle", r: handleAt.r, c: handleAt.c };
       }
     }
     return { kind: "cell", r, c };
@@ -917,11 +937,13 @@ export function createGrid(ctx: SpreadsheetContext): GridHandle {
   function visibleRange(): CellRange {
     const scrollW = Math.max(0, root.clientWidth - headColW() - frozenW);
     const scrollH = Math.max(0, root.clientHeight - headRowH() - frozenH);
+    const left = paneBR.scrollLeft + frozenW;
+    const top = paneBR.scrollTop + frozenH;
     return {
-      r0: rowGeo.indexAt(paneBR.scrollTop),
-      c0: colGeo.indexAt(paneBR.scrollLeft),
-      r1: Math.min(extent.rows - 1, rowGeo.indexAt(paneBR.scrollTop + scrollH)),
-      c1: Math.min(extent.cols - 1, colGeo.indexAt(paneBR.scrollLeft + scrollW)),
+      r0: rowGeo.indexAt(top),
+      c0: colGeo.indexAt(left),
+      r1: Math.min(extent.rows - 1, rowGeo.indexAt(top + scrollH)),
+      c1: Math.min(extent.cols - 1, colGeo.indexAt(left + scrollW)),
     };
   }
 

A00_Common/spreadsheet/spreadsheet_parser.ts

@@ -184,7 +184,7 @@ export function parseFormula(formula: string): ParseResult {
   };
   const primary = (): FormulaNode => {
     const t = peek();
-    if (!t) throw new Fail("식이 끝남", text.length);
+    if (!t) throw new Fail("식이 덜 끝남", text.length);
     p++;
     switch (t.kind) {
       case "number":

resources/tester/spreadsheet/helper_spreadsheet_d.cjs

@@ -69,6 +69,12 @@ const out = {
     (t) => ed.textToCell(t, { 서식: 4 }),
   ),
   textToCellNoStyle: ed.textToCell("", {}),
+  // 친 모양대로 숫자 형식 · 식 대문자 · 닫는 괄호 채움(엑셀)
+  typedFormat: ["50%", "12.5%", "1,234.5", "1,000", "7", "abc", "1e3%"].map(ed.typedFormat),
+  upperFormula: ["sum(a1:b2)+round(c3,0)", "'시트 a'!a1*true", '"abc"&a1', "내이름*2"].map(
+    ed.upperFormula,
+  ),
+  closeParens: ["=(1+2", "=SUM(1,ROUND(2,0", "=1+", "=(1+2)", '=")"&(1'].map(ed.closeParens),
   cellToText: [
     { 값: "=12" },
     { 값: "12" },

resources/tester/spreadsheet/test_spreadsheet_d_input.py

@@ -111,3 +111,20 @@ def test_abs_cycle_and_fold(r):
 def test_links_follow_rows_cols(r):
     # 행 넣기 → 밀림 · 연결 칸 열 지움 → 빠짐 · 되돌리기 → 제자리
     assert r["links"] == ["L:B7,W:D5", "L:B7", "L:B7,W:D5", "L:B5,W:D3", "D1"]
+
+
+def test_typed_format(r):
+    assert r["typedFormat"] == ["0%", "0.0%", "#,##0.0", "#,##0", None, None, None]
+
+
+def test_upper_formula(r):
+    assert r["upperFormula"] == [
+        "SUM(A1:B2)+ROUND(C3,0)",
+        "'시트 a'!A1*TRUE",
+        '"abc"&A1',
+        "내이름*2",
+    ]
+
+
+def test_close_parens(r):
+    assert r["closeParens"] == ["=(1+2)", "=SUM(1,ROUND(2,0))", None, None, '=")"&(1)']

resources/tester/spreadsheet/test_spreadsheet_saved_values.py

@@ -0,0 +1,50 @@
+"""저장 뒤 식 · 값 유지 — M02 면적산출 · 재료산출 저장본을 서버 엔진으로 다시 풀면 저장된 `계산값` 과 같음.
+
+읽기만 함(저장본을 고치지 않음). 저장 때 서버가 적은 값과 지금 엔진 풀이가 어긋나면 화면을 다시 열 때
+값이 달라 보임.
+"""
+
+import json
+import shutil
+from pathlib import Path
+
+import pytest
+
+from common_util import common_util_spreadsheet as spreadsheet
+
+ROOT = Path(__file__).resolve().parents[3]
+FOLDER = ROOT / "resources" / "master_template"
+
+pytestmark = pytest.mark.skipif(shutil.which("node") is None, reason="node 가 없음")
+
+
+def _books() -> list[tuple[str, dict]]:
+    out = []
+    for kind in ("area", "material"):
+        for path in sorted((FOLDER / kind).glob("[!.]*.json")):
+            book = json.loads(path.read_text(encoding="utf-8"))
+            if isinstance(book, dict) and book.get("시트"):
+                out.append((f"{kind}/{path.stem}", book))
+    return out
+
+
+def test_저장본_서버_재계산_같음():
+    books = _books()
+    assert any("계산값" in b for _, b in books), "계산값 있는 저장본이 없음"
+    fresh = spreadsheet.recalc_workbooks([b for _, b in books])
+    diffs = []
+    for (name, book), values in zip(books, fresh):
+        if "계산값" not in book:
+            continue  # 옛 저장본 — 풀리기만 하면 됨
+        saved = book["계산값"]
+        for sheet, cells in values.items():
+            for addr, v in cells.items():
+                if saved.get(sheet, {}).get(addr) != v:
+                    diffs.append(
+                        f"{name} {sheet}!{addr}: 저장 {saved.get(sheet, {}).get(addr)} · 지금 {v}"
+                    )
+        for sheet, cells in saved.items():
+            for addr in cells:
+                if addr not in values.get(sheet, {}):
+                    diffs.append(f"{name} {sheet}!{addr}: 저장에만 있음")
+    assert not diffs, "\n".join(diffs[:30])