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

충돌 풂 — 양쪽 다 살림: M02 좌측(층 인식 도면 양식 + 구조물 옵션 보이기는 시스템 층만) · 스타일 · 사전(층 화면 + 항목 고르기) · B05 목록·패널 타입(공용 측점 표기 + 집계 항목 import)

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

M02_MasterTemplete/M02_MasterTemplete_Api_Fetch.ts

@@ -259,6 +259,29 @@ export const editMaterialCombo = (
 export const deleteMaterialCombo = (키: string, 판: string): Promise<unknown> =>
   scoped(`/material-combos/${enc(키)}?판=${enc(판)}`, { method: "DELETE" });
 
+/* --- 구조물 옵션 보이기(마스터 템플릿 `구조물옵션표시.json`) — 좌측 「구조물 옵션 보이기」 줄 --- */
+export interface OptionKind {
+  type_id: string;
+  group: string;
+  name: string;
+  /** 거짓이면 B05 선택지에 안 나오는 종류 */
+  enabled: boolean;
+  options: { key: string; label: string; phase: "b05" | "detail"; required: boolean }[];
+}
+
+/** 판 · 표시(숨긴 것만 `{종류: {옵션: false}}`) · 종류(옵션이 있는 것과 그 옵션) */
+export interface OptionsDoc {
+  판: string;
+  표시: Record<string, Record<string, false>>;
+  종류: OptionKind[];
+}
+
+export const fetchStructureOptions = (): Promise<OptionsDoc> => call("/structure-options");
+
+/** 고쳐 씀 — 숨긴 것만 보냄 · 낡은 판이면 StaleError · 돌려받는 것은 새 문서 */
+export const saveStructureOptions = (판: string, 표시: OptionsDoc["표시"]): Promise<OptionsDoc> =>
+  call("/structure-options", { method: "PUT", body: JSON.stringify({ 판, 표시 }) });
+
 /** 다른 열(`from`) 구조물 도면 내용을 받는 열(`column`)로 가져옴 — 도번 · 열은 받는 쪽 그대로 */
 export const copyStructure = async (column: string, from: string): Promise<void> => {
   await scoped(`/structures/${enc(column)}/copy?from=${enc(from)}`, { method: "POST" });

M02_MasterTemplete/M02_MasterTemplete_Items.py

@@ -0,0 +1,130 @@
+"""M02 층 집계표 항목 — 회사 · 개인 층 빈 뼈대 · 항목 목록 · 항목 복사(PLAN 21-1 · 21-2).
+
+항목 = 구조물집계표조합(SS) 한 줄 — 그 열의 일위대가(UA) · 자재조합(UM) ·
+도번 SD · 면적번 SA · 재료번 SM.
+층 폴더(시스템 · 회사 · 개인)는 모양이 같아 저장소 함수를 `store.at(층 폴더)` 안에서 그대로 부름.
+권한은 부르는 쪽(`M02_MasterTemplete_Router_Items.py`) 몫 — 여기는 폴더와 파일만.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from common_util.common_util_json import atomic_write_json
+from M02_MasterTemplete import M02_MasterTemplete_Matset as matset
+from M02_MasterTemplete import M02_MasterTemplete_Store as store
+
+# 21-1 목록 칸 — SS 줄에서 그대로(키는 `key`)
+ITEM_FIELDS = (
+    "열",
+    "종류",
+    "분류1",
+    "분류2",
+    "분류3",
+    "단위",
+    "일위대가",
+    "자재조합",
+    "도번",
+    "면적번",
+    "재료번",
+)
+
+
+def ensure(folder: Path) -> bool:
+    """회사 · 개인 층 첫 진입 — 빈 집계표(열 0 · 층 이름 · 줄 머리는 시스템 것) ·
+    조합 장부(`다음` 1) · 자재 조합 빈 표 · 종류 폴더.
+    이미 집계표가 있으면 아무것도 안 함(시스템 층은 늘 있음)."""
+    table = Path(folder) / "table" / f"{store.STRUCTURE_TABLE}.json"
+    if table.is_file():
+        return False
+    system = json.loads((store.FOLDER / "table" / f"{store.STRUCTURE_TABLE}.json").read_bytes())
+    doc = {
+        **system,
+        "열": [],
+        "줄": [{**r, "값": {}} for r in system.get("줄", []) if isinstance(r, dict)],
+        "합계줄": [],
+        "보기": {},
+    }
+    with store.at(folder):
+        for kind in store.KINDS:
+            (Path(folder) / kind).mkdir(parents=True, exist_ok=True)
+        with store._LOCK:
+            if table.is_file():  # 그 사이 다른 요청이 만듦
+                return False
+            atomic_write_json(table, doc)
+        store.sync_combos()
+        mat = Path(folder) / matset.FILE
+        if not mat.is_file():
+            atomic_write_json(mat, matset._load()[0])
+    return True
+
+
+def items(folder: Path) -> list[dict[str, Any]]:
+    """그 층 항목 — SS 줄마다 `{key, 열, 종류, 분류1~3, 단위, 일위대가, 자재조합,
+    도번, 면적번, 재료번}`."""
+    with store.at(folder):
+        rows = store.read_combos().get("줄", [])
+    return [{"key": r.get("키"), **{k: r.get(k) for k in ITEM_FIELDS}} for r in rows]
+
+
+def _fresh_id(want: str, used: set[str]) -> str:
+    out, n = want, 2
+    while out in used:
+        out, n = f"{want}_{n}", n + 1
+    return out
+
+
+def copy_item(source: Path, target: Path, key: str, origin: dict[str, Any]) -> dict[str, Any]:
+    """다른 층 항목(SS `key`) → `target` 층 새 열 하나 — 머리 · 단위 · 일위대가 · 바인딩 그대로 ·
+    도면 · 면적산출 · 재료산출 내용(알약 연결 포함) · 자재 조합 줄(새 UM) 복사 ·
+    새 번호 · 새 SS 키 ·
+    열 `본뜬` = `origin`(원래 층 · 주인 · 키). 돌려줌 `{key, 열, 이름}`."""
+    with store.at(source):
+        row = next((r for r in store.read_combos().get("줄", []) if r.get("키") == key), None)
+        if row is None:
+            raise store.StoreError(404, f"없는 항목 「{key}」")
+        col_id = row["열"]
+        col = next(c for c in store._structure_columns() if c["id"] == col_id)
+        docs = {}
+        for kind, _, _, _ in store.PARTS:
+            try:
+                docs[kind] = store.read(kind, col_id)["문서"]
+            except store.StoreError:
+                pass  # 없는 파일은 새 층에서 빈 문서로 섬
+        um = None
+        if col.get("자재조합"):
+            try:
+                um = matset.one(col["자재조합"])
+            except store.StoreError:
+                um = None  # 가리키던 줄이 없으면 비움
+    ensure(target)
+    with store.at(target):
+        new_um = None
+        if um:
+            names = matset.listing()["줄"]
+            taken = {str(r.get("이름") or "") for r in names}
+            name, n = str(um.get("이름") or key), 2
+            base = name
+            while name in taken:
+                name, n = f"{base} ({n})", n + 1
+            got = {k: um.get(k) for k in ("담은자재", "소유", "비고")}
+            new_um = matset.create({**got, "이름": name, "본뜬키": None})["키"]
+        table = store.read("table", store.STRUCTURE_TABLE)
+        doc = table["문서"]
+        new_id = _fresh_id(col_id, {c.get("id") for c in doc.get("열", []) if isinstance(c, dict)})
+        made = {**json.loads(json.dumps(col)), "id": new_id, "자재조합": new_um, "본뜬": origin}
+        doc["열"] = [*doc.get("열", []), made]
+        store.write("table", store.STRUCTURE_TABLE, table["판"], doc)  # 빈 세 파일 · 번호 · SS
+        for kind, got in docs.items():
+            number = store._KEY[kind]
+            have = store.read(kind, new_id)["문서"]
+            body = {k: v for k, v in got.items() if k != "계산값"}
+            body = {**body, "열": new_id, number: have.get(number)}
+            if kind in store.SHEETS:
+                body = store._server_values(body)
+            with store._LOCK:
+                atomic_write_json(store._path(kind, new_id), body)
+        ss = next(r for r in store.read_combos()["줄"] if r.get("열") == new_id)
+    return {"key": ss["키"], "열": new_id, "이름": " ".join(h for h in store._heads(made) if h)}

M02_MasterTemplete/M02_MasterTemplete_Matset.py

@@ -22,7 +22,7 @@ _HEAD = "UM"
 
 def _load() -> tuple[dict[str, Any], str]:
     """(표, 판) — 파일이 없으면 빈 표 · 판 빈 글."""
-    path = store.FOLDER / FILE
+    path = store.root() / FILE
     if not path.is_file():
         return {"그룹": mmc.GROUP, "판": "2026", "비고": [], "다음": 1, "줄": []}, ""
     raw = path.read_bytes()
@@ -95,7 +95,7 @@ def _save(doc: dict, version: str) -> str:
     """틀 검사 → 판이 같을 때만 씀 → 새 판."""
     if errors := mmc.check_form(FILE, doc):
         raise store.StoreError(422, {"errors": errors})
-    path = store.FOLDER / FILE
+    path = store.root() / FILE
     with store._LOCK:
         have = store.version_of(path.read_bytes()) if path.is_file() else ""
         if have != (version or ""):

M02_MasterTemplete/M02_MasterTemplete_Options.py

@@ -0,0 +1,149 @@
+"""M02 구조물 옵션 보이기 — 구조물 종류마다 B05/B06 폼에 보일 옵션을 사용자가 체크.
+
+정본 = `resources/master_template/구조물옵션표시.json` = `{type_id: {option_key: false}}`
+— 없는 종류 · 키는 보임(파일이 없어도 모두 보임).
+저장은 **숨김(false)만** 남김 — 「모두 보임」 = `{}`.
+옵션 정의 · 옛 값은 그대로 — 폼이 그리는 것만 갈림(`GET /api/projects/structure-types` `visible`).
+판 = 파일 sha256 앞 16자(`store.version_of`) · 낡은 판으로 쓰면 409.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from typing import Any
+
+from pydantic import Field
+
+from B05_Profile.B05_Profile_Structures_Schema import (
+    StructureOptionField,
+    StructureType,
+    StructureTypesResponse,
+    load_structure_types,
+    registry_schema_version,
+)
+from common_util.common_util_json import atomic_write_json
+from M02_MasterTemplete import M02_MasterTemplete_Store as store
+
+FILE = "구조물옵션표시.json"
+logger = logging.getLogger(__name__)
+
+
+class OptionWithVisible(StructureOptionField):
+    """폼 옵션 한 칸 + 보임 여부(서버가 채움)."""
+
+    visible: bool = True
+
+
+class TypeWithVisible(StructureType):
+    options: list[OptionWithVisible] = Field(default_factory=list)
+
+
+class TypesWithVisible(StructureTypesResponse):
+    """`GET /structure-types` 응답 — 옵션마다 `visible` 칸."""
+
+    types: list[TypeWithVisible]
+
+
+def _load() -> tuple[dict[str, Any], str]:
+    """(숨김 표 · 판) — 파일이 없으면 빈 표 · 판 빈 글."""
+    path = store.FOLDER / FILE
+    if not path.is_file():
+        return {}, ""
+    raw = path.read_bytes()
+    try:
+        doc = json.loads(raw)
+    except ValueError as e:
+        raise store.StoreError(500, f"{FILE} 을 못 읽음 — {e}") from e
+    if not isinstance(doc, dict):
+        raise store.StoreError(500, f"{FILE} 은 종류별 묶음이어야 함")
+    return doc, store.version_of(raw)
+
+
+def _shown(doc: dict[str, Any], type_id: str, key: str) -> bool:
+    row = doc.get(type_id)
+    return not (isinstance(row, dict) and row.get(key) is False)
+
+
+def with_visible() -> TypesWithVisible:
+    """레지스트리 정본 + 보임 여부 — 파일이 깨졌으면 모두 보임(폼이 죽지 않게 · 로그만)."""
+    try:
+        doc = _load()[0]
+    except store.StoreError as e:
+        logger.warning("구조물 옵션 표시 표를 못 읽어 모두 보임으로 냄 — %s", e.detail)
+        doc = {}
+    types = [
+        {
+            **t.model_dump(),
+            "options": [
+                {**o.model_dump(), "visible": _shown(doc, t.type_id, o.key)} for o in t.options
+            ],
+        }
+        for t in load_structure_types()
+    ]
+    return TypesWithVisible.model_validate(
+        {"schema_version": registry_schema_version(), "types": types}
+    )
+
+
+def listing() -> dict[str, Any]:
+    """`{판, 표시, 종류}` — 표시 = 숨긴 것만 · 종류 = 옵션이 있는 종류와 그 옵션."""
+    doc, version = _load()
+    hidden: dict[str, dict[str, bool]] = {}
+    kinds = []
+    for t in load_structure_types():
+        if not t.options:
+            continue
+        off = {o.key: False for o in t.options if not _shown(doc, t.type_id, o.key)}
+        if off:
+            hidden[t.type_id] = off
+        kinds.append(
+            {
+                "type_id": t.type_id,
+                "group": t.group,
+                "name": t.name,
+                "enabled": t.enabled,
+                "options": [
+                    {"key": o.key, "label": o.label, "phase": o.phase, "required": o.required}
+                    for o in t.options
+                ],
+            }
+        )
+    return {"판": version, "표시": hidden, "종류": kinds}
+
+
+def _clean(shown: Any) -> dict[str, dict[str, bool]]:
+    """받은 표 검사 → 숨김만 남김. 없는 종류 · 키 · 참거짓 아닌 값은 422."""
+    if not isinstance(shown, dict):
+        raise store.StoreError(400, "표시는 종류별 묶음이어야 함")
+    keys = {t.type_id: {o.key for o in t.options} for t in load_structure_types()}
+    errors: list[str] = []
+    out: dict[str, dict[str, bool]] = {}
+    for type_id, row in shown.items():
+        if type_id not in keys:
+            errors.append(f"없는 구조물 종류 「{type_id}」")
+        elif not isinstance(row, dict):
+            errors.append(f"「{type_id}」 는 옵션별 묶음이어야 함")
+        else:
+            for key, value in row.items():
+                if key not in keys[type_id]:
+                    errors.append(f"「{type_id}」 에 없는 옵션 「{key}」")
+                elif not isinstance(value, bool):
+                    errors.append(f"「{type_id}.{key}」 는 참 · 거짓이어야 함")
+                elif not value:
+                    out.setdefault(type_id, {})[key] = False
+    if errors:
+        raise store.StoreError(422, {"errors": errors})
+    return out
+
+
+def save(shown: Any, version: str) -> dict[str, Any]:
+    """고쳐 씀 — 판이 같을 때만. 돌려주는 것 = 새 `listing()`."""
+    fixed = _clean(shown)
+    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, fixed)
+    return listing()

M02_MasterTemplete/M02_MasterTemplete_Options.ts

@@ -0,0 +1,220 @@
+/* =============================================================================
+ * M02_MasterTemplete_Options.ts
+ * 좌측 「구조물 옵션 보이기」 줄(구조물 집계 양식 아래 별도) — 누르면 메인 칸에
+ * 종류 목록(군별) → 고른 종류의 옵션 체크 목록(라벨 · 키 작은 글 · B06 전용 · 필수 표시) ·
+ * [저장] · [모두 보임]. 체크 안 한 옵션은 B05 · B06 구조물 폼에서 숨음(정의 · 값은 그대로).
+ * 서버 = `M02_MasterTemplete_Options.py`(마스터 템플릿 `구조물옵션표시.json` · 숨긴 것만 저장).
+ * ========================================================================== */
+
+import { createButton, createTag, el, showToast } from "@ui/ui_template_elements";
+import {
+  fetchStructureOptions,
+  saveStructureOptions,
+  StaleError,
+  type OptionKind,
+  type OptionsDoc,
+} from "./M02_MasterTemplete_Api_Fetch";
+import { to } from "./M02_MasterTemplete_Options_Text";
+
+export interface OptionsSectionOptions {
+  isAdmin: boolean;
+  /** 저장 안 한 고침을 버릴지 확인 — 취소면 false */
+  confirmLeave: () => Promise<boolean>;
+  /** 메인 칸에 화면을 띄움 — 고침 표시 손잡이를 돌려받음 */
+  show: (label: string, node: HTMLElement) => (dirty: boolean) => void;
+  /** 화면을 열었음 — 좌측 다른 고름 표시를 지움 */
+  onOpen: () => void;
+}
+
+export interface OptionsSection {
+  title: string;
+  body: HTMLElement;
+  /** 다른 화면을 열었음 — 고름 표시만 지움 */
+  clear: () => void;
+}
+
+const why = (error: unknown): string => (error instanceof Error ? error.message : "");
+
+export function buildOptionsSection(opt: OptionsSectionOptions): OptionsSection {
+  const row = el("button", {
+    className: "m02-side__item ui-sidebar-row",
+    text: to("Row"),
+    attrs: { type: "button", "data-options-row": "" },
+  });
+  const body = el("div", { className: "m02-side__items ui-sidebar-list", children: [row] });
+  row.addEventListener("click", () => void open());
+
+  /** 이 화면이 열려 있는 동안 참 — 다른 것이 열리면 `clear` 가 내림 */
+  let opened = false;
+  const mark = (on: boolean): void => {
+    opened = on;
+    row.classList.toggle("is-active", on);
+  };
+
+  async function open(): Promise<void> {
+    if (opened || !(await opt.confirmLeave())) return;
+    let doc: OptionsDoc;
+    try {
+      doc = await fetchStructureOptions();
+    } catch (error) {
+      return showToast(to("Load_Failed", why(error)), "error");
+    }
+    draw(doc);
+  }
+
+  /** 메인 칸 화면 — `doc.표시` 를 고칠 사본(저장 전까지 서버에 안 감)으로 쥠 */
+  function draw(doc: OptionsDoc): void {
+    let version = doc.판;
+    const edit = opt.isAdmin;
+    /** 숨긴 옵션 — 종류 → 키 집합 */
+    const hidden = new Map<string, Set<string>>();
+    const load = (src: OptionsDoc["표시"]): void => {
+      hidden.clear();
+      for (const [id, keys] of Object.entries(src)) hidden.set(id, new Set(Object.keys(keys)));
+    };
+    load(doc.표시);
+    let kinds = doc.종류;
+    let current: OptionKind | null = null;
+
+    const kindList = el("div", { className: "m02-opts__kinds" });
+    const optionList = el("div", { className: "m02-opts__list" });
+    const off = (id: string): number => hidden.get(id)?.size ?? 0;
+
+    const paintKinds = (): void => {
+      const parts: HTMLElement[] = [];
+      let group = "";
+      for (const k of kinds) {
+        if (k.group !== group) {
+          group = k.group;
+          parts.push(
+            el("h4", {
+              className: "m02-opts__group",
+              text: group.length === 1 ? to("Group", group) : group,
+            }),
+          );
+        }
+        const n = off(k.type_id);
+        const b = el("button", {
+          className: `m02-opts__kind${k.type_id === current?.type_id ? " is-active" : ""}`,
+          attrs: { type: "button", "data-options-kind": k.type_id },
+          children: [
+            el("span", { text: k.name }),
+            ...(n ? [createTag(to("Hidden", String(n)), "warning")] : []),
+            ...(k.enabled ? [] : [createTag(to("Off"), "neutral")]),
+          ],
+        });
+        b.addEventListener("click", () => {
+          current = k;
+          paintKinds();
+          paintOptions();
+        });
+        parts.push(b);
+      }
+      kindList.replaceChildren(...parts);
+    };
+
+    const paintOptions = (): void => {
+      if (!current) {
+        optionList.replaceChildren(el("p", { className: "m02-side__empty", text: to("Pick") }));
+        return;
+      }
+      const kind = current;
+      optionList.replaceChildren(
+        el("h3", { className: "m02-matset__head", text: kind.name }),
+        ...kind.options.map((o) => {
+          const box = el("input", {
+            attrs: { type: "checkbox", "data-options-key": o.key },
+          }) as HTMLInputElement;
+          box.checked = !hidden.get(kind.type_id)?.has(o.key);
+          box.disabled = !edit;
+          box.addEventListener("change", () => {
+            const set = hidden.get(kind.type_id) ?? new Set<string>();
+            if (box.checked) set.delete(o.key);
+            else set.add(o.key);
+            hidden.set(kind.type_id, set);
+            setDirty(true);
+            paintKinds();
+          });
+          const tags: HTMLElement[] = [];
+          if (o.phase === "detail") tags.push(createTag(to("Detail"), "accent"));
+          if (o.required && o.phase === "b05") {
+            const tag = createTag(to("Required"), "danger");
+            tag.title = to("RequiredTip");
+            tags.push(tag);
+          }
+          return el("label", {
+            className: "m02-opts__option",
+            children: [
+              box,
+              el("span", { text: o.label }),
+              el("small", { className: "m02-opts__key", text: o.key }),
+              ...tags,
+            ],
+          });
+        }),
+      );
+    };
+
+    const save = createButton({ label: to("Save"), variant: "filled" });
+    const all = createButton({ label: to("ShowAll"), variant: "ghost" });
+    all.addEventListener("click", () => {
+      if (![...hidden.values()].some((s) => s.size)) return;
+      hidden.clear();
+      setDirty(true);
+      paintKinds();
+      paintOptions();
+    });
+    save.addEventListener("click", async () => {
+      const 표시: OptionsDoc["표시"] = {};
+      for (const [id, keys] of hidden)
+        if (keys.size) 표시[id] = Object.fromEntries([...keys].map((k) => [k, false as const]));
+      save.disabled = true; // 연달아 눌러도 한 번만
+      try {
+        const done = await saveStructureOptions(version, 표시);
+        version = done.판;
+        load(done.표시);
+        setDirty(false);
+        showToast(to("Saved"), "success");
+        paintKinds();
+        paintOptions();
+      } catch (error) {
+        if (error instanceof StaleError) {
+          showToast(to("Stale"), "error");
+          try {
+            const fresh = await fetchStructureOptions();
+            version = fresh.판;
+            kinds = fresh.종류;
+            load(fresh.표시);
+            setDirty(false);
+            current = kinds.find((k) => k.type_id === current?.type_id) ?? null;
+            paintKinds();
+            paintOptions();
+          } catch (again) {
+            showToast(to("Load_Failed", why(again)), "error");
+          }
+        } else showToast(to("Failed", why(error)), "error");
+      } finally {
+        save.disabled = false;
+      }
+    });
+
+    const node = el("div", {
+      className: "m02-opts",
+      children: [
+        el("p", { className: "m02-side__empty", text: to("Note") }),
+        el("div", {
+          className: "m02-opts__panes",
+          children: [kindList, optionList],
+        }),
+        ...(edit ? [el("div", { className: "m02-side__row", children: [save, all] })] : []),
+      ],
+    });
+    const setDirty = opt.show(to("Screen"), node);
+    paintKinds();
+    paintOptions();
+    opt.onOpen();
+    mark(true);
+  }
+
+  return { title: to("Title"), body, clear: () => mark(false) };
+}

M02_MasterTemplete/M02_MasterTemplete_Options_Text.ts

@@ -0,0 +1,43 @@
+/* =============================================================================
+ * M02_MasterTemplete_Options_Text.ts
+ * 좌측 「구조물 옵션 보이기」 줄 · 상세 화면 글자 — [한국어, 영어]
+ * ========================================================================== */
+
+import { currentLanguageIndex } from "@ui/ui_template_locale";
+
+const TEXT = {
+  Title: ["구조물 옵션 보이기", "Structure options shown"],
+  Row: ["종류마다 보일 옵션 고르기", "Choose options per type"],
+  Screen: ["구조물 옵션 보이기", "Structure options shown"],
+  Note: [
+    "체크한 옵션만 B05 · B06 구조물 폼에 보임 — 옵션 정의 · 이미 넣은 값은 그대로 · 처음은 모두 보임",
+    "Only checked options appear in the B05 · B06 forms — definitions and stored values stay",
+  ],
+  Group: ["{value}군", "Group {value}"],
+  Hidden: ["숨김 {value}", "{value} hidden"],
+  Off: ["안 쓰는 종류", "Not offered"],
+  NoOption: ["옵션 없음", "No options"],
+  Pick: ["왼쪽에서 구조물 종류를 고름", "Pick a structure type on the left"],
+  Detail: ["B06 전용", "B06 only"],
+  Required: ["필수", "Required"],
+  RequiredTip: [
+    "필수 옵션 — 숨기면 B05 폼에서 값을 못 넣어 저장이 막힐 수 있음",
+    "Required — hiding it leaves the B05 form unable to set it",
+  ],
+  Save: ["저장", "Save"],
+  ShowAll: ["모두 보임", "Show all"],
+  Saved: ["저장함", "Saved"],
+  Stale: [
+    "그 사이 옵션 표시가 바뀜 — 새로 받았으니 다시 고쳐 주세요",
+    "Changed meanwhile — reloaded, please edit again",
+  ],
+  Load_Failed: ["옵션 표시를 못 받음 — {value}", "Could not load option display — {value}"],
+  Failed: ["옵션 표시를 못 저장함 — {value}", "Could not save option display — {value}"],
+} as const satisfies Record<string, readonly [string, string]>;
+
+export type OptionsTextKey = keyof typeof TEXT;
+
+export function to(key: OptionsTextKey, value = ""): string {
+  const entry = TEXT[key];
+  return (entry[currentLanguageIndex as 0 | 1] ?? entry[0]).replace("{value}", value);
+}

M02_MasterTemplete/M02_MasterTemplete_Router.py

@@ -12,6 +12,7 @@ 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_Options as options
 from M02_MasterTemplete import M02_MasterTemplete_Store as store
 
 router = APIRouter(prefix="/api/m02", tags=["M02 MasterTemplete"])
@@ -41,6 +42,11 @@ class MatsetBody(BaseModel):
     줄: dict[str, Any]
 
 
+class OptionsBody(BaseModel):
+    판: str = ""  # 옵션 표시 표 판 — 어긋나면 409
+    표시: dict[str, Any]  # {종류: {옵션 키: 참 · 거짓}} — 거짓만 남김
+
+
 def _call(fn, *args):
     try:
         return fn(*args)
@@ -127,6 +133,19 @@ def delete_material_combo(key: str, 판: str = "") -> dict:
     return _call(matset.delete, key, 판)
 
 
+# 구조물 옵션 보이기 — B05/B06 폼에 보일 옵션(마스터 템플릿 `구조물옵션표시.json`)
+@router.get("/structure-options")
+def get_structure_options() -> dict:
+    """`{판, 표시, 종류}` — 표시 = 숨긴 것만 · 종류 = 옵션 있는 종류와 그 옵션."""
+    return _call(options.listing)
+
+
+@router.put("/structure-options")
+def put_structure_options(body: OptionsBody) -> dict:
+    """고쳐 씀(낡은 판이면 409 · 없는 종류 · 키는 422) — 돌려주는 것 = 새 `{판, 표시, 종류}`."""
+    return _call(options.save, body.표시, body.판)
+
+
 # 복사 가져오기 — 다른 열(`from`) 내용을 받는 열로 · 번호 · 열은 받는 쪽 그대로
 @router.post("/structures/{column}/copy")
 def post_structure_copy(column: str, source: str = Query(alias="from")) -> dict:

M02_MasterTemplete/M02_MasterTemplete_Router_Items.py

@@ -0,0 +1,263 @@
+"""M02 층 집계표 API — `/api/m02/layers/{layer}/…` · 항목 목록 · 항목 복사(PLAN 21-1 · 21-2).
+
+⚠ 등록은 `main.py`(로그인만) · 층 권한은 여기서(`Router_Layers._layer_dir` 와 같은 규칙):
+    system    읽기 = 로그인 누구나(항목 고르기) · 쓰기 = SYSTEM_ADMIN
+    company   읽기 = 같은 회사 · 쓰기 = 회사 관리자(ADMIN · 마스터 · SYSTEM_ADMIN)
+    personal  읽기 · 쓰기 = 본인(SYSTEM_ADMIN 은 누구나) · 회사 없음 = 쓰기 409 「회사부터 등록」
+옛 길(`/api/m02/structures/…` 등 · `M02_MasterTemplete_Router.py`)은 시스템 층 별칭으로 그대로.
+회사 · 개인 층은 처음 부를 때 빈 뼈대를 만듦(`Items.ensure`).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Literal
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+from pydantic import BaseModel
+
+from common_util.common_util_auth import verify_session
+from M02_MasterTemplete import M02_MasterTemplete_Branch as branch
+from M02_MasterTemplete import M02_MasterTemplete_Items as items_store
+from M02_MasterTemplete import M02_MasterTemplete_Matset as matset
+from M02_MasterTemplete import M02_MasterTemplete_Store as store
+from M02_MasterTemplete import M02_Template_Layers as layers
+from M02_MasterTemplete.M02_MasterTemplete_Router import (
+    BranchBody,
+    MaterialBranchBody,
+    MatsetBody,
+    UseComboBody,
+)
+
+router = APIRouter(prefix="/api/m02", tags=["M02 MasterTemplete Items"])
+
+Layer = Literal["system", "company", "personal"]
+Session = dict[str, Any]
+NO_COMPANY = "회사부터 등록 — 회사 없이는 회사 · 개인 구조물 집계표를 만들 수 없음"
+
+
+class CopyItemBody(BaseModel):
+    from_layer: Literal["system", "company"]
+    from_owner: str | None = None
+    key: str
+
+
+def _admin(session: Session) -> bool:
+    return session.get("role") == "SYSTEM_ADMIN"
+
+
+def _company_admin(session: Session) -> bool:
+    return session.get("role") in ("ADMIN", "SYSTEM_ADMIN") or bool(session.get("is_master"))
+
+
+def _owner(session: Session, layer: str, owner: str | None) -> str | None:
+    """층 주인 글 — 회사 `{회사}` · 개인 `{회사}/{사용자}` · 시스템 None ·
+    남의 것은 SYSTEM_ADMIN 만."""
+    if layer == "system":
+        return None
+    company, user = session.get("company_id"), session.get("user_id")
+    mine = str(company) if layer == "company" else f"{company}/{user}"
+    if owner in (None, "", mine):
+        return None if company is None else mine
+    if not _admin(session):
+        raise HTTPException(status_code=403, detail="다른 회사 · 다른 사람의 구조물 집계표입니다.")
+    return owner
+
+
+def _folder(layer: str, owner: str | None) -> Path:
+    if layer == "system":
+        return store.FOLDER
+    try:
+        if layer == "company":
+            return layers.company_dir(owner)
+        company, user = str(owner).split("/", 1)
+        return layers.personal_dir(company, user)
+    except ValueError as error:
+        raise HTTPException(status_code=400, detail=f"층 주인 모양 — {error}") from error
+
+
+def _root(session: Session, layer: str, owner: str | None = None, write: bool = False) -> Path:
+    """층 폴더(권한까지) — 회사 · 개인은 없으면 빈 뼈대를 만듦. 회사 없는 사람: 쓰기 409."""
+    if layer == "system":
+        if write and not _admin(session):
+            raise HTTPException(status_code=403, detail="마스터 템플릿은 시스템 관리자만 고침.")
+        return store.FOLDER
+    who = _owner(session, layer, owner)
+    if who is None:
+        raise HTTPException(status_code=409, detail=NO_COMPANY)
+    if write and layer == "company" and not _company_admin(session):
+        raise HTTPException(
+            status_code=403, detail="회사용은 회사 관리자만 고침 — 개인용으로 복사해서 씀."
+        )
+    folder = _folder(layer, who)
+    items_store.ensure(folder)
+    return folder
+
+
+def _call(folder: Path, fn, *args):
+    with store.at(folder):
+        try:
+            return fn(*args)
+        except store.StoreError as e:
+            raise HTTPException(status_code=e.status, detail=e.detail) from e
+
+
+# ── 항목 목록 · 복사 ───────────────────────────────────
+
+
+def _listing(session: Session, layer: str, owner: str | None) -> dict[str, Any]:
+    who = None if layer == "system" else _owner(session, layer, owner)
+    if layer != "system" and who is None:
+        return {"layer": layer, "owner": None, "items": []}  # 회사 없음 = 빈 그룹
+    folder = _root(session, layer, who)
+    return {"layer": layer, "owner": who, "items": items_store.items(folder)}
+
+
+@router.get("/items")
+def get_items(
+    layer: Layer = "system",
+    owner: str | None = None,
+    all: bool = False,  # noqa: A002 — 21-1 약속 이름 `?all=1`
+    session: Session = Depends(verify_session),
+):
+    """21-1 — 한 층이면 `[{key, 열, 종류, 분류1~3, 단위, 일위대가, 자재조합, 도번, 면적번,
+    재료번}]` ·
+    `?all=1` 이면 세 층 `[{layer, owner, items}]`(회사 · 개인은 세션 것 · 회사 없으면 빈 목록)."""
+    if all:
+        return [_listing(session, one, None) for one in ("system", "company", "personal")]
+    return _listing(session, layer, owner)["items"]
+
+
+@router.post("/layers/personal/items/copy")
+def copy_item(body: CopyItemBody, session: Session = Depends(verify_session)) -> dict:
+    """회사 · 마스터 항목 → 내 개인 층 새 항목(열 · 세 파일 · 자재 조합 줄 · 새 SS 키 · `본뜬`)."""
+    target = _root(session, "personal", None, write=True)
+    source = _root(session, body.from_layer, body.from_owner)
+    owner = (
+        None if body.from_layer == "system" else _owner(session, body.from_layer, body.from_owner)
+    )
+    origin = {"layer": body.from_layer, "owner": owner, "key": body.key}
+    try:
+        return items_store.copy_item(source, target, body.key, origin)
+    except store.StoreError as e:
+        raise HTTPException(status_code=e.status, detail=e.detail) from e
+
+
+# ── 층 길 — 옛 시스템 길과 같은 모양 ─────────────────────
+
+
+@router.get("/layers/{layer}/structures/numbers")
+def get_numbers(layer: Layer, owner: str | None = None, session: Session = Depends(verify_session)):
+    return _call(_root(session, layer, owner), store.structure_numbers)
+
+
+@router.get("/layers/{layer}/structure-combos")
+def get_combos(layer: Layer, owner: str | None = None, session: Session = Depends(verify_session)):
+    return _call(_root(session, layer, owner), store.read_combos)
+
+
+@router.post("/layers/{layer}/structures/{column}")
+def post_structure(
+    layer: Layer, column: str, owner: str | None = None, session: Session = Depends(verify_session)
+):
+    return _call(_root(session, layer, owner, write=True), store.create_structure, column)
+
+
+@router.post("/layers/{layer}/structures/{column}/combo")
+def post_combo(
+    layer: Layer,
+    column: str,
+    body: BranchBody,
+    owner: str | None = None,
+    session: Session = Depends(verify_session),
+):
+    """일위대가 조합 갈라 내기 — 새 UA 는 M01 시스템 마스터에 생기므로 SYSTEM_ADMIN 만."""
+    folder = _root(session, layer, owner, write=True)
+    if not _admin(session):
+        raise HTTPException(status_code=403, detail="일위대가 조합은 시스템 관리자만 새로 만듦.")
+    return _call(
+        folder, branch.branch_combo, column, body.본뜬키, body.담은로직, body.이름, body.판
+    )
+
+
+@router.post("/layers/{layer}/structures/{column}/material-combo")
+def post_material_combo_branch(
+    layer: Layer,
+    column: str,
+    body: MaterialBranchBody,
+    owner: str | None = None,
+    session: Session = Depends(verify_session),
+):
+    folder = _root(session, layer, owner, write=True)
+    args = (column, body.본뜬키, body.담은자재, body.이름, body.판)
+    return _call(folder, branch.branch_material_combo, *args)
+
+
+@router.post("/layers/{layer}/structures/{column}/use-combo")
+def post_use_combo(
+    layer: Layer,
+    column: str,
+    body: UseComboBody,
+    owner: str | None = None,
+    session: Session = Depends(verify_session),
+):
+    folder = _root(session, layer, owner, write=True)
+    return _call(folder, branch.use_combo, column, body.종류, body.키, body.판)
+
+
+@router.post("/layers/{layer}/{kind}/{column}/copy")
+def post_copy(
+    layer: Layer,
+    kind: Literal["structures", "area", "material"],
+    column: str,
+    source: str = Query(alias="from"),
+    owner: str | None = None,
+    session: Session = Depends(verify_session),
+):
+    folder = _root(session, layer, owner, write=True)
+    part = "structure" if kind == "structures" else kind
+    return _call(folder, store.copy_from, part, column, source)
+
+
+@router.get("/layers/{layer}/material-combos")
+def get_matsets(layer: Layer, owner: str | None = None, session: Session = Depends(verify_session)):
+    return _call(_root(session, layer, owner), matset.listing)
+
+
+@router.get("/layers/{layer}/material-combos/{key}")
+def get_matset(
+    layer: Layer, key: str, owner: str | None = None, session: Session = Depends(verify_session)
+):
+    return _call(_root(session, layer, owner), matset.one, key)
+
+
+@router.post("/layers/{layer}/material-combos")
+def post_matset(
+    layer: Layer,
+    body: MatsetBody,
+    owner: str | None = None,
+    session: Session = Depends(verify_session),
+):
+    return _call(_root(session, layer, owner, write=True), matset.create, body.줄, body.판)
+
+
+@router.put("/layers/{layer}/material-combos/{key}")
+def put_matset(
+    layer: Layer,
+    key: str,
+    body: MatsetBody,
+    owner: str | None = None,
+    session: Session = Depends(verify_session),
+):
+    return _call(_root(session, layer, owner, write=True), matset.edit, key, body.줄, body.판)
+
+
+@router.delete("/layers/{layer}/material-combos/{key}")
+def delete_matset(
+    layer: Layer,
+    key: str,
+    판: str = "",
+    owner: str | None = None,
+    session: Session = Depends(verify_session),
+):
+    return _call(_root(session, layer, owner, write=True), matset.delete, key, 판)

M02_MasterTemplete/M02_MasterTemplete_Router_Layers.py

@@ -1,7 +1,7 @@
 """M02 양식 층 API — 계약 `tmp/M02_분석/6_계약.md` 「층 (sub4)」.
 
 ⚠ 등록은 `main.py`(로그인만) · 층마다 권한은 여기서:
-    system    읽기만(고치기는 `/api/m02/templates` 시스템 관리자 길)
+    system    읽기 · 쓰기는 시스템 관리자(옛 `/api/m02/templates` 길과 같은 저장소)
     company   같은 회사 읽기 · 쓰기는 회사 관리자(ADMIN · 마스터 · 시스템 관리자)
     personal  본인 읽기·쓰기 · 같은 회사 사람 것은 읽기만(가져오기)
     project   같은 회사 프로젝트 · 작업본 쓰기 · `_initial/` 은 안 씀
@@ -26,6 +26,8 @@ from common_util import common_util_spreadsheet as spreadsheet
 from common_util.common_util_auth import verify_session
 from common_util.common_util_storage import resolve_stored_project_path
 from config.config_db import get_db_pool, run_with_connection
+from M02_MasterTemplete import M02_MasterTemplete_Items as items_store
+from M02_MasterTemplete import M02_MasterTemplete_Store as store
 from M02_MasterTemplete import M02_Table_Fill as fill
 from M02_MasterTemplete import M02_Template_Layers as layers
 
@@ -152,8 +154,8 @@ async def _project(session: dict[str, Any], project_id: str | None) -> dict[str,
 
 def _company_of(session: dict[str, Any], project: dict[str, Any] | None) -> int:
     company_id = project["company_id"] if project else session.get("company_id")
-    if company_id is None:
-        raise HTTPException(status_code=403, detail="회사 연결이 필요합니다.")
+    if company_id is None:  # 회사 없는 사용자는 없음(21-0) — 회사 · 개인 층은 회사부터
+        raise HTTPException(status_code=409, detail="회사부터 등록 — 회사 연결이 필요합니다.")
     return int(company_id)
 
 
@@ -174,8 +176,8 @@ async def _layer_dir(
 ) -> Path:
     """층 폴더 — 읽기·쓰기 권한까지 여기서 가름."""
     if layer == "system":
-        if write:
-            raise HTTPException(status_code=403, detail="시스템 양식은 마스터 템플릿 화면에서만.")
+        if write and not _is_system_admin(session):
+            raise HTTPException(status_code=403, detail="시스템 양식은 시스템 관리자만.")
         return layers.system_dir()
     if layer == "project":
         return layers.project_dir((await _project(session, project_id))["root"])
@@ -184,16 +186,22 @@ async def _layer_dir(
     if layer == "company":
         if write and not _is_company_admin(session):
             raise HTTPException(status_code=403, detail="회사 공식 양식은 회사 관리자만.")
-        return layers.company_dir(company_id)
+        return _ensured(layers.company_dir(company_id))
     if layer == "personal":
         owner = int(user_id) if user_id is not None else int(session["user_id"])
         if write and owner != session.get("user_id"):
             raise HTTPException(status_code=403, detail="개인 양식은 본인만 고칩니다.")
         await _same_company_user(session, owner, company_id)
-        return layers.personal_dir(company_id, owner)
+        return _ensured(layers.personal_dir(company_id, owner))
     raise HTTPException(status_code=404, detail="없는 층입니다.")
 
 
+def _ensured(folder: Path) -> Path:
+    """회사 · 개인 층 첫 진입 — 빈 구조물집계표 뼈대(PLAN 21-2 · `Items.ensure`)."""
+    items_store.ensure(folder)
+    return folder
+
+
 def _bad(error: ValueError) -> HTTPException:
     return HTTPException(status_code=400, detail=str(error))
 
@@ -261,6 +269,13 @@ async def save_layer_template(
     if kind == "table" and fill.is_fillable(document):
         # 채운 표가 와도 설계값은 안 받아 적음 — 양식 + 손 값만(5장 · 브라우저 값을 믿지 않음)
         document = fill.strip_design(document)
+    if layer != "project":
+        # 시스템 · 회사 · 개인 층 = 마스터 저장소 규칙 그대로(집계표 저장 때 새 열 파일 ·
+        # 번호 · SS 장부 ·
+        # 계산값 서버 풀이 · 번호 칸 보존 — `M02_MasterTemplete_Store.write`)
+        return await asyncio.to_thread(
+            _store_save, folder, kind, name, body.판 or "", document, layer
+        )
     if kind in ("area", "material"):
         # 면적산출 · 재료산출 계산값은 서버가 같은 TS 엔진을 Node 로 돌려 새로 적음
         # (브라우저 값 버림 · 5장 ②)
@@ -287,6 +302,15 @@ async def save_layer_template(
     return {"종류": kind, "이름": name, "판": version, "층": layer}
 
 
+def _store_save(folder: Path, kind: str, name: str, version: str, doc: Any, layer: str) -> dict:
+    with store.at(folder):
+        try:
+            info = store.write(kind, name, version, doc)
+        except store.StoreError as error:
+            raise HTTPException(status_code=error.status, detail=error.detail) from error
+    return {"종류": kind, "이름": name, "판": info["판"], "층": layer}
+
+
 @router.delete("/layers/{layer}/templates/{kind}/{name}")
 async def delete_layer_template(
     layer: Layer,
@@ -296,10 +320,15 @@ async def delete_layer_template(
     project_id: str | None = Query(None),
     session: dict[str, Any] = Depends(verify_session),
 ) -> dict[str, Any]:
-    """개인 = 본인만 · 회사 = 회사 관리자만 · 시스템 · 프로젝트 층은 거절 · 판이 다르면 409."""
-    if layer in ("system", "project"):
-        raise HTTPException(status_code=403, detail="개인 · 회사 층 양식만 지울 수 있습니다.")
+    """개인 = 본인만 · 회사 = 회사 관리자만 · 시스템 = 시스템 관리자 · 프로젝트 층은 거절 ·
+    판이 다르면 409 · 프로그램이 이름으로 부르는 양식(`store.IN_USE` — 구조물집계표 등)은 409."""
+    if layer == "project":
+        raise HTTPException(
+            status_code=403, detail="개인 · 회사 · 시스템 층 양식만 지울 수 있습니다."
+        )
     folder = await _layer_dir(session, layer, project_id=project_id, write=True)
+    if (kind, name) in store.IN_USE:
+        raise HTTPException(status_code=409, detail=f"쓰는 양식이라 못 지움 「{name}」")
     try:
         layers.check_kind(kind)
         layers.check_name(name)

M02_MasterTemplete/M02_MasterTemplete_Store.py

@@ -1,4 +1,4 @@
-"""M02 마스터 템플릿 — 시스템 층 저장소 (`resources/master_template/{종류}/<이름>.json`).
+"""M02 마스터 템플릿 — 층 저장소 · 기본 시스템 층(`resources/master_template/{종류}/<이름>.json`).
 
 M01 `Store` 방식 — 판(파일 sha256 앞 16자) · 판이 다르면 409 · 원자 쓰기.
 권한은 등록하는 쪽(`main.py`)이 붙임.
@@ -10,6 +10,9 @@ import hashlib
 import json
 import re
 import threading
+from collections.abc import Iterator
+from contextlib import contextmanager
+from contextvars import ContextVar
 from datetime import datetime
 from pathlib import Path
 from typing import Any
@@ -20,6 +23,26 @@ from M02_MasterTemplete import M02_Template_Layers as layers
 
 FOLDER: Path = Path(__file__).resolve().parent.parent / "resources" / "master_template"
 KINDS = layers.KINDS  # 시험은 FOLDER 를 사본으로 바꿈
+# 지금 다루는 층 폴더 — 층 라우터가 `at(층 폴더)` 로 바꿈 · 안 바꾸면 시스템 층(`FOLDER`).
+# 회사 · 개인 층도 시스템과 같은 모양(`table/구조물집계표.json` · 조합 장부 ·
+# structure/area/material · 자재조합.json — PLAN 21-1)이라 아래 함수는 그대로 씀
+_ROOT: ContextVar[Path | None] = ContextVar("m02_layer_root", default=None)
+
+
+def root() -> Path:
+    return _ROOT.get() or FOLDER
+
+
+@contextmanager
+def at(folder: str | Path) -> Iterator[Path]:
+    """이 안에서 부르는 저장소 함수는 `folder` 층을 봄(요청 하나 · 스레드 하나 안에서만)."""
+    token = _ROOT.set(Path(folder))
+    try:
+        yield Path(folder)
+    finally:
+        _ROOT.reset(token)
+
+
 # 구조물집계표 구조물 열(꼴=수) 마다 세 파일(파일 이름 = 열 id) —
 #   구조물 도면 `structure/` (도각 없는 전용 화면) · 면적산출 `area/` · 재료산출 `material/`
 #   (둘 다 스프레드시트 통합문서)
@@ -75,7 +98,7 @@ def _path(kind: str, name: str) -> Path:
         or _BAD_NAME.search(name)
     ):
         raise StoreError(400, f"쓸 수 없는 글자가 있는 이름 「{name}」")
-    return FOLDER / kind / f"{name}.json"
+    return root() / kind / f"{name}.json"
 
 
 def _info(kind: str, path: Path) -> dict[str, Any]:
@@ -91,7 +114,7 @@ def list_all() -> list[dict[str, Any]]:
     rows = [
         _info(kind, p)
         for kind in KINDS
-        for p in sorted((FOLDER / kind).glob("*.json"))
+        for p in sorted((root() / kind).glob("*.json"))
         if not p.name.startswith(".")
     ]
     return rows
@@ -162,7 +185,7 @@ def delete(kind: str, name: str, version: str | None = None) -> None:
 
 
 def _docs(kind: str) -> list[tuple[str, Any]]:
-    folder = FOLDER / kind
+    folder = root() / kind
     return [(p.stem, json.loads(p.read_bytes())) for p in sorted(folder.glob("[!.]*.json"))]
 
 
@@ -260,7 +283,7 @@ def _new_code(column: str) -> str:
 
 def _retired() -> list[str]:
     """지운 열의 8자리 — 조합 장부 `지운번호`(한 번 준 번호는 다시 안 줌)."""
-    path = FOLDER / COMBO_FILE
+    path = root() / COMBO_FILE
     return json.loads(path.read_bytes()).get("지운번호", []) if path.is_file() else []
 
 
@@ -318,7 +341,7 @@ def _take_origins(doc: Any) -> dict[str, str]:
         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():
+        if (root() / "structure" / f"{col['id']}.json").is_file():
             continue
         out[col["id"]] = source
         for field in ("일위대가", "자재조합"):
@@ -360,14 +383,14 @@ def prune_removed_structures() -> list[str]:
     codes: set[str] = set()
     with _LOCK:
         for kind, key, _, _ in PARTS:
-            for path in sorted((FOLDER / kind).glob("[!.]*.json")):
+            for path in sorted((root() / 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
+            book = root() / COMBO_FILE
             doc = json.loads(book.read_bytes()) if book.is_file() else {}
             doc["지운번호"] = sorted(codes | set(doc.get("지운번호", [])))
             atomic_write_json(book, doc)
@@ -377,7 +400,7 @@ def prune_removed_structures() -> list[str]:
 def _move_basis() -> list[str]:
     """12장 산출근거 `basis/` → 면적산출 `area/` (내용 · 알약 연결 그대로 · 표번 칸 → 면적번 ·
     시트 이름 산출근거 → 면적산출) · 옮긴 뒤 빈 `basis/` 폴더를 지움."""
-    old = FOLDER / "basis"
+    old = root() / "basis"
     if not old.is_dir():
         return []
     moved: list[str] = []
@@ -478,7 +501,7 @@ def _combo_row(key: str, col: dict[str, Any], numbers: dict[str, str]) -> dict[s
 def sync_combos() -> dict[str, Any]:
     """조합 표를 집계표에 맞춤 — 새 열 = 새 SS 키 · 지운 열 = 줄 지움 · 고친 열 = 칸 갱신 ·
     줄 차례 = 집계표 열 차례. 바뀐 것이 없으면 파일을 안 씀."""
-    path = FOLDER / COMBO_FILE
+    path = root() / COMBO_FILE
     with _LOCK:
         old = json.loads(path.read_bytes()) if path.is_file() else {}
         keys = {row["열"]: row["키"] for row in old.get("줄", [])}
@@ -502,5 +525,5 @@ def sync_combos() -> dict[str, Any]:
 
 def read_combos() -> dict[str, Any]:
     """조합 표 — 파일이 아직 없으면 지금 열 전부로 처음 한 번 만듦."""
-    path = FOLDER / COMBO_FILE
+    path = root() / COMBO_FILE
     return json.loads(path.read_bytes()) if path.is_file() else sync_combos()

M02_MasterTemplete/M02_MasterTemplete_UI_Side.ts

@@ -37,6 +37,7 @@ import {
   type StructureColumn,
 } from "./M02_MasterTemplete_Structure";
 import { buildMatsetSection } from "./M02_MasterTemplete_Matset";
+import { buildOptionsSection } from "./M02_MasterTemplete_Options";
 import { canEdit, type Selection } from "./M02_MasterTemplete_UI_Main";
 
 const KINDS: { kind: Kind; label: () => string }[] = [
@@ -126,13 +127,20 @@ export function buildSide(opt: SideOptions): SideHandle {
     confirmLeave: opt.confirmLeave,
     show: opt.showView,
     close: () => opt.onOpen(null),
-    onOpen: () => paint(),
+    onOpen: () => (options.clear(), 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 options = buildOptionsSection({
+    isAdmin: canEdit(layer, opt.isAdmin),
+    confirmLeave: opt.confirmLeave,
+    show: opt.showView,
+    onOpen: () => (matset.clear(), paint()),
+  });
   // 구조물 집계 양식 — 집계표 줄 아래 하위 컨테이너 넷(들여 · 같이 접힘) · 처음부터 펼침(집계표가 열려 있음)
   const summary = section(
     L("M02_KindTable"),
@@ -147,7 +155,10 @@ export function buildSide(opt: SideOptions): SideHandle {
     children: [
       summary,
       ...(layer === "system"
-        ? [section(L("M02_KindDrawing"), bodies.get("drawing")!, ...actionRow("drawing"))]
+        ? [
+            section(options.title, options.body),
+            section(L("M02_KindDrawing"), bodies.get("drawing")!, ...actionRow("drawing")),
+          ]
         : []),
     ],
   });
@@ -223,6 +234,7 @@ export function buildSide(opt: SideOptions): SideHandle {
     paintColumns();
     paintButtons();
     if (opt.getOpen()) matset.clear();
+    if (opt.getOpen()) options.clear();
   }
 
   // 여는 것은 편집 칸(`onOpen`) — 편집 칸이 열 때마다 `paint` 를 부름(페이지가 이음)

M02_MasterTemplete/M02_MasterTemplete_UI_Style.css

@@ -145,3 +145,73 @@
   padding: var(--spacing-24);
   color: var(--color-text);
 }
+
+/* 좌측 「구조물 옵션 보이기」 화면(메인 칸) — 왼쪽 종류(군별) · 오른쪽 옵션 체크 */
+.m02-opts {
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-12);
+  max-width: 64rem;
+  font-size: var(--text-body-sm);
+}
+
+.m02-opts__panes {
+  display: grid;
+  grid-template-columns: minmax(14rem, 20rem) 1fr;
+  gap: var(--spacing-16);
+  align-items: start;
+}
+
+.m02-opts__kinds,
+.m02-opts__list {
+  max-height: calc(100vh - 20rem);
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-4);
+  min-width: 0;
+}
+
+.m02-opts__group {
+  margin: var(--spacing-8) 0 0;
+  color: var(--color-text-muted);
+  font-size: var(--text-body-sm);
+}
+
+.m02-opts__kind {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: var(--spacing-4);
+  padding: var(--spacing-4) var(--spacing-8);
+  border: 1px solid transparent;
+  border-radius: var(--radius-sm);
+  background: none;
+  color: var(--color-text);
+  font: inherit;
+  text-align: left;
+  cursor: pointer;
+}
+
+.m02-opts__kind:hover {
+  background: var(--color-mist-violet);
+}
+
+.m02-opts__kind.is-active {
+  border-color: var(--color-accent);
+  background: var(--color-mist-violet);
+}
+
+.m02-opts__option {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: var(--spacing-8);
+  padding: var(--spacing-4) 0;
+  cursor: pointer;
+}
+
+.m02-opts__key {
+  color: var(--color-text-muted);
+  font-size: 11px;
+}