Merge remote-tracking branch 'origin/sub_laptop_3' into sub_laptop_2

M01_MasterData/M01_MasterData_Router.py

@@ -15,6 +15,7 @@ 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"])
 
@@ -114,6 +115,20 @@ 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] = {}  # 변수마다 정한 것 {이름: {무엇, 단위, 비목, 요소·찾기·값}}
@@ -349,3 +364,29 @@ 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)

M01_MasterData/M01_MasterData_Store_Combo.py

@@ -213,20 +213,22 @@ def combo_edit(key: str, version: str, combo_: dict, owner: str = "") -> dict:
     was = _find(data, key)
     if store.read(FILE)[1] != version:
         raise store.StoreError(409, {"stale": [FILE]})
+    if isinstance(combo_, dict):  # 화면이 안 보내도 계보(본뜬키)는 남김
+        combo_ = {"본뜬키": was.get("본뜬키"), **combo_}
     fixed = _clean(combo_, owner or str(was.get("소유") or OWNERS[0]), key)
     done = _write([{"op": "edit", "key": key, "row": fixed}], version)
     return {**done, "combo": _find(store.read(FILE)[0], key)}
 
 
-def combo_users(key: str) -> list[str]:
-    """이 조합을 「일위대가」 로 쓰는 구조물 열 이름들 — 집계표 · SS 장부를 함께 봄."""
+def users_of(field: str, key: str) -> list[str]:
+    """집계표 · SS 장부에서 열 칸 `field`(「일위대가」 · 「자재조합」)가 `key` 인 열 이름들."""
     names: dict[str, str] = {}
     for path in USERS:
         if not path.is_file():
             continue
         doc = json.loads(path.read_text(encoding="utf-8"))
         for col in doc.get("열") or doc.get("줄") or []:
-            if col.get("일위대가") != key:
+            if col.get(field) != key:
                 continue
             head = col.get("머리") or [col.get(k) for k in ("종류", "분류1", "분류2", "분류3")]
             cid = str(col.get("id") or col.get("열"))
@@ -234,6 +236,10 @@ def combo_users(key: str) -> list[str]:
     return list(names.values())
 
 
+def combo_users(key: str) -> list[str]:
+    return users_of("일위대가", key)
+
+
 def combo_delete(key: str, version: str) -> dict:
     data, _ = _read()
     _find(data, key)

M01_MasterData/M01_MasterData_Store_Matset.py

@@ -0,0 +1,136 @@
+"""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)

M02_MasterTemplete/M02_MasterTemplete_Api_Fetch.ts

@@ -138,6 +138,8 @@ export interface StructureCombo extends StructureNumbers {
   분류3: string | null;
   단위: string | null;
   일위대가: string | null;
+  /** 자재 조합 키 `UM` */
+  자재조합: string | null;
   바인딩: unknown;
   펼침: unknown;
 }
@@ -153,6 +155,59 @@ export interface StructureCombos {
 /** 조합 표 — 서버가 집계표 [저장] 때 맞춤(읽기만) */
 export const fetchStructureCombos = (): Promise<StructureCombos> => call("/structure-combos");
 
+/** 조합 갈라 내기 결과 — `새로만듦` false = 같은 담은 로직의 조합이 이미 있어 그 키를 가리킴 */
+export interface BranchedCombo {
+  키: string;
+  이름: string;
+  새로만듦: boolean;
+  집계표판: string;
+}
+
+/** 이 열이 가리키는 일위대가 조합을 고친 담은 로직으로 갈라 냄 — 새 UA · 집계표 그 열만 새 키 ·
+ * `판`(집계표 판)을 주면 어긋날 때 StaleError · 원래 조합은 그대로 */
+export const branchCombo = (
+  column: string,
+  body: {
+    본뜬키: string;
+    담은로직: { 로직: string; 메모?: string | null }[];
+    이름: string;
+    판?: string;
+  },
+): Promise<BranchedCombo> =>
+  call(`/structures/${enc(column)}/combo`, { method: "POST", body: JSON.stringify(body) });
+
+/** 자재 조합(키 `UM`) 담은 자재 한 줄 */
+export interface MaterialItem {
+  코드: string;
+  이름: string | null;
+  규격: string | null;
+  단위: string | null;
+}
+
+/** 자재 조합 한 줄 — 본뜬키 = 갈라 낸 원래 키(없으면 null) */
+export interface MaterialCombo {
+  키: string;
+  이름: string;
+  담은자재: MaterialItem[];
+  본뜬키: string | null;
+  소유: string;
+  비고: string | null;
+}
+
+export const fetchMaterialCombo = (key: string): Promise<MaterialCombo> =>
+  call(`/material-combos/${enc(key)}`);
+
+/** 이 열의 자재 조합을 고친 담은 자재로 갈라 냄 — 규칙은 `branchCombo` 와 같음 ·
+ * `본뜬키` 빈 글 = 이 열의 첫 자재 조합 */
+export const branchMaterialCombo = (
+  column: string,
+  body: { 본뜬키?: string; 담은자재: MaterialItem[]; 이름: string; 판?: string },
+): Promise<BranchedCombo> =>
+  call(`/structures/${enc(column)}/material-combo`, {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+
 /** 다른 열(`from`) 구조물 도면 내용을 받는 열(`column`)로 가져옴 — 도번 · 열은 받는 쪽 그대로 */
 export const copyStructure = async (column: string, from: string): Promise<void> => {
   await call(`/structures/${enc(column)}/copy?from=${enc(from)}`, { method: "POST" });

M02_MasterTemplete/M02_MasterTemplete_Branch.py

@@ -0,0 +1,151 @@
+"""조합 갈라 내기 — 구조물 열 하나가 가리키는 조합을 고친 내용으로 새로 만들어 그 열만 새 키를
+가리키게 함(PLAN 15장 · 검토 `14_조합편집검토.md` 1장).
+  · 일위대가 조합(UA · `일위대가조합.json`) — 새 줄은 M01 조합 저장소가 만듦(부르기만)
+  · 자재 조합(UM · `자재조합.json`) — M01 마스터 저장(`save`)으로 더함(키 = 대장 다음 번호)
+
+조합은 여러 열 · 모든 프로젝트가 같이 씀 — 제자리 고치지 않음. 담은 것의 집합(차례 · 메모 무시)이
+이미 있는 조합과 같으면 새로 안 만들고 그 키 · 새 줄의 본뜬키 = 원래 키 · 소유 현장.
+"""
+
+from __future__ import annotations
+
+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_Store as store
+
+_OWNER = "현장"
+MATERIAL_FILE = "자재조합.json"
+
+
+def _m01(fn, *args):
+    """M01 막힘은 M02 막힘으로 — 상태 · 까닭 그대로."""
+    try:
+        return fn(*args)
+    except m01.StoreError as e:
+        raise store.StoreError(e.status, e.detail) from e
+
+
+def _free_name(name: str, rows: list[dict]) -> str:
+    taken = {str(r.get("이름") or "") for r in rows}
+    n, out = 2, name
+    while out in taken:
+        out, n = f"{name} ({n})", n + 1
+    return out
+
+
+def _branch(
+    column: str,
+    version: str,
+    field: str,
+    file: str,
+    slot: str,
+    ident: str,
+    items: list[dict],
+    source: str,
+    make: Callable[[str, list[dict]], dict],
+    name: str,
+) -> dict[str, Any]:
+    """집계표 판 검사 → 같은 내용 찾기 · 없으면 `make(이름, 줄들)` 로 새 줄 → 집계표 그 열 `field`.
+    `slot` = 담은 칸(담은로직 · 담은자재) · `ident` = 담은 줄의 알맹이 칸(로직 · 코드)."""
+    table = store.read("table", store.STRUCTURE_TABLE)
+    if version and table["판"] != version:
+        raise store.StoreError(409, {"stale": [store.STRUCTURE_TABLE], "판": table["판"]})
+    col = next((c for c in store._structure_columns() if c["id"] == column), None)
+    if col is None:
+        raise store.StoreError(404, f"{store.STRUCTURE_TABLE}에 없는 구조물 열 「{column}」")
+    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))
+
+    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:
+        key, made_name, made = str(hit["키"]), str(hit.get("이름") or ""), False
+    else:
+        made_name = _free_name(name, rows)
+        key, made = make(made_name, rows), True
+    # ponytail: 조합 쓰기와 집계표 쓰기는 한 묶음 아님 — 사이에 집계표가 바뀌면 409 뒤 주인 없는
+    # 조합 하나가 남음(다시 하면 같은 내용이라 그 키를 씀)
+    doc = table["문서"]
+    for c in doc.get("열", []):
+        if isinstance(c, dict) and c.get("id") == column:
+            c[field] = key
+    info = store.write("table", store.STRUCTURE_TABLE, table["판"], doc)  # SS 도 여기서 맞춤
+    return {"키": key, "이름": made_name, "새로만듦": made, "집계표판": info["판"]}
+
+
+def branch_combo(
+    column: str, source: str, items: list[dict], name: str, version: str = ""
+) -> dict[str, Any]:
+    """일위대가 조합 갈라 내기 — 구분 · 상세구분 · 단위 · 출처 = 본뜬 것."""
+    was = _m01(combo_store.combo, source)["combo"]
+    items = [
+        {"로직": str(x.get("로직") or ""), "메모": x.get("메모")}
+        for x in items or []
+        if isinstance(x, dict)
+    ]
+
+    def make(made_name: str, _rows) -> str:
+        row = {
+            "이름": made_name,
+            **{k: was.get(k) for k in ("구분", "상세구분", "단위")},
+            "담은로직": items,
+            "본뜬키": source,
+            "출처": was.get("출처"),
+        }
+        return str(_m01(combo_store.combo_new, row, _OWNER)["key"])
+
+    name = name.strip() or str(was.get("이름") or source)
+    return _branch(
+        column, version, "일위대가", combo_store.FILE, "담은로직", "로직", 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
+
+
+def branch_material_combo(
+    column: str, source: str, items: list[dict], name: str, version: str = ""
+) -> dict[str, Any]:
+    """자재 조합 갈라 내기 — `source` 가 빈 글이면 이 열의 첫 자재 조합(본뜬키 null)."""
+    was = material_combo(source) if source else {}
+    items = [
+        {k: x.get(k) for k in ("코드", "이름", "규격", "단위")}
+        for x in items or []
+        if isinstance(x, dict)
+    ]
+
+    def make(made_name: str, rows: list[dict]) -> 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))
+
+    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)
+    return _branch(
+        column, version, "자재조합", MATERIAL_FILE, "담은자재", "코드", items, source, make, name
+    )

M02_MasterTemplete/M02_MasterTemplete_Router.py

@@ -10,6 +10,7 @@ from typing import Any
 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_Store as store
 
 router = APIRouter(prefix="/api/m02", tags=["M02 MasterTemplete"])
@@ -20,6 +21,20 @@ class SaveBody(BaseModel):
     문서: Any
 
 
+class BranchBody(BaseModel):
+    본뜬키: str
+    담은로직: list[dict[str, Any]]
+    이름: str = ""
+    판: str = ""  # 집계표 판 — 주면 어긋날 때 409
+
+
+class MaterialBranchBody(BaseModel):
+    본뜬키: str = ""  # 빈 글 = 이 열의 첫 자재 조합
+    담은자재: list[dict[str, Any]]
+    이름: str = ""
+    판: str = ""
+
+
 def _call(fn, *args):
     try:
         return fn(*args)
@@ -49,6 +64,26 @@ def post_structure(column: str) -> dict:
     return _call(store.create_structure, column)
 
 
+@router.post("/structures/{column}/combo")
+def post_structure_combo(column: str, body: BranchBody) -> dict:
+    """조합 갈라 내기 — 고친 담은 로직으로 새 UA(같은 로직 집합이면 있는 키) · 이 열만 가리킴."""
+    return _call(branch.branch_combo, column, body.본뜬키, body.담은로직, body.이름, body.판)
+
+
+@router.post("/structures/{column}/material-combo")
+def post_structure_material_combo(column: str, body: MaterialBranchBody) -> dict:
+    """자재 조합 갈라 내기 — 같은 규칙(같은 자재 집합이면 있는 키 · 아니면 새 UM)."""
+    return _call(
+        branch.branch_material_combo, column, body.본뜬키, body.담은자재, body.이름, body.판
+    )
+
+
+@router.get("/material-combos/{key}")
+def get_material_combo(key: str) -> dict:
+    """자재 조합 한 줄(키 UM) — 키 · 이름 · 담은자재 · 본뜬키 · 소유 · 비고."""
+    return _call(branch.material_combo, key)
+
+
 # 복사 가져오기 — 다른 열(`from`) 내용을 받는 열로 · 번호 · 열은 받는 쪽 그대로
 @router.post("/structures/{column}/copy")
 def post_structure_copy(column: str, source: str = Query(alias="from")) -> dict:

M02_MasterTemplete/M02_MasterTemplete_Store.py

@@ -109,9 +109,12 @@ def write(kind: str, name: str, version: str, doc: Any) -> dict[str, Any]:
     만들고 지운 열(또는 구조물이 아니게 된 열)의 세 파일을 지움(잠금 밖에서 · 안에서 부르면 죽음).
     통합문서(area · material)는 서버가 같은 TS 엔진을 Node 로 돌려 `계산값` 을 새로 적음
     (브라우저 값 버림 · 5장 ②) · 알약 `연결` 은 문서와 같이 그대로 적힘.
-    번호 칸(도번 · 면적번 · 재료번)은 서버 것 — 있던 파일 번호를 그대로 둠(화면 값을 안 받음)."""
+    번호 칸(도번 · 면적번 · 재료번)은 서버 것 — 있던 파일 번호를 그대로 둠(화면 값을 안 받음).
+    표 열의 `본뜬열`(분류 더하기로 복사한 새 열)은 적지 않음 — 집계표면 아직 파일이 없는 새 열이
+    원본 열의 일위대가 · 자재조합 키와 세 파일 내용을 받음(새 번호 · 그 뒤로는 열마다 따로)."""
     path = _path(kind, name)
     _check_skeleton(kind, doc)
+    origins = _take_origins(doc) if kind == "table" else {}
     if kind in SHEETS:
         doc = _server_values(doc)
     with _LOCK:
@@ -124,6 +127,9 @@ def write(kind: str, name: str, version: str, doc: Any) -> dict[str, Any]:
         atomic_write_json(path, doc)
         info = _info(kind, path)
     if kind == "table" and name == STRUCTURE_TABLE:
+        for column, source in origins.items():  # 빈 파일 채우기 앞 — 원본 내용으로 만듦
+            for part in _KEY:
+                _ensure(part, column, source)
         backfill_missing_structures()  # 지우기 앞 — 같은 저장의 새 열이 지운 번호를 안 받게
         prune_removed_structures()
         sync_combos()  # 번호가 다 선 뒤 — 조합 표 도번 · 면적번 · 재료번 칸
@@ -256,17 +262,46 @@ def _blank(kind: str, column: str) -> dict[str, Any]:
     }
 
 
-def _ensure(kind: str, column: str) -> bool:
-    """그 열의 파일이 없으면 빈 문서를 번호(세 파일이 같은 8자리)와 같이 만듦 · 있으면 그대로."""
+def _ensure(kind: str, column: str, source: str | None = None) -> bool:
+    """그 열의 파일이 없으면 빈 문서를 번호(세 파일이 같은 8자리)와 같이 만듦 · 있으면 그대로.
+    `source` 열 파일이 있으면 빈 문서 대신 그 내용(알약 `연결` 포함 · 계산값은 서버가 다시 풂)."""
     path = _path(kind, column)
+    if path.is_file():
+        return False
     head = next(h for k, _, h, _ in PARTS if k == kind)
+    base = _blank(kind, column)
+    if source and _path(kind, source).is_file():
+        got = json.loads(_path(kind, source).read_bytes())
+        base = {**{k: v for k, v in got.items() if k != "계산값"}, "열": column}
+        if kind in SHEETS:
+            base = _server_values(base)
     with _LOCK:
         if path.is_file():
             return False
-        atomic_write_json(path, {**_blank(kind, column), _KEY[kind]: head + _new_code(column)})
+        atomic_write_json(path, {**base, _KEY[kind]: head + _new_code(column)})
     return True
 
 
+def _take_origins(doc: Any) -> dict[str, str]:
+    """표 열의 `본뜬열` 을 떼어 냄 → `{새 열: 원본 열}` (구조물 파일이 아직 없는 열만) ·
+    그 열에 일위대가 · 자재조합 키가 비었으면 원본 열 것을 받음."""
+    cols = (
+        [c for c in (doc.get("열") or []) if isinstance(c, dict)] if isinstance(doc, dict) else []
+    )
+    by_id = {c.get("id"): c for c in cols}
+    out: dict[str, str] = {}
+    for col in cols:
+        source = col.pop("본뜬열", None)
+        if not source or source not in by_id or not col.get("id"):
+            continue
+        if (FOLDER / "structure" / f"{col['id']}.json").is_file():
+            continue
+        out[col["id"]] = source
+        for field in ("일위대가", "자재조합"):
+            col[field] = col.get(field) or by_id[source].get(field)
+    return out
+
+
 def create_structure(column: str) -> dict[str, Any]:
     """구조물 열 하나의 구조물 도면 새로 — 도번 SD + 8자리 · 이미 있으면 409.
     면적산출 · 재료산출 파일이 없으면 빈 통합문서도 같이 만듦(같은 8자리)."""
@@ -400,6 +435,7 @@ def _combo_row(key: str, col: dict[str, Any], numbers: dict[str, str]) -> dict[s
         "분류3": level3,
         "단위": col.get("단위"),
         "일위대가": col.get("일위대가"),
+        "자재조합": col.get("자재조합"),
         **{field: numbers.get(field, "") for _, field, _, _ in PARTS},
         "바인딩": col.get("바인딩"),
         "펼침": col.get("펼침"),

resources/master_data/_키대장.json

@@ -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},
+  "다음": {"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},
   "폐기": {"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"},

resources/master_data/_틀.md

@@ -38,7 +38,7 @@
 | MT  | 재료 자재품목 | CF · CC      | 계수 산림 · 건설        |
 | MO  | 재료 유가     | RT           | 요율                    |
 | MP  | 재료 품셈재료(old/ — PLAN 7-4b) | GF · GC · GX | 로직 산림 · 건설 · 자체 |
-| EQ  | 기계          |              |                         |
+| EQ  | 기계          | UA · UM      | 일위대가 조합 · 자재 조합 |
 
 - 빌더는 옛 모양(`열쇠` · 원문별 파일)으로 쓰고 끝에 `scripts/master_keys.py` 의 `adopt` 를 부름 — 키·원문번호·한 테이블·장 파일 이름으로 받음. 옛 이름으로 읽기는 `old_view`.
 
@@ -279,17 +279,17 @@
         { "로직": "GF000219", "메모": "인력 메쌓기" },
         { "로직": "GF000220", "메모": null }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": null
     }
   ]
 }
 ```
 
-- 열 한 벌 — `키` · `이름` · `구분` · `상세구분` · `단위` · `담은로직` · `출처` · `소유` · `본뜬키` · `비고`(차례까지 이대로 · 안 채운 칸은 `null`).
-- `본뜬키` = 이 조합을 본떠 만든 원본 조합 키(같은 파일의 다른 UA) · `null` 이면 원본 · 자기 키 안 됨 · M02 가 열 몫으로 갈라 낼 때 채움.
+- 열 한 벌 — `키` · `이름` · `구분` · `상세구분` · `단위` · `담은로직` · `본뜬키` · `출처` · `소유` · `비고`(차례까지 이대로 · 안 채운 칸은 `null`).
+- `본뜬키` = 갈라 낸 원래 조합 키(M02 조합 갈라 내기) · 없으면 `null` · M01 고치기는 안 보내도 그대로 둠.
 - **담은 로직 목록만 둠** — 수량 · 비율 · 계산 칸을 두지 않음. 로직마다 하는 일이 달라 수량은 로직마다 따로 들어가고, 그 대입과 합계는 프로젝트 몫(B08 · B09).
 - `담은로직` 줄 = `{로직, 메모}` 뿐 · 목록 차례가 곧 조합 안 차례. `메모` = 글자 또는 `null` — 수량 같은 값을 넣는 자리가 아님.
 - `키` = `UA` + 6자리 — 대장 `_키대장.json` 의 `UA` 다음 번호(서버가 줌). 원문이 없어 **줄에 `원문번호` 를 두지 않음**(대장 열쇠는 조합 이름).
@@ -297,3 +297,13 @@
 - `이름` = 글자 · 빈 이름 안 됨 · 60자까지(`master_combo.MAX_이름`) · 같은 파일 안에서 안 겹침.
 - 검사(`check_master.py 조합` · 엔진 `scripts/master_combo.py`) — 없는 로직 키 · 단가산출 로직이 아닌 키 · 같은 로직 두 번 · 빈 조합 · **조합이 조합을 담음**(1단만) · 메모가 글자·`null` 아님 · 이름이 글자 아니거나 없음·너무 김·겹침.
 - 「이 로직을 쓰는 조합」 은 로직 줄에 칸으로 박지 않고 물을 때 훑어 찾음(`master_combo.using`) — 조합은 관리자가 그때그때 만드는 것이라 박아 두면 낡음. 소요량 「용도」 와 결은 같되 자리가 다름.
+
+## 11. 자재 조합 파일
+
+`자재조합.json` 하나 — 구조물 열 재료산출이 쓰는 **자재 목록 묶음**. 머리 `그룹` · `판` · `비고` · `줄`(원문 없음).
+
+- 열 한 벌 — `키` · `이름` · `담은자재` · `본뜬키` · `소유` · `비고`(차례까지 이대로 · 엔진 `scripts/master_material_combo.py`).
+- `키` = `UM` + 6자리 — 대장 `UM` 다음 번호 · 줄에 `원문번호` 를 두지 않음.
+- `담은자재` 줄 = `{코드, 이름, 규격, 단위}` 뿐 · 빈 목록 안 됨 · 같은 코드 두 번 안 됨 · 수량 · 계산은 두지 않음(재료산출 몫).
+- `본뜬키` = 갈라 낸 원래 자재 조합 키 · 없으면 `null` · `소유` = `현장` · `공용`.
+- 새 줄은 M02 갈라 내기(`POST /api/m02/structures/{열}/material-combo`)가 만듦 — 같은 자재 집합이 있으면 그 키.

resources/master_data/_화면_계약.md

@@ -196,6 +196,22 @@
   - 못 도는 줄은 통째로 멈추지 않고 그 줄만 `ok` false · `까닭` · `멈춤` 에 한 줄 — 나머지 줄의 합계는 그대로 냄.
 - 답 — 200 · 400(틀린 몸 · 이름 없음 · 모르는 소유) · 404(없는 키) · 409(낡은 판본) · 422 `{detail: {errors: […]}}`(검사 걸림 — 없는 로직 키 · 같은 로직 두 번 · 빈 조합 · 조합을 담음).
 
+### 자재 조합
+
+재료산출에서 쓸 **자재 목록 묶음**(파일 `자재조합.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 목록에 같이 보임.
+
 ## 10. 재료 · 기계 고르기
 
 재료 줄은 키 대신 기본 검색어로 품목을 찾음 — 파일 모양 · 찾기 규칙 · 자동값 차례 · 단위 환산은 `_틀.md` 7장.

resources/master_data/scripts/check_master.py

@@ -30,6 +30,7 @@ sys.path.insert(0, str(ROOT / "resources/knowledge/original/_pipeline"))
 import master_combo as mcb  # noqa: E402
 import master_formula as mf  # noqa: E402
 import master_keys as mk  # noqa: E402
+import master_material_combo as mmc  # noqa: E402
 from pum_md_tool import _NUM, md_lines  # noqa: E402
 
 BOOKS = (
@@ -226,7 +227,6 @@ def check_combo_form(name: str, data: dict) -> list[str]:
     if not isinstance(rows_, list):
         return out + [f"{name} · 머리 「줄」 목록 없음"]
     seen_names: dict[str, str] = {}
-    own = {str(r.get("키")) for r in rows_}
     for row in rows_:
         key = str(row.get("키"))
         where = f"{name} · {key} {row.get('이름') or ''}".strip()
@@ -251,14 +251,16 @@ def check_combo_form(name: str, data: dict) -> list[str]:
         if not _source_ok(row.get("출처")):
             out.append(f"{where} · 출처 모양 「{row.get('출처')}」")
         origin = row.get("본뜬키")
-        if origin is not None and (origin == key or origin not in own):
-            out.append(f"{where} · 본뜬키 「{origin}」 — 비었거나 이 파일의 다른 조합 키여야 함")
+        if origin is not None and not (mk.KEY.fullmatch(str(origin)) and origin[:2] == mcb.TID):
+            out.append(f"{where} · 본뜬키 모양 「{origin}」")
     return out
 
 
 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)

resources/master_data/scripts/master_combo.py

@@ -18,8 +18,8 @@ FILE = "일위대가조합.json"
 TID = "UA"
 OWNERS = ("현장", "공용")
 MAX_이름 = 60  # 조합 이름 최대 글자 수 — 관리자가 짓는 짧은 이름이라 이보다 길면 저장 막음
-# 줄 열 한 벌 — 차례까지 이대로(`_틀.md` 10장)
-COLS = ("키", "이름", "구분", "상세구분", "단위", "담은로직", "출처", "소유", "본뜬키", "비고")
+# 줄 열 한 벌 — 차례까지 이대로(`_틀.md` 10장) · 본뜬키 = 갈라 낸 원래 조합 키(없으면 null)
+COLS = ("키", "이름", "구분", "상세구분", "단위", "담은로직", "본뜬키", "출처", "소유", "비고")
 ITEM_COLS = ("로직", "메모")
 
 

resources/master_data/scripts/master_keys.py

@@ -32,12 +32,13 @@ 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")
+NO_NUMBER = ("MT", "UA", "UM")
 
 
 def table_id(group: str, book: str | None) -> str:
@@ -181,11 +182,12 @@ ROW_ORDER = {
         "상세구분",
         "단위",
         "담은로직",
+        "본뜬키",
         "출처",
         "소유",
-        "본뜬키",
         "비고",
     ),
+    "자재조합": ("키", "이름", "담은자재", "본뜬키", "소유", "비고"),
 }
 OLD_CHAPTER = re.compile(r"^(소요량|계수|로직)_(산림품셈|건설품셈)_(\D*)(\d+)장\.json$")
 CHAPTER = re.compile(r"^(소요량|계수|로직)_(산림품셈|건설품셈|자체)_(\d\d)장_.+\.json$")

resources/master_data/scripts/master_material_combo.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+"""자재 조합 — 구조물 열 재료산출이 쓰는 자재 목록 묶음(키 UM · `_틀.md` 11장).
+
+담은 자재 목록만 지님(수량 · 계산은 재료산출 몫). 일위대가 조합(`master_combo`)과 같은 결 —
+갈라 내기(M02) 때 새 줄 · 본뜬키 = 원래 키.
+"""
+
+from __future__ import annotations
+
+import master_combo as mcb
+import master_keys as mk
+
+GROUP = "자재조합"
+FILE = "자재조합.json"
+TID = "UM"
+OWNERS = mcb.OWNERS
+MAX_이름 = mcb.MAX_이름
+COLS = mk.ROW_ORDER[GROUP]  # 키 · 이름 · 담은자재 · 본뜬키 · 소유 · 비고
+ITEM_COLS = ("코드", "이름", "규격", "단위")
+
+
+def items(row: dict) -> list[dict]:
+    got = row.get("담은자재")
+    return got if isinstance(got, list) else []
+
+
+def check_form(name: str, data: dict) -> list[str]:
+    """파일 틀 + 줄 — 키 모양 · 열 한 벌 · 이름 · 소유 · 담은 자재(빈 목록 · 모양 · 같은 코드 두 번)."""
+    out = [] if data.get("그룹") == GROUP else [f"{name} · 머리 그룹이 「{GROUP}」 아님"]
+    rows = data.get("줄")
+    if not isinstance(rows, list):
+        return out + [f"{name} · 머리 「줄」 목록 없음"]
+    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자리 아님")
+        if tuple(row) != COLS:
+            out.append(f"{where} · 열이 한 벌이 아님 — 「{' · '.join(COLS)}」")
+        plain = row.get("이름").strip() if isinstance(row.get("이름"), str) else ""
+        if not plain or len(plain) > MAX_이름:
+            out.append(f"{where} · 「이름」 이 없거나 {MAX_이름}자 넘음")
+        elif plain in seen_names:
+            out.append(f"{where} · 「이름」 이 같은 조합과 겹침 — {seen_names[plain]}")
+        seen_names.setdefault(plain, key)
+        if row.get("소유") not in OWNERS:
+            out.append(f"{where} · 소유 「{row.get('소유')}」 — {' · '.join(OWNERS)} 아님")
+        origin = row.get("본뜬키")
+        if origin is not None and not (mk.KEY.fullmatch(str(origin)) and origin[:2] == TID):
+            out.append(f"{where} · 본뜬키 모양 「{origin}」")
+        got = items(row)
+        if not got:
+            out.append(f"{where} · 빈 조합 — 담은 자재가 없음")
+        codes: set[str] = set()
+        for at, one in enumerate(got, start=1):
+            if not isinstance(one, dict) or set(one) - set(ITEM_COLS):
+                out.append(f"{where} 줄{at} · 담은 자재 줄 모양 「{one}」")
+                continue
+            code = str(one.get("코드") or "")
+            if not mk.KEY.fullmatch(code):
+                out.append(f"{where} 줄{at} · 자재 코드 모양 아님 「{code}」")
+            elif code in codes:
+                out.append(f"{where} 줄{at} · 같은 자재를 두 번 담음 「{code}」")
+            codes.add(code)
+    return out

resources/master_data/일위대가조합.json

@@ -10,9 +10,9 @@
       "상세구분": null,
       "단위": "식",
       "담은로직": [{ "로직": "GF000219", "메모": "메쌓기 — 돌쌓기 인력" }, { "로직": "GF000119", "메모": "노체포설 — 굴착기 0.7㎥" }, { "로직": "GF000137", "메모": "운반 — 중기운반 트레일러(20ton)" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "브레인이 넣은 견본 · 조합 화면을 바로 볼 수 있게 함 · 지워도 됨"
     },
     {
@@ -29,9 +29,9 @@
         { "로직": "GF000156", "메모": "콘크리트비빔 채움재 (실무 수는 옛 판 값)" },
         { "로직": "GC000214", "메모": "유로폼 설치 및 해체 간단" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "글자새김 자당 6*6 — 우리 로직에 없음\n잔토처리 굴삭기 0.2m3 — 우리 로직에 없음\n실무 호표 — 봉화 B00005 · 울진대흥 B01224"
     },
     {
@@ -51,9 +51,9 @@
         { "로직": "GF000218", "메모": "잡석운반및다짐 (실무 수는 옛 판 값)" },
         { "로직": "GF000124", "메모": "면고르기" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "깬잡석채집 L=30cm 내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계(0.7㎥,100%) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n잔토처리 굴삭기 0.7m3 — 우리 로직에 없음\n측구수로관부설 500∼700kg미만 — 우리 로직에 없음\n기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n실무 호표 — 봉화 B00008 · 봉화 B00030 · 영월 B02019 · 영월 B02052 · 영월 B02134"
     },
     {
@@ -75,9 +75,9 @@
         { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" },
         { "로직": "GF000113", "메모": "구조물되메우기 굴착기0.6m3 (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "깬잡석채집 L=45cm 내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계(0.7㎥,100%) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n막자갈채집 기계(0.7㎥,100%) — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n막자갈채집 기계 — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 굴삭기0.7m3 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n막자갈채우기 150mm내외 — 후보 「자갈고르기」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 봉화 B00010 · 봉화 B00011 · 봉화 B00022 · 봉화 B00047 · 울진대흥 B01212 · 울진대흥 B01213 · 울진대흥 B01214 · 울진대흥 B01215 · 울진대흥 B01216 · 울진대흥 B01225 · 울진대흥 B01226 · 울진대흥 B01227 · 울진대흥 B01231 · 울진소광 B02122"
     },
     {
@@ -99,9 +99,9 @@
         { "로직": "GC000015", "메모": "강관동바리 2.5m이하(1개월) (실무 수는 옛 판 값)" },
         { "로직": "GC000821", "메모": "잡철물제작및설치(현장) 일반철재" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "PE관 부설 및 접합 D50 — 후보 「부단수 할정자관 부설 및 접합」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n실무 호표 — 봉화 B00012 · 영월 B02002 · 거창 제12호표"
     },
     {
@@ -116,9 +116,9 @@
         { "로직": "GF000156", "메모": "콘크리트믹서사용 0.45 m3 (실무 수는 옛 판 값)" },
         { "로직": "GF000162", "메모": "콘크리트포장(B-type) t=20cm (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "실무 호표 — 봉화 B00014 · 울진대흥 B01232"
     },
     {
@@ -128,9 +128,9 @@
       "상세구분": null,
       "단위": "m",
       "담은로직": [{ "로직": "GF000162", "메모": "콘크리트포장(인력) T=20㎝" }, { "로직": "GC000211", "메모": "합판거푸집(6회) 간단" }, { "로직": "GF000163", "메모": "콘크리트포장절단공 임도 (실무 수는 옛 판 값)" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n실무 호표 — 영월 B02059"
     },
     {
@@ -155,9 +155,9 @@
         { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" },
         { "로직": "GF000113", "메모": "구조물되메우기 굴착기0.6m3 (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "막자갈채집 기계(0.7㎥,100%) — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n깬잡석채집 L=30cm 내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계(0.7㎥,100%) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n야면석 채집 운반 (25x25x35㎝)장비 — 후보 「야면석 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집운반 4.5톤덤프(L=500) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n큰돌채집운반(뒷길이 0.6~0.8m) 장비(80%) + 인력(20%) — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n녹생토(종자배합) 암절개지 및 특수지반 녹화용 (700kg/㎥) — 우리 로직에 없음\n막자갈채집 기계 — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 굴삭기0.7m3 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n막자갈(파쇄석)채집 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n막자갈채우기 150mm내외 — 후보 「자갈고르기」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 봉화 B00017 · 봉화 B00018 · 봉화 B00029 · 봉화 B00048 · 봉화 B00049 · 봉화 B00055 · 봉화 B00056 · 영월 B01981 · 영월 B01983 · 영월 B01988 · 영월 B02045 · 영월 B02155 · 울진대흥 B01219 · 울진대흥 B01220 · 울진소광 B02120"
     },
     {
@@ -176,9 +176,9 @@
         { "로직": "GC000677", "메모": "모르터바르기 1:3" },
         { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "깬잡석채집 L=30cm 내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계(0.7㎥,100%) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n잔토처리 굴삭기 0.7m3 — 우리 로직에 없음\n깬잡석채집 L=60cm 내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n파쇄석 채집 L3=35cm내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 굴삭기0.2m3 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 봉화 B00020 · 봉화 B00032 · 봉화 B00036 · 봉화 B00064 · 울진대흥 B01222 · 울진대흥 B01223 · 울진대흥 B01229 · 울진대흥 B01230 · 울진소광 B02125"
     },
     {
@@ -198,9 +198,9 @@
         { "로직": "GC000088", "메모": "구조물 터파기(토사) 굴삭기 0.2m3" },
         { "로직": "GF000113", "메모": "구조물 되메우기 굴삭기 0.2m3 (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "잔토처리 굴삭기 0.2m3 — 우리 로직에 없음\n실무 호표 — 봉화 B00025"
     },
     {
@@ -217,9 +217,9 @@
         { "로직": "GC000677", "메모": "모르타르배합 1:3" },
         { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "깬잡석채집 L=35cm 내외 — 후보 「막돌 채집」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집 기계(0.7㎥,100%) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n야면석 채집 운반 (25x25x35㎝)장비 — 후보 「야면석 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집운반 4.5톤덤프(L=500) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n야면석소운반(L=35CM) (L=20m) — 우리 로직에 없음\n콘크리트소운반 (L=20m) — 우리 로직에 없음\n고임돌채집 굴삭기0.7m3 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 봉화 B00034 · 영월 B02016 · 영월 B02017 · 울진소광 B02124"
     },
     {
@@ -234,9 +234,9 @@
         { "로직": "GC000206", "메모": "철근가공및조립(현장) 일반(Type-Ⅰ-1)" },
         { "로직": "GC000207", "메모": "철근가공및조립(현장) 일반(Type-Ⅰ-1)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "실무 호표 — 봉화 B00038"
     },
     {
@@ -252,9 +252,9 @@
         { "로직": "GC000207", "메모": "철근가공 및 조립 Type-Ⅰ-1,현장가공조립" },
         { "로직": "GC000712", "메모": "유성페인트칠(붓칠)-황색 콘크리트,모르타르면3회 (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "실무 호표 — 봉화 B00041"
     },
     {
@@ -272,9 +272,9 @@
         { "로직": "GC000022", "메모": "강관비계 3개월사용 (실무 수는 옛 판 값)" },
         { "로직": "GC000211", "메모": "합판거푸집 6회 (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "실무 호표 — 봉화 B00058 · 거창 제5호표 · 거창 제6호표"
     },
     {
@@ -289,9 +289,9 @@
         { "로직": "GC000206", "메모": "철근가공 및 조립 Type-Ⅰ-1,현장가공조립" },
         { "로직": "GC000207", "메모": "철근가공 및 조립 Type-Ⅰ-1,현장가공조립" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "실무 호표 — 봉화 B00062 · 거창 제9호표"
     },
     {
@@ -306,9 +306,9 @@
         { "로직": "GF000101", "메모": "구조물터파기(인력) 경질토사 (실무 수는 옛 판 값)" },
         { "로직": "GF000113", "메모": "구조물되메우기 (인력) (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "잔토처리 인력100% — 우리 로직에 없음\n실무 호표 — 영월 B00704"
     },
     {
@@ -324,9 +324,9 @@
         { "로직": "GF000101", "메모": "구조물터파기(인력) 경질토사 (실무 수는 옛 판 값)" },
         { "로직": "GF000113", "메모": "구조물되메우기 (인력) (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n잔토처리 인력100% — 우리 로직에 없음\n실무 호표 — 영월 B01982"
     },
     {
@@ -342,9 +342,9 @@
         { "로직": "GF000113", "메모": "구조물되메우기 (인력) (실무 수는 옛 판 값)" },
         { "로직": "GC000310", "메모": "도로반사경설치 D=1000(STS)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n잔토처리 인력100% — 우리 로직에 없음\n실무 호표 — 영월 B01997"
     },
     {
@@ -359,9 +359,9 @@
         { "로직": "GF000101", "메모": "구조물터파기(인력) 경질토사 (실무 수는 옛 판 값)" },
         { "로직": "GF000113", "메모": "구조물되메우기 (인력) (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "기초잡석채집및운반부설 4.5톤(L=500) — 우리 로직에 없음\n잔토처리 인력100% — 우리 로직에 없음\n실무 호표 — 영월 B02152"
     },
     {
@@ -371,9 +371,9 @@
       "상세구분": null,
       "단위": "㎡",
       "담은로직": [{ "로직": "GC000149", "메모": "관목식재(단식) H=0.3~0.7m" }, { "로직": "GC000148", "메모": "굴취(관목) H=0.3~0.7m" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "인력운반 기타 — 우리 로직에 없음\n실무 호표 — 계류보전 B01099"
     },
     {
@@ -388,9 +388,9 @@
         { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" },
         { "로직": "GF000113", "메모": "구조물되메우기 굴착기0.6m3 (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 울진소광 B02121"
     },
     {
@@ -400,9 +400,9 @@
       "상세구분": null,
       "단위": "개소",
       "담은로직": [{ "로직": "GC000198", "메모": "레미콘타설 무근(장비)" }, { "로직": "GC000214", "메모": "유로폼 설치 및 해체 간단" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "실무 호표 — 울진소광 B02129"
     },
     {
@@ -416,9 +416,9 @@
         { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" },
         { "로직": "GF000113", "메모": "구조물되메우기 굴착기0.6m3 (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "고임돌채집 굴삭기0.7m3 — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n막자갈채우기 150mm내외 — 후보 「자갈고르기」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 울진소광 B02123"
     },
     {
@@ -436,9 +436,9 @@
         { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" },
         { "로직": "GF000113", "메모": "구조물되메우기 굴착기0.6m3 (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "물구멍설치 D=50mm — 우리 로직에 없음\n실무 호표 — 울진소광 B02128"
     },
     {
@@ -453,9 +453,9 @@
         { "로직": "GC000206", "메모": "철근가공및조립(현장) Type-Ⅱ-1" },
         { "로직": "GC000207", "메모": "철근가공및조립(현장) Type-Ⅱ-1" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "실무 호표 — 거창 제7호표 · 거창 제8호표"
     },
     {
@@ -465,9 +465,9 @@
       "상세구분": null,
       "단위": "m",
       "담은로직": [{ "로직": "GC000088", "메모": "구조물 터파기(토사) 굴삭기 0.2m3" }, { "로직": "GF000113", "메모": "구조물 되메우기 굴삭기 0.2m3 (실무 수는 옛 판 값)" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "실무 호표 — 봉화 B00007"
     },
     {
@@ -477,9 +477,9 @@
       "상세구분": null,
       "단위": "m",
       "담은로직": [{ "로직": "GC000088", "메모": "구조물 터파기(토사) 굴삭기 0.2m3" }, { "로직": "GF000113", "메모": "구조물 되메우기 굴삭기 0.2m3 (실무 수는 옛 판 값)" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "PE관 부설 및 접합 D50 — 후보 「부단수 할정자관 부설 및 접합」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n실무 호표 — 봉화 B00039"
     },
     {
@@ -489,9 +489,9 @@
       "상세구분": null,
       "단위": "m",
       "담은로직": [{ "로직": "GC000143", "메모": "평떼붙임 (실무 수는 옛 판 값)" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "단끊기 — 우리 로직에 없음\n단끊기 절취없음 — 우리 로직에 없음\n떼 하차비 — 우리 로직에 없음\n실무 호표 — 봉화 B00052 · 울진소광 B02130"
     },
     {
@@ -501,9 +501,9 @@
       "상세구분": null,
       "단위": "m",
       "담은로직": [{ "로직": "GF000101", "메모": "구조물터파기 토사(B/H 90%+인력10%)" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "잔토처리 토사(B/H 100%) — 우리 로직에 없음\n실무 호표 — 영월 B01963"
     },
     {
@@ -513,9 +513,9 @@
       "상세구분": null,
       "단위": "m",
       "담은로직": [{ "로직": "GF000218", "메모": "잡석운반및다짐 (실무 수는 옛 판 값)" }, { "로직": "GF000124", "메모": "면고르기" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "실무 호표 — 영월 B01984"
     },
     {
@@ -525,9 +525,9 @@
       "상세구분": null,
       "단위": "㎡",
       "담은로직": [{ "로직": "GF000218", "메모": "뒷채움돌채집운반부설 4.5톤 덤프트럭(L=500m) (실무 수는 옛 판 값)" }, { "로직": "GF000226", "메모": "큰돌메쌓기 뒷길이 0.6~0.8m" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "고임돌채집운반 4.5톤덤프(L=500) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n큰돌채집운반(뒷길이 0.6~0.8m) 장비(80%) + 인력(20%) — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n녹생토(종자배합) 암절개지 및 특수지반 녹화용 (700kg/㎥) — 우리 로직에 없음\n실무 호표 — 영월 B02133"
     },
     {
@@ -537,9 +537,9 @@
       "상세구분": null,
       "단위": "㎡",
       "담은로직": [{ "로직": "GF000218", "메모": "뒷채움돌채집운반부설 4.5톤 덤프트럭(L=500m) (실무 수는 옛 판 값)" }, { "로직": "GF000226", "메모": "큰돌메쌓기 뒷길이 0.6~0.8m" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "큰돌채집운반(뒷길이 0.6~0.8m) 장비(80%) + 인력(20%) — 후보 「모래·자갈·약돌 채집(인력)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n고임돌채집운반 4.5톤덤프(L=500) — 후보 「큰돌 채집(기계)」 와 수가 다름(옛 판 값) · 이름이 달라 뺌\n녹생토(종자배합) 암절개지 및 특수지반 녹화용 (700kg/㎥) — 우리 로직에 없음\n실무 호표 — 영월 B02156"
     },
     {
@@ -549,9 +549,9 @@
       "상세구분": null,
       "단위": "개소",
       "담은로직": [{ "로직": "GF000101", "메모": "구조물터파기(토사) 굴삭기0.7m3 (실무 수는 옛 판 값)" }, { "로직": "GC000105", "메모": "다지기 굴삭기0.7m3 (실무 수는 옛 판 값)" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "실무 호표 — 울진대흥 B01221"
     },
     {
@@ -566,9 +566,9 @@
         { "로직": "GF000156", "메모": "콘크리트믹서사용 0.45 m3 (실무 수는 옛 판 값)" },
         { "로직": "GC000214", "메모": "유로폼 설치 및 해체 보통" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "실무 호표 — 울진대흥 B01234"
     },
     {
@@ -578,9 +578,9 @@
       "상세구분": null,
       "단위": "kg",
       "담은로직": [{ "로직": "GC000206", "메모": "철근(현장)가공 Type-Ⅰ-----아님 (실무 수는 옛 판 값)" }, { "로직": "GC000207", "메모": "철근(현장)조립 Type-Ⅰ-----아님" }],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "실무 호표 — 울진소광 B00287"
     },
     {
@@ -594,9 +594,9 @@
         { "로직": "GC000088", "메모": "구조물터파기(토사) 굴착기0.6m3" },
         { "로직": "GF000113", "메모": "구조물되메우기 굴착기0.6m3 (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "구조물잔토처리 굴착기0.6m3 — 우리 로직에 없음\n실무 호표 — 울진소광 B02119"
     },
     {
@@ -610,9 +610,9 @@
         { "로직": "GF000155", "메모": "레미콘타설(인력운반타설) 소형구조물" },
         { "로직": "GC000211", "메모": "합판거푸집 6회, 간단 (실무 수는 옛 판 값)" }
       ],
+      "본뜬키": null,
       "출처": "자체",
       "소유": "현장",
-      "본뜬키": null,
       "비고": "실무 호표 — 거창 제13호표"
     }
   ]

resources/master_data/자재조합.json

@@ -0,0 +1,6 @@
+{
+  "그룹": "자재조합",
+  "판": "2026",
+  "비고": ["자재 조합 = 구조물 열 재료산출이 쓰는 자재 목록 묶음 · 수량·계산은 두지 않음(재료산출 몫)"],
+  "줄": []
+}

resources/master_template/구조물집계표조합.json

@@ -13,6 +13,7 @@
       "분류3": "기초유",
       "단위": "m",
       "일위대가": "UA000004",
+      "자재조합": null,
       "도번": "SD01010100",
       "면적번": "SA01010100",
       "재료번": "SM01010100",
@@ -76,7 +77,8 @@
       "분류2": "1.2m",
       "분류3": "기초무, 소단",
       "단위": "m",
-      "일위대가": null,
+      "일위대가": "UA000004",
+      "자재조합": null,
       "도번": "SD01010101",
       "면적번": "SA01010101",
       "재료번": "SM01010101",
@@ -91,7 +93,8 @@
       "분류2": "1.5m",
       "분류3": "기초유",
       "단위": "m",
-      "일위대가": null,
+      "일위대가": "UA000004",
+      "자재조합": null,
       "도번": "SD01010200",
       "면적번": "SA01010200",
       "재료번": "SM01010200",
@@ -106,7 +109,8 @@
       "분류2": null,
       "분류3": null,
       "단위": "m",
-      "일위대가": null,
+      "일위대가": "UA000004",
+      "자재조합": null,
       "도번": "SD01020000",
       "면적번": "SA01020000",
       "재료번": "SM01020000",
@@ -122,6 +126,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD02010100",
       "면적번": "SA02010100",
       "재료번": "SM02010100",
@@ -155,6 +160,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": "UA000007",
+      "자재조합": null,
       "도번": "SD02010200",
       "면적번": "SA02010200",
       "재료번": "SM02010200",
@@ -188,6 +194,7 @@
       "분류3": null,
       "단위": "㎡",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD02010300",
       "면적번": "SA02010300",
       "재료번": "SM02010300",
@@ -221,6 +228,7 @@
       "분류3": null,
       "단위": "㎡",
       "일위대가": "UA000006",
+      "자재조합": null,
       "도번": "SD02010400",
       "면적번": "SA02010400",
       "재료번": "SM02010400",
@@ -236,6 +244,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD02010500",
       "면적번": "SA02010500",
       "재료번": "SM02010500",
@@ -251,6 +260,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD02010600",
       "면적번": "SA02010600",
       "재료번": "SM02010600",
@@ -266,6 +276,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": "UA000036",
+      "자재조합": null,
       "도번": "SD03010100",
       "면적번": "SA03010100",
       "재료번": "SM03010100",
@@ -302,6 +313,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD03010200",
       "면적번": "SA03010200",
       "재료번": "SM03010200",
@@ -317,6 +329,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000008",
+      "자재조합": null,
       "도번": "SD04010100",
       "면적번": "SA04010100",
       "재료번": "SM04010100",
@@ -364,6 +377,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": "UA000014",
+      "자재조합": null,
       "도번": "SD05010100",
       "면적번": "SA05010100",
       "재료번": "SM05010100",
@@ -396,6 +410,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000025",
+      "자재조합": null,
       "도번": "SD05010200",
       "면적번": "SA05010200",
       "재료번": "SM05010200",
@@ -444,6 +459,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD06010000",
       "면적번": "SA06010000",
       "재료번": "SM06010000",
@@ -480,6 +496,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD07010100",
       "면적번": "SA07010100",
       "재료번": "SM07010100",
@@ -513,6 +530,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD07010200",
       "면적번": "SA07010200",
       "재료번": "SM07010200",
@@ -546,6 +564,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": "UA000026",
+      "자재조합": null,
       "도번": "SD08010100",
       "면적번": "SA08010100",
       "재료번": "SM08010100",
@@ -576,6 +595,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000003",
+      "자재조합": null,
       "도번": "SD08010200",
       "면적번": "SA08010200",
       "재료번": "SM08010200",
@@ -615,6 +635,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD09010100",
       "면적번": "SA09010100",
       "재료번": "SM09010100",
@@ -651,6 +672,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD10010100",
       "면적번": "SA10010100",
       "재료번": "SM10010100",
@@ -697,6 +719,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": "UA000032",
+      "자재조합": null,
       "도번": "SD11010100",
       "면적번": "SA11010100",
       "재료번": "SM11010100",
@@ -733,6 +756,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD12010100",
       "면적번": "SA12010100",
       "재료번": "SM12010100",
@@ -772,6 +796,7 @@
       "분류3": null,
       "단위": "㎡",
       "일위대가": "UA000031",
+      "자재조합": null,
       "도번": "SD12010200",
       "면적번": "SA12010200",
       "재료번": "SM12010200",
@@ -787,6 +812,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD13010000",
       "면적번": "SA13010000",
       "재료번": "SM13010000",
@@ -817,6 +843,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD14000000",
       "면적번": "SA14000000",
       "재료번": "SM14000000",
@@ -835,6 +862,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD15000000",
       "면적번": "SA15000000",
       "재료번": "SM15000000",
@@ -853,6 +881,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD15010000",
       "면적번": "SA15010000",
       "재료번": "SM15010000",
@@ -868,6 +897,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD16000000",
       "면적번": "SA16000000",
       "재료번": "SM16000000",
@@ -886,6 +916,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD17000000",
       "면적번": "SA17000000",
       "재료번": "SM17000000",
@@ -904,6 +935,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD18000000",
       "면적번": "SA18000000",
       "재료번": "SM18000000",
@@ -925,6 +957,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD19000000",
       "면적번": "SA19000000",
       "재료번": "SM19000000",
@@ -946,6 +979,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000017",
+      "자재조합": null,
       "도번": "SD20000000",
       "면적번": "SA20000000",
       "재료번": "SM20000000",
@@ -967,6 +1001,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000018",
+      "자재조합": null,
       "도번": "SD21000000",
       "면적번": "SA21000000",
       "재료번": "SM21000000",
@@ -985,6 +1020,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000010",
+      "자재조합": null,
       "도번": "SD22000000",
       "면적번": "SA22000000",
       "재료번": "SM22000000",
@@ -1003,6 +1039,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000016",
+      "자재조합": null,
       "도번": "SD23000000",
       "면적번": "SA23000000",
       "재료번": "SM23000000",
@@ -1021,6 +1058,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000002",
+      "자재조합": null,
       "도번": "SD24000000",
       "면적번": "SA24000000",
       "재료번": "SM24000000",
@@ -1039,6 +1077,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD25010000",
       "면적번": "SA25010000",
       "재료번": "SM25010000",
@@ -1069,6 +1108,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000005",
+      "자재조합": null,
       "도번": "SD26000000",
       "면적번": "SA26000000",
       "재료번": "SM26000000",
@@ -1084,6 +1124,7 @@
       "분류3": null,
       "단위": "㎡",
       "일위대가": "UA000009",
+      "자재조합": null,
       "도번": "SD27010000",
       "면적번": "SA27010000",
       "재료번": "SM27010000",
@@ -1099,6 +1140,7 @@
       "분류3": null,
       "단위": "㎡",
       "일위대가": "UA000009",
+      "자재조합": null,
       "도번": "SD27020000",
       "면적번": "SA27020000",
       "재료번": "SM27020000",
@@ -1114,6 +1156,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": "UA000011",
+      "자재조합": null,
       "도번": "SD28000000",
       "면적번": "SA28000000",
       "재료번": "SM28000000",
@@ -1129,6 +1172,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": "UA000023",
+      "자재조합": null,
       "도번": "SD29000000",
       "면적번": "SA29000000",
       "재료번": "SM29000000",
@@ -1144,6 +1188,7 @@
       "분류3": null,
       "단위": "m",
       "일위대가": "UA000012",
+      "자재조합": null,
       "도번": "SD30000000",
       "면적번": "SA30000000",
       "재료번": "SM30000000",
@@ -1159,6 +1204,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000013",
+      "자재조합": null,
       "도번": "SD31000000",
       "면적번": "SA31000000",
       "재료번": "SM31000000",
@@ -1174,6 +1220,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000033",
+      "자재조합": null,
       "도번": "SD32000000",
       "면적번": "SA32000000",
       "재료번": "SM32000000",
@@ -1189,6 +1236,7 @@
       "분류3": null,
       "단위": "개소",
       "일위대가": "UA000034",
+      "자재조합": null,
       "도번": "SD33000000",
       "면적번": "SA33000000",
       "재료번": "SM33000000",
@@ -1204,6 +1252,7 @@
       "분류3": null,
       "단위": "경간",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD34000000",
       "면적번": "SA34000000",
       "재료번": "SM34000000",
@@ -1219,6 +1268,7 @@
       "분류3": null,
       "단위": "㎥",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD35000000",
       "면적번": "SA35000000",
       "재료번": "SM35000000",
@@ -1234,6 +1284,7 @@
       "분류3": null,
       "단위": "ton",
       "일위대가": null,
+      "자재조합": null,
       "도번": "SD36000000",
       "면적번": "SA36000000",
       "재료번": "SM36000000",

resources/tester/test_m01_matset.py

@@ -0,0 +1,107 @@
+"""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

resources/tester/test_m02_combo_branch.py

@@ -0,0 +1,211 @@
+"""조합 갈라 내기 · 분류 더하기 복사 (PLAN 15장).
+
+M02 견본 표(`write_sample_table`) + M01 마스터 사본(조합 줄은 비워 시작)으로만 봄.
+  · 일위대가(UA) — 새로 만듦(본뜬키 = 원래 키) · 이 열만 새 키 · 다른 열은 옛 키 · 원래 조합 그대로 ·
+    SS 장부 맞춤 · 담은 로직 집합(차례 · 메모 무시)이 같으면 있는 키 · 또 고치면 또 새로 · 같은 이름 (2)
+  · 자재 조합(UM) — 같은 규칙 · 처음 만드는 열(본뜬키 없음) · 읽기
+  · 집계표 판 어긋남 = 409 · 조합 안 만듦
+  · 분류 더하기로 복사한 열(`본뜬열`) — [저장] 때 원본 키 · 세 파일 내용을 새 번호로 받음
+"""
+
+import json
+import shutil
+
+import pytest
+from fastapi import FastAPI
+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
+
+REAL = m01.FOLDER
+A, B, C = "GF000219", "GF000220", "GF000211"  # 돌쌓기 메쌓기(인력 · 장비) · 채집(인력)
+M1, M2 = (
+    {"코드": "MT000001", "이름": "시멘트", "규격": "40kg", "단위": "포"},
+    {"코드": "MT000002", "이름": "모래", "규격": None, "단위": "㎥"},
+)
+TABLE = "/api/m02/templates/table/구조물집계표"
+
+
+@pytest.fixture()
+def client(tmp_path, monkeypatch):
+    master = tmp_path / "master"
+    master.mkdir()
+    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")
+    monkeypatch.setattr(m01, "FOLDER", master)
+    template = tmp_path / "template"
+    template.mkdir()
+    write_sample_table(template)
+    monkeypatch.setattr(store, "FOLDER", template)
+    app = FastAPI()
+    app.include_router(router)
+    return TestClient(app)
+
+
+def _source(client) -> str:
+    """원래 조합(A · B) — rv · c1 두 열이 같이 가리킴."""
+    got = combo_store.combo_new(
+        {
+            "이름": "기슭막이",
+            "구분": "실무 일위대가",
+            "상세구분": "13장 구조물",
+            "단위": "m",
+            "담은로직": [{"로직": A, "메모": None}, {"로직": B, "메모": None}],
+            "출처": "자체",
+        },
+        "현장",
+    )
+    table = client.get(TABLE).json()
+    for col in table["문서"]["열"]:
+        if col["id"] in ("rv", "c1"):
+            col["일위대가"] = got["key"]
+    assert client.put(TABLE, json={"판": table["판"], "문서": table["문서"]}).status_code == 200
+    return got["key"]
+
+
+def _branch(client, column, source, keys, name="", 판="", want=200):
+    body = {"본뜬키": source, "담은로직": [{"로직": k} for k in keys], "이름": name, "판": 판}
+    res = client.post(f"/api/m02/structures/{column}/combo", json=body)
+    assert res.status_code == want, res.text
+    return res.json()
+
+
+def _cols(client, field="일위대가") -> dict[str, str | None]:
+    return {c["id"]: c.get(field) for c in client.get(TABLE).json()["문서"]["열"]}
+
+
+def _ss(client, field="일위대가") -> dict[str, str | None]:
+    rows = client.get("/api/m02/structure-combos").json()["줄"]
+    return {r["열"]: r[field] for r in rows}
+
+
+def test_새로_만듦_이_열만_새_키_원래_조합_그대로(client):
+    ua = _source(client)
+    판 = client.get(TABLE).json()["판"]
+    got = _branch(client, "rv", ua, [A, B, C], "기슭막이 · 돌기슭막이", 판)
+    assert got["새로만듦"] is True and got["키"] != ua
+    assert got["이름"] == "기슭막이 · 돌기슭막이"
+    assert got["집계표판"] == client.get(TABLE).json()["판"] != 판
+    cols = _cols(client)
+    assert (cols["rv"], cols["c1"]) == (got["키"], ua)  # 다른 열은 옛 키
+    assert _ss(client)["rv"] == got["키"] and _ss(client)["c1"] == ua  # SS 장부 맞춤
+    new = combo_store.combo(got["키"])["combo"]
+    assert tuple(new) == combo_store.mcb.COLS  # 열 한 벌 · 본뜬키 칸 포함
+    assert [x["로직"] for x in new["담은로직"]] == [A, B, C]
+    assert (new["본뜬키"], new["구분"], new["상세구분"], new["단위"], new["출처"], new["소유"]) == (
+        ua,
+        "실무 일위대가",
+        "13장 구조물",
+        "m",
+        "자체",
+        "현장",
+    )
+    assert [x["로직"] for x in combo_store.combo(ua)["combo"]["담은로직"]] == [A, B]
+    # M01 에서 고쳐도(화면이 본뜬키를 안 보내도) 계보는 남음
+    one = combo_store.combo(got["키"])
+    edited = {k: v for k, v in one["combo"].items() if k != "본뜬키"} | {"이름": "고친 이름"}
+    combo_store.combo_edit(got["키"], one["version"], edited)
+    assert combo_store.combo(got["키"])["combo"]["본뜬키"] == ua
+
+
+def test_같은_로직_집합이면_있는_키_또_고치면_또_새로_같은_이름은_2(client):
+    ua = _source(client)
+    same = _branch(client, "c1", ua, [B, A])  # 차례만 바꿈 = 원래 조합
+    assert (same["키"], same["새로만듦"]) == (ua, False)
+    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)
+    assert _cols(client)["c1"] == first["키"] and _ss(client)["c1"] == first["키"]
+
+
+def test_집계표_판_어긋나면_409_조합_안_만듦(client):
+    ua = _source(client)
+    before = len(m01.read(combo_store.FILE)[0]["줄"])
+    _branch(client, "rv", ua, [A, B, C], "x", "0000000000000000", want=409)
+    assert len(m01.read(combo_store.FILE)[0]["줄"]) == before
+    assert _cols(client)["rv"] == ua
+    _branch(client, "no", ua, [A, C], want=404)  # 글 열(구조물 아님)
+    _branch(client, "rv", "UA999999", [A, C], want=404)  # 없는 원래 조합
+
+
+def _material(client, column, source, items, name="", want=200):
+    body = {"본뜬키": source, "담은자재": items, "이름": name}
+    res = client.post(f"/api/m02/structures/{column}/material-combo", json=body)
+    assert res.status_code == want, res.text
+    return res.json()
+
+
+def test_자재_조합_처음_만듦_같은_내용이면_있는_키_고치면_새로(client):
+    first = _material(client, "rv", "", [M1, M2])
+    assert first["새로만듦"] is True and first["키"].startswith("UM")
+    assert first["이름"] == "돌기슭막이 (형태마다) H=(높이마다)"  # 이름 없으면 열 머리
+    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])  # 차례만 다름 = 있는 키
+    assert (same["키"], same["새로만듦"]) == (first["키"], False)
+    fork = _material(client, "c1", first["키"], [M1], "시멘트만")
+    assert fork["새로만듦"] is True and fork["키"] != first["키"]
+    assert client.get(f"/api/m02/material-combos/{fork['키']}").json()["본뜬키"] == first["키"]
+    assert (_cols(client, "자재조합")["rv"], _cols(client, "자재조합")["c1"]) == (
+        first["키"],
+        fork["키"],
+    )
+    assert _ss(client, "자재조합")["c1"] == fork["키"]
+    assert client.get("/api/m02/material-combos/UM999999").status_code == 404
+    _material(client, "rv", "", [{"코드": "없는모양"}], want=422)  # M01 저장 검사
+
+
+def test_분류_더하기로_복사한_열은_원본_키_세_파일_내용을_받음(client):
+    ua = _source(client)
+    table = client.get(TABLE).json()
+    doc = table["문서"]
+    rv = next(c for c in doc["열"] if c["id"] == "rv")
+    rv["자재조합"] = "UM000001"
+    assert client.put(TABLE, json={"판": table["판"], "문서": doc}).status_code == 200
+    drawing = client.get("/api/m02/templates/structure/rv").json()
+    marked = {**drawing["문서"], "도면": {"format": 6, "entities": [{"type": "line"}]}}
+    put = client.put("/api/m02/templates/structure/rv", json={"판": drawing["판"], "문서": marked})
+    assert put.status_code == 200
+    table = client.get(TABLE).json()
+    doc = table["문서"]
+    at = next(i for i, c in enumerate(doc["열"]) if c["id"] == "rv")
+    head = ["돌기슭막이", "(형태마다)", "H=(높이마다) 2", None]
+    doc["열"].insert(at + 1, {"id": "c9", "머리": head, "단위": None, "꼴": "수", "본뜬열": "rv"})
+    assert client.put(TABLE, json={"판": table["판"], "문서": doc}).status_code == 200
+    saved = next(c for c in client.get(TABLE).json()["문서"]["열"] if c["id"] == "c9")
+    assert "본뜬열" not in saved  # 뗌
+    assert (saved["일위대가"], saved["자재조합"]) == (ua, "UM000001")
+    copy = client.get("/api/m02/templates/structure/c9").json()["문서"]
+    assert copy["도면"]["entities"] == [{"type": "line"}] and copy["열"] == "c9"
+    numbers = client.get("/api/m02/structures/numbers").json()
+    assert numbers["c9"]["도번"] != numbers["rv"]["도번"]  # 새 번호
+    assert numbers["c9"]["면적번"][2:] == numbers["c9"]["도번"][2:]
+    for kind in ("area", "material"):
+        assert client.get(f"/api/m02/templates/{kind}/c9").json()["문서"]["열"] == "c9"
+    # 그 뒤로는 열마다 따로 — 원본을 고쳐도 복사본은 그대로
+    drawing = client.get("/api/m02/templates/structure/rv").json()
+    client.put(
+        "/api/m02/templates/structure/rv",
+        json={
+            "판": drawing["판"],
+            "문서": {**drawing["문서"], "도면": marked["도면"] | {"entities": []}},
+        },
+    )
+    again = client.get("/api/m02/templates/structure/c9").json()["문서"]
+    assert again["도면"]["entities"] == [{"type": "line"}]

ui_template/sheet/ui_template_sheet_ops.ts

@@ -141,7 +141,16 @@ export function addLevel(
     "c",
     doc.열.map((c) => c.id),
   );
-  doc.열.splice(at + 1, 0, { id, 머리: head, 단위: base.단위 ?? null, 꼴: "수" });
+  // 원본(`after`) 열을 따라감 — 일위대가 · 자재조합 같은 키 · 구조물 파일은 저장 때 서버가 복사
+  doc.열.splice(at + 1, 0, {
+    id,
+    머리: head,
+    단위: base.단위 ?? null,
+    꼴: "수",
+    ...(base.꼴 !== "글"
+      ? { 본뜬열: base.id, 일위대가: base.일위대가 ?? null, 자재조합: base.자재조합 ?? null }
+      : {}),
+  });
   return id;
 }
 

ui_template/sheet/ui_template_sheet_types.ts

@@ -35,6 +35,10 @@ export interface SheetColumn {
   바인딩?: SheetBinding | null;
   /** 일위대가 조합 키. */
   일위대가?: string | null;
+  /** 자재 조합 키(`UM`). */
+  자재조합?: string | null;
+  /** 분류 더하기로 복사한 원본 열 id — 저장 때 서버가 원본 열 내용을 새 열로 복사하고 뗌. */
+  본뜬열?: string | null;
   /** 마스터 한 칸 → 프로젝트에서 설계 값마다 열. */
   펼침?: boolean;
   /** 사용자 입력 열. */