Merge remote-tracking branch 'origin/dev' into sub_laptop_7

# Conflicts:
#	M02_MasterTemplete/M02_MasterTemplete_Api_Fetch.ts
#	M02_MasterTemplete/M02_MasterTemplete_Branch.py

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":

M02_MasterTemplete/M02_MasterTemplete_Api_Fetch.ts

@@ -38,18 +38,21 @@ async function call<T>(path: string, init: RequestInit = {}): Promise<T> {
     ...init,
   });
   const body = (await response.json().catch(() => ({}))) as { detail?: unknown } & T;
-  // 서버 까닭 목록(`{errors: [...]}` — 422 검사 걸림 · 409 쓰는 곳 있어 못 지움)은 글로
-  const errors = (body.detail as { errors?: unknown } | null)?.errors;
-  const said = Array.isArray(errors) ? errors.join(" / ") : "";
-  if (response.status === 409 && !said)
-    throw new StaleError(typeof body.detail === "string" ? body.detail : "409");
-  if (!response.ok) {
-    const detail = body.detail;
-    throw new Error(said || (typeof detail === "string" ? detail : `HTTP ${response.status}`));
-  }
+  if (response.status === 409) throw new StaleError(reason(body.detail, response.status));
+  if (!response.ok) throw new Error(reason(body.detail, response.status));
   return body;
 }
 
+/** 서버가 막은 까닭 그대로 — 문장 · `{errors: [...]}` · 입력 검사 목록(`[{msg}]`) */
+function reason(detail: unknown, status: number): string {
+  if (typeof detail === "string") return detail;
+  const list = Array.isArray(detail) ? detail : (detail as { errors?: unknown } | null)?.errors;
+  const lines = Array.isArray(list)
+    ? list.map((x) => (typeof x === "string" ? x : String((x as { msg?: unknown })?.msg ?? "")))
+    : [];
+  return lines.filter(Boolean).join(" · ") || `HTTP ${status}`;
+}
+
 const enc = encodeURIComponent;
 const q = (projectId: string | null): string => (projectId ? `?project_id=${enc(projectId)}` : "");
 const head = (layer: Layer): string =>

M02_MasterTemplete/M02_MasterTemplete_Branch.py

@@ -3,8 +3,8 @@
   · 일위대가 조합(UA · `일위대가조합.json`) — 새 줄은 M01 조합 저장소가 만듦(부르기만)
   · 자재 조합(UM · 마스터 템플릿 `자재조합.json`) — M02 자재 조합 저장소가 만듦(표 「다음」 번호)
 
-조합은 여러 열 · 모든 프로젝트가 같이 씀 — 제자리 고치지 않음. 담은 것의 집합(차례 · 메모 무시)이
-이미 있는 조합과 같으면 새로 안 만들고 그 키 · 새 줄의 본뜬키 = 원래 키 · 소유 현장.
+조합은 여러 열 · 모든 프로젝트가 같이 씀 — 제자리 고치지 않음. 담은 것(차례 · 메모까지)이
+이미 있는 조합과 같으면 새로 안 만들고 그 키(원래 키 먼저) · 새 줄의 본뜬키 = 원래 키 · 소유 현장.
 """
 
 from __future__ import annotations
@@ -41,14 +41,14 @@ def _branch(
     field: str,
     rows: list[dict],
     slot: str,
-    ident: str,
+    ident: tuple[str, ...],
     items: list[dict],
     source: str,
     make: Callable[[str, list[dict]], dict],
     name: str,
 ) -> dict[str, Any]:
     """집계표 판 검사 → 같은 내용 찾기 · 없으면 `make(이름, 줄들)` 로 새 줄 → 집계표 그 열 `field`.
-    `slot` = 담은 칸(담은로직 · 담은자재) · `ident` = 담은 줄의 알맹이 칸(로직 · 코드)."""
+    `slot` = 담은 칸(담은로직 · 담은자재) · `ident` = 담은 줄에서 견주는 칸(로직 · 메모 / 코드)."""
     table = store.read("table", store.STRUCTURE_TABLE)
     if version and table["판"] != version:
         raise store.StoreError(409, {"stale": [store.STRUCTURE_TABLE], "판": table["판"]})
@@ -58,8 +58,10 @@ def _branch(
     if not isinstance(items, list) or not items:
         raise store.StoreError(400, "담은 것이 비었음")
 
-    def body(got) -> frozenset[str]:
-        return frozenset(str(x.get(ident) or "") for x in got or [] if isinstance(x, dict))
+    def body(got) -> tuple:  # 차례대로 · 빈 메모 = null
+        return tuple(
+            tuple(str(x.get(k) or "") for k in ident) for x in got or [] if isinstance(x, dict)
+        )
 
     same = [r for r in rows if body(r.get(slot)) == body(items)]
     hit = next((r for r in same if source and r.get("키") == source), same[0] if same else None)
@@ -101,7 +103,9 @@ def branch_combo(
 
     name = name.strip() or str(was.get("이름") or source)
     rows = _m01(m01.read, combo_store.FILE)[0].get("줄") or []
-    return _branch(column, version, "일위대가", rows, "담은로직", "로직", items, source, make, name)
+    return _branch(
+        column, version, "일위대가", rows, "담은로직", ("로직", "메모"), items, source, make, name
+    )
 
 
 def material_combo(key: str) -> dict[str, Any]:
@@ -127,4 +131,6 @@ def branch_material_combo(
     default = " ".join(h for h in store._heads(heads) if h) if heads else column
     name = name.strip() or str(was.get("이름") or default or column)
     rows = matset.listing()["줄"]
-    return _branch(column, version, "자재조합", rows, "담은자재", "코드", items, source, make, name)
+    return _branch(
+        column, version, "자재조합", rows, "담은자재", ("코드",), items, source, make, name
+    )

M02_MasterTemplete/M02_MasterTemplete_Combo.ts

@@ -116,8 +116,13 @@ export function askBranch(message: string, defaultName: string): Promise<string
   });
 }
 
-/** 새 조합 이름 자동 — 원래 이름 · 구조물 이름(한쪽이 다른 쪽을 이미 품으면 긴 쪽 하나만) */
-export const branchName = (original: string, label: string): string =>
+/** 새 조합 이름 자동 — 원래 이름(끝 「 (n)」 뗌 · 서버가 새로 붙임) · 구조물 이름(한쪽이 다른 쪽을
+ * 이미 품으면 긴 쪽 하나만) */
+export const branchName = (
+  named: string,
+  label: string,
+  original = named.replace(/ \(\d+\)$/, ""),
+): string =>
   !original || label.includes(original)
     ? label || original
     : !label || original.includes(label)

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])

resources/tester/test_m02_combo_branch.py

@@ -3,7 +3,8 @@
 M02 견본 표(`write_sample_table`) + M01 마스터 사본(조합 줄은 비워 시작)으로만 봄 · 자재 조합 표는
 마스터 템플릿 사본(없이 시작).
   · 일위대가(UA) — 새로 만듦(본뜬키 = 원래 키) · 이 열만 새 키 · 다른 열은 옛 키 · 원래 조합 그대로 ·
-    SS 장부 맞춤 · 담은 로직 집합(차례 · 메모 무시)이 같으면 있는 키 · 또 고치면 또 새로 · 같은 이름 (2)
+    SS 장부 맞춤 · 담은 로직(차례 · 메모까지)이 같으면 있는 키(되돌리면 원래 키) · 차례 · 메모만
+    바꿔도 새로 · 또 고치면 또 새로 · 같은 이름 (2)
   · 자재 조합(UM) — 같은 규칙 · 처음 만드는 열(본뜬키 없음) · 읽기
   · 집계표 판 어긋남 = 409 · 조합 안 만듦
   · 분류 더하기로 복사한 열(`본뜬열`) — [저장] 때 원본 키 · 세 파일 내용을 새 번호로 받음
@@ -74,7 +75,9 @@ def _source(client) -> str:
 
 
 def _branch(client, column, source, keys, name="", 판="", want=200):
-    body = {"본뜬키": source, "담은로직": [{"로직": k} for k in keys], "이름": name, "판": 판}
+    """`keys` = 로직 키 또는 (로직, 메모)"""
+    lines = [{"로직": k[0], "메모": k[1]} if isinstance(k, tuple) else {"로직": k} for k in keys]
+    body = {"본뜬키": source, "담은로직": lines, "이름": name, "판": 판}
     res = client.post(f"/api/m02/structures/{column}/combo", json=body)
     assert res.status_code == want, res.text
     return res.json()
@@ -118,17 +121,27 @@ def test_새로_만듦_이_열만_새_키_원래_조합_그대로(client):
     assert combo_store.combo(got["키"])["combo"]["본뜬키"] == ua
 
 
-def test_같은_로직_집합이면_있는_키_또_고치면_또_새로_같은_이름은_2(client):
+def test_차례_메모까지_같으면_있는_키_또_고치면_또_새로_같은_이름은_2(client):
     ua = _source(client)
-    same = _branch(client, "c1", ua, [B, A])  # 차례만 바꿈 = 원래 조합
+    same = _branch(client, "c1", ua, [(A, ""), (B, None)])  # 빈 메모 = null → 원래 조합
     assert (same["키"], same["새로만듦"]) == (ua, False)
+    order = _branch(client, "c1", ua, [B, A])  # 차례만 바꿈 = 새로
+    assert order["새로만듦"] is True and order["키"] != ua
+    got = combo_store.combo(order["키"])["combo"]
+    assert ([x["로직"] for x in got["담은로직"]], got["본뜬키"]) == ([B, A], ua)
+    memo = _branch(client, "c1", order["키"], [B, (A, "사면 쪽")])  # 메모만 바꿈 = 또 새로
+    assert memo["새로만듦"] is True and memo["키"] not in (ua, order["키"])
+    assert combo_store.combo(memo["키"])["combo"]["담은로직"][1]["메모"] == "사면 쪽"
+    back = _branch(client, "c1", memo["키"], [A, B])  # 원래와 똑같이 되돌림 = 원래 키
+    assert (back["키"], back["새로만듦"]) == (ua, False)
+    assert _cols(client)["c1"] == ua and _ss(client)["c1"] == ua
     first = _branch(client, "rv", ua, [A, B, C], "갈래")
     again = _branch(client, "rv", first["키"], [A, C], "갈래")  # 갈라 낸 것을 또 고침 = 또 새로
     assert again["새로만듦"] is True and again["키"] not in (ua, first["키"])
     assert again["이름"] == "갈래 (2)"
     assert combo_store.combo(again["키"])["combo"]["본뜬키"] == first["키"]
-    back = _branch(client, "c1", ua, [C, A, B])  # 다른 열이 같게 고침 = 있는 키
-    assert (back["키"], back["새로만듦"]) == (first["키"], False)
+    twin = _branch(client, "c1", ua, [A, B, C])  # 다른 열이 똑같이 고침 = 있는 키
+    assert (twin["키"], twin["새로만듦"]) == (first["키"], False)
     assert _cols(client)["c1"] == first["키"] and _ss(client)["c1"] == first["키"]
 
 
@@ -156,8 +169,10 @@ def test_자재_조합_처음_만듦_같은_내용이면_있는_키_고치면_
     row = client.get(f"/api/m02/material-combos/{first['키']}").json()
     assert tuple(row) == ("키", "이름", "담은자재", "본뜬키", "소유", "비고")
     assert (row["본뜬키"], row["소유"], row["담은자재"]) == (None, "현장", [M1, M2])
-    same = _material(client, "c1", "", [M2, M1])  # 차례만 다름 = 있는 키
+    same = _material(client, "c1", "", [M1, M2])  # 같은 차례 = 있는 키
     assert (same["키"], same["새로만듦"]) == (first["키"], False)
+    order = _material(client, "c1", first["키"], [M2, M1], "모래 먼저")  # 차례만 다름 = 새로
+    assert order["새로만듦"] is True and order["키"] != first["키"]
     fork = _material(client, "c1", first["키"], [M1], "시멘트만")
     assert fork["새로만듦"] is True and fork["키"] != first["키"]
     assert client.get(f"/api/m02/material-combos/{fork['키']}").json()["본뜬키"] == first["키"]