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

# Conflicts: # A00_Common/spreadsheet/spreadsheet_grid.ts # A00_Common/spreadsheet/spreadsheet_links.ts
2026-09-28 22:59:00 +09:00
parent 7389335ca9 9a3645bcaa
commit 85e7e7eaf7
63 changed files with 1547 additions and 1012 deletions
@@ -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");
@@ -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;
  }

@@ -73,6 +73,7 @@

 .ss-fmtdlg__row select,
 .ss-fmtdlg__row input[type="text"],
+.ss-fmtdlg__row input:not([type]),
 .ss-fmtdlg__row input[type="number"],
 .ss-fmtdlg__code {
  height: 28px;
@@ -185,7 +185,7 @@
 }

 .aislo-cell.is-error {
-  color: #c00;
+  color: var(--color-danger, #c00);
 }

 /* 오류 칸 — 엑셀 오류 검사 초록 세모(왼 위 · sub3 오류 까닭은 title 풍선). */
@@ -248,3 +248,18 @@
 .aislo-grid__overlay > * {
  pointer-events: auto;
 }
+
+/* 긴 글 넘침(`spreadsheet_spill.ts`) — 옆 빈 칸 위로 글을 폄 · 덮은 칸 사이 눈금선은 감춤(엑셀) ·
+ * 고치는 중에는 활성 칸 넘침을 감춤(편집기와 안 겹치게). */
+.aislo-cell.is-spill {
+  overflow: visible;
+  z-index: 1;
+}
+
+.aislo-grid--gridlines .aislo-cell.is-spill-r {
+  border-right-color: transparent;
+}
+
+.ss--editing .aislo-cell.is-selected.is-spill > .aislo-cell__text {
+  visibility: hidden;
+}
@@ -37,6 +37,7 @@ import {
 } from "./spreadsheet_headers";
 import { resolveCondFmtStyle, type CondFmtValue } from "./spreadsheet_condfmt";
 import { formatValue } from "./spreadsheet_numfmt";
+import { spillOf, type SpillAlign, type SpillSlot } from "./spreadsheet_spill";
 import { MAX_COLS, MAX_ROWS } from "./spreadsheet_types";
 import type {
  CellRange,
@@ -139,6 +140,19 @@ function buildMergeMap(sheet: Sheet): Map<string, CellRange> {
 let measureRuler: CanvasRenderingContext2D | null = null;

 /** 글 너비(px) — 칸 재기용(수가 칸 폭보다 길면 `#####`). */
+const SPILL_ALIGN: Partial<Record<HAlign, SpillAlign>> = {
+  general: "left",
+  left: "left",
+  right: "right",
+  center: "center",
+};
+
+function resetSpill(cell: HTMLElement): void {
+  cell.classList.remove("is-spill", "is-spill-r");
+  const t = cell.firstElementChild as HTMLElement | null;
+  if (t) t.style.width = t.style.marginLeft = t.style.clipPath = "";
+}
+
 function measureText(text: string, font: string): number {
  measureRuler ??= document.createElement("canvas").getContext("2d");
  if (!measureRuler) return text.length * 7;
@@ -417,6 +431,16 @@ export function createGrid(ctx: SpreadsheetContext): GridHandle {
    const sheet = ctx.sheet();
    const book = ctx.book;
    const keep = new Set<string>();
+    // 긴 글 넘침 — 줄마다 칸 자리를 모았다가 판을 다 그린 뒤 폄(옆 칸이 빈지 알아야 해서)
+    const slots = new Map<number, Map<number, SpillSlot>>();
+    const longs: {
+      r: number;
+      c: number;
+      el: HTMLElement;
+      own: number;
+      need: number;
+      align: SpillAlign;
+    }[] = [];
    for (const r of rowsVisible) {
      for (const c of colsVisible) {
        const merge = merges.get(`${r},${c}`);
@@ -475,6 +499,16 @@ export function createGrid(ctx: SpreadsheetContext): GridHandle {
          }
        }
        setCellText(cellEl, text, display.title || comment || undefined);
+        resetSpill(cellEl);
+        if (!merge) {
+          (slots.get(r0) ?? slots.set(r0, new Map()).get(r0)!).set(c0, { w, empty: text === "" });
+          const align = SPILL_ALIGN[display.hAlign];
+          if (align && text && !display.isNumeric && !display.isError && !style.줄바꿈) {
+            // 캔버스 폭은 거르기만(글꼴 대체로 조금 어긋남) — 정확한 폭은 아래서 글 요소 scrollWidth 로
+            const need = measureText(text, cellFont(style, book, zoom)) + 4;
+            if (need > w * 0.9) longs.push({ r: r0, c: c0, el: cellEl, own: w, need, align });
+          }
+        }
        cellEl.classList.toggle("is-error", display.isError);
        cellEl.classList.toggle("has-comment", !!comment);
        cellEl.classList.toggle(
@@ -483,6 +517,20 @@ export function createGrid(ctx: SpreadsheetContext): GridHandle {
        );
      }
    }
+    // 글 폭 + 칸 안 여백(양쪽 2px) · 오른 선 1px — 읽기를 먼저 몰아 한 번만 배치 계산
+    for (const l of longs) l.need = (l.el.firstElementChild as HTMLElement).scrollWidth + 5;
+    for (const l of longs) {
+      const sp = spillOf(slots.get(l.r)!, l.c, l.own, l.need, l.align);
+      if (!sp) continue;
+      l.el.classList.add("is-spill");
+      const t = l.el.firstElementChild as HTMLElement;
+      t.style.width = `calc(100% + ${sp.left + sp.right}px)`;
+      t.style.marginLeft = `${-sp.left}px`;
+      if (sp.clipLeft || sp.clipRight)
+        t.style.clipPath = `inset(0 ${sp.clipRight}px 0 ${sp.clipLeft}px)`;
+      for (let k = sp.from; k < sp.to; k++)
+        pool.used.get(`${l.r},${k}`)?.classList.add("is-spill-r");
+    }
    poolSweep(pool, keep);
  }

@@ -652,9 +700,9 @@ 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);
-    // 본문 판의 스크롤 0 = 틀고정 경계(frozenW · frozenH) — 시트 자리로 바꿔 재야 아래 · 오른쪽 끝까지 그림
-    const left = frozenW + paneBR.scrollLeft;
-    const top = frozenH + paneBR.scrollTop;
+    // 본문 판 스크롤 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(
@@ -824,14 +872,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) {
@@ -886,12 +952,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 };
@@ -923,11 +988,11 @@ 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 top = frozenH + paneBR.scrollTop;
-    const left = frozenW + paneBR.scrollLeft;
+    const left = paneBR.scrollLeft + frozenW;
+    const top = paneBR.scrollTop + frozenH;
    return {
-      r0: Math.max(frozenRows, rowGeo.indexAt(top)),
-      c0: Math.max(frozenCols, colGeo.indexAt(left)),
+      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)),
    };
@@ -209,7 +209,7 @@ export function mountLinks(
      e.preventDefault();
      const inList = opts?.모드 === "자재" && items.some((i) => i.키 === item.키);
      if (ctx.readOnly || !(hit || inList)) return;
-      const o = ctx.root.getBoundingClientRect(); // 메뉴는 부품 뿌리 기준 자리
+      const o = ctx.root.getBoundingClientRect(); // 메뉴는 부품 안 절대 위치 — 누른 자리에 뜨게
      menu.open(e.clientX - o.left, e.clientY - o.top, [
        ...(hit ? [[TEXT.unlink, () => (unlink(), back())] as [string, () => void]] : []),
        ...(inList
@@ -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":
@@ -0,0 +1,61 @@
+/* =============================================================================
+ * spreadsheet_spill.ts
+ * 긴 글 넘침(엑셀) — 칸보다 긴 글을 옆 빈 칸 위로 보임. 왼쪽 · 일반 맞춤은 오른쪽으로 · 오른쪽 맞춤은
+ * 왼쪽으로 · 가운데는 양쪽으로. 비지 않은 칸 · 병합 칸 · 판 끝(틀 고정 경계 · 그린 범위 밖)에서 멈춤.
+ * 격자(`spreadsheet_grid.ts`)가 판 하나를 그릴 때 줄마다 칸 자리(`slots`)를 모아 부름 — 계산만 여기.
+ * ========================================================================== */
+
+/** 같은 판 · 같은 줄 · 병합 아닌 칸 하나(병합 칸 · 안 그린 칸은 넣지 않음 → 거기서 멈춤) */
+export interface SpillSlot {
+  w: number;
+  empty: boolean;
+}
+
+/** 넘침 — 왼 · 오른쪽으로 더 쓸 폭(px) · 덮은 칸 열 범위 · 가운데 맞춤이 한쪽만 막혀 잘라 낼 폭 */
+export interface Spill {
+  left: number;
+  right: number;
+  from: number;
+  to: number;
+  /** 가운데 맞춤 — 글 상자는 양쪽 반씩 늘리고 막힌 쪽은 이만큼 잘라 냄(글은 칸 가운데 그대로) */
+  clipLeft: number;
+  clipRight: number;
+}
+
+export type SpillAlign = "left" | "right" | "center";
+
+/** 칸 c(폭 own)의 글 폭 need 가 넘치면 정렬 쪽 빈 칸으로 늘린 결과 · 안 넘치거나 못 늘리면 null */
+export function spillOf(
+  slots: Map<number, SpillSlot>,
+  c: number,
+  own: number,
+  need: number,
+  align: SpillAlign,
+): Spill | null {
+  if (need <= own) return null;
+  let from = c;
+  let to = c;
+  const grow = (dir: -1 | 1, want: number): number => {
+    let got = 0;
+    for (let k = c + dir; got < want; k += dir) {
+      const s = slots.get(k);
+      if (!s || !s.empty) break;
+      got += s.w;
+      if (dir < 0) from = k;
+      else to = k;
+    }
+    return got;
+  };
+  if (align === "center") {
+    const half = (need - own) / 2;
+    const l = Math.min(grow(-1, half), half);
+    const r = Math.min(grow(1, half), half);
+    if (!l && !r) return null;
+    return { left: half, right: half, from, to, clipLeft: half - l, clipRight: half - r };
+  }
+  const got = grow(align === "right" ? -1 : 1, need - own);
+  if (!got) return null;
+  return align === "right"
+    ? { left: got, right: 0, from, to, clipLeft: 0, clipRight: 0 }
+    : { left: 0, right: got, from, to, clipLeft: 0, clipRight: 0 };
+}
@@ -41,6 +41,8 @@ export class ScreenCanvasDrawController implements DrawController {
 	private screenScale = 1;
 	private screenMouseLocation: Point;
 	private canvasSize: Point = new Point(100, 100);
+	/** 맞춤 뒤 사용자가 화면을 안 옮겼음 — 캔버스 크기가 바뀌면 다시 맞춘다(첫 표시 때 iframe 이 늦게 커짐). */
+	private viewFitted = false;

 	// Style-run batching (static scene rendering): consecutive stroke calls
 	// with the same style are collected into one Path2D and stroked once.
@@ -61,7 +63,9 @@ export class ScreenCanvasDrawController implements DrawController {
 	}

 	public setCanvasSize(newCanvasSize: Point) {
+		const changed = newCanvasSize.x !== this.canvasSize.x || newCanvasSize.y !== this.canvasSize.y;
 		this.canvasSize = newCanvasSize;
+		if (changed && this.viewFitted) this.zoomToFitScreen();
 	}

 	public getScreenScale() {
@@ -70,6 +74,7 @@ export class ScreenCanvasDrawController implements DrawController {

 	public setScreenScale(newScreenScale: number) {
 		this.screenScale = newScreenScale;
+		this.viewFitted = false;
 		triggerReactUpdate(StateVariable.screenZoom);
 	}

@@ -79,6 +84,7 @@ export class ScreenCanvasDrawController implements DrawController {

 	public setScreenOffset(newScreenOffset: Point) {
 		this.screenOffset = newScreenOffset;
+		this.viewFitted = false;
 		triggerReactUpdate(StateVariable.screenOffset);
 	}

@@ -96,6 +102,7 @@ export class ScreenCanvasDrawController implements DrawController {
 	}

 	public panScreen(screenOffsetX: number, screenOffsetY: number) {
+		this.viewFitted = false;
 		this.screenOffset = new Point(
 			this.screenOffset.x - screenOffsetX / this.screenScale,
 			this.screenOffset.y - screenOffsetY / this.screenScale
@@ -145,7 +152,14 @@ export class ScreenCanvasDrawController implements DrawController {
 		// 확정). 도각까지 넣으면 A1 한 장 전체가 잡혀 화면의 40%가 여백으로 간다.
 		const pickable = getPickableEntities();
 		const entities = pickable.length ? pickable : getEntities();
-		if (!entities.length) return;
+		if (!entities.length) {
+			// 빈 도면 — 원점(0,0)을 화면 가운데로. 안 옮기면 기준점 십자가 왼쪽 아래 귀퉁이에 잘린다.
+			const canvasSize = this.getCanvasSize();
+			const zoom = this.getScreenScale();
+			this.setScreenOffset(new Point(-canvasSize.x / 2 / zoom, -canvasSize.y / 2 / zoom));
+			this.viewFitted = true;
+			return;
+		}
 		const boundingBox = getBoundingBoxOfMultipleEntities(entities);
 		const boundingWidth = boundingBox.maxX - boundingBox.minX;
 		const boundingHeight = boundingBox.maxY - boundingBox.minY;
@@ -171,6 +185,7 @@ export class ScreenCanvasDrawController implements DrawController {
 				worldCenterY - canvasSize.y / 2 / zoomLevel
 			)
 		);
+		this.viewFitted = true;
 	}

 	/**
@@ -12,6 +12,8 @@ import {
 	getSnapPoint,
 	isDrawingDirty,
 	isDrawingReadOnly,
+	isOriginMarker,
+	isViewOnly,
 } from '../state';
 import { Point } from '@flatten-js/core';
 import { isEntityHidden } from './visibility';
@@ -47,6 +49,9 @@ export function registerCadDebugHook(): void {
 		readOnly: () => isDrawingReadOnly(),
 		dirty: () => isDrawingDirty(),
 		meta: () => getDesignMeta(),
+		// 기준점 십자 · 미리보기(보기 전용) 켜짐 — 그림이 안 도는 탭에서도 수치로 본다.
+		originMarker: () => isOriginMarker(),
+		viewOnly: () => isViewOnly(),
 		// 세계 좌표 → 화면 좌표. 그림·글자가 "제 자리에 그려졌나"를 픽셀로 판정할 때 쓴다.
 		screen: (x: number, y: number) => {
 			const point = getScreenCanvasDrawController().worldToTarget(new Point(x, y));
@@ -3,8 +3,9 @@
 *
 * iframe은 호스트와 **같은 오리진**이라 `localStorage["frd_theme"]`를 공유한다.
 * 부모가 토글하며 값을 쓰면 이 문서에는 `storage` 이벤트가 오므로, 부모 쪽에
- * 별도 전달 코드(postMessage)를 넣지 않는다. 값이 없으면 미지정 상태로 두어
- * `ui_template_theme.css`의 `prefers-color-scheme` 폴백이 그대로 먹는다.
+ * 별도 전달 코드(postMessage)를 넣지 않는다. 값이 없으면 부모 문서의 `data-theme`
+ * (호스트 index.html 기본값 light)를 따른다 — 시스템 설정을 따로 따르면 호스트와 어긋난다.
+ * 부모가 없을 때(단독 실행)만 `prefers-color-scheme` 폴백이 먹는다.
 */

 import { bumpSceneVersion } from './helpers/scene-version.ts';
@@ -27,11 +28,22 @@ function applyTheme(value: string | null): void {
 	bumpSceneVersion();
 }

+/** 부모(호스트) 문서의 테마 — 부모가 없거나 못 읽으면 null. */
+function parentTheme(): string | null {
+	try {
+		return window.parent === window
+			? null
+			: window.parent.document.documentElement.getAttribute('data-theme');
+	} catch {
+		return null;
+	}
+}
+
 /** 부팅 시 1회 호출 — 현재 테마 반영 + 이후 변경 구독. */
 export function syncThemeFromHost(): void {
-	applyTheme(localStorage.getItem(THEME_STORAGE_KEY));
+	applyTheme(localStorage.getItem(THEME_STORAGE_KEY) ?? parentTheme());
 	window.addEventListener('storage', (event) => {
-		if (event.key === THEME_STORAGE_KEY) applyTheme(event.newValue);
+		if (event.key === THEME_STORAGE_KEY) applyTheme(event.newValue ?? parentTheme());
 	});
 	// 시스템 설정 폴백으로 도는 중이면 OS 전환도 따라간다.
 	window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', () => {
@@ -15,7 +15,6 @@ from pydantic import BaseModel
 from M01_MasterData import M01_MasterData_Store as store
 from M01_MasterData import M01_MasterData_Store_Combo as combo_store
 from M01_MasterData import M01_MasterData_Store_Make as make
-from M01_MasterData import M01_MasterData_Store_Matset as matset_store

 router = APIRouter(prefix="/api/m01", tags=["M01 MasterData"])

@@ -115,20 +114,6 @@ class PreviewCombo(BaseModel):
    inputs: dict[str, dict[str, Any]] = {}


-class NewMatset(BaseModel):
-    """자재 조합 — 담은 자재 목록만(코드 · 이름 · 규격 · 단위 · 수량 · 단가는 안 둠)."""
-
-    matset: dict[str, Any]
-    owner: str = matset_store.OWNERS[0]
-
-
-class EditMatset(BaseModel):
-    key: str
-    version: str
-    matset: dict[str, Any]
-    owner: str = ""
-
-
 class DraftLogic(BaseModel):
    text: str  # 줄로 적은 식 — 줄마다 「이름 = 식」
    decided: dict[str, Any] = {}  # 변수마다 정한 것 {이름: {무엇, 단위, 비목, 요소·찾기·값}}
@@ -364,29 +349,3 @@ def post_combo_delete(body: DeleteCombo) -> dict:
 def post_combo_preview(body: PreviewCombo) -> dict:
    """담은 로직마다 값을 뽑아 비목별로 갈라 합계 — 저장하지 않음."""
    return _call(combo_store.combo_preview, body.combo, body.inputs)
-
-
-# ── 자재 조합(계약 9장 끝) ─────────────────────────────────────────────
-@router.get("/matsets")
-def get_matsets(q: str = "", owner: str = "") -> dict:
-    return {"matsets": _call(matset_store.matsets, q, owner)}
-
-
-@router.get("/matset")
-def get_matset(key: str) -> dict:
-    return _call(matset_store.matset, key)
-
-
-@router.post("/matset/new")
-def post_matset_new(body: NewMatset) -> dict:
-    return _call(matset_store.matset_new, body.matset, body.owner)
-
-
-@router.post("/matset/edit")
-def post_matset_edit(body: EditMatset) -> dict:
-    return _call(matset_store.matset_edit, body.key, body.version, body.matset, body.owner)
-
-
-@router.post("/matset/delete")
-def post_matset_delete(body: DeleteCombo) -> dict:
-    return _call(matset_store.matset_delete, body.key, body.version)
@@ -1,136 +0,0 @@
-"""M01 자재 조합 저장소 — 목록 · 하나 읽기 · 만들기 · 고치기 · 지우기.
-
-계약: `_화면_계약.md` 9장 끝 · 파일 모양: `_틀.md` 11장 · 엔진: `scripts/master_matset.py`.
-조합은 담은 자재 목록(코드 · 이름 · 규격 · 단위)만 지님 — 수량 · 단가는 두지 않음(재료산출 몫).
-자리는 `자재조합.json` 한 파일 · 키는 `_키대장.json` 의 `UM` 다음 번호(서버가 줌).
-"""
-
-from __future__ import annotations
-
-from datetime import date
-from pathlib import Path
-
-from M01_MasterData import M01_MasterData_Store as store
-from M01_MasterData import M01_MasterData_Store_Combo as combos
-
-cm = store.cm
-msk = cm.mmc  # sub4 가 세운 자재 조합 엔진(`scripts/master_material_combo.py`)
-
-FILE = msk.FILE
-OWNERS = msk.OWNERS
-
-
-def _path() -> Path:
-    return store.FOLDER / FILE
-
-
-def _make_file() -> None:
-    """파일이 없으면 머리만 두고 만듦."""
-    if not _path().is_file():
-        head = {"그룹": msk.GROUP, "판": str(date.today().year), "줄": []}
-        _path().write_text(store.dump(head), encoding="utf-8", newline="\n")
-
-
-def _read() -> tuple[dict, str]:
-    _make_file()
-    return store.read(FILE)
-
-
-def _keys() -> list[str]:
-    return [str(r.get("키")) for r in _read()[0].get("줄") or []]
-
-
-def _find(data: dict, key: str) -> dict:
-    for row in data.get("줄") or []:
-        if str(row.get("키")) == key:
-            return row
-    raise store.StoreError(404, f"없는 자재 조합 「{key}」")
-
-
-def _clean(one: dict, owner: str, key: str | None = None) -> dict:
-    """서버가 잡는 칸 — 키 · 소유 · 열 한 벌(안 준 칸은 null · 자재 줄은 네 칸만)."""
-    if not isinstance(one, dict):
-        raise store.StoreError(400, "자재 조합 줄이 묶음 아님")
-    name = one.get("이름")
-    if not isinstance(name, str) or not name.strip():
-        raise store.StoreError(400, "자재 조합 줄에 「이름」 이 없거나 글자 아님")
-    if owner not in OWNERS:
-        raise store.StoreError(400, f"모르는 소유 「{owner}」 — {' · '.join(OWNERS)}")
-    origin = one.get("본뜬키")
-    if origin is not None and (origin == key or origin not in _keys()):
-        raise store.StoreError(400, f"본뜬키 「{origin}」 — 비었거나 있는 다른 자재 조합 키여야 함")
-    got = one.get("담은자재")
-    if isinstance(got, list):  # 화면이 덤을 실어도 자재 줄은 네 칸만 · 안 준 칸은 빈 글
-        got = [{c: m.get(c, "") for c in msk.ITEM_COLS} if isinstance(m, dict) else m for m in got]
-    rest = {k: v for k, v in one.items() if k not in ("키", "원문번호", "소유")}
-    _check_codes(got)
-    row = {**({"키": key} if key else {}), "소유": owner, **rest, "담은자재": got or []}
-    for col in msk.COLS:
-        row.setdefault(col, None)
-    return {k: row[k] for k in msk.COLS if k in row}
-
-
-def _check_codes(got) -> None:
-    """담은 자재 코드가 마스터 어느 줄에도 없으면 422 — 틀 검사는 저장 길(`store.save`)이 함."""
-    if not isinstance(got, list) or not got:
-        return
-    known = {str(r.get("키")) for d in store.loaded()[0].values() for r in d.get("줄") or []}
-    lost = [str(m.get("코드")) for m in got if isinstance(m, dict) and m.get("코드") not in known]
-    if lost:
-        raise store.StoreError(422, {"errors": [f"마스터에 없는 자재 {' · '.join(lost)}"]})
-
-
-def _write(changes: list[dict], version: str | None = None) -> dict:
-    _make_file()
-    return store.save(
-        [{"file": FILE, "version": version or store.read(FILE)[1], "changes": changes}]
-    )[0]
-
-
-def matsets(q: str = "", owner: str = "") -> list[dict]:
-    """목록 — 찾기(이름 · 키)와 소유로 거름 · 줄마다 자재 수."""
-    out = []
-    for row in store.loaded()[0].get(FILE, {}).get("줄") or []:
-        if owner and row.get("소유") != owner:
-            continue
-        if not store._hit(row, q):
-            continue
-        out.append(
-            {k: row.get(k) for k in msk.COLS if k != "담은자재"}
-            | {"file": FILE, "count": len(msk.items(row))}
-        )
-    return out
-
-
-def matset(key: str) -> dict:
-    data, version = _read()
-    return {"file": FILE, "version": version, "matset": _find(data, key)}
-
-
-def matset_new(one: dict, owner: str = OWNERS[0]) -> dict:
-    """새 자재 조합 — 키는 서버가 `UM` 다음 번호로 줌."""
-    before = set(_keys())
-    done = _write([{"op": "add", "row": _clean(one, owner)}])
-    key = next((k for k in reversed(_keys()) if k not in before), "")
-    return {**done, "key": key, "matset": _find(_read()[0], key) if key else {}}
-
-
-def matset_edit(key: str, version: str, one: dict, owner: str = "") -> dict:
-    data, _ = _read()
-    was = _find(data, key)
-    if store.read(FILE)[1] != version:
-        raise store.StoreError(409, {"stale": [FILE]})
-    fixed = _clean(one, owner or str(was.get("소유") or OWNERS[0]), key)
-    done = _write([{"op": "edit", "key": key, "row": fixed}], version)
-    return {**done, "matset": _find(_read()[0], key)}
-
-
-def matset_delete(key: str, version: str) -> dict:
-    """지우기 — 구조물 열이 「자재조합」 칸으로 쓰면 409 + 구조물 이름들(지우지 않음)."""
-    _find(_read()[0], key)
-    if users := combos.users_of("자재조합", key):
-        msg = f"구조물 {len(users)} 곳이 쓰는 자재 조합이라 못 지움 — {' · '.join(users)}"
-        raise store.StoreError(409, {"errors": [msg], "users": users})
-    if store.read(FILE)[1] != version:
-        raise store.StoreError(409, {"stale": [FILE]})
-    return _write([{"op": "delete", "key": key}], version)
@@ -0,0 +1,14 @@
+/* 일위대가 조합 화면 — 표는 칸 폭을 채움 · 미리 보기 금액은 오른쪽 맞춤 ·
+   흐린 안내 글은 보조 글색(뮤트 글색은 밝은 테마에서 대비 3.1 로 모자람) */
+.m01-combo .m01-master__grid {
+  width: 100%;
+}
+
+.m01-combo [data-combo="preview"] th:not(:first-child),
+.m01-combo [data-combo="preview"] td:not(:first-child) {
+  text-align: right;
+}
+
+.m01-combo .m01-logic__muted {
+  color: var(--color-text-secondary);
+}
@@ -28,6 +28,7 @@ import { tc } from "./M01_MasterData_UI_Combo_Text";
 import type { SideHandle } from "./M01_MasterData_UI_Side";
 import "./M01_MasterData_UI_Logic_Style.css";
 import "./M01_MasterData_UI_LogicLab_Style.css";
+import "./M01_MasterData_UI_Combo.css";

 const FILTER_ID = "조합|";
 const blankCombo = (): Combo => ({
@@ -47,7 +48,9 @@ const blankCombo = (): Combo => ({
 function reason(error: unknown): string {
  if (error instanceof ApiError && typeof error.detail === "object" && error.detail) {
    const d = error.detail as { errors?: string[]; stale?: string[] };
-    if (d.errors) return d.errors.join(" / ");
+    // 서버 검사 글 머리(「파일.json · 키 」)는 떼고 보임 — 새로 만들 때 키는 아직 없는 번호라 헷갈림
+    if (d.errors)
+      return d.errors.map((x) => x.replace(/^\S+\.json · (U[AM]\d{6} )?/, "")).join(" / ");
    if (d.stale) return tc("Stale");
  }
  return error instanceof Error ? error.message : tc("Load_Failed");
@@ -62,6 +65,8 @@ export function mountM01Combo(
  host: HTMLElement,
  side: SideHandle,
  onOpenLogic: (key: string) => void,
+  /** 왼쪽 거름 · 찾기를 만지면 — 다른 화면이 떠 있으면 이 화면으로 */
+  activate: () => void = () => {},
 ): ComboHandle {
  let items: ComboSummary[] = [];
  let logics = new Map<string, LogicSummary>();
@@ -69,11 +74,19 @@ export function mountM01Combo(
  /** 화면을 바꾼 횟수 — 늦게 온 답은 이 값이 달라졌으면 버림 */
  let nav = 0;
  /** 열어 둔 상세 — 다른 화면에 갔다 와도 그대로 돌아오게 기억 */
-  let current: { combo: Combo; version: string } | null = null;
+  /** `saved` = 연 때의 모양 — 다시 그려도 「저장 안 한 고침」 판정이 안 풀리게 */
+  let current: { combo: Combo; version: string; saved: string } | null = null;
  let logicsReady: Promise<void> = Promise.resolve();
+  let q = "";
  const filterHost = el("div");
-  side.comboHost.replaceChildren(filterHost);
-  const view = el("div", { className: "m01-logic__editor" });
+  const find = createInputField({ type: "search", placeholder: tc("Search") });
+  find.input.addEventListener("input", () => {
+    q = find.input.value.trim().toLowerCase();
+    activate();
+    if (!current) drawList();
+  });
+  side.comboHost.replaceChildren(find.root, filterHost);
+  const view = el("div", { className: "m01-logic__editor m01-combo" });
  host.replaceChildren(view);

  /** 목록만 받음 — 로직 이름표(1300여 개)는 따로 받아 목록을 붙잡지 않음 */
@@ -106,7 +119,7 @@ export function mountM01Combo(
    await load(false);
    if (!current) drawList();
    await logicsReady;
-    if (current) draw(current.combo, current.version);
+    if (current) draw(current.combo, current.version, current.saved);
  };

  /* --- 왼쪽 거름 --- */
@@ -130,6 +143,7 @@ export function mountM01Combo(
        detailLabel: tc("Detail"),
        onPick: (sub, detail) => {
          pick = { sub, detail };
+          activate();
          drawList();
        },
      }),
@@ -154,7 +168,10 @@ export function mountM01Combo(
    nav++;
    current = null;
    const shown = items.filter(
-      (x) => (!pick.sub || x.구분 === pick.sub) && (!pick.detail || x.상세구분 === pick.detail),
+      (x) =>
+        (!pick.sub || x.구분 === pick.sub) &&
+        (!pick.detail || x.상세구분 === pick.detail) &&
+        (!q || `${x.키} ${x.이름}`.toLowerCase().includes(q)),
    );
    const heads = [
      tc("Head_Key"),
@@ -177,7 +194,7 @@ export function mountM01Combo(
          x.단위 ?? "",
          String(x.count),
          x.본뜬키 ?? tc("Origin_Self"),
-        ].map((v) => el("td", { text: v })),
+        ].map((v) => el("td", { text: v, attrs: { title: v } })),
      });
      tr.addEventListener("click", () => void open(x.키));
      return tr;
@@ -199,7 +216,7 @@ export function mountM01Combo(
              }),
            ],
          })
-        : el("p", { className: "m01-logic__muted", text: tc("Empty") }),
+        : el("p", { className: "m01-logic__muted", text: tc(items.length ? "NoMatch" : "Empty") }),
    );
  };

@@ -216,14 +233,14 @@ export function mountM01Combo(
  };

  /* --- 상세 --- */
-  const draw = (combo: Combo, version: string): void => {
+  const draw = (combo: Combo, version: string, saved = JSON.stringify(combo)): void => {
    nav++;
-    current = { combo, version };
-    const saved = JSON.stringify(combo);
+    current = { combo, version, saved };
    const field = (label: string, name: "이름" | "구분" | "상세구분" | "단위" | "비고") => {
      const f = createInputField({ type: "text", label });
      f.input.value = combo[name] ?? "";
      f.input.setAttribute("data-combo-field", name);
+      if (name === "이름") f.input.maxLength = 60; // 서버 한도(`MAX_이름`)와 같음
      f.input.addEventListener("input", () => {
        const v = f.input.value;
        if (name === "이름") combo.이름 = v;
@@ -350,7 +367,11 @@ export function mountM01Combo(
      label: tc("Delete"),
      variant: "ghost",
      onClick: async () => {
-        if (!combo.키 || !(await showConfirmDialog(tc("DeleteAsk")))) return;
+        if (
+          !combo.키 ||
+          !(await showConfirmDialog(`${combo.키} ${combo.이름} — ${tc("DeleteAsk")}`))
+        )
+          return;
        try {
          await deleteCombo(combo.키, version);
          showToast(tc("Deleted"), "success");
@@ -360,7 +381,18 @@ export function mountM01Combo(
        }
      },
    });
-    const back = createButton({ label: "←", variant: "ghost", onClick: () => drawList() });
+    const back = createButton({
+      label: "←",
+      variant: "ghost",
+      onClick: async () => {
+        if (JSON.stringify(combo) !== saved && !(await showConfirmDialog(tc("BackAsk")))) return;
+        drawList();
+      },
+    });
+    const origin = createInputField({ type: "text", label: tc("Head_Origin") });
+    origin.input.value = combo.본뜬키 ?? tc("Origin_Self");
+    origin.input.readOnly = true;
+    origin.input.setAttribute("data-combo-origin", combo.본뜬키 ?? "");
    view.replaceChildren(
      el("div", {
        className: "m01-logic__section-head",
@@ -377,11 +409,7 @@ export function mountM01Combo(
              field(tc("Detail"), "상세구분"),
              field(tc("Head_Unit"), "단위"),
              field(tc("Head_Note"), "비고"),
-              el("p", {
-                className: "m01-logic__muted",
-                text: `${tc("Head_Origin")}: ${combo.본뜬키 ?? tc("Origin_Self")}`,
-                attrs: { "data-combo-origin": combo.본뜬키 ?? "" },
-              }),
+              origin.root,
            ],
          }),
        ],
@@ -18,6 +18,8 @@ import {
  type SubBrief,
 } from "./M01_MasterData_UI_Logic_Api";
 import { tc } from "./M01_MasterData_UI_Combo_Text";
+import "./M01_MasterData_UI_Logic_Style.css"; // 창 겉틀 — M02 에서 열 때도 이 모듈이 불러옴
+import "./M01_MasterData_UI_Combo.css";

 const opts = (values: string[]): { value: string; text: string }[] =>
  [L("M01_All"), ...values].map((v, i) => ({ value: i ? v : "", text: v }));
@@ -76,7 +78,7 @@ export function openLogicPicker(done: (logic: LogicSummary) => void): void {
  });

  const dialog = el("div", {
-    className: "m01-logic__pick",
+    className: "m01-logic__pick m01-combo",
    attrs: { role: "dialog", "aria-label": tc("Pick_Title") },
    children: [
      el("div", {
@@ -103,6 +105,8 @@ export function openLogicPicker(done: (logic: LogicSummary) => void): void {
  backdrop.addEventListener("click", (ev) => ev.target === backdrop && close());
  backdrop.addEventListener("keydown", (ev) => ev.key === "Escape" && close());
  document.body.append(backdrop);
+  searchField.input.addEventListener("keydown", (ev) => ev.key === "Enter" && find());
+  searchField.input.focus();

  void Promise.all([fetchLogicSubs(), fetchLogics()])
    .then(([s, l]) => {
@@ -37,7 +37,7 @@ function inputCell(
  const choices = input.고르기?.map((v) => ({ value: String(v), text: String(v) }));
  const field = choices
    ? createSelectField({ options: choices, value, compact: true, label: input.이름 })
-    : createInputField({ type: "text", label: input.이름 });
+    : createInputField({ type: "text", label: input.이름, compact: true });
  const control = "select" in field ? field.select : field.input;
  control.value = value;
  control.setAttribute("data-input", `${key}|${input.이름}`);
@@ -72,7 +72,10 @@ export function buildPreview(combo: () => Combo): PreviewHandle {
  const rowOf = (cells: string[], note = "", bold = false): HTMLElement =>
    el("tr", {
      className: bold ? "m01lab__subtotal" : "",
-      children: cells.map((t, i) => el("td", { text: i === 0 && note ? `${t} — ${note}` : t })),
+      children: cells.map((t, i) => {
+        const text = i === 0 && note ? `${t} — ${note}` : t;
+        return el("td", { text, attrs: { title: text } });
+      }),
    });

  const run = async (): Promise<void> => {
@@ -23,6 +23,12 @@ const TEXT = {
    "저장 안 한 고침이 있음 — 로직 상세로 가면 이 화면에서는 그대로 두고 옮겨 감. 갈까요?",
    "Unsaved edits — go to the logic anyway?",
  ],
+  BackAsk: [
+    "저장 안 한 고침이 있음 — 버리고 목록으로 갈까요?",
+    "Unsaved edits — discard and go back to the list?",
+  ],
+  Search: ["이름 · 키로 찾기", "Search by name or key"],
+  NoMatch: ["찾은 조합 없음 — 거름 · 찾기 글을 바꿔 봄", "No match — change the filter or search"],
  NeedName: ["이름을 적어야 저장됨", "A name is required"],
  Load_Failed: ["불러오지 못함", "Load failed"],
  Head_Key: ["키", "Key"],
@@ -121,6 +121,11 @@
  font-size: var(--text-body-sm);
 }

+/* 한 줄 칸은 작은 고르기칸과 같은 높이 */
+input.m01-logic__input {
+  height: var(--control-height-sm);
+}
+
 .m01-logic__note {
  min-height: 48px;
  resize: vertical;
@@ -1,367 +0,0 @@
-/* =============================================================================
- * M01_MasterData_UI_Matset.ts
- * 자재 조합 화면 — 왼쪽 컨테이너(찾기) / 오른쪽 목록 · 상세 (일위대가 조합 화면과 같은 틀)
- * 상세 = 이름 · 비고 + 본뜬키 줄 + 담은 자재 표(코드 · 이름 · 규격 · 단위 · 빼기) + [자재 더하기]
- * 저장 · 지우기는 서버 자재 조합 마스터(`자재조합.json` · 키 UM) — 길은 `Matset_Api` 한 곳
- * ========================================================================== */
-
-import {
-  createButton,
-  createInputField,
-  el,
-  showConfirmDialog,
-  showToast,
-} from "@ui/ui_template_elements";
-import { searchMaterials } from "./M01_MasterData_Api_Fetch";
-import { ApiError } from "./M01_MasterData_UI_Logic_Api";
-import {
-  deleteMatset,
-  editMatset,
-  fetchMatset,
-  fetchMatsets,
-  newMatset,
-  type MatItem,
-  type Matset,
-  type MatsetSummary,
-} from "./M01_MasterData_UI_Matset_Api";
-import { tm } from "./M01_MasterData_UI_Matset_Text";
-import type { SideHandle } from "./M01_MasterData_UI_Side";
-import "./M01_MasterData_UI_Logic_Style.css";
-import "./M01_MasterData_UI_LogicLab_Style.css";
-
-const blank = (): Matset => ({
-  키: "",
-  이름: "",
-  담은자재: [],
-  본뜬키: null,
-  소유: "현장",
-  비고: null,
-});
-
-/** 서버가 준 까닭 — 422 · 409(지우기 막음) 는 글 목록 · 409 낡은 판본은 stale */
-function reason(error: unknown): string {
-  if (error instanceof ApiError && typeof error.detail === "object" && error.detail) {
-    const d = error.detail as { errors?: string[]; stale?: string[] };
-    if (d.errors) return d.errors.join(" / ");
-    if (d.stale) return tm("Stale");
-  }
-  return error instanceof Error ? error.message : tm("Load_Failed");
-}
-
-const fail = (error: unknown): void =>
-  showToast(error instanceof Error ? error.message : tm("Load_Failed"), "error");
-
-/** [자재 더하기] 창 — 낱말로 자재DB 를 찾아 하나씩 고름 */
-function openMaterialPicker(have: Set<string>, done: (item: MatItem) => void): void {
-  const search = createInputField({ type: "search", placeholder: tm("Pick_Search") });
-  const list = el("div", { className: "m01-logic__pick-list" });
-  const hint = el("p", { className: "m01-logic__muted", text: tm("Pick_Hint") });
-  const close = (): void => backdrop.remove();
-  const find = async (): Promise<void> => {
-    try {
-      const found = await searchMaterials(search.input.value.trim());
-      hint.textContent = found.length ? String(found.length) : tm("Pick_None");
-      list.replaceChildren(
-        ...found.map((x) => {
-          const taken = have.has(x.코드);
-          const row = el("button", {
-            className: "m01-logic__pick-row m01-logic__pick-row--button",
-            attrs: { type: "button", "data-pick": x.코드, ...(taken ? { disabled: "" } : {}) },
-            children: [
-              el("div", {
-                className: "m01-logic__stack",
-                children: [
-                  el("strong", { text: x.이름 }),
-                  el("span", { className: "m01-logic__muted", text: `${x.코드} · ${x.규격}` }),
-                ],
-              }),
-              el("span", { text: taken ? tm("Pick_Have") : x.단위 }),
-            ],
-          });
-          row.addEventListener("click", () => {
-            close();
-            done(x);
-          });
-          return row;
-        }),
-      );
-    } catch (error) {
-      fail(error);
-    }
-  };
-  search.input.addEventListener("keydown", (ev) => ev.key === "Enter" && void find());
-  const dialog = el("div", {
-    className: "m01-logic__pick",
-    attrs: { role: "dialog", "aria-label": tm("Pick_Title") },
-    children: [
-      el("div", {
-        className: "m01-logic__section-head",
-        children: [
-          el("h3", { text: tm("Pick_Title") }),
-          createButton({ label: tm("Pick_Close"), variant: "ghost", onClick: close }),
-        ],
-      }),
-      el("div", {
-        className: "m01-logic__filters",
-        children: [
-          search.root,
-          createButton({ label: tm("Pick_Find"), variant: "filled", onClick: () => void find() }),
-        ],
-      }),
-      hint,
-      list,
-    ],
-  });
-  const backdrop = el("div", { className: "m01-logic__backdrop", children: [dialog] });
-  backdrop.addEventListener("click", (ev) => ev.target === backdrop && close());
-  backdrop.addEventListener("keydown", (ev) => ev.key === "Escape" && close());
-  document.body.append(backdrop);
-  search.input.focus();
-}
-
-export interface MatsetHandle {
-  /** 컨테이너를 펼칠 때 — 목록을 새로 받아 그림 */
-  show: () => Promise<void>;
-}
-
-export function mountM01Matset(host: HTMLElement, side: SideHandle): MatsetHandle {
-  let items: MatsetSummary[] = [];
-  let q = "";
-  /** 화면을 바꾼 횟수 — 늦게 온 답은 이 값이 달라졌으면 버림 */
-  let nav = 0;
-  /** 열어 둔 상세 — 다른 화면에 갔다 와도 그대로 돌아오게 기억 */
-  let current: { matset: Matset; version: string } | null = null;
-  const view = el("div", { className: "m01-logic__editor" });
-  host.replaceChildren(view);
-
-  const find = createInputField({ type: "search", placeholder: tm("Search") });
-  find.input.addEventListener("input", () => {
-    q = find.input.value.trim().toLowerCase();
-    if (!current) drawList();
-  });
-  side.matsetHost.replaceChildren(find.root);
-
-  const load = async (redraw = true): Promise<void> => {
-    const my = nav;
-    try {
-      items = await fetchMatsets();
-    } catch (error) {
-      fail(error);
-    }
-    if (redraw && my === nav) drawList();
-  };
-
-  const show = async (): Promise<void> => {
-    if (!items.length && !current) {
-      view.replaceChildren(el("p", { className: "m01-logic__muted", text: tm("Loading") }));
-    }
-    await load(false);
-    if (current) draw(current.matset, current.version);
-    else drawList();
-  };
-
-  /* --- 목록 --- */
-  const drawList = (): void => {
-    nav++;
-    current = null;
-    const shown = items.filter((x) => !q || `${x.키} ${x.이름}`.toLowerCase().includes(q));
-    const heads = [
-      tm("Head_Key"),
-      tm("Head_Name"),
-      tm("Head_Count"),
-      tm("Head_Origin"),
-      tm("Head_Owner"),
-    ];
-    const rows = shown.map((x) => {
-      const tr = el("tr", {
-        className: "m01-master__table-row",
-        attrs: { "data-matset-key": x.키 },
-        children: [x.키, x.이름, String(x.count), x.본뜬키 ?? tm("Origin_Self"), x.소유 ?? ""].map(
-          (v) => el("td", { text: v }),
-        ),
-      });
-      tr.addEventListener("click", () => void open(x.키));
-      return tr;
-    });
-    view.replaceChildren(
-      el("div", {
-        className: "m01-logic__section-head",
-        children: [
-          createButton({ label: tm("New"), variant: "filled", onClick: () => draw(blank(), "") }),
-        ],
-      }),
-      shown.length
-        ? el("div", {
-            className: "m01-master__grid-wrap",
-            children: [
-              el("table", {
-                className: "m01-master__grid",
-                children: [
-                  el("thead", {
-                    children: [el("tr", { children: heads.map((t) => el("th", { text: t })) })],
-                  }),
-                  el("tbody", { children: rows }),
-                ],
-              }),
-            ],
-          })
-        : el("p", { className: "m01-logic__muted", text: tm("Empty") }),
-    );
-  };
-
-  const open = async (key: string): Promise<void> => {
-    try {
-      const my = ++nav;
-      const one = await fetchMatset(key);
-      if (my !== nav) return;
-      draw(one.matset, one.version);
-    } catch (error) {
-      fail(error);
-    }
-  };
-
-  /* --- 상세 --- */
-  const draw = (matset: Matset, version: string): void => {
-    nav++;
-    current = { matset, version };
-    const field = (label: string, name: "이름" | "비고") => {
-      const f = createInputField({ type: "text", label });
-      f.input.value = matset[name] ?? "";
-      f.input.setAttribute("data-matset-field", name);
-      f.input.addEventListener("input", () => {
-        if (name === "이름") matset.이름 = f.input.value;
-        else matset.비고 = f.input.value || null;
-      });
-      return f.root;
-    };
-    const table = el("div", { className: "m01-master__grid-wrap" });
-    const drawTable = (): void => {
-      const trs = matset.담은자재.map((m, i) =>
-        el("tr", {
-          attrs: { "data-matset-item": m.코드 },
-          children: [
-            el("td", { text: m.코드 }),
-            el("td", { text: m.이름 }),
-            el("td", { text: m.규격 }),
-            el("td", { text: m.단위 }),
-            el("td", {
-              children: [
-                createButton({
-                  label: tm("Remove"),
-                  variant: "ghost",
-                  size: "sm",
-                  onClick: () => {
-                    matset.담은자재.splice(i, 1);
-                    drawTable();
-                  },
-                }),
-              ],
-            }),
-          ],
-        }),
-      );
-      const heads = [
-        tm("Col_Code"),
-        tm("Col_Name"),
-        tm("Col_Spec"),
-        tm("Col_Unit"),
-        tm("Col_Move"),
-      ];
-      table.replaceChildren(
-        el("table", {
-          className: "m01-master__grid",
-          children: [
-            el("thead", {
-              children: [el("tr", { children: heads.map((t) => el("th", { text: t })) })],
-            }),
-            el("tbody", { children: trs }),
-          ],
-        }),
-        ...(trs.length ? [] : [el("p", { className: "m01-logic__muted", text: tm("NoItem") })]),
-      );
-    };
-    drawTable();
-
-    const add = createButton({
-      label: tm("AddItem"),
-      variant: "filled",
-      onClick: () =>
-        openMaterialPicker(new Set(matset.담은자재.map((m) => m.코드)), (x) => {
-          matset.담은자재.push({ 코드: x.코드, 이름: x.이름, 규격: x.규격, 단위: x.단위 });
-          drawTable();
-        }),
-    });
-    const save = createButton({
-      label: tm("Save"),
-      variant: "filled",
-      onClick: async () => {
-        if (!matset.이름.trim()) return showToast(tm("NeedName"), "error");
-        if (!matset.담은자재.length) return showToast(tm("NeedItem"), "error");
-        const my = nav;
-        try {
-          const key = matset.키 ? matset.키 : (await newMatset(matset)).key;
-          if (matset.키) await editMatset(matset.키, version, matset);
-          showToast(tm("Saved"), "success");
-          await load(false);
-          if (my !== nav) {
-            if (current?.matset === matset) current = null; // 저장 사이에 나감 — 옛 판본을 붙들지 않음
-            return;
-          }
-          await open(key);
-        } catch (error) {
-          showToast(reason(error), "error");
-        }
-      },
-    });
-    const remove = createButton({
-      label: tm("Delete"),
-      variant: "ghost",
-      onClick: async () => {
-        if (!matset.키 || !(await showConfirmDialog(tm("DeleteAsk")))) return;
-        try {
-          await deleteMatset(matset.키, version);
-          showToast(tm("Deleted"), "success");
-          await load();
-        } catch (error) {
-          showToast(reason(error), "error");
-        }
-      },
-    });
-    const back = createButton({ label: "←", variant: "ghost", onClick: () => drawList() });
-    view.replaceChildren(
-      el("div", {
-        className: "m01-logic__section-head",
-        children: [back, el("h3", { text: matset.키 || tm("New") }), remove, save],
-      }),
-      el("section", {
-        className: "m01lab__box m01-logic__section",
-        children: [
-          el("div", {
-            className: "m01lab__info",
-            children: [
-              field(tm("Head_Name"), "이름"),
-              field(tm("Head_Note"), "비고"),
-              el("p", {
-                className: "m01-logic__muted",
-                text: `${tm("Head_Origin")}: ${matset.본뜬키 ?? tm("Origin_Self")}`,
-                attrs: { "data-matset-origin": matset.본뜬키 ?? "" },
-              }),
-            ],
-          }),
-        ],
-      }),
-      el("section", {
-        className: "m01lab__box m01-logic__section",
-        children: [
-          el("div", {
-            className: "m01-logic__section-head",
-            children: [el("h3", { text: tm("Items_Title") }), add],
-          }),
-          table,
-        ],
-      }),
-    );
-  };
-
-  return { show };
-}
@@ -1,60 +0,0 @@
-/* =============================================================================
- * M01_MasterData_UI_Matset_Api.ts
- * 자재 조합(`자재조합.json` · 키 UM) 서버 길 — 목록 · 하나 · 새로 · 고치기 · 지우기
- * 계약: `resources/master_data/_화면_계약.md` 9장 「자재 조합」
- * ========================================================================== */
-
-import { API_BASE_URL } from "@config/config_frontend";
-import { ApiError } from "./M01_MasterData_UI_Logic_Api";
-
-/** 담은 자재 한 줄 — 고를 때의 사본(수량 · 단가는 안 둠) */
-export interface MatItem {
-  코드: string;
-  이름: string;
-  규격: string;
-  단위: string;
-}
-export interface Matset {
-  키: string;
-  이름: string;
-  담은자재: MatItem[];
-  /** 본뜬 원본 자재 조합 키 — 비면 원본 */
-  본뜬키: string | null;
-  소유: string | null;
-  비고: string | null;
-}
-export interface MatsetSummary extends Omit<Matset, "담은자재"> {
-  count: number;
-}
-export interface MatsetOne {
-  file: string;
-  version: string;
-  matset: Matset;
-}
-
-async function request<T>(path: string, body?: unknown): Promise<T> {
-  const response = await fetch(`${API_BASE_URL}/m01${path}`, {
-    method: body === undefined ? "GET" : "POST",
-    credentials: "include",
-    headers: { "Content-Type": "application/json" },
-    body: body === undefined ? undefined : JSON.stringify(body),
-  });
-  const data = (await response.json().catch(() => ({}))) as { detail?: unknown } & T;
-  if (!response.ok) throw new ApiError(response.status, data.detail ?? response.statusText);
-  return data;
-}
-
-export const fetchMatsets = (): Promise<MatsetSummary[]> =>
-  request<{ matsets: MatsetSummary[] }>("/matsets").then((d) => d.matsets);
-
-export const fetchMatset = (key: string): Promise<MatsetOne> =>
-  request(`/matset?key=${encodeURIComponent(key)}`);
-
-export const newMatset = (matset: Matset): Promise<{ key: string; version: string }> =>
-  request("/matset/new", { matset });
-
-export const editMatset = (key: string, version: string, matset: Matset): Promise<unknown> =>
-  request("/matset/edit", { key, version, matset });
-
-export const deleteMatset = (key: string, version: string): Promise<unknown> =>
-  request("/matset/delete", { key, version });
@@ -1,59 +0,0 @@
-/* =============================================================================
- * M01_MasterData_UI_Matset_Text.ts
- * 자재 조합 화면 글자 — [한국어, 영어]
- * ========================================================================== */
-
-import { currentLanguageIndex } from "@ui/ui_template_locale";
-
-const TEXT = {
-  Title: ["자재 조합", "Material set"],
-  Search: ["이름 · 키로 찾기", "Search by name or key"],
-  Empty: [
-    "자재 조합이 없음 — [새 자재 조합]으로 만듦",
-    "No material sets — press [New material set]",
-  ],
-  New: ["새 자재 조합", "New material set"],
-  Delete: ["지우기", "Delete"],
-  Save: ["저장", "Save"],
-  DeleteAsk: ["이 자재 조합을 지울까요?", "Delete this material set?"],
-  Saved: ["저장함", "Saved"],
-  Deleted: ["지움", "Deleted"],
-  Stale: ["그 사이 자재 조합 파일이 바뀜 — 다시 열어 주세요", "The file changed — reopen it"],
-  Loading: ["불러오는 중…", "Loading…"],
-  NeedName: ["이름을 적어야 저장됨", "A name is required"],
-  NeedItem: ["담은 자재가 하나는 있어야 저장됨", "Add at least one material"],
-  Load_Failed: ["불러오지 못함", "Load failed"],
-  Head_Key: ["키", "Key"],
-  Head_Name: ["이름", "Name"],
-  Head_Count: ["자재 수", "Materials"],
-  Head_Origin: ["본뜬키", "Copied from"],
-  Head_Owner: ["소유", "Owner"],
-  Head_Note: ["비고", "Note"],
-  Origin_Self: ["원본", "Original"],
-  Items_Title: ["담은 자재", "Materials in it"],
-  Col_Code: ["자재 코드", "Code"],
-  Col_Name: ["이름", "Name"],
-  Col_Spec: ["규격", "Spec"],
-  Col_Unit: ["단위", "Unit"],
-  Col_Move: ["빼기", "Remove"],
-  Remove: ["빼기", "Remove"],
-  AddItem: ["자재 더하기", "Add material"],
-  NoItem: ["담은 자재 없음", "No materials yet"],
-  Pick_Title: ["자재 고르기", "Pick a material"],
-  Pick_Search: ["이름 · 규격으로 찾기", "Search by name or spec"],
-  Pick_Find: ["찾기", "Find"],
-  Pick_Hint: [
-    "낱말을 적고 [찾기]를 누름 — 하나씩 직접 고름",
-    "Type words, press Find — pick one by one",
-  ],
-  Pick_None: ["찾은 자재 없음", "No materials found"],
-  Pick_Have: ["이미 담음", "Already in"],
-  Pick_Close: ["닫기", "Close"],
-} as const satisfies Record<string, readonly [string, string]>;
-
-export type MatsetTextKey = keyof typeof TEXT;
-
-export function tm(key: MatsetTextKey): string {
-  const entry = TEXT[key];
-  return entry[currentLanguageIndex as 0 | 1] ?? entry[0];
-}
@@ -39,7 +39,6 @@ import { tl } from "./M01_MasterData_UI_LogicLab_Text";
 import { renderTables } from "./M01_MasterData_UI_Tables";
 import type { LogicHandle } from "./M01_MasterData_UI_LogicLab";
 import type { ComboHandle } from "./M01_MasterData_UI_Combo";
-import type { MatsetHandle } from "./M01_MasterData_UI_Matset";
 import "./M01_MasterData_UI_Style.css";

 const TABLE_GROUPS = ["소요량", "계수"];
@@ -61,7 +60,6 @@ function buildPage(): HTMLElement {
  let dispose = (): void => {};
  let logicMounted = false;
  let comboHandle: ComboHandle | null = null;
-  let matsetHandle: MatsetHandle | null = null;

  /* --- 우측: 머리(제목·찾기·저장) + 알림 + 본문 --- */
  const title = el("h2", { className: "m01-master__title", text: L("M01_PickFile") });
@@ -78,7 +76,6 @@ function buildPage(): HTMLElement {
  });
  const logicHost = el("div", { className: "m01-master__logic", attrs: { hidden: "" } });
  const comboHost = el("div", { className: "m01-master__logic", attrs: { hidden: "" } });
-  const matsetHost = el("div", { className: "m01-master__logic", attrs: { hidden: "" } });
  const elementView = el("div", {
    className: "m01-master__elements",
    children: [
@@ -101,10 +98,9 @@ function buildPage(): HTMLElement {
  onDraftChange(refreshBar);
  refreshBar();

-  const showMode = (mode: "elements" | "logic" | "combo" | "matset"): void => {
+  const showMode = (mode: "elements" | "logic" | "combo"): void => {
    logicHost.hidden = mode !== "logic";
    comboHost.hidden = mode !== "combo";
-    matsetHost.hidden = mode !== "matset";
    elementView.hidden = mode !== "elements";
  };

@@ -221,27 +217,16 @@ function buildPage(): HTMLElement {
      return;
    }
    void import("./M01_MasterData_UI_Combo").then((m) => {
-      comboHandle = m.mountM01Combo(comboHost, side, (key) => openLogicTab(key));
+      comboHandle = m.mountM01Combo(
+        comboHost,
+        side,
+        (key) => openLogicTab(key),
+        () => comboHost.hidden && openComboTab(),
+      );
      void comboHandle.show();
    });
  };

-  /** 「자재 조합」 — 목록을 새로 받아 그림 */
-  const openMatsetTab = (): void => {
-    dispose();
-    dispose = (): void => {};
-    current = null;
-    showMode("matset");
-    if (matsetHandle) {
-      void matsetHandle.show();
-      return;
-    }
-    void import("./M01_MasterData_UI_Matset").then((m) => {
-      matsetHandle = m.mountM01Matset(matsetHost, side);
-      void matsetHandle.show();
-    });
-  };
-
  /** 알약 → 마스터 화면 — 찾기 글을 그 키로 두고 열고, 알림줄에 「단가산출 로직으로 돌아가기」를 둠 */
  const jump = async (target: MasterJump): Promise<void> => {
    let group = target.kind === "element" ? target.group : "";
@@ -282,7 +267,7 @@ function buildPage(): HTMLElement {
  setMasterJump((target) => void jump(target));

  /* --- 좌측: 컨테이너 --- */
-  const side = buildSide(openFile, () => openLogicTab(), openComboTab, openMatsetTab);
+  const side = buildSide(openFile, () => openLogicTab(), openComboTab);

  const layout = el("div", { className: "ui-workflow-layout m01-master" });
  const main = el("main", {
@@ -290,7 +275,7 @@ function buildPage(): HTMLElement {
    children: [
      el("div", {
        className: "m01-master__panel",
-        children: [elementView, logicHost, comboHost, matsetHost],
+        children: [elementView, logicHost, comboHost],
      }),
    ],
  });
@@ -11,7 +11,6 @@ import { t as L } from "@ui/ui_template_locale";
 import { fetchFiles, fetchSubsAll, type FileInfo, type SubInfo } from "./M01_MasterData_Api_Fetch";
 import { tx } from "./M01_MasterData_UI_Logic_Text";
 import { tc } from "./M01_MasterData_UI_Combo_Text";
-import { tm } from "./M01_MasterData_UI_Matset_Text";
 import { renderTree, type MakeRow } from "./M01_MasterData_UI_Tree";

 /** 컨테이너마다 기억하는 화면 상태 — 찾기 글 · 쪽 · 소요량·계수 표의 용도 대상 거름 (거름은 `m01.filter.*`) */
@@ -89,8 +88,6 @@ export interface SideHandle {
  logicHost: HTMLElement;
  /** 일위대가 조합 컨테이너 안(구분 · 상세구분 거름이 들어갈 자리) */
  comboHost: HTMLElement;
-  /** 자재 조합 컨테이너 안(찾기 칸이 들어갈 자리) */
-  matsetHost: HTMLElement;
  /** 그룹의 파일 판본을 다시 받음(저장 뒤) — 돌려받는 것 = 새 목록 */
  refresh: (group: string) => Promise<FileInfo[]>;
  /** 그룹의 파일 목록(이미 받은 것) */
@@ -149,13 +146,11 @@ const LEAF: Group[] = ["환율", "요율"];
 const FILTERED: Group[] = ["인력", "기계", "소요량", "계수"];
 const LOGIC_ID = "로직|";
 const COMBO_ID = "조합|";
-const MATSET_ID = "자재조합|";

 export function buildSide(
  onOpen: (pick: Pick) => void,
  onLogic: () => void,
  onCombo: () => void = () => {},
-  onMatset: () => void = () => {},
 ): SideHandle {
  const lists = new Map<Group, FileInfo[]>();
  const bodies = new Map<Group, HTMLElement>();
@@ -465,17 +460,9 @@ ${first.file}`
    onCombo();
  });

-  const matsetHost = el("div", { className: "m01-side__items ui-sidebar-list" });
-  const matset = section(tm("Title"), matsetHost);
-  matset.querySelector(".ui-collapsible__title")?.addEventListener("click", () => {
-    if (!matset.classList.contains("is-collapsed")) return;
-    setActive(buttons.has(MATSET_ID) ? MATSET_ID : null);
-    onMatset();
-  });
-
  const root = el("div", {
    className: "m01-side ui-sidebar-panel",
-    children: [...groups, logic, combo, matset],
+    children: [...groups, logic, combo],
  });
  attachCollapsible(root);
  void Promise.all(GROUPS.map(refresh)).catch((error) =>
@@ -485,5 +472,5 @@ ${first.file}`
    onPicked = fn;
  };
  const files = (group: string): FileInfo[] => lists.get(group as Group) ?? [];
-  return { root, logicHost, comboHost, matsetHost, refresh, files, setActive, setOnPicked, filter };
+  return { root, logicHost, comboHost, refresh, files, setActive, setOnPicked, filter };
 }
@@ -16,6 +16,8 @@ export interface TemplateInfo {
  이름: string;
  판: string;
  수정일: string;
+  /** 프로그램이 이름으로 부르는 양식이면 그 쓰는 곳 — 있으면 못 지움 */
+  쓰는곳?: string;
 }

 export interface TemplateDoc {
@@ -36,15 +38,21 @@ async function call<T>(path: string, init: RequestInit = {}): Promise<T> {
    ...init,
  });
  const body = (await response.json().catch(() => ({}))) as { detail?: unknown } & T;
-  if (response.status === 409)
-    throw new StaleError(typeof body.detail === "string" ? body.detail : "409");
-  if (!response.ok) {
-    const detail = body.detail;
-    throw new Error(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 =>
@@ -208,6 +216,33 @@ export const branchMaterialCombo = (
    body: JSON.stringify(body),
  });

+/* --- 자재 조합 표(마스터 템플릿 `자재조합.json`) — 좌측 「자재 조합」 컨테이너 --- */
+/** 표 통째 — 판(파일 판본) · 줄(담은 자재 포함) · 쓰는곳(키 → 쓰는 구조물 열 이름들) */
+export const listMaterialCombos = (): Promise<{
+  판: string;
+  줄: MaterialCombo[];
+  쓰는곳: Record<string, string[]>;
+}> => call("/material-combos");
+
+/** 새로 · 본떠 만들기(`본뜬키`) — 키는 서버가 표 「다음」 번호로 줌 */
+export const createMaterialCombo = (
+  판: string,
+  줄: Omit<MaterialCombo, "키">,
+): Promise<{ 키: string; 판: string; 줄: MaterialCombo }> =>
+  call("/material-combos", { method: "POST", body: JSON.stringify({ 판, 줄 }) });
+
+/** 고치기 — 이름 · 비고 · 담은자재(본뜬키 · 소유는 서버가 있던 것으로) */
+export const editMaterialCombo = (
+  키: string,
+  판: string,
+  줄: MaterialCombo,
+): Promise<{ 키: string; 판: string; 줄: MaterialCombo }> =>
+  call(`/material-combos/${enc(키)}`, { method: "PUT", body: JSON.stringify({ 판, 줄 }) });
+
+/** 지우기 — 구조물 열이 쓰면 서버가 막고 그 열 이름들을 까닭으로 줌 */
+export const deleteMaterialCombo = (키: string, 판: string): Promise<unknown> =>
+  call(`/material-combos/${enc(키)}?판=${enc(판)}`, { method: "DELETE" });
+
 /** 다른 열(`from`) 구조물 도면 내용을 받는 열(`column`)로 가져옴 — 도번 · 열은 받는 쪽 그대로 */
 export const copyStructure = async (column: string, from: string): Promise<void> => {
  await call(`/structures/${enc(column)}/copy?from=${enc(from)}`, { method: "POST" });
@@ -1,10 +1,10 @@
 """조합 갈라 내기 — 구조물 열 하나가 가리키는 조합을 고친 내용으로 새로 만들어 그 열만 새 키를
 가리키게 함(PLAN 15장 · 검토 `14_조합편집검토.md` 1장).
  · 일위대가 조합(UA · `일위대가조합.json`) — 새 줄은 M01 조합 저장소가 만듦(부르기만)
-  · 자재 조합(UM · `자재조합.json`) — M01 마스터 저장(`save`)으로 더함(키 = 대장 다음 번호)
+  · 자재 조합(UM · 마스터 템플릿 `자재조합.json`) — M02 자재 조합 저장소가 만듦(표 「다음」 번호)

-조합은 여러 열 · 모든 프로젝트가 같이 씀 — 제자리 고치지 않음. 담은 것의 집합(차례 · 메모 무시)이
-이미 있는 조합과 같으면 새로 안 만들고 그 키 · 새 줄의 본뜬키 = 원래 키 · 소유 현장.
+조합은 여러 열 · 모든 프로젝트가 같이 씀 — 제자리 고치지 않음. 담은 것(차례 · 메모까지)이
+이미 있는 조합과 같으면 새로 안 만들고 그 키(원래 키 먼저) · 새 줄의 본뜬키 = 원래 키 · 소유 현장.
 """

 from __future__ import annotations
@@ -13,10 +13,10 @@ from typing import Any, Callable

 from M01_MasterData import M01_MasterData_Store as m01
 from M01_MasterData import M01_MasterData_Store_Combo as combo_store
+from M02_MasterTemplete import M02_MasterTemplete_Matset as matset
 from M02_MasterTemplete import M02_MasterTemplete_Store as store

 _OWNER = "현장"
-MATERIAL_FILE = "자재조합.json"


 def _m01(fn, *args):
@@ -39,16 +39,16 @@ def _branch(
    column: str,
    version: str,
    field: str,
-    file: 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,10 +58,11 @@ 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)
+        )

-    rows = _m01(m01.read, file)[0].get("줄") or []
    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)
    if hit:
@@ -101,20 +102,14 @@ def branch_combo(
        return str(_m01(combo_store.combo_new, row, _OWNER)["key"])

    name = name.strip() or str(was.get("이름") or source)
+    rows = _m01(m01.read, combo_store.FILE)[0].get("줄") or []
    return _branch(
-        column, version, "일위대가", combo_store.FILE, "담은로직", "로직", items, source, make, name
+        column, version, "일위대가", rows, "담은로직", ("로직", "메모"), items, source, make, name
    )


-def _material_rows() -> list[dict]:
-    return _m01(m01.read, MATERIAL_FILE)[0].get("줄") or []
-
-
 def material_combo(key: str) -> dict[str, Any]:
-    row = next((r for r in _material_rows() if r.get("키") == key), None)
-    if row is None:
-        raise store.StoreError(404, f"없는 자재 조합 「{key}」")
-    return row
+    return matset.one(key)


 def branch_material_combo(
@@ -128,24 +123,14 @@ def branch_material_combo(
        if isinstance(x, dict)
    ]

-    def make(made_name: str, rows: list[dict]) -> str:
+    def make(made_name: str, _rows) -> str:
        row = {"이름": made_name, "담은자재": items, "본뜬키": source or None, "소유": _OWNER}
-        before = {r.get("키") for r in rows}
-        _m01(
-            m01.save,
-            [
-                {
-                    "file": MATERIAL_FILE,
-                    "version": _m01(m01.read, MATERIAL_FILE)[1],
-                    "changes": [{"op": "add", "row": {**row, "비고": None}}],
-                }
-            ],
-        )
-        return str(next(r["키"] for r in _material_rows() if r.get("키") not in before))
+        return matset.create(row)["키"]

    heads = next((c for c in store._structure_columns() if c["id"] == column), {})
    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, "자재조합", MATERIAL_FILE, "담은자재", "코드", items, source, make, name
+        column, version, "자재조합", rows, "담은자재", ("코드",), items, source, make, name
    )
@@ -6,7 +6,13 @@
 * 갈라 내기 모달(`askBranch`)은 재료산출 자재 목록(`M02_MasterTemplete_Materials.ts`)도 씀.
 * ========================================================================== */

-import { createButton, createInputField, el, showToast } from "@ui/ui_template_elements";
+import {
+  createButton,
+  createInputField,
+  el,
+  showConfirmDialog,
+  showToast,
+} from "@ui/ui_template_elements";
 import { openModal } from "@ui/ui_template_modal";
 import { fetchCombo, type ComboLine } from "../M01_MasterData/M01_MasterData_UI_Combo_Api";
 import { openLogicPicker } from "../M01_MasterData/M01_MasterData_UI_Combo_Pick";
@@ -35,6 +41,11 @@ const TEXT = {
  close: "닫기",
  empty: "담은 로직이 없음",
  unchanged: "고친 것이 없음",
+  discard: "고친 것을 버리고 닫음",
+  discardOk: "버리고 닫음",
+  nameEmpty: "이름을 넣음",
+  noLines: "담은 로직이 없어 적용 안 됨 — 로직을 하나 이상 담음",
+  nameLong: "이름은 {n}자까지",
  loadFailed: "조합을 못 읽음 — {value}",
  askTitle: "새 조합으로 갈라 냄",
  askName: "새 조합 이름",
@@ -49,6 +60,9 @@ const TEXT = {
  failed: "조합을 못 고침 — {value}",
 };

+/** 조합 이름 글자 수 한도 — 서버 `master_combo.MAX_이름` 과 같음 */
+const MAX_NAME = 60;
+
 const fill = (text: string, value: string | number): string =>
  text.replace("{n}", String(value)).replace("{value}", String(value));

@@ -66,17 +80,23 @@ export function askBranch(message: string, defaultName: string): Promise<string
      dialogClass: "m02-modal m02-branch",
      mount: (body, close) => {
        const name = createInputField({ label: TEXT.askName, type: "text" });
-        name.input.value = defaultName;
+        name.input.value = defaultName.slice(0, MAX_NAME);
+        name.input.maxLength = MAX_NAME;
        const ok = createButton({
          label: TEXT.askOk,
          variant: "filled",
          onClick: () => {
            const value = name.input.value.trim();
-            if (!value) return name.input.focus();
+            if (!value || value.length > MAX_NAME) {
+              name.setError(value ? fill(TEXT.nameLong, MAX_NAME) : TEXT.nameEmpty);
+              return name.input.focus();
+            }
            finish(value);
            close();
          },
        });
+        name.input.addEventListener("input", () => name.setError(undefined));
+        name.input.addEventListener("keydown", (ev) => ev.key === "Enter" && ok.click());
        body.append(
          el("p", { className: "m02-branch__msg", text: message }),
          name.root,
@@ -95,9 +115,18 @@ export function askBranch(message: string, defaultName: string): Promise<string
  });
 }

-/** 새 조합 이름 자동 — 원래 이름 · 구조물 이름(원래 이름이 이미 구조물 이름으로 끝나면 덧붙이지 않음) */
-export const branchName = (original: string, label: string): string =>
-  !original ? label : !label || original.endsWith(label) ? original : `${original} · ${label}`;
+/** 새 조합 이름 자동 — 원래 이름(끝 「 (n)」 뗌 · 서버가 새로 붙임) · 구조물 이름(한쪽이 다른 쪽을
+ * 이미 품으면 긴 쪽 하나만) */
+export const branchName = (
+  named: string,
+  label: string,
+  original = named.replace(/ \(\d+\)$/, ""),
+): string =>
+  !original || label.includes(original)
+    ? label || original
+    : !label || original.includes(label)
+      ? original
+      : `${original} · ${label}`;

 /** 결과 알림 — 새로 만듦 / 같은 조합 씀 */
 export const branchToast = (r: BranchedCombo): void =>
@@ -163,6 +192,8 @@ export async function buildComboBar(opts: ComboBarOptions): Promise<HTMLElement

  function openEditor(from: ComboLine[], comboName: string, others: number): void {
    const original = JSON.stringify(from.map((l) => [l.로직, l.메모 ?? null]));
+    const changed = (): boolean =>
+      JSON.stringify(lines.map((l) => [l.로직, l.메모 ?? null])) !== original;
    const lines: Line[] = from.map((l) => ({
      로직: l.로직,
      메모: l.메모,
@@ -173,6 +204,8 @@ export async function buildComboBar(opts: ComboBarOptions): Promise<HTMLElement
      title: fill(TEXT.editTitle, opts.label),
      closeLabel: TEXT.close,
      dialogClass: "m02-modal m02-combo-edit",
+      // 고친 채 닫기 · Esc · 바깥 누르기 — 버릴지 물음
+      beforeClose: () => !changed() || showConfirmDialog(TEXT.discard, TEXT.discardOk),
      mount: (body, close) => {
        const table = el("div", { className: "m02-combo-edit__table" });
        const paint = (): void => {
@@ -185,9 +218,12 @@ export async function buildComboBar(opts: ComboBarOptions): Promise<HTMLElement
          const rows = lines.map((line, i) => {
            const memo = el("input", {
              className: "ui-input",
-              attrs: { type: "text", value: line.메모 ?? "" },
+              attrs: { type: "text", value: line.메모 ?? "", title: line.메모 ?? "" },
+            });
+            memo.addEventListener("input", () => {
+              line.메모 = memo.value || null;
+              memo.title = memo.value;
            });
-            memo.addEventListener("input", () => (line.메모 = memo.value || null));
            const move = (to: number): void => {
              if (to < 0 || to >= lines.length) return;
              [lines[i], lines[to]] = [lines[to], lines[i]];
@@ -236,9 +272,10 @@ export async function buildComboBar(opts: ComboBarOptions): Promise<HTMLElement
        );
        const apply = createButton({ label: TEXT.apply, variant: "filled" });
        apply.addEventListener("click", async () => {
-          if (JSON.stringify(lines.map((l) => [l.로직, l.메모 ?? null])) === original) {
+          if (!changed()) {
            return showToast(TEXT.unchanged, "info");
          }
+          if (!lines.length) return showToast(TEXT.noLines, "error");
          const message = others ? fill(TEXT.askBody, others + 1) : TEXT.askAlone;
          const name = await askBranch(message, branchName(comboName, opts.label));
          if (name === null) return;
@@ -147,7 +147,13 @@ export function mountDrawingTemplate(
      values.every(Number.isFinite) &&
      values[0] < values[2] &&
      values[1] < values[3];
-    areaInputs.forEach((field) => field.setError(valid ? undefined : "왼쪽<오른쪽 · 아래<위"));
+    // 빈 칸 · 숫자 아님은 그 칸만 짚음 — 모두 숫자인데 어긋나면 크기 순서 안내
+    const own = areaInputs.map((field) => {
+      const raw = field.input.value.trim();
+      return raw === "" ? "값을 넣을 것" : Number.isFinite(Number(raw)) ? undefined : "숫자만";
+    });
+    const order = own.some(Boolean) ? undefined : "왼쪽<오른쪽 · 아래<위";
+    areaInputs.forEach((field, index) => field.setError(valid ? undefined : (own[index] ?? order)));
    areaButton.textContent = `작도 영역 ${areaInputs.map((f) => f.input.value.trim() || "?").join(" · ")}`;
    areaButton.classList.toggle("is-invalid", !valid);
    return valid ? (values as [number, number, number, number]) : null;
@@ -227,6 +233,7 @@ export function mountDrawingTemplate(
        .then((response) => {
          // 불러온 도각은 아직 저장하지 않는다 — 자리표를 놓고 [저장]을 눌러야 양식이 된다.
          load(response.drawing);
+          options.onChanged?.(true); // 불러온 것은 아직 저장 전 — 떠날 때 묻게 함
          showToast(`도형 ${response.entity_count}개를 불러왔습니다.`, "success");
        })
        .catch((error) =>
@@ -40,6 +40,8 @@ const TEXT = {
  apply: "적용",
  undo: "되돌리기",
  empty: "담은 자재가 없음",
+  noItems: "담은 자재가 없어 적용 안 됨 — 자재를 하나 이상 담음",
+  already: "이미 담은 자재 — {value}",
  unlinkAsk: "{value} 자재는 {cell} 칸에 이어져 있음 — 빼면 연결도 풂",
  unlinkOk: "빼고 연결 풂",
  loadFailed: "자재 조합을 못 읽음 — {value}",
@@ -118,8 +120,8 @@ export interface MaterialPanelOptions {
  unlink: (codes: string[]) => void;
 }

-/** 자재 고르기 창 — 이름 · 규격 · 코드 낱말로 찾아 하나 고름 */
-function pickMaterial(done: (item: MaterialItem) => void): void {
+/** 자재 고르기 창 — 이름 · 규격 · 코드 낱말로 찾아 하나 고름(좌측 자재 조합 상세도 씀) */
+export function pickMaterial(done: (item: MaterialItem) => void): void {
  openModal({
    title: TEXT.pickTitle,
    closeLabel: TEXT.pickClose,
@@ -233,7 +235,7 @@ export function buildMaterialPanel(opts: MaterialPanelOptions): MaterialPanel {
          )
            return;
          items.splice(i, 1);
-          removed.push(m.코드);
+          if (cells.length) opts.unlink([m.코드]); // 확인 글대로 바로 풂(알약 막대 「목록에서 빼기」와 같음)
          paint();
          opts.onChange(items);
        });
@@ -257,16 +259,14 @@ export function buildMaterialPanel(opts: MaterialPanelOptions): MaterialPanel {
    paintToggle();
  };

-  /** 이번에 뺀 자재 코드 — 적용하면 이은 칸 연결도 풂 */
-  let removed: string[] = [];
  const paintFoot = (): void => {
    if (!opts.isAdmin) return foot.replaceChildren();
    const add = createButton({ label: TEXT.add, variant: "ghost", size: "sm" });
    add.addEventListener("click", () =>
      pickMaterial((m) => {
-        if (items.some((x) => x.코드 === m.코드)) return;
+        if (items.some((x) => x.코드 === m.코드))
+          return showToast(fill(TEXT.already, { value: m.코드 }), "info");
        items.push(m);
-        removed = removed.filter((c) => c !== m.코드);
        paint();
        opts.onChange(items);
      }),
@@ -275,6 +275,7 @@ export function buildMaterialPanel(opts: MaterialPanelOptions): MaterialPanel {
    if (sig(items) !== sig(saved)) {
      const apply = createButton({ label: TEXT.apply, variant: "filled", size: "sm" });
      apply.addEventListener("click", async () => {
+        if (!items.length) return showToast(TEXT.noItems, "error");
        const message = !key
          ? TEXT.askFirst
          : others
@@ -290,8 +291,6 @@ export function buildMaterialPanel(opts: MaterialPanelOptions): MaterialPanel {
            이름: name,
          });
          branchToast(result);
-          if (removed.length) opts.unlink(removed);
-          removed = [];
          key = result.키;
          others = 0;
          combo = await fetchMaterialCombo(key).catch(() => null);
@@ -306,7 +305,6 @@ export function buildMaterialPanel(opts: MaterialPanelOptions): MaterialPanel {
      const undo = createButton({ label: TEXT.undo, variant: "ghost", size: "sm" });
      undo.addEventListener("click", () => {
        items = [...saved];
-        removed = [];
        paint();
        opts.onChange(items);
      });
@@ -0,0 +1,133 @@
+"""M02 자재 조합 저장소 — 마스터 템플릿 표 `자재조합.json`(구조물집계표조합.json 과 같은 자리).
+
+줄 = 키 UM · 이름 · 담은자재(코드 · 이름 · 규격 · 단위) · 본뜬키 · 소유 · 비고 — 수량 · 단가는 안 둠
+(재료산출 몫). 키는 표 안 「다음」 번호(지운 키는 다시 안 씀) · 집계표 열 `자재조합` 칸이 가리킴.
+틀 검사 = `master_material_combo.check_form`(check_master 와 같은 것) · 판 = 파일 sha256 앞 16자.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from common_util.common_util_json import atomic_write_json
+from M01_MasterData import M01_MasterData_Store as m01
+from M02_MasterTemplete import M02_MasterTemplete_Store as store
+
+mmc = m01.cm.mmc  # 자재 조합 틀(`resources/master_data/scripts/master_material_combo.py`)
+FILE = mmc.FILE
+OWNERS = mmc.OWNERS
+_HEAD = "UM"
+
+
+def _load() -> tuple[dict[str, Any], str]:
+    """(표, 판) — 파일이 없으면 빈 표 · 판 빈 글."""
+    path = store.FOLDER / FILE
+    if not path.is_file():
+        return {"그룹": mmc.GROUP, "판": "2026", "비고": [], "다음": 1, "줄": []}, ""
+    raw = path.read_bytes()
+    return json.loads(raw), store.version_of(raw)
+
+
+def _find(doc: dict, key: str) -> dict[str, Any]:
+    row = next((r for r in doc["줄"] if r.get("키") == key), None)
+    if row is None:
+        raise store.StoreError(404, f"없는 자재 조합 「{key}」")
+    return row
+
+
+def listing() -> dict[str, Any]:
+    """표 통째 — 판 · 줄(담은 자재 포함 · 작아서 한 번에) · 쓰는곳(키 → 쓰는 구조물 열 이름들)."""
+    doc, version = _load()
+    used: dict[str, list[str]] = {}
+    for col in store._structure_columns():
+        if key := col.get("자재조합"):
+            used.setdefault(key, []).append(_name(col))
+    return {"판": version, "줄": doc["줄"], "쓰는곳": used}
+
+
+def _name(col: dict) -> str:
+    return " ".join(h for h in store._heads(col) if h) or col["id"]
+
+
+def one(key: str) -> dict[str, Any]:
+    return _find(_load()[0], key)
+
+
+def users_of(key: str) -> list[str]:
+    """구조물집계표에서 `자재조합` 칸이 이 키인 열 — 머리 글(없으면 열 id)."""
+    out = []
+    for col in store._structure_columns():
+        if col.get("자재조합") == key:
+            out.append(_name(col))
+    return out
+
+
+def _clean(row: Any, key: str, keep: dict | None = None) -> dict[str, Any]:
+    """서버가 잡는 칸 — 키 · 열 한 벌 · 자재 줄 네 칸 · 본뜬키는 만들 때만(고칠 때는 있던 것)."""
+    if not isinstance(row, dict):
+        raise store.StoreError(400, "자재 조합 줄이 묶음 아님")
+    name = row.get("이름")
+    if not isinstance(name, str) or not name.strip():
+        raise store.StoreError(400, "자재 조합 줄에 「이름」 이 없거나 글자 아님")
+    got = row.get("담은자재")
+    got = [
+        {c: m.get(c) for c in mmc.ITEM_COLS} if isinstance(m, dict) else m
+        for m in (got if isinstance(got, list) else [])
+    ]
+    known = {str(r.get("키")) for d in m01.loaded()[0].values() for r in d.get("줄") or []}
+    lost = [str(m.get("코드")) for m in got if isinstance(m, dict) and m.get("코드") not in known]
+    if lost:
+        raise store.StoreError(422, {"errors": [f"마스터에 없는 자재 {' · '.join(lost)}"]})
+    base = keep or row
+    owner = base.get("소유") or OWNERS[0]
+    return {
+        "키": key,
+        "이름": name.strip(),
+        "담은자재": got,
+        "본뜬키": base.get("본뜬키") or None,
+        "소유": owner,
+        "비고": row.get("비고") or None,
+    }
+
+
+def _save(doc: dict, version: str) -> str:
+    """틀 검사 → 판이 같을 때만 씀 → 새 판."""
+    if errors := mmc.check_form(FILE, doc):
+        raise store.StoreError(422, {"errors": errors})
+    path = store.FOLDER / FILE
+    with store._LOCK:
+        have = store.version_of(path.read_bytes()) if path.is_file() else ""
+        if have != (version or ""):
+            raise store.StoreError(409, {"stale": [FILE], "판": have})
+        atomic_write_json(path, doc)
+        return store.version_of(path.read_bytes())
+
+
+def create(row: Any, version: str | None = None) -> dict[str, Any]:
+    """새 줄 — 키 = 「다음」 번호 · 본뜬키는 있는 다른 키만. `version` None = 지금 판(갈라 내기)."""
+    doc, have = _load()
+    key = f"{_HEAD}{int(doc.get('다음') or 1):06d}"
+    fixed = _clean(row, key)
+    if fixed["본뜬키"] and fixed["본뜬키"] not in {r.get("키") for r in doc["줄"]}:
+        raise store.StoreError(400, f"본뜬키 「{fixed['본뜬키']}」 — 있는 다른 자재 조합 키여야 함")
+    doc = {**doc, "다음": int(doc.get("다음") or 1) + 1, "줄": [*doc["줄"], fixed]}
+    return {"키": key, "판": _save(doc, have if version is None else version), "줄": fixed}
+
+
+def edit(key: str, row: Any, version: str) -> dict[str, Any]:
+    doc, _ = _load()
+    fixed = _clean(row, key, keep=_find(doc, key))
+    doc = {**doc, "줄": [fixed if r.get("키") == key else r for r in doc["줄"]]}
+    return {"키": key, "판": _save(doc, version), "줄": fixed}
+
+
+def delete(key: str, version: str) -> dict[str, Any]:
+    """지우기 — 구조물 열이 쓰면 409 + 열 이름들(지우지 않음)."""
+    doc, _ = _load()
+    _find(doc, key)
+    if users := users_of(key):
+        msg = f"구조물 {len(users)} 곳이 쓰는 자재 조합이라 못 지움 — {' · '.join(users)}"
+        raise store.StoreError(409, {"errors": [msg], "users": users})
+    doc = {**doc, "줄": [r for r in doc["줄"] if r.get("키") != key]}
+    return {"판": _save(doc, version)}
@@ -0,0 +1,264 @@
+/* =============================================================================
+ * M02_MasterTemplete_Matset.ts
+ * 좌측 「자재 조합」 컨테이너 — 찾기 · 목록(키 맨 앞) · 새로 · 본떠 만들기 · 지우기(컨테이너 안) ·
+ * 줄을 누르면 메인 칸에 상세: 이름 · 비고 · 본뜬키 · 담은 자재 표(빼기) · [자재 더하기] · [저장].
+ * 표 = 마스터 템플릿 `자재조합.json`(키 UM · 서버 `M02_MasterTemplete_Matset.py`) · 지우기는 쓰는 열이
+ * 있으면 서버가 막음. 재료산출 옆 판이 갈라 낸 조합도 같은 표라 여기 보임(펼칠 때 새로 받음).
+ * ========================================================================== */
+
+import {
+  createButton,
+  createInputField,
+  el,
+  showConfirmDialog,
+  showToast,
+} from "@ui/ui_template_elements";
+import { t as L } from "@ui/ui_template_locale";
+import {
+  createMaterialCombo,
+  deleteMaterialCombo,
+  editMaterialCombo,
+  listMaterialCombos,
+  StaleError,
+  type MaterialCombo,
+} from "./M02_MasterTemplete_Api_Fetch";
+import { pickMaterial } from "./M02_MasterTemplete_Materials";
+import { tm } from "./M02_MasterTemplete_Matset_Text";
+
+export interface MatsetSectionOptions {
+  isAdmin: boolean;
+  /** 저장 안 한 고침을 버릴지 확인 — 취소면 false */
+  confirmLeave: () => Promise<boolean>;
+  /** 메인 칸에 상세를 띄움 — 고침 표시 손잡이를 돌려받음 */
+  show: (label: string, node: HTMLElement) => (dirty: boolean) => void;
+  /** 메인 칸을 비움(지운 뒤) */
+  close: () => void;
+  /** 상세를 열었음 — 좌측 다른 줄 고름 표시를 지움 */
+  onOpen: () => void;
+}
+
+export interface MatsetSection {
+  title: string;
+  body: HTMLElement;
+  /** 새로 · 본떠 만들기 · 지우기 줄(관리자만 · 아니면 빈 목록) */
+  actions: HTMLElement[];
+  /** 표를 새로 받아 목록을 다시 그림 */
+  refresh: () => Promise<void>;
+  /** 다른 양식을 열었음 — 고름 표시만 지움 */
+  clear: () => void;
+}
+
+const why = (error: unknown): string => (error instanceof Error ? error.message : "");
+
+export function buildMatsetSection(opt: MatsetSectionOptions): MatsetSection {
+  let all: MaterialCombo[] = [];
+  let version = "";
+  let used: Record<string, string[]> = {};
+  let q = "";
+  /** 열린 상세의 키 — 새(저장 전)는 빈 글 · 안 열렸으면 null */
+  let openKey: string | null = null;
+
+  const find = createInputField({ type: "search", placeholder: tm("Search") });
+  const list = el("div", { className: "m02-side__items ui-sidebar-list" });
+  const body = el("div", { className: "m02-side__items", children: [find.root, list] });
+  find.input.addEventListener("input", () => {
+    q = find.input.value.trim().toLowerCase();
+    paintList();
+  });
+
+  const btnNew = createButton({ label: L("M02_New"), variant: "filled", size: "sm" });
+  const btnCopy = createButton({ label: L("M02_Copy"), variant: "ghost", size: "sm" });
+  const btnDel = createButton({ label: L("M02_Delete"), variant: "danger", size: "sm" });
+  const actions = opt.isAdmin
+    ? [el("div", { className: "m02-side__row", children: [btnNew, btnCopy, btnDel] })]
+    : [];
+  const paintButtons = (): void => {
+    btnCopy.disabled = btnDel.disabled = !openKey;
+  };
+
+  function paintList(): void {
+    const shown = all.filter((x) => !q || `${x.키} ${x.이름}`.toLowerCase().includes(q));
+    list.replaceChildren(
+      ...(shown.length
+        ? shown.map((x) => {
+            const b = el("button", {
+              className: `m02-side__item ui-sidebar-row${x.키 === openKey ? " is-active" : ""}`,
+              text: `${x.키} ${x.이름}`,
+              attrs: { type: "button", "data-matset-key": x.키 },
+            });
+            b.addEventListener("click", () => void select(x.키));
+            return b;
+          })
+        : [el("p", { className: "m02-side__empty", text: tm("Empty") })]),
+    );
+  }
+
+  async function refresh(): Promise<void> {
+    try {
+      ({ 판: version, 줄: all, 쓰는곳: used } = await listMaterialCombos());
+    } catch (error) {
+      showToast(tm("Load_Failed", why(error)), "error");
+    }
+    paintList();
+    paintButtons();
+  }
+
+  async function select(key: string): Promise<void> {
+    if (key === openKey || !(await opt.confirmLeave())) return;
+    const row = all.find((x) => x.키 === key);
+    if (row) draw(structuredClone(row), false);
+  }
+
+  /** 메인 칸 상세 — `row` 는 고칠 사본(저장 전까지 표에 안 들어감) */
+  function draw(row: MaterialCombo, isNew: boolean): void {
+    openKey = isNew ? "" : row.키;
+    const edit = opt.isAdmin;
+    const field = (label: string, name: "이름" | "비고") => {
+      const f = createInputField({ type: "text", label });
+      f.input.value = row[name] ?? "";
+      f.input.disabled = !edit;
+      f.input.setAttribute("data-matset-field", name);
+      f.input.addEventListener("input", () => {
+        if (name === "이름") row.이름 = f.input.value;
+        else row.비고 = f.input.value || null;
+        setDirty(true);
+      });
+      return f.root;
+    };
+    const table = el("div", { className: "m02-matset__table" });
+    const paintItems = (): void => {
+      const head = el("div", {
+        className: "m02-mat__row m02-mat__row--head",
+        children: [tm("Col_Code"), tm("Col_Name"), tm("Col_Spec"), tm("Col_Unit"), "", ""].map(
+          (t) => el("span", { text: t }),
+        ),
+      });
+      const rows = row.담은자재.map((m, i) => {
+        const acts = el("span");
+        if (edit) {
+          const del = createButton({ label: tm("Remove"), variant: "ghost", size: "sm" });
+          del.addEventListener("click", () => {
+            row.담은자재.splice(i, 1);
+            setDirty(true);
+            paintItems();
+          });
+          acts.append(del);
+        }
+        return el("div", {
+          className: "m02-mat__row",
+          attrs: { "data-matset-item": m.코드 },
+          children: [m.코드, m.이름 ?? "", m.규격 ?? "", m.단위 ?? "", ""]
+            .map((t) => el("span", { text: t }))
+            .concat(acts),
+        });
+      });
+      table.replaceChildren(
+        head,
+        ...(rows.length ? rows : [el("p", { className: "m02-side__empty", text: tm("NoItem") })]),
+      );
+    };
+    paintItems();
+
+    const add = createButton({ label: tm("AddItem"), variant: "ghost" });
+    add.addEventListener("click", () =>
+      pickMaterial((m) => {
+        if (row.담은자재.some((x) => x.코드 === m.코드)) return;
+        row.담은자재.push({ 코드: m.코드, 이름: m.이름, 규격: m.규격, 단위: m.단위 });
+        setDirty(true);
+        paintItems();
+      }),
+    );
+    const save = createButton({ label: tm("Save"), variant: "filled" });
+    save.addEventListener("click", async () => {
+      if (!row.이름.trim()) return showToast(tm("NeedName"), "error");
+      if (!row.담은자재.length) return showToast(tm("NeedItem"), "error");
+      save.disabled = true; // 연달아 눌러도 한 번만
+      try {
+        const { 키, ...rest } = row;
+        const done = isNew
+          ? await createMaterialCombo(version, rest)
+          : await editMaterialCombo(키, version, row);
+        setDirty(false);
+        showToast(tm("Saved"), "success");
+        await refresh();
+        draw(structuredClone(done.줄), false);
+      } catch (error) {
+        if (error instanceof StaleError) {
+          showToast(tm("Stale"), "error");
+          await refresh();
+        } else showToast(tm("Failed", why(error)), "error");
+      } finally {
+        save.disabled = false;
+      }
+    });
+
+    const node = el("div", {
+      className: "m02-matset",
+      children: [
+        el("div", {
+          className: "m02-matset__fields",
+          children: [
+            field(tm("Head_Name"), "이름"),
+            field(tm("Head_Note"), "비고"),
+            el("p", {
+              className: "m02-side__empty",
+              text: `${tm("Head_Origin")}: ${row.본뜬키 ?? tm("Origin_Self")}`,
+              attrs: { "data-matset-origin": row.본뜬키 ?? "" },
+            }),
+          ],
+        }),
+        el("h3", { className: "m02-matset__head", text: tm("Items_Title") }),
+        table,
+        ...(edit ? [el("div", { className: "m02-side__row", children: [add, save] })] : []),
+      ],
+    });
+    const setDirty = opt.show(isNew ? tm("New") : `${row.키} ${row.이름}`, node);
+    if (isNew) setDirty(true);
+    opt.onOpen();
+    paintList();
+    paintButtons();
+  }
+
+  btnNew.addEventListener("click", async () => {
+    if (!(await opt.confirmLeave())) return;
+    draw({ 키: "", 이름: "", 담은자재: [], 본뜬키: null, 소유: "현장", 비고: null }, true);
+  });
+  btnCopy.addEventListener("click", async () => {
+    const from = all.find((x) => x.키 === openKey);
+    if (!from || !(await opt.confirmLeave())) return;
+    const copy = structuredClone(from);
+    draw({ ...copy, 키: "", 이름: tm("CopyName", from.이름), 본뜬키: from.키, 소유: "현장" }, true);
+  });
+  btnDel.addEventListener("click", async () => {
+    const key = openKey;
+    if (!key) return;
+    await refresh(); // 최신 판 · 쓰는 열로
+    // 쓰는 열이 있으면 확인 창 없이 바로 알림(서버도 막음)
+    const users = used[key] ?? [];
+    if (users.length) return showToast(tm("InUse", users.join(" · ")), "error");
+    if (!(await showConfirmDialog(tm("DeleteAsk", key)))) return;
+    try {
+      await deleteMaterialCombo(key, version);
+      showToast(tm("Deleted"), "success");
+      openKey = null;
+      opt.close();
+    } catch (error) {
+      showToast(tm("Failed", why(error)), "error");
+    }
+    await refresh();
+  });
+
+  paintButtons();
+  return {
+    title: tm("Title"),
+    body,
+    actions,
+    refresh,
+    clear: () => {
+      if (openKey === null) return;
+      openKey = null;
+      paintList();
+      paintButtons();
+    },
+  };
+}
@@ -0,0 +1,49 @@
+/* =============================================================================
+ * M02_MasterTemplete_Matset_Text.ts
+ * 좌측 「자재 조합」 컨테이너 · 상세 화면 글자 — [한국어, 영어]
+ * ========================================================================== */
+
+import { currentLanguageIndex } from "@ui/ui_template_locale";
+
+const TEXT = {
+  Title: ["자재 조합", "Material sets"],
+  Search: ["키 · 이름으로 찾기", "Search by key or name"],
+  Empty: ["자재 조합 없음", "No material sets"],
+  New: ["새 자재 조합(저장 전)", "New material set (unsaved)"],
+  CopyName: ["{value} 본뜸", "{value} copy"],
+  Save: ["저장", "Save"],
+  InUse: [
+    "{value} 열이 쓰는 자재 조합이라 못 지움",
+    "Used by the column(s) {value} — cannot delete",
+  ],
+  DeleteAsk: ["자재 조합 {value} 을 지울까요?", "Delete material set {value}?"],
+  Saved: ["저장함", "Saved"],
+  Deleted: ["지움", "Deleted"],
+  Stale: [
+    "그 사이 자재 조합 표가 바뀜 — 목록을 새로 받았으니 다시 고쳐 주세요",
+    "The table changed meanwhile — reloaded, please edit again",
+  ],
+  NeedName: ["이름을 적어야 저장됨", "A name is required"],
+  NeedItem: ["담은 자재가 하나는 있어야 저장됨", "Add at least one material"],
+  Load_Failed: ["자재 조합을 못 받음 — {value}", "Could not load material sets — {value}"],
+  Failed: ["자재 조합을 못 고침 — {value}", "Could not change the material set — {value}"],
+  Head_Name: ["이름", "Name"],
+  Head_Note: ["비고", "Note"],
+  Head_Origin: ["본뜬키", "Copied from"],
+  Origin_Self: ["원본", "Original"],
+  Items_Title: ["담은 자재", "Materials in it"],
+  Col_Code: ["코드", "Code"],
+  Col_Name: ["이름", "Name"],
+  Col_Spec: ["규격", "Spec"],
+  Col_Unit: ["단위", "Unit"],
+  Remove: ["빼기", "Remove"],
+  AddItem: ["자재 더하기", "Add material"],
+  NoItem: ["담은 자재 없음", "No materials yet"],
+} as const satisfies Record<string, readonly [string, string]>;
+
+export type MatsetTextKey = keyof typeof TEXT;
+
+export function tm(key: MatsetTextKey, value = ""): string {
+  const entry = TEXT[key];
+  return (entry[currentLanguageIndex as 0 | 1] ?? entry[0]).replace("{value}", value);
+}
@@ -11,6 +11,7 @@ from fastapi import APIRouter, HTTPException, Query
 from pydantic import BaseModel

 from M02_MasterTemplete import M02_MasterTemplete_Branch as branch
+from M02_MasterTemplete import M02_MasterTemplete_Matset as matset
 from M02_MasterTemplete import M02_MasterTemplete_Store as store

 router = APIRouter(prefix="/api/m02", tags=["M02 MasterTemplete"])
@@ -35,6 +36,11 @@ class MaterialBranchBody(BaseModel):
    판: str = ""


+class MatsetBody(BaseModel):
+    판: str = ""  # 자재 조합 표 판 — 어긋나면 409
+    줄: dict[str, Any]
+
+
 def _call(fn, *args):
    try:
        return fn(*args)
@@ -78,12 +84,37 @@ def post_structure_material_combo(column: str, body: MaterialBranchBody) -> dict
    )


+# 자재 조합 표(마스터 템플릿 `자재조합.json` · 키 UM) — 좌측 「자재 조합」 컨테이너
+@router.get("/material-combos")
+def get_material_combos() -> dict:
+    """표 통째 — `{판, 줄}`(줄마다 담은 자재 포함)."""
+    return _call(matset.listing)
+
+
@router.get("/material-combos/{key}")
 def get_material_combo(key: str) -> dict:
    """자재 조합 한 줄(키 UM) — 키 · 이름 · 담은자재 · 본뜬키 · 소유 · 비고."""
    return _call(branch.material_combo, key)


+@router.post("/material-combos")
+def post_material_combo(body: MatsetBody) -> dict:
+    """새로 · 본떠 만들기(`줄.본뜬키`) — 키는 표 「다음」 번호 · `{키, 판, 줄}`."""
+    return _call(matset.create, body.줄, body.판)
+
+
+@router.put("/material-combos/{key}")
+def put_material_combo(key: str, body: MatsetBody) -> dict:
+    """고치기 — 이름 · 비고 · 담은자재(본뜬키 · 소유는 있던 것)."""
+    return _call(matset.edit, key, body.줄, body.판)
+
+
+@router.delete("/material-combos/{key}")
+def delete_material_combo(key: str, 판: str = "") -> dict:
+    """지우기 — 구조물 열이 쓰면 409 `{errors, users}`."""
+    return _call(matset.delete, key, 판)
+
+
 # 복사 가져오기 — 다른 열(`from`) 내용을 받는 열로 · 번호 · 열은 받는 쪽 그대로
@router.post("/structures/{column}/copy")
 def post_structure_copy(column: str, source: str = Query(alias="from")) -> dict:
@@ -81,7 +81,10 @@ def _path(kind: str, name: str) -> Path:
 def _info(kind: str, path: Path) -> dict[str, Any]:
    raw = path.read_bytes()
    stamp = datetime.fromtimestamp(path.stat().st_mtime).isoformat(timespec="seconds")
-    return {"종류": kind, "이름": path.stem, "판": version_of(raw), "수정일": stamp}
+    row = {"종류": kind, "이름": path.stem, "판": version_of(raw), "수정일": stamp}
+    if (kind, path.stem) in IN_USE:
+        row["쓰는곳"] = IN_USE[(kind, path.stem)]  # 화면이 지우기 확인 창 전에 막음
+    return row


 def list_all() -> list[dict[str, Any]]:
@@ -210,13 +213,19 @@ def _column_ids() -> list[str]:
    return [col["id"] for col in _structure_columns()]


-def _pick_code(col: dict[str, Any], taken: dict[str, str], heads: dict[str, tuple]) -> str:
+def _pick_code(
+    col: dict[str, Any],
+    taken: dict[str, str],
+    heads: dict[str, tuple],
+    retired: list[str] | None = None,
+) -> str:
    """새 열 번호 — 층마다 같은 무리(그 층까지 제목행이 같은 열)가 이미 번호를 가졌으면 그 두 자리를
    이어 받고 · 없으면 그 층 가장 큰 번호 + 1 · 빈 층(종류 밖)은 00 · 맨 아래 층(분류3)은 늘 다음
    번호. 같은 8자리가 이미 있으면(같은 제목행 · 빈 분류3 겹침) 맨 아래 층을 그 무리 다음 번호로.
-    `taken` = 이미 번호 있는 열 `{열 id: 8자리}` · `heads` = 열 id → 제목행."""
+    `taken` = 이미 번호 있는 열 `{열 id: 8자리}` · `heads` = 열 id → 제목행 ·
+    `retired` = 지운 열의 번호(다시 안 줌 — 「가장 큰 번호」 · 겹침 셈에만 듦)."""
    parts = _heads(col)
-    codes = list(taken.values())
+    codes = [*taken.values(), *(retired or [])]
    mates = [(heads[cid], code) for cid, code in taken.items() if cid in heads]

    def next_of(prefix: str) -> str:
@@ -246,7 +255,13 @@ def _new_code(column: str) -> str:
        return taken[column]
    cols = _structure_columns()
    col = next((c for c in cols if c["id"] == column), {"id": column})
-    return _pick_code(col, taken, {c["id"]: _heads(c) for c in cols})
+    return _pick_code(col, taken, {c["id"]: _heads(c) for c in cols}, _retired())
+
+
+def _retired() -> list[str]:
+    """지운 열의 8자리 — 조합 장부 `지운번호`(한 번 준 번호는 다시 안 줌)."""
+    path = FOLDER / COMBO_FILE
+    return json.loads(path.read_bytes()).get("지운번호", []) if path.is_file() else []


 def _blank(kind: str, column: str) -> dict[str, Any]:
@@ -342,12 +357,20 @@ def prune_removed_structures() -> list[str]:
    번호는 비워 둠(다른 열 번호를 안 당김)."""
    keep = set(_column_ids())
    gone: list[str] = []
+    codes: set[str] = set()
    with _LOCK:
-        for kind in _KEY:
+        for kind, key, _, _ in PARTS:
            for path in sorted((FOLDER / kind).glob("[!.]*.json")):
                if path.stem not in keep:
+                    code = _code(json.loads(path.read_bytes()), key)
+                    codes.update([code] if code else [])
                    path.unlink()
                    gone.append(f"{kind}/{path.stem}")
+        if codes:  # 지운 번호는 장부에 남겨 새 열이 다시 안 받게
+            book = FOLDER / COMBO_FILE
+            doc = json.loads(book.read_bytes()) if book.is_file() else {}
+            doc["지운번호"] = sorted(codes | set(doc.get("지운번호", [])))
+            atomic_write_json(book, doc)
    return gone


@@ -387,9 +410,10 @@ def renumber() -> dict[str, list[str]]:
        cols = _structure_columns()
        heads = {c["id"]: _heads(c) for c in cols}
        taken = _codes()
+        retired = _retired()
        for col in cols:
            if col["id"] not in taken:
-                taken[col["id"]] = _pick_code(col, taken, heads)
+                taken[col["id"]] = _pick_code(col, taken, heads, retired)
        docs = {kind: dict(_docs(kind)) for kind in _KEY}
        for col in cols:
            cid = col["id"]
@@ -467,7 +491,10 @@ def sync_combos() -> dict[str, Any]:
                keys[col["id"]] = f"{_COMBO_HEAD}{after:06d}"
                after += 1
            rows.append(_combo_row(keys[col["id"]], col, numbers.get(col["id"], {})))
-        doc = {"그룹": "구조물집계표조합", "판": 1, "비고": _COMBO_NOTE, "다음": after, "줄": rows}
+        doc = {"그룹": "구조물집계표조합", "판": 1, "비고": _COMBO_NOTE, "다음": after}
+        if old.get("지운번호"):
+            doc["지운번호"] = old["지운번호"]  # 지운 열의 도번 8자리 — 다시 안 줌
+        doc["줄"] = rows
        if doc != old:
            atomic_write_json(path, doc)
    return doc
@@ -501,6 +501,8 @@ export function createStructurePanel(opts: StructurePanelOptions): StructurePane
  async function openEdit(kind: EditKind): Promise<void> {
    const at = column;
    if (!at) return;
+    // 저장 전 새 열(분류 더하기) — 문서 · 번호가 아직 없음 · 떠나면 집계표 고침까지 버리게 됨
+    if (!numbers[at]?.[PARTS[kind].field]) return void showToast(TEXT.saveFirst, "info");
    if (!(await opts.confirmLeave())) return;
    opts.onEdit(at, columnLabel, kind);
  }
@@ -86,6 +86,8 @@ export interface MainHandle {
  current: () => Selection | null;
  /** 저장 안 한 고침이 있으면 버릴지 물음 — 취소면 false */
  confirmLeave: () => Promise<boolean>;
+  /** 양식 밖 화면(좌측 자재 조합 상세)을 띄움 — 머리는 제목만 · 고침 표시 손잡이를 돌려줌 */
+  showView: (label: string, node: HTMLElement) => (dirty: boolean) => void;
 }

 /** 이 층에서 고칠 수 있나 — 시스템은 관리자만 · 회사는 여기서 못 고침(공식으로 저장으로만) */
@@ -93,7 +95,12 @@ export function canEdit(layer: Layer, isAdmin: boolean): boolean {
  return layer === "project" || layer === "personal" || (layer === "system" && isAdmin);
 }

-export function createMain(isAdmin: boolean, onSaved?: () => void): MainHandle {
+/** `onOpened` — 무엇을 열든(좌측 · 카드 [도면 수정] · 다시 읽기) 연 바로 뒤 부름(좌측 고름 표시) */
+export function createMain(
+  isAdmin: boolean,
+  onSaved?: () => void,
+  onOpened?: () => void,
+): MainHandle {
  const title = el("h2", { className: "m02-main__title", text: L("M02_PickTemplate") });
  const reload = createButton({ label: L("M02_Reload"), variant: "ghost" });
  const save = createButton({ label: L("M02_Save"), variant: "filled" });
@@ -134,7 +141,13 @@ export function createMain(isAdmin: boolean, onSaved?: () => void): MainHandle {
  window.addEventListener("beforeunload", guard);
  const confirmLeave = async (): Promise<boolean> => {
    if (!dirty) return true;
-    if (!(await showConfirmDialog(L("M02_DiscardConfirm")))) return false;
+    if (!(await showConfirmDialog(L("M02_DiscardConfirm")))) {
+      // 취소 — 초점을 시트(고른 칸 입력 자리) · 집계표 · 도면으로 돌려 키보드 그대로
+      host
+        .querySelector<HTMLElement>(".ss-input, .ui-sheet, iframe")
+        ?.focus({ preventScroll: true });
+      return false;
+    }
    dirty = false;
    return true;
  };
@@ -357,6 +370,7 @@ export function createMain(isAdmin: boolean, onSaved?: () => void): MainHandle {
    drop();
    showNotice([]);
    sel = next;
+    onOpened?.();
    bar();
    if (!next) {
      title.textContent = L("M02_PickTemplate");
@@ -429,11 +443,24 @@ export function createMain(isAdmin: boolean, onSaved?: () => void): MainHandle {
    }
  }

+  function showView(label: string, node: HTMLElement): (d: boolean) => void {
+    ++seq;
+    dirty = false;
+    drop();
+    showNotice([]);
+    sel = null;
+    onOpened?.(); // 좌측 양식 · 열 줄 고름 지움
+    bar();
+    title.textContent = label;
+    host.replaceChildren(node);
+    return (d) => (dirty = d);
+  }
+
  save.addEventListener("click", () => void doSave());
  reload.addEventListener("click", async () => {
    if (sel && (await confirmLeave())) void open(sel);
  });
  bar();
  empty("");
-  return { root, open, current: () => sel, confirmLeave };
+  return { root, open, current: () => sel, confirmLeave, showView };
 }
@@ -17,12 +17,17 @@ import "./M02_MasterTemplete_UI_Style.css";
 export async function renderM02MasterTemplate(root: HTMLElement): Promise<void> {
  const user = await fetchSessionUser().catch(() => null);
  const isAdmin = user?.role === "SYSTEM_ADMIN";
-  const main = createMain(isAdmin, () => void side.refresh());
+  const main = createMain(
+    isAdmin,
+    () => void side.refresh(),
+    () => side.paint(),
+  );
  const side = buildSide({
    isAdmin,
    onOpen: (sel) => void main.open(sel),
    getOpen: main.current,
    confirmLeave: main.confirmLeave,
+    showView: main.showView,
  });

  const layout = el("div", { className: "ui-workflow-layout m02-master" });
@@ -3,7 +3,7 @@
 * 마스터 템플릿 좌측 패널 — 시스템 양식 목록(표/도면/구조물 도면/면적산출/재료산출) · 새로 · 본떠 · 지우기.
 * 서버 길은 계약 `6_계약.md`. 구조물 도면 · 면적산출 · 재료산출 줄은 집계표 구조물 열(꼴=수)마다 하나씩 —
 * 서버가 미리 만들어 둠(도번 SD · 면적번 SA · 재료번 SM + 같은 8자리) ·
- * 줄 글은 번호가 맨 앞(「SD01010100 돌기슭막이 …」).
+ * 줄 글은 번호가 맨 앞(「SD01010100 돌기슭막이 …」). 맨 아래 「자재 조합」 컨테이너는 `M02_MasterTemplete_Matset.ts`.
 * ========================================================================== */

 import {
@@ -34,6 +34,7 @@ import {
  structureLabel,
  type StructureColumn,
 } from "./M02_MasterTemplete_Structure";
+import { buildMatsetSection } from "./M02_MasterTemplete_Matset";
 import { canEdit, type Selection } from "./M02_MasterTemplete_UI_Main";

 const KINDS: { kind: Kind; label: () => string }[] = [
@@ -75,13 +76,15 @@ export interface SideOptions {
  getOpen: () => Selection | null;
  /** 저장 안 한 고침을 버릴지 확인 — 취소면 false */
  confirmLeave: () => Promise<boolean>;
+  /** 메인 칸에 양식 밖 화면(자재 조합 상세)을 띄움 */
+  showView: (label: string, node: HTMLElement) => (dirty: boolean) => void;
 }

 export interface SideHandle {
  root: HTMLElement;
  refresh: () => Promise<void>;
-  /** 좌측 고름 표시만 옮김 — 화면은 열지 않음 */
-  select: (kind: Kind, name: string) => void;
+  /** 고름 표시를 지금 열린 것 한 줄로 — 편집 칸이 무엇을 열든(카드 [도면 수정] 등) 부름 */
+  paint: () => void;
 }

 /** 서버 이름 규칙과 같게 — 화면에서 먼저 막음 */
@@ -102,8 +105,6 @@ export function buildSide(opt: SideOptions): SideHandle {
  let numbers: Record<string, StructureNumbers> = {};
  let seq = 0;

-  let picked: { kind: Kind; name: string } | null = null;
-
  const section = (title: string, body: HTMLElement, ...more: HTMLElement[]): HTMLElement =>
    el("section", {
      className: "m02-side__group ui-collapsible ui-sidebar-section ui-sidebar-card is-collapsed",
@@ -128,21 +129,33 @@ export function buildSide(opt: SideOptions): SideHandle {
    del.addEventListener("click", () => void deleteCurrent());
    return [el("div", { className: "m02-side__row", children: [btnNew, copy, del] })];
  };
+  const matset = buildMatsetSection({
+    isAdmin: canEdit(layer, opt.isAdmin),
+    confirmLeave: opt.confirmLeave,
+    show: opt.showView,
+    close: () => opt.onOpen(null),
+    onOpen: () => paint(),
+  });
+  const matsetSection = section(matset.title, matset.body, ...matset.actions);
+  // 펼칠 때마다 새로 받음 — 재료산출 옆 판이 갈라 낸 조합도 바로 보이게
+  matsetSection.querySelector(".ui-collapsible__title")?.addEventListener("click", () => {
+    if (matsetSection.classList.contains("is-collapsed")) void matset.refresh();
+  });
  const listHost = el("div", {
    className: "m02-side__lists ui-sidebar-panel",
    children: [
      section(L("M02_KindTable"), bodies.get("table")!, ...actionRow("table")),
      section(L("M02_KindDrawing"), bodies.get("drawing")!, ...actionRow("drawing")),
      ...COLUMN_KINDS.map((k, i) => section(k.label(), columnBodies[i])),
+      matsetSection,
    ],
  });
  attachCollapsible(listHost);

  const root = el("div", { className: "m02-side ui-sidebar-panel", children: [listHost] });

-  /** 고름 표시 — `picked`(방금 누름) 이 있으면 그것 · 없으면 지금 열린 것과 비교 */
+  /** 고름 표시 — 편집 칸에 지금 열린 것 하나뿐 */
  const isPicked = (kind: Kind, name: string): boolean => {
-    if (picked) return picked.kind === kind && picked.name === name;
    const cur = opt.getOpen();
    return !!cur && cur.layer === layer && cur.kind === kind && cur.name === name;
  };
@@ -199,21 +212,25 @@ export function buildSide(opt: SideOptions): SideHandle {
    for (const [kind, b] of editButtons) b.copy.disabled = b.del.disabled = cur?.종류 !== kind;
  }

+  /** 고름 표시는 여기서만 — 목록 · 열 줄 · 자재 조합 줄을 함께 그려야 두 줄이 동시에 안 남음
+   * (양식이 열려 있으면 자재 조합 고름은 지움 · 자재 조합 상세는 열린 양식이 없음) */
+  function paint(): void {
+    paintList();
+    paintColumns();
+    paintButtons();
+    if (opt.getOpen()) matset.clear();
+  }
+
+  // 여는 것은 편집 칸(`onOpen`) — 편집 칸이 열 때마다 `paint` 를 부름(페이지가 이음)
  async function select(info: TemplateInfo): Promise<void> {
    if (!isOpen(info) && !(await opt.confirmLeave())) return;
-    picked = null;
    opt.onOpen({ layer, projectId: null, kind: info.종류, name: info.이름 });
-    paintList();
-    paintButtons();
  }

  async function selectColumn(col: StructureColumn, kind: ColumnKind): Promise<void> {
    if (!isPicked(kind, col.id) && !(await opt.confirmLeave())) return;
-    picked = null;
    // 제목은 편집 화면이 문서 번호를 앞에 붙임(「SD010101 돌기슭막이 …」)
    opt.onOpen({ layer, projectId: null, kind, name: col.id, label: columnHead(col) });
-    paintColumns();
-    paintButtons();
  }

  async function refreshStructure(): Promise<void> {
@@ -245,7 +262,7 @@ export function buildSide(opt: SideOptions): SideHandle {
    if (mine !== seq) return;
    paintList();
    paintButtons();
-    await refreshStructure();
+    await Promise.all([refreshStructure(), matset.refresh()]);
  }

  /* --- 시스템 층 새로 · 본떠 · 지우기(표 · 도면만 — 구조물 도면은 집계표 열이 정함) --- */
@@ -272,8 +289,10 @@ export function buildSide(opt: SideOptions): SideHandle {
            ok.disabled = false;
          }
        });
+        name.input.addEventListener("keydown", (event) => {
+          if (event.key === "Enter" && !event.isComposing) ok.click();
+        });
        body.append(name.root, ok);
-        name.input.focus();
      },
    });
  };
@@ -307,6 +326,13 @@ export function buildSide(opt: SideOptions): SideHandle {
    await refresh(); // 저장 직후여도 최신 판으로
    const info = currentInfo();
    if (!info) return;
+    if (info.쓰는곳) {
+      showToast(
+        L("M02_InUse").replace("{value}", info.이름).replace("{use}", info.쓰는곳),
+        "error",
+      );
+      return;
+    }
    if (!(await showConfirmDialog(L("M02_DeleteConfirm").replace("{value}", info.이름)))) return;
    try {
      await deleteTemplate(info.종류, info.이름, info.판);
@@ -319,13 +345,5 @@ export function buildSide(opt: SideOptions): SideHandle {
  }

  void refresh();
-  return {
-    root,
-    refresh,
-    select: (kind, name) => {
-      picked = { kind, name };
-      paintList();
-      paintColumns();
-    },
-  };
+  return { root, refresh, paint };
 }
@@ -96,3 +96,25 @@
  flex-direction: column;
  gap: var(--spacing-4);
 }
+
+/* 좌측 「자재 조합」 상세(메인 칸) — 이름 · 비고 · 본뜬키 + 담은 자재 표(줄 모양은 재료산출 옆 판 `m02-mat__row`) */
+.m02-matset {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-12);
+  max-width: 56rem;
+  font-size: var(--text-body-sm);
+}
+
+.m02-matset__fields {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: flex-end;
+  gap: var(--spacing-12);
+}
+
+.m02-matset__head {
+  margin: 0;
+  color: var(--color-text);
+  font-size: var(--text-body);
+}
@@ -1,5 +1,5 @@
 {
-  "다음": {"LB": 409, "EQ": 655, "RT": 20, "MN": 7000, "MT": 30719, "MO": 74, "MP": 364, "FX": 6, "CF": 159, "QF": 477, "GF": 252, "CC": 341, "GC": 1104, "QC": 2060, "GX": 1, "UA": 38, "UM": 1},
+  "다음": {"LB": 409, "EQ": 655, "RT": 20, "MN": 7000, "MT": 30719, "MO": 74, "MP": 364, "FX": 6, "CF": 159, "QF": 477, "GF": 252, "CC": 341, "GC": 1104, "QC": 2060, "GX": 1, "UA": 38},
  "폐기": {"MT000001": "자재품목 휘발유 — 값이 비고 글뿐 · 유가 테이블로 감", "MT000002": "자재품목 경유 — 값이 비고 글뿐 · 유가 테이블로 감", "MT000003": "자재품목 선박용경유 — 값이 비고 글뿐 · 유가 테이블로 감", "MT000004": "자재품목 중유 — 값이 비고 글뿐 · 유가 테이블로 감", "MT000005": "자재품목 등유 — 값이 비고 글뿐 · 유가 테이블로 감", "LB000399": "이름 「〃」 — 직종이 아니라 되풀이 기호 · 소요량 13-6-9 에서 윗줄 직종으로 바로잡음", "MN": "재료_나라장터자재 — old 로 옮김 · 로직은 자재품목·품셈재료로 갈아 끼움", "LB000372": "미확보 고급기능사 — 측량노임 항공사진고급기능사 옛이름으로 옮김", "LB000393": "미확보 리베팅공 — 건설노임 철골공 옛이름으로 옮김(2010 통합표 연번10)", "LB000405": "미확보 Belt Conveyor 설치공 — 품셈 13-10-1 주② 배분으로 다섯 직종에 나눔", "MT000006": "자재품목 전력 — 재료_유가전력 전력 줄로 감", "MT000007": "자재품목 전력 — 재료_유가전력 전력 줄로 감", "LB000368": "미확보 기술사 — 기술사(건설) 옛이름으로 옮김", "LB000369": "미확보 특급기술자 — 특급기술자(건설) 옛이름으로 옮김", "LB000370": "미확보 고급기술자 — 고급기술자(건설) 옛이름으로 옮김", "LB000361": "미확보 중급기술자 — 중급기술자(건설) 옛이름으로 옮김", "LB000364": "미확보 초급기술자 — 초급기술자(건설) 옛이름으로 옮김", "LB000365": "미확보 고급숙련기술자 — 고급숙련기술자(건설) 옛이름으로 옮김", "LB000366": "미확보 중급숙련기술자 — 중급숙련기술자(건설) 옛이름으로 옮김", "LB000367": "미확보 초급숙련기술자 — 초급숙련기술자(건설) 옛이름으로 옮김", "LB000389": "미확보 기계기사 — 초급기술자(기계·설비) 옛이름으로 옮김", "LB000388": "미확보 기계산업기사 — 초급숙련기술자(기계·설비) 옛이름으로 옮김", "MO000055": {"원문번호": "주택용저압:기본_200이하", "파일": "재료_유가전력.json"}, "MO000056": {"원문번호": "주택용저압:기본_201~400", "파일": "재료_유가전력.json"}, "MO000057": {"원문번호": "주택용저압:기본_400초과", "파일": "재료_유가전력.json"}, "MO000059": {"원문번호": "주택용저압:전력량_다음200", "파일": "재료_유가전력.json"}, "MO000060": {"원문번호": "주택용저압:전력량_400초과", "파일": "재료_유가전력.json"}, "MO000061": {"원문번호": "주택용저압:월간최저요금", "파일": "재료_유가전력.json"}, "MO000062": {"원문번호": "일반용갑I저압:기본", "파일": "재료_유가전력.json"}, "MO000063": {"원문번호": "일반용갑I저압:전력량_여름철", "파일": "재료_유가전력.json"}, "MO000064": {"원문번호": "일반용갑I저압:전력량_봄가을철", "파일": "재료_유가전력.json"}, "MO000065": {"원문번호": "일반용갑I저압:전력량_겨울철", "파일": "재료_유가전력.json"}, "MO000066": {"원문번호": "산업용갑I저압:기본", "파일": "재료_유가전력.json"}, "MO000067": {"원문번호": "산업용갑I저압:전력량_여름철", "파일": "재료_유가전력.json"}, "MO000068": {"원문번호": "산업용갑I저압:전력량_봄가을철", "파일": "재료_유가전력.json"}, "MO000069": {"원문번호": "산업용갑I저압:전력량_겨울철", "파일": "재료_유가전력.json"}, "MO000070": {"원문번호": "임시전력갑:기본요금적용", "파일": "재료_유가전력.json"}, "MO000071": {"원문번호": "임시전력갑:전력량요금적용", "파일": "재료_유가전력.json"}, "MO000072": {"원문번호": "임시전력갑:월간최저요금", "파일": "재료_유가전력.json"}},
  "키": {
    "CC000001": {"원문번호": "공통 1-3-1 콘크리트 및 포장용 재료", "파일": "계수_건설품셈_01장_적용기준.json"},
@@ -38,7 +38,7 @@
 | MT  | 재료 자재품목 | CF · CC      | 계수 산림 · 건설        |
 | MO  | 재료 유가     | RT           | 요율                    |
 | MP  | 재료 품셈재료(old/ — PLAN 7-4b) | GF · GC · GX | 로직 산림 · 건설 · 자체 |
-| EQ  | 기계          | UA · UM      | 일위대가 조합 · 자재 조합 |
+| EQ  | 기계          | UA           | 일위대가 조합           |

 - 빌더는 옛 모양(`열쇠` · 원문별 파일)으로 쓰고 끝에 `scripts/master_keys.py` 의 `adopt` 를 부름 — 키·원문번호·한 테이블·장 파일 이름으로 받음. 옛 이름으로 읽기는 `old_view`.

@@ -300,10 +300,10 @@

 ## 11. 자재 조합 파일

-`자재조합.json` 하나 — 구조물 열 재료산출이 쓰는 **자재 목록 묶음**. 머리 `그룹` · `판` · `비고` · `줄`(원문 없음).
+마스터 템플릿 `resources/master_template/자재조합.json` 하나(이 폴더 밖 · `구조물집계표조합.json` 과 같은 자리) — 구조물 열 재료산출이 쓰는 **자재 목록 묶음**. 머리 `그룹` · `판` · `비고` · `다음` · `줄`(원문 없음). 검사는 `check_master.py 틀` 이 같이 봄(`master_material_combo.check_file`).

 - 열 한 벌 — `키` · `이름` · `담은자재` · `본뜬키` · `소유` · `비고`(차례까지 이대로 · 엔진 `scripts/master_material_combo.py`).
- `키` = `UM` + 6자리 — 대장 `UM` 다음 번호 · 줄에 `원문번호` 를 두지 않음.
+- `키` = `UM` + 6자리 — 표 머리 `다음` 번호(`_키대장` 밖) · 지운 키는 다시 안 씀 · 줄에 `원문번호` 를 두지 않음.
 - `담은자재` 줄 = `{코드, 이름, 규격, 단위}` 뿐 · 빈 목록 안 됨 · 같은 코드 두 번 안 됨 · 수량 · 계산은 두지 않음(재료산출 몫).
 - `본뜬키` = 갈라 낸 원래 자재 조합 키 · 없으면 `null` · `소유` = `현장` · `공용`.
 - 새 줄은 M02 갈라 내기(`POST /api/m02/structures/{열}/material-combo`)가 만듦 — 같은 자재 집합이 있으면 그 키.
@@ -198,19 +198,7 @@

 ### 자재 조합

-재료산출에서 쓸 **자재 목록 묶음**(파일 `자재조합.json` · 키 `UM` · `_틀.md` 11장). 담은 자재 `{코드, 이름, 규격, 단위}` 만 지님 — 수량 · 단가 없음. 요소 그룹이 아님(`/groups` · `/rows` 에 안 끼고 제 길로만).
-
-| 길                    | 받음                            | 줌                                          |
-| --------------------- | ------------------------------- | ------------------------------------------- |
-| `GET /matsets`        | `q?` `owner?`                   | `{matsets: […]}` — 줄마다 `count` (자재 수) |
-| `GET /matset`         | `key`                           | `{file, version, matset}`                   |
-| `POST /matset/new`    | `{matset, owner?}`              | `{file, version, key, matset}`              |
-| `POST /matset/edit`   | `{key, version, matset, owner?}` | `{file, version, matset}`                   |
-| `POST /matset/delete` | `{key, version}`                | `{file, version}`                           |
-
- 답 — 200 · 400(이름 없음 · 모르는 소유 · 없는/자기 본뜬키) · 404 · 409(낡은 판본 · 지우기 막음) · 422(없는 자재 코드 · 같은 자재 두 번 · 자재 줄 모양).
- 지우기는 구조물집계표 · `구조물집계표조합` 의 「자재조합」 칸으로 쓰는 열이 있으면 409 `{detail: {errors: […], users: [구조물 이름…]}}` — 지우지 않음.
- M02 화면이 새로 만드는 조합도 같은 파일 · 같은 길이라 M01 목록에 같이 보임.
+M01 에 없음 — 마스터 템플릿 표(`resources/master_template/자재조합.json` · 키 `UM` · `_틀.md` 11장) · 길과 화면은 M02(`/api/m02/material-combos…` · 좌측 「자재 조합」 컨테이너).

 ## 10. 재료 · 기계 고르기

@@ -259,8 +259,6 @@ def check_combo_form(name: str, data: dict) -> list[str]:
 def check_form(name: str, data: dict) -> list[str]:
    if name == mcb.FILE:
        return check_combo_form(name, data)
-    if name == mmc.FILE:
-        return mmc.check_form(name, data)
    if name in SPECIAL_FILES:
        return []
    m = _FILE.match(name)
@@ -685,6 +683,7 @@ def main(argv: list[str]) -> int:
    report = {}
    if mode in ("틀", "전부"):
        report["틀"] = [x for name, data in files.items() for x in check_form(name, data)]
+        report["틀"] += mmc.check_file()  # 자재 조합은 마스터 템플릿 표
    if mode in ("본문", "전부"):
        report["본문"] = check_body(files)
    if mode in ("로직", "전부"):
@@ -32,13 +32,12 @@ TABLES = {
    ("로직", "건설품셈"): "GC",
    ("로직", "자체"): "GX",
    ("일위대가조합", None): "UA",
-    ("자재조합", None): "UM",
 }
 GROUP_OF = {tid: group for (group, _), tid in TABLES.items()}
 IDS = tuple(GROUP_OF)
 # 줄에 원문번호를 두지 않는 테이블 — 자재품목은 번호가 남의 품번이라 이름 몫을 못 하고,
 # 조합은 원문이 없어 번호 자체가 없음(대조는 대장에만)
-NO_NUMBER = ("MT", "UA", "UM")
+NO_NUMBER = ("MT", "UA")


 def table_id(group: str, book: str | None) -> str:
@@ -187,7 +186,6 @@ ROW_ORDER = {
        "소유",
        "비고",
    ),
-    "자재조합": ("키", "이름", "담은자재", "본뜬키", "소유", "비고"),
 }
 OLD_CHAPTER = re.compile(r"^(소요량|계수|로직)_(산림품셈|건설품셈)_(\D*)(\d+)장\.json$")
 CHAPTER = re.compile(r"^(소요량|계수|로직)_(산림품셈|건설품셈|자체)_(\d\d)장_.+\.json$")
@@ -1,12 +1,16 @@
 # -*- coding: utf-8 -*-
 """자재 조합 — 구조물 열 재료산출이 쓰는 자재 목록 묶음(키 UM · `_틀.md` 11장).

-담은 자재 목록만 지님(수량 · 계산은 재료산출 몫). 일위대가 조합(`master_combo`)과 같은 결 —
-갈라 내기(M02) 때 새 줄 · 본뜬키 = 원래 키.
+자리는 마스터 템플릿 `resources/master_template/자재조합.json`(구조물집계표조합.json 과 같은 결) ·
+키는 표 안 「다음」 번호(`_키대장` 밖). 담은 자재 목록만 지님(수량 · 계산은 재료산출 몫) ·
+갈라 내기(M02) 때 새 줄 · 본뜬키 = 원래 키. 저장 · 화면은 M02(`M02_MasterTemplete_Matset.py`).
 """

 from __future__ import annotations

+import json
+from pathlib import Path
+
 import master_combo as mcb
 import master_keys as mk

@@ -15,7 +19,8 @@ FILE = "자재조합.json"
 TID = "UM"
 OWNERS = mcb.OWNERS
 MAX_이름 = mcb.MAX_이름
-COLS = mk.ROW_ORDER[GROUP]  # 키 · 이름 · 담은자재 · 본뜬키 · 소유 · 비고
+PATH = Path(__file__).resolve().parents[2] / "master_template" / FILE
+COLS = ("키", "이름", "담은자재", "본뜬키", "소유", "비고")
 ITEM_COLS = ("코드", "이름", "규격", "단위")


@@ -30,12 +35,18 @@ def check_form(name: str, data: dict) -> list[str]:
    rows = data.get("줄")
    if not isinstance(rows, list):
        return out + [f"{name} · 머리 「줄」 목록 없음"]
+    after = data.get("다음")
+    if not isinstance(after, int) or after < 1:
+        out.append(f"{name} · 머리 「다음」 이 1 이상 정수 아님")
+        after = None
    seen_names: dict[str, str] = {}
    for row in rows:
        key = str(row.get("키"))
        where = f"{name} · {key} {row.get('이름') or ''}".strip()
        if not mk.KEY.fullmatch(key) or key[:2] != TID:
            out.append(f"{where} · 키 모양이 「{TID}」 + 6자리 아님")
+        elif after and int(key[2:]) >= after:
+            out.append(f"{where} · 키 번호가 머리 「다음」({after}) 보다 작지 않음")
        if tuple(row) != COLS:
            out.append(f"{where} · 열이 한 벌이 아님 — 「{' · '.join(COLS)}」")
        plain = row.get("이름").strip() if isinstance(row.get("이름"), str) else ""
@@ -64,3 +75,10 @@ def check_form(name: str, data: dict) -> list[str]:
                out.append(f"{where} 줄{at} · 같은 자재를 두 번 담음 「{code}」")
            codes.add(code)
    return out
+
+
+def check_file(path: Path = PATH) -> list[str]:
+    """마스터 템플릿 자재 조합 표 — 없으면 한 줄."""
+    if not path.is_file():
+        return [f"{path.name} · 마스터 템플릿에 없음"]
+    return check_form(path.name, json.loads(path.read_text(encoding="utf-8")))
@@ -1,6 +1,7 @@
 {
  "그룹": "자재조합",
  "판": "2026",
-  "비고": ["자재 조합 = 구조물 열 재료산출이 쓰는 자재 목록 묶음 · 수량·계산은 두지 않음(재료산출 몫)"],
+  "비고": ["자재 조합 = 구조물 열 재료산출이 쓰는 자재 목록 묶음 · 수량·계산은 두지 않음(재료산출 몫) · 키 UM 은 「다음」 번호로 매김 · 지운 키는 다시 안 씀"],
+  "다음": 1,
  "줄": []
 }
@@ -58,6 +58,31 @@ describe('기준점 십자', () => {
 		expect(b.origin.x - a.origin.x).toBeCloseTo(-100); // 세계 50 = 화면 100px(2배) — 화면을 옮기면 원점이 반대로 감
 	});

+	it('빈 도면 맞춤은 원점을 화면 가운데로 — 십자가 귀퉁이에 안 잘림', () => {
+		const { context } = recordingContext();
+		const controller = new ScreenCanvasDrawController(context);
+		controller.setCanvasSize(new Point(800, 600));
+		controller.setScreenScale(2);
+		controller.setScreenOffset(new Point(0, 0));
+		controller.zoomToFitScreen();
+		const origin = controller.worldToTarget(new Point(0, 0));
+		expect([origin.x, origin.y]).toEqual([400, 300]);
+	});
+
+	it('맞춘 뒤 캔버스가 커지면 다시 맞춤 · 사용자가 옮긴 뒤에는 그대로', () => {
+		const { context } = recordingContext();
+		const controller = new ScreenCanvasDrawController(context);
+		controller.setCanvasSize(new Point(200, 100));
+		controller.zoomToFitScreen();
+		controller.setCanvasSize(new Point(800, 600));
+		const refit = controller.worldToTarget(new Point(0, 0));
+		expect([refit.x, refit.y]).toEqual([400, 300]);
+		controller.panScreen(50, 0);
+		controller.setCanvasSize(new Point(1000, 600));
+		const kept = controller.worldToTarget(new Point(0, 0));
+		expect([kept.x, kept.y]).toEqual([450, 300]);
+	});
+
 	it('그리기만 — 도면 개체를 만들지 않음', () => {
 		drawAt(1, new Point(0, 0));
 		expect(getEntities()).toHaveLength(0);
@@ -7,6 +7,7 @@ const sel = load(path.join(SS, "spreadsheet_selection.ts"));
 const ed = load(path.join(SS, "spreadsheet_editor.ts"));
 const mouse = load(path.join(SS, "spreadsheet_mouse.ts"));
 const addr = load(path.join(SS, "spreadsheet_address.ts"));
+const spill = load(path.join(SS, "spreadsheet_spill.ts"));
 const sample = require(path.join(SS, "spreadsheet_sample.json"));

 const s1 = sample.시트[0];
@@ -69,6 +70,27 @@ const out = {
    (t) => ed.textToCell(t, { 서식: 4 }),
  ),
  textToCellNoStyle: ed.textToCell("", {}),
+  // 긴 글 넘침 — 칸 0..5 폭 50 · 3 은 값 있음 · 칸 2 에서 폭 130 글
+  spill: (() => {
+    const row = (full) =>
+      new Map([0, 1, 2, 3, 4, 5].map((c) => [c, { w: 50, empty: !full.includes(c) }]));
+    const f = (sp) => sp && [sp.left, sp.right, sp.from, sp.to, sp.clipLeft, sp.clipRight];
+    return {
+      left: f(spill.spillOf(row([2, 3]), 2, 50, 130, "left")),
+      leftFree: f(spill.spillOf(row([2]), 2, 50, 130, "left")),
+      right: f(spill.spillOf(row([2]), 2, 50, 130, "right")),
+      center: f(spill.spillOf(row([2]), 2, 50, 130, "center")),
+      centerBlocked: f(spill.spillOf(row([2, 3]), 2, 50, 130, "center")),
+      fits: f(spill.spillOf(row([2]), 2, 50, 40, "left")),
+      edge: f(spill.spillOf(new Map([[2, { w: 50, empty: false }]]), 2, 50, 130, "left")),
+    };
+  })(),
+  // 친 모양대로 숫자 형식 · 식 대문자 · 닫는 괄호 채움(엑셀)
+  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" },
@@ -111,3 +111,31 @@ 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)']
+
+
+def test_spill(r):
+    sp = r["spill"]
+    assert sp["left"] is None  # 오른 칸(3)에 값 → 못 넘침
+    assert sp["leftFree"] == [0, 100, 2, 4, 0, 0]  # 빈 칸 둘 덮음
+    assert sp["right"] == [100, 0, 0, 2, 0, 0]
+    assert sp["center"] == [40, 40, 1, 3, 0, 0]
+    assert sp["centerBlocked"] == [40, 40, 1, 2, 0, 40]  # 오른쪽 막힘 → 오른쪽 반 잘라 냄
+    assert sp["fits"] is None
+    assert sp["edge"] is None  # 판 끝(그린 칸 없음)
@@ -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])
@@ -1,107 +0,0 @@
-"""M01 자재 조합(`/api/m01/matset…` · 파일 `자재조합.json` · 키 UM) — 담은 자재 목록만 지님.
-
-못박는 것
-  - 새로 만들면 키를 서버가 `UM` 다음 번호로 줌 · 열 한 벌 · 담은 자재는 네 칸.
-  - 없는 자재 코드 · 같은 자재 두 번 · 이름 없음 · 없는 본뜬키는 막음.
-  - 고치기는 낡은 판본이면 409 · 지우기는 구조물 열이 「자재조합」 칸으로 쓰면 409 + 구조물 이름들.
-  - 정본은 읽기만 함(사본 폴더 · 사본 집계표).
-"""
-
-from __future__ import annotations
-
-import json
-import shutil
-from pathlib import Path
-
-import pytest
-from fastapi import FastAPI
-from fastapi.testclient import TestClient
-
-from M01_MasterData import M01_MasterData_Router as router_module
-from M01_MasterData import M01_MasterData_Store as store
-from M01_MasterData import M01_MasterData_Store_Combo as combo_store
-
-ROOT = Path(__file__).resolve().parents[2]
-
-
-@pytest.fixture
-def client(tmp_path: Path, monkeypatch) -> TestClient:
-    for path in store.FOLDER.glob("*.json"):
-        if not path.name.startswith("_") or path.name == store.mk.BOOK.name:
-            shutil.copy(path, tmp_path / path.name)
-    monkeypatch.setattr(store, "FOLDER", tmp_path)
-    sheet = tmp_path / "집계표.json"
-    sheet.write_text(json.dumps({"열": []}), encoding="utf-8")
-    monkeypatch.setattr(combo_store, "USERS", (sheet,))
-    app = FastAPI()
-    app.include_router(router_module.router)
-    return TestClient(app)
-
-
-def _mat(client: TestClient) -> dict:
-    """자재품목에서 실제 줄 하나 — 자재 찾기 길 그대로."""
-    got = client.get("/api/m01/pick", params={"kind": "price", "q": "합판", "limit": 2}).json()
-    one = got["items"][0]
-    return {"코드": one["ref"], "이름": one["이름"], "규격": one["규격"], "단위": one["단위"]}
-
-
-def _new(client: TestClient, name: str, mats: list[dict], **more) -> dict:
-    body = {"matset": {"이름": name, "담은자재": mats, **more}}
-    return client.post("/api/m01/matset/new", json=body)
-
-
-def test_정본_자재조합_파일은_틀대로다() -> None:
-    data = json.loads((ROOT / "resources/master_data/자재조합.json").read_text(encoding="utf-8"))
-    assert data["그룹"] == "자재조합" and isinstance(data["줄"], list)
-    assert store.cm.mmc.check_form("자재조합.json", data) == []
-    assert '"UM"' in (ROOT / "resources/master_data/_키대장.json").read_text(encoding="utf-8")
-
-
-def test_새로_만들면_UM_키와_열_한_벌(client) -> None:
-    mat = _mat(client)
-    res = _new(client, "합판 자재", [{**mat, "덤": 1}])
-    assert res.status_code == 200, res.text
-    made = res.json()
-    assert made["key"].startswith("UM") and len(made["key"]) == 8
-    assert tuple(made["matset"]) == store.cm.mmc.COLS
-    assert made["matset"]["담은자재"] == [mat] and made["matset"]["본뜬키"] is None
-    rows = client.get("/api/m01/matsets").json()["matsets"]
-    assert [(r["키"], r["count"]) for r in rows] == [(made["key"], 1)]
-    got = client.get("/api/m01/matset", params={"key": made["key"]}).json()
-    assert got["matset"]["이름"] == "합판 자재"
-
-
-def test_없는_자재_두_번_담기_이름_본뜬키는_막는다(client) -> None:
-    mat = _mat(client)
-    assert _new(client, "없는 코드", [{**mat, "코드": "MT999999"}]).status_code == 422
-    assert _new(client, "두 번", [mat, mat]).status_code == 422
-    assert _new(client, " ", [mat]).status_code == 400
-    assert _new(client, "없는 원본", [mat], 본뜬키="UM999999").status_code == 400
-    ok = _new(client, "원본", [mat]).json()["key"]
-    assert _new(client, "본뜬 것", [mat], 본뜬키=ok).json()["matset"]["본뜬키"] == ok
-    assert _new(client, "원본", [mat]).status_code == 422  # 이름 겹침
-
-
-def test_고치기는_낡은_판본이면_409(client) -> None:
-    mat = _mat(client)
-    key = _new(client, "고칠 것", [mat]).json()["key"]
-    one = client.get("/api/m01/matset", params={"key": key}).json()
-    body = {"key": key, "version": one["version"], "matset": {**one["matset"], "이름": "고침"}}
-    assert client.post("/api/m01/matset/edit", json=body).status_code == 200
-    assert client.post("/api/m01/matset/edit", json=body).status_code == 409  # 같은 옛 판본
-
-
-def test_쓰는_열이_있으면_못_지우고_없으면_지워진다(client) -> None:
-    mat = _mat(client)
-    key = _new(client, "쓰는 것", [mat]).json()["key"]
-    cols = [{"id": "c9", "머리": ["돌붙임", "찰붙임", "", ""], "자재조합": key}]
-    combo_store.USERS[0].write_text(json.dumps({"열": cols}, ensure_ascii=False), encoding="utf-8")
-    version = client.get("/api/m01/matset", params={"key": key}).json()["version"]
-    res = client.post("/api/m01/matset/delete", json={"key": key, "version": version})
-    assert res.status_code == 409 and res.json()["detail"]["users"] == ["돌붙임 찰붙임"]
-    combo_store.USERS[0].write_text(json.dumps({"열": []}), encoding="utf-8")
-    assert (
-        client.post("/api/m01/matset/delete", json={"key": key, "version": version}).status_code
-        == 200
-    )
-    assert client.get("/api/m01/matset", params={"key": key}).status_code == 404
@@ -1,8 +1,10 @@
 """조합 갈라 내기 · 분류 더하기 복사 (PLAN 15장).

-M02 견본 표(`write_sample_table`) + M01 마스터 사본(조합 줄은 비워 시작)으로만 봄.
+M02 견본 표(`write_sample_table`) + M01 마스터 사본(조합 줄은 비워 시작)으로만 봄 · 자재 조합 표는
+마스터 템플릿 사본(없이 시작).
  · 일위대가(UA) — 새로 만듦(본뜬키 = 원래 키) · 이 열만 새 키 · 다른 열은 옛 키 · 원래 조합 그대로 ·
-    SS 장부 맞춤 · 담은 로직 집합(차례 · 메모 무시)이 같으면 있는 키 · 또 고치면 또 새로 · 같은 이름 (2)
+    SS 장부 맞춤 · 담은 로직(차례 · 메모까지)이 같으면 있는 키(되돌리면 원래 키) · 차례 · 메모만
+    바꿔도 새로 · 또 고치면 또 새로 · 같은 이름 (2)
  · 자재 조합(UM) — 같은 규칙 · 처음 만드는 열(본뜬키 없음) · 읽기
  · 집계표 판 어긋남 = 409 · 조합 안 만듦
  · 분류 더하기로 복사한 열(`본뜬열`) — [저장] 때 원본 키 · 세 파일 내용을 새 번호로 받음
@@ -17,7 +19,6 @@ from fastapi.testclient import TestClient

 from M01_MasterData import M01_MasterData_Store as m01
 from M01_MasterData import M01_MasterData_Store_Combo as combo_store
-from M02_MasterTemplete import M02_MasterTemplete_Branch as branch
 from M02_MasterTemplete import M02_MasterTemplete_Store as store
 from M02_MasterTemplete.M02_MasterTemplete_Router import router
 from resources.tester.test_m02_structure import write_sample_table
@@ -25,8 +26,8 @@ from resources.tester.test_m02_structure import write_sample_table
 REAL = m01.FOLDER
 A, B, C = "GF000219", "GF000220", "GF000211"  # 돌쌓기 메쌓기(인력 · 장비) · 채집(인력)
 M1, M2 = (
-    {"코드": "MT000001", "이름": "시멘트", "규격": "40kg", "단위": "포"},
-    {"코드": "MT000002", "이름": "모래", "규격": None, "단위": "㎥"},
+    {"코드": "MT000008", "이름": "시멘트", "규격": "40kg", "단위": "포"},
+    {"코드": "MT000009", "이름": "모래", "규격": None, "단위": "㎥"},
 )
 TABLE = "/api/m02/templates/table/구조물집계표"

@@ -38,11 +39,10 @@ def client(tmp_path, monkeypatch):
    for path in REAL.glob("*.json"):
        if not path.name.startswith("_") or path.name == m01.mk.BOOK.name:
            shutil.copy(path, master / path.name)
-    for name in (combo_store.FILE, branch.MATERIAL_FILE):
-        own = master / name
-        data = json.loads(own.read_text(encoding="utf-8"))
-        data["줄"] = []
-        own.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+    own = master / combo_store.FILE
+    data = json.loads(own.read_text(encoding="utf-8"))
+    data["줄"] = []
+    own.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    monkeypatch.setattr(m01, "FOLDER", master)
    template = tmp_path / "template"
    template.mkdir()
@@ -75,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()
@@ -119,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["키"]


@@ -157,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["키"]
@@ -168,7 +182,7 @@ def test_자재_조합_처음_만듦_같은_내용이면_있는_키_고치면_
    )
    assert _ss(client, "자재조합")["c1"] == fork["키"]
    assert client.get("/api/m02/material-combos/UM999999").status_code == 404
-    _material(client, "rv", "", [{"코드": "없는모양"}], want=422)  # M01 저장 검사
+    _material(client, "rv", "", [{"코드": "없는모양"}], want=422)  # 자재 조합 저장 검사


 def test_분류_더하기로_복사한_열은_원본_키_세_파일_내용을_받음(client):
@@ -0,0 +1,125 @@
+"""M02 자재 조합(`/api/m02/material-combos…` · 마스터 템플릿 `자재조합.json` · 키 UM).
+
+못박는 것
+  - 정본 표는 마스터 템플릿 자리 · 틀대로(머리 「다음」) · 키 대장에 UM 없음 · M01 길 없음.
+  - 새로 만들면 키 = 표 「다음」 번호 · 열 한 벌 · 담은 자재는 네 칸 · 지운 키는 다시 안 씀.
+  - 없는 자재 코드 · 같은 자재 두 번 · 이름 없음 · 이름 겹침 · 없는 본뜬키는 막음.
+  - 고치기 · 지우기는 낡은 판이면 409 · 본뜬키는 고쳐도 그대로 · 쓰는 열이 있으면 못 지움.
+  - 정본은 읽기만 함(사본 폴더 · 견본 집계표).
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from M01_MasterData import M01_MasterData_Router as m01_router
+from M01_MasterData import M01_MasterData_Store as m01
+from M02_MasterTemplete import M02_MasterTemplete_Matset as matset
+from M02_MasterTemplete import M02_MasterTemplete_Store as store
+from M02_MasterTemplete.M02_MasterTemplete_Router import router
+from resources.tester.test_m02_structure import write_sample_table
+
+ROOT = Path(__file__).resolve().parents[2]
+M1, M2 = (
+    {"코드": "MT000008", "이름": "시멘트", "규격": "40kg", "단위": "포"},
+    {"코드": "MT000009", "이름": "모래", "규격": "", "단위": "㎥"},
+)
+URL = "/api/m02/material-combos"
+TABLE = "/api/m02/templates/table/구조물집계표"
+
+
+@pytest.fixture
+def client(tmp_path: Path, monkeypatch) -> TestClient:
+    write_sample_table(tmp_path)
+    monkeypatch.setattr(store, "FOLDER", tmp_path)
+    app = FastAPI()
+    app.include_router(router)
+    return TestClient(app)
+
+
+def _new(client: TestClient, name: str, mats: list[dict], 판: str | None = None, **more):
+    if 판 is None:
+        판 = client.get(URL).json()["판"]
+    return client.post(URL, json={"판": 판, "줄": {"이름": name, "담은자재": mats, **more}})
+
+
+def test_정본_표는_마스터_템플릿_자리_틀대로_UM_은_대장_밖() -> None:
+    path = ROOT / "resources/master_template/자재조합.json"
+    data = json.loads(path.read_text(encoding="utf-8"))
+    assert data["그룹"] == "자재조합" and isinstance(data["다음"], int)
+    assert matset.mmc.check_file(path) == []
+    assert not (ROOT / "resources/master_data/자재조합.json").exists()
+    book = (ROOT / "resources/master_data/_키대장.json").read_text(encoding="utf-8")
+    assert '"UM"' not in book.splitlines()[1]  # 대장 머리 「다음」
+    assert not any("matset" in getattr(r, "path", "") for r in m01_router.router.routes)
+
+
+def test_새로_만들면_다음_번호_열_한_벌_지운_키는_다시_안_씀(client) -> None:
+    res = _new(client, "합판 자재", [{**M1, "덤": 1}])
+    assert res.status_code == 200, res.text
+    made = res.json()
+    assert made["키"] == "UM000001" and tuple(made["줄"]) == matset.mmc.COLS
+    assert made["줄"]["담은자재"] == [M1] and made["줄"]["본뜬키"] is None
+    listed = client.get(URL).json()
+    assert listed["판"] == made["판"] and [r["키"] for r in listed["줄"]] == ["UM000001"]
+    assert client.get(f"{URL}/UM000001").json()["이름"] == "합판 자재"
+    assert client.delete(f"{URL}/UM000001", params={"판": made["판"]}).status_code == 200
+    again = _new(client, "다음 것", [M2]).json()
+    assert again["키"] == "UM000002"  # 지운 번호는 다시 안 씀
+    assert json.loads((store.FOLDER / matset.FILE).read_text(encoding="utf-8"))["다음"] == 3
+
+
+def test_없는_자재_두_번_이름_본뜬키는_막는다(client) -> None:
+    assert _new(client, "없는 코드", [{**M1, "코드": "MT999999"}]).status_code == 422
+    assert _new(client, "두 번", [M1, M1]).status_code == 422
+    assert _new(client, " ", [M1]).status_code == 400
+    assert _new(client, "빈 것", []).status_code == 422
+    assert _new(client, "없는 원본", [M1], 본뜬키="UM999999").status_code == 400
+    ok = _new(client, "원본", [M1]).json()["키"]
+    copy = _new(client, "본뜬 것", [M1, M2], 본뜬키=ok).json()
+    assert copy["줄"]["본뜬키"] == ok and copy["키"] != ok
+    assert _new(client, "원본", [M2]).status_code == 422  # 이름 겹침
+    assert _new(client, "낡은 판", [M2], 판="0000").status_code == 409
+
+
+def test_고치기는_낡은_판이면_409_본뜬키는_그대로(client) -> None:
+    src = _new(client, "원본", [M1]).json()["키"]
+    made = _new(client, "고칠 것", [M1], 본뜬키=src).json()
+    row = {**made["줄"], "이름": "고침", "담은자재": [M1, M2], "본뜬키": None}
+    res = client.put(f"{URL}/{made['키']}", json={"판": made["판"], "줄": row})
+    assert res.status_code == 200, res.text
+    assert res.json()["줄"]["이름"] == "고침" and res.json()["줄"]["본뜬키"] == src
+    assert client.put(f"{URL}/{made['키']}", json={"판": made["판"], "줄": row}).status_code == 409
+    assert client.put(f"{URL}/UM999999", json={"판": "", "줄": row}).status_code == 404
+
+
+def test_쓰는_열이_있으면_못_지우고_없으면_지워진다(client) -> None:
+    made = _new(client, "쓰는 것", [M1]).json()
+    table = client.get(TABLE).json()
+    for col in table["문서"]["열"]:
+        if col["id"] == "rv":
+            col["자재조합"] = made["키"]
+    assert client.put(TABLE, json={"판": table["판"], "문서": table["문서"]}).status_code == 200
+    res = client.delete(f"{URL}/{made['키']}", params={"판": made["판"]})
+    assert client.get(URL).json()["쓰는곳"] == {made["키"]: ["돌기슭막이 (형태마다) H=(높이마다)"]}
+    assert res.status_code == 409 and res.json()["detail"]["users"] == [
+        "돌기슭막이 (형태마다) H=(높이마다)"
+    ]
+    rows = client.get("/api/m02/structure-combos").json()["줄"]
+    assert next(r for r in rows if r["열"] == "rv")["자재조합"] == made["키"]  # SS 장부 칸
+    table = client.get(TABLE).json()
+    for col in table["문서"]["열"]:
+        col.pop("자재조합", None)
+    assert client.put(TABLE, json={"판": table["판"], "문서": table["문서"]}).status_code == 200
+    assert client.delete(f"{URL}/{made['키']}", params={"판": "낡음"}).status_code == 409
+    assert client.delete(f"{URL}/{made['키']}", params={"판": made["판"]}).status_code == 200
+    assert client.get(f"{URL}/{made['키']}").status_code == 404
+
+
+def test_M01_마스터는_UM_을_모른다() -> None:
+    assert "UM" not in m01.cm.mk.IDS and "자재조합" not in m01.cm.mk.ROW_ORDER
@@ -100,6 +100,12 @@ def test_in_use_templates_not_deleted(client):
        got = client.delete(f"/api/m02/templates/{kind}/{name}")
        assert got.status_code == 409 and "쓰는 양식" in got.json()["detail"]
        assert client.get(f"/api/m02/templates/{kind}/{name}").status_code == 200
+    # 목록이 쓰는 곳을 실어 화면이 확인 창 전에 막음 · 안 쓰는 양식엔 없음
+    client.put("/api/m02/templates/drawing/아무도", json={"판": "", "문서": doc})
+    rows = {(r["종류"], r["이름"]): r for r in client.get("/api/m02/templates").json()}
+    for key, use in store.IN_USE.items():
+        assert rows[key]["쓰는곳"] == use
+    assert "쓰는곳" not in rows[("drawing", "아무도")]


 def test_empty_doc_rejected_and_file_untouched(client):
@@ -187,6 +187,21 @@ def test_집계표_저장_때_새_열은_만들고_지운_열은_같이_지움(c
    assert numbers["pv_y"] == _num("02010101")  # pv_b 무리 안 분류3 다음 번호


+def test_지운_열_번호는_다음_저장에도_다시_안_줌(client):
+    """무리 맨 끝 열(pv_jt 02010400)을 지워 저장한 뒤 새 열을 더해도 04 를 다시 안 받음."""
+    store.renumber()
+    url = "/api/m02/templates/table/구조물집계표"
+    got = client.get(url).json()
+    got["문서"]["열"] = [c for c in got["문서"]["열"] if c["id"] != "pv_jt"]
+    assert client.put(url, json={"판": got["판"], "문서": got["문서"]}).status_code == 200
+    assert client.get("/api/m02/structure-combos").json()["지운번호"] == ["02010400"]
+    got = client.get(url).json()
+    new = {"id": "pv_z", "머리": ["콘크리트포장", "T=(두께마다)", "Z", None], "꼴": "수"}
+    got["문서"]["열"].append(new)
+    assert client.put(url, json={"판": got["판"], "문서": got["문서"]}).status_code == 200
+    assert client.get("/api/m02/structures/numbers").json()["pv_z"] == _num("02010500")
+
+
 def test_다른_열_도면을_복사해_가져옴(client):
    store.renumber()
    src = client.get("/api/m02/templates/structure/rv").json()
@@ -148,6 +148,21 @@ def test_좌측_새로_본떠_지우기는_표_도면_컨테이너_안에_하나
    assert "양식: name" in side.split("function copyTemplate")[1]  # 복사본 머리 이름 = 새 이름


+def test_좌측_고름_표시는_열린_것_한_줄뿐():
+    """카드 [도면 수정] 등 무엇으로 열든 편집 칸이 좌측 `paint` 를 부름 — 목록 · 열 줄을 함께 그림."""
+    side = _text(SIDE)
+    assert "picked" not in side  # 따로 든 고름 상태 없음 — 편집 칸의 지금 열린 것만 봄
+    assert re.search(r"function paint\(\): void \{\s*paintList\(\);\s*paintColumns\(\);", side)
+    for fn in ("async function select(", "async function selectColumn("):
+        body = side.split(fn)[1].split("\n  }\n")[0]
+        assert "paint" not in body, fn  # 여기서 한쪽만 그리면 두 줄이 남음
+    assert re.search(r"sel = next;\s*onOpened\?\.\(\);", _text(MAIN))
+    # 자재 조합 상세도 같은 한 곳 — 열면 양식 · 열 줄 고름 지움 · 양식을 열면 자재 조합 고름 지움
+    assert re.search(r"sel = null;\s*onOpened\?\.\(\);", _text(MAIN))
+    assert "if (opt.getOpen()) matset.clear();" in side.split("function paint(): void {")[1]
+    assert "() => side.paint()" in _text(M02 / "M02_MasterTemplete_UI_Page.ts")
+
+
 def test_리본_접힘_모드에서_탭으로_편_것은_밖을_누르면_다시_접힘():
    ribbon = _text(ROOT / "B07_DesignDetail/openwebcad/src/ribbon/Ribbon.tsx")
    assert "if (collapsed) setPeek(true);" in ribbon  # 탭 = 잠깐 펼침(접힘 모드 유지)
@@ -23,7 +23,7 @@

 .ui-sheet__hint {
  margin: 0;
-  color: var(--color-text-muted);
+  color: var(--color-text-secondary); /* muted 는 작은 글에 대비 3:1 — 모자람 */
  font-size: 0.8rem;
 }

@@ -23,6 +23,8 @@ import {
  deleteColumn,
  deleteRow,
  isBlankPick,
+  isBoundColumn,
+  isCalcColumn,
  KEY_PRICE,
  KEY_UNIT,
  navRows,
@@ -168,7 +170,8 @@ export function createSheet(host: HTMLElement, input: SheetDoc, opts: SheetOptio
    const col = state.sel ? colOf(state.sel.c) : undefined;
    if (opts.mode === "master") syncLevels(!!col);
    colDelete.disabled = !col || state.doc.열.length <= 1;
-    colHand.disabled = !col;
+    // 바인딩 · 계산 열은 손 입력이 안 먹음(프로젝트에서 잠김) — 켜지 못하게 · 이미 켜진 것은 끌 수 있게
+    colHand.disabled = !col || (!col.손 && (isBoundColumn(col) || isCalcColumn(col)));
    colHand.classList.toggle("is-on", !!col?.손);
  };

@@ -72,6 +72,8 @@ export interface InputFieldOptions {
  min?: number;
  max?: number;
  onInput?: (value: string) => void;
+  /** 좁은 자리(표 칸·좌측 패널)용 작은 크기 — 작은 고르기칸(compact)과 높이가 같음 */
+  compact?: boolean;
 }

 export interface InputFieldHandle {
@@ -90,7 +92,7 @@ export function createInputField(opts: InputFieldOptions): InputFieldHandle {
  }

  const input = el("input", {
-    className: "ui-input",
+    className: opts.compact ? "ui-input ui-input--sm" : "ui-input",
    attrs: {
      type: opts.type ?? "text",
      ...(opts.placeholder ? { placeholder: opts.placeholder } : {}),
@@ -318,17 +320,26 @@ export function showConfirmDialog(message: string, confirmLabel = "확인"): Pro
    const panel = el("div", { className: "ui-confirm__panel" });
    const text = el("p", { className: "ui-confirm__message", text: message });
    const actions = el("div", { className: "ui-confirm__actions" });
+    const back = document.activeElement as HTMLElement | null; // 닫힐 때 초점을 돌려놓을 자리
    const done = (result: boolean): void => {
      overlay.remove();
+      if (back?.isConnected && back !== document.body) back.focus({ preventScroll: true });
      resolve(result);
    };
+    const cancel = createButton({ label: "취소", variant: "ghost", onClick: () => done(false) });
    actions.append(
-      createButton({ label: "취소", variant: "ghost", onClick: () => done(false) }),
+      cancel,
      createButton({ label: confirmLabel, variant: "danger", onClick: () => done(true) }),
    );
+    overlay.addEventListener("keydown", (ev) => {
+      if (ev.key !== "Escape") return;
+      ev.stopPropagation(); // 뒤 창 · 페이지 Esc 까지 닫지 않음
+      done(false);
+    });
    panel.append(text, actions);
    overlay.append(panel);
    document.body.append(overlay);
+    cancel.focus(); // 창에 초점 — 뒤 칸에 글이 들어가지 않고 Esc 가 먹음
  });
 }

@@ -99,6 +99,10 @@ const BASE_CSS = `
  transition: border-color var(--transition-fast), box-shadow var(--transition-fast);
 }
 .ui-input::placeholder { color: var(--color-text-muted); }
+/* 입력칸 · 고르기칸 높이는 크기마다 한 값 — 같은 줄에 놓여도 위아래 · 글자 줄이 맞음(date 칸 포함) */
+.ui-input:not(textarea), .ui-select { height: var(--control-height); line-height: 20px; }
+.ui-input--sm:not(textarea), .ui-select--sm { height: var(--control-height-sm); line-height: 20px; }
+.ui-input--sm { padding: 4px 8px; }
 .ui-input:focus {
  outline: none;
  border-color: var(--color-focus-ring);
@@ -23,6 +23,10 @@ export const ui_locales_m2 = {
  M02_Close: ["닫기", "Close"],
  M02_NameNeeded: ["이름을 적을 것", "Enter a name"],
  M02_DeleteConfirm: ["「{value}」 양식을 지울까?", "Delete template “{value}”?"],
+  M02_InUse: [
+    "쓰는 양식이라 못 지움 「{value}」 — {use}",
+    "“{value}” is in use and cannot be deleted — {use}",
+  ],
  M02_Deleted: ["지웠음", "Deleted"],
  M02_Created: ["만들었음", "Created"],
  M02_Saved: ["저장했음", "Saved"],
@@ -13,11 +13,16 @@ export interface ModalOptions {
  mount: (body: HTMLElement, close: () => void) => void;
  dialogClass?: string;
  backdropClass?: string;
+  /** 닫기 단추 · Esc · 바깥 누르기 전에 물음 — false 면 안 닫음(몸의 `close` 는 묻지 않고 닫음) */
+  beforeClose?: () => boolean | Promise<boolean>;
 }

 export function openModal(opts: ModalOptions): { close: () => void } {
  const body = el("div", { className: "ui-modal__body" });
  const close = (): void => backdrop.remove();
+  const ask = async (): Promise<void> => {
+    if (!opts.beforeClose || (await opts.beforeClose())) close();
+  };
  const dialog = el("div", {
    className: `ui-modal ${opts.dialogClass ?? ""}`.trim(),
    attrs: { role: "dialog", "aria-label": opts.title },
@@ -26,7 +31,7 @@ export function openModal(opts: ModalOptions): { close: () => void } {
        className: "ui-modal__top",
        children: [
          el("h3", { text: opts.title }),
-          createButton({ label: opts.closeLabel, variant: "ghost", onClick: close }),
+          createButton({ label: opts.closeLabel, variant: "ghost", onClick: () => void ask() }),
        ],
      }),
      body,
@@ -36,11 +41,12 @@ export function openModal(opts: ModalOptions): { close: () => void } {
    className: `ui-modal__backdrop ${opts.backdropClass ?? ""}`.trim(),
    children: [dialog],
  });
-  backdrop.addEventListener("click", (ev) => ev.target === backdrop && close());
-  backdrop.addEventListener("keydown", (ev) => ev.key === "Escape" && close());
+  backdrop.addEventListener("click", (ev) => ev.target === backdrop && void ask());
+  backdrop.addEventListener("keydown", (ev) => ev.key === "Escape" && void ask());
  opts.mount(body, close);
  document.body.append(backdrop);
  dialog.tabIndex = -1;
-  dialog.focus();
+  // 몸의 첫 입력 칸에 커서 — mount 안의 focus() 는 붙기 전이라 안 먹음
+  (body.querySelector<HTMLElement>("input, textarea, select") ?? dialog).focus();
  return { close };
 }
@@ -154,6 +154,10 @@
  --radius-icons: var(--radius-lg);
  --radius-large: var(--radius-3xl);

+  /* 입력칸 · 고르기칸 높이 — 크기마다 한 값(같은 줄이면 위아래가 맞음) */
+  --control-height: 42px;
+  --control-height-sm: 30px;
+
  /* ---------------------------------------------------------------------------
   * 6. 그림자 (Shadows) — 블루틴트, 서브틀 (최대 32px blur / 6% opacity)
   * ------------------------------------------------------------------------ */