feat(B07): 배수유역도 종류화 · 평면도 드롭다운 공용 꼴 · IP 표 차례 · 용지도 라벨 2배와 상자 밑 선 자름(109-1~4)

- 배수유역도 = 기본 종류(양식 watershed · 1/6,000 한 장 · 조각 없음) · 도면 id plan_watershed · × 지우기 · 「새 종류」 양식 고르기로 다시 · 옛 폴더에 한 번만 더함
- 평면도 칸 종류 · 양식 고르기 = 공용 createSelectField(compact)
- IP 표 첫 줄 맨 위 · 왼 → 오 · 위 → 아래(묶음 왼쪽 아래 기준 그대로)
- 용지도 필지 정보 글 3.6(상수 하나) · 상자 밑 등고선 · 계류 · 필지 · 읍면동 · 시군구 선 잘라 냄(clip_lines 일반화)
- 시험: 기본 종류 · 유역 한 장 · 지우기 · 다시 만들기 · IP 표 두 줄 · 상자 안 선 0

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

B07_DesignDetail/B07_DesignDetail_Api_Fetch.ts

@@ -180,7 +180,10 @@ export interface PlanKind {
   id: string;
   name: string;
   pieces: string[];
+  /** 양식 — plan(평면도 · 조각 고름) · watershed(유역도 1/6,000 한 장 · 조각 없음). */
+  layout: PlanKindLayout;
 }
+export type PlanKindLayout = "plan" | "watershed";
 export interface PlanMark {
   chainage_m: number;
   refuge: boolean;
@@ -202,10 +205,11 @@ export function addPlanKind(
   projectId: string,
   name: string,
   pieces: string[],
+  layout: PlanKindLayout = "plan",
 ): Promise<PlanKindsState> {
   return requestJson(`/projects/${projectId}/plan-kinds`, {
     method: "POST",
-    body: JSON.stringify({ name, pieces }),
+    body: JSON.stringify({ name, pieces, layout }),
   });
 }
 

B07_DesignDetail/B07_DesignDetail_Engine_Cad_IpTable.py

@@ -110,33 +110,31 @@ def ip_blocks(
 
 
 def _place(blocks: list[dict[str, Any]], width_mm: float) -> None:
-    """묶음마다 표 왼쪽 위 자리(종이 mm) `origin` — 왼쪽 아래부터 나란히 · 넘치면 위로 다음 줄."""
+    """묶음마다 표 왼쪽 위 자리(종이 mm) `origin` — 왼쪽 → 오른쪽 · 위 → 아래(첫 줄 맨 위).
+
+    묶음 전체는 도곽 왼쪽 아래 기준 — 줄이 늘면 위로 쌓이고 마지막 줄이 맨 아래다.
+    """
     block_w = sum(_COLUMNS)
     per_line = max(1, int((width_mm - 2 * _MARGIN) // block_w))
+    lines = -(-len(blocks) // per_line)
     for order, block in enumerate(blocks):
         line, column = divmod(order, per_line)
-        top = _MARGIN + line * (_IP_ROWS * _ROW_H + _LINE_GAP) + _IP_ROWS * _ROW_H
+        top = _MARGIN + (lines - 1 - line) * (_IP_ROWS * _ROW_H + _LINE_GAP) + _IP_ROWS * _ROW_H
         block["origin"] = [_MARGIN + column * block_w, top]
         block["rows"] = _END_ROWS if "ia" not in block else _IP_ROWS
 
 
-def _clip(pieces: dict[str, dict[str, Any]], blocks: list[dict[str, Any]], box: Any) -> None:
-    """표 칸 밑 선 조각(등고선 · 계류 · 노견선 · 외곽선 · 중심선)을 표 밖으로 잘라 낸다."""
-    min_x, min_y = box[0], box[1]
-    width = sum(_COLUMNS) / MM
-    area = unary_union(
-        [
-            rect(
-                min_x + b["origin"][0] / MM,
-                min_y + b["origin"][1] / MM - b["rows"] * _ROW_H / MM,
-                min_x + b["origin"][0] / MM + width,
-                min_y + b["origin"][1] / MM,
-            )
-            for b in blocks
-        ]
-    )
+def clip_lines(
+    pieces: dict[str, dict[str, Any]],
+    rects: list[tuple[float, float, float, float]],
+    names: tuple[str, ...],
+) -> None:
+    """상자들(사업지 m · 최소 x · y · 최대 x · y) 밑 선 조각 `names` 를 상자 밖으로 잘라 낸다."""
+    if not rects:
+        return
+    area = unary_union([rect(*bounds) for bounds in rects])
     inside = prep(area)
-    for piece in _CLIPPED:
+    for piece in names:
         lines = (pieces.get(piece) or {}).get("lines")
         if not lines:
             continue
@@ -155,6 +153,22 @@ def _clip(pieces: dict[str, dict[str, Any]], blocks: list[dict[str, Any]], box:
         pieces[piece]["lines"] = kept
 
 
+def _clip(pieces: dict[str, dict[str, Any]], blocks: list[dict[str, Any]], box: Any) -> None:
+    """표 칸 밑 선 조각(등고선 · 계류 · 노견선 · 외곽선 · 중심선)을 표 밖으로 잘라 낸다."""
+    min_x, min_y = box[0], box[1]
+    width = sum(_COLUMNS) / MM
+    rects = [
+        (
+            min_x + b["origin"][0] / MM,
+            min_y + b["origin"][1] / MM - b["rows"] * _ROW_H / MM,
+            min_x + b["origin"][0] / MM + width,
+            min_y + b["origin"][1] / MM,
+        )
+        for b in blocks
+    ]
+    clip_lines(pieces, rects, _CLIPPED)
+
+
 def ip_table_piece(
     pieces: dict[str, dict[str, Any]],
     curves: list[dict[str, Any]],

B07_DesignDetail/B07_DesignDetail_Engine_Cad_PlanKinds.py

@@ -75,7 +75,7 @@ LEGACY_PIECES: dict[str, tuple[str, ...]] = {
 _OUTLINE = LEGACY_PIECES["slope_outline"]
 
 _TERRAIN = ("contour", "stream", "centerline", *_OUTLINE, "slope_ticks", "ip", "radius")
-# 기본 종류 넷 — 지울 수 있다. id 는 옛 도면 id(plan_terrain …)와 같아 확정본이 이어진다.
+# 기본 종류 — 지울 수 있다. id 는 옛 도면 id(plan_terrain …)와 같아 확정본이 이어진다.
 DEFAULT_KINDS: tuple[dict[str, Any], ...] = (
     {"id": "terrain", "name": "지형", "pieces": [*_TERRAIN, "station"]},
     {
@@ -100,6 +100,8 @@ DEFAULT_KINDS: tuple[dict[str, Any], ...] = (
         "name": "용지도",
         "pieces": ["contour", "centerline", "parcel", "parcel_info", "emd", "sgg"],
     },
+    # 배수유역도 = 양식이 다른 종류(1/6,000 한 장 · 정보표) — 조각을 고르지 않는다(109장).
+    {"id": "watershed", "name": "배수유역도", "pieces": [], "layout": "watershed"},
 )
 
 _COLORS = {
@@ -127,7 +129,7 @@ _BOUNDARY_STYLE: dict[str, tuple[int, list[int] | None]] = {
     "emd": (2, [8, 4]),
     "sgg": (3, [14, 5, 3, 5]),
 }
-_PARCEL_FONT = 1.8
+PARCEL_FONT = 3.6  # 필지 정보 글 크기(종이 mm) — 용지도 자리 잡기도 이 값
 TICK_STEP_M = 2.0  # 비탈 눈금 간격(실거리 m) — 긴 · 짧은 눈금이 번갈아 선다
 _MAJOR_EVERY = 5  # 측점 NO 큰 글자 · 동그라미 간격(측점 수)
 _LABEL_FONT = 2.5
@@ -518,7 +520,7 @@ def _piece_entities(
                     "rect",
                     layer=layer,
                     color=color,
-                    font=_PARCEL_FONT,
+                    font=PARCEL_FONT,
                 )
             )
     return out

B07_DesignDetail/B07_DesignDetail_Router.py

@@ -39,14 +39,12 @@ from B07_DesignDetail.B07_DesignDetail_Engine_Template import (
 from B07_DesignDetail.B07_DesignDetail_Router_Support import (
     CROSS_STANDARD_ID,
     MASS_HAUL_ID,
-    WATERSHED_ID,
     _cross_sheet_plan,
     _drawing_list,
     _invalidate_drawing,
     _read_drawing,
     _read_json,
     _store_confirmed_drawing,
-    watershed_source,
 )
 from B07_DesignDetail.B07_DesignDetail_Router_Support_Overlay import cross_overlay_extents
 from B07_DesignDetail.B07_DesignDetail_Router_Support_Plan import PLAN_KIND_ID, plan_kind_source
@@ -322,12 +320,6 @@ async def get_design_drawing(
             async with pool.acquire() as connection:
                 section = await get_longitudinal_section(connection, project_id, route_id)
             source_design = ((section or {}).get("data") or {}).get("mass_haul")
-        elif drawing_id == WATERSHED_ID:
-            # 유역도는 B04 배수유역 산출물 + 도엽 배경을 사업지 CRS로 모아 넘긴다.
-            context, reason = await load_drainage_context(project_id)
-            if context is None:
-                return JSONResponse(status_code=404, content={"status": "error", "message": reason})
-            source_design = await asyncio.to_thread(watershed_source, context)
         elif drawing_id == CROSS_STANDARD_ID:
             # 표준 횡단면도는 B06 「표준 횡단면 설정」 저장값으로 그린다(없으면 config 기본값).
             pool = get_db_pool()

B07_DesignDetail/B07_DesignDetail_Router_PlanKinds.py

@@ -34,6 +34,8 @@ router = APIRouter(prefix="/api/projects", tags=["B07 Design Detail"])
 class PlanKindRequest(BaseModel):
     name: str
     pieces: list[str] = Field(default_factory=list)
+    # 양식 — plan(평면도 · 조각 고름) · watershed(유역도). 추가에서만 쓰고 업데이트는 그대로 둔다.
+    layout: str = "plan"
 
 
 class PlanMark(BaseModel):
@@ -79,10 +81,10 @@ async def get_plan_kinds(project_id: UUID) -> Any:
 
 @router.post("/{project_id}/plan-kinds")
 async def post_plan_kind(project_id: UUID, request: PlanKindRequest) -> Any:
-    """종류 추가 — 조각을 골라 이름을 붙인다."""
+    """종류 추가 — 양식 · 조각을 골라 이름을 붙인다."""
     try:
         root = await _project_root(project_id)
-        await asyncio.to_thread(add_kind, root, request.name, request.pieces)
+        await asyncio.to_thread(add_kind, root, request.name, request.pieces, request.layout)
         return await asyncio.to_thread(_state, root)
     except ValueError as exc:
         return _error(400, exc)

B07_DesignDetail/B07_DesignDetail_Router_Support.py

@@ -76,6 +76,7 @@ from B07_DesignDetail.B07_DesignDetail_Router_Support_Io import (
 )
 from B07_DesignDetail.B07_DesignDetail_Router_Support_Plan import (
     PLAN_KIND_ID,
+    WATERSHED_LAYOUT,
     plan_kind_items,
 )
 from B07_DesignDetail.B07_DesignDetail_Schema import (
@@ -92,7 +93,6 @@ _CROSS_ID = re.compile(rf"^cross_{CROSS_KEY_PATTERN}m$")
 _LONG_ID = re.compile(r"^longitudinal(?:_(\d+))?$")
 # 노선 전장에 한 장씩만 나오는 도면 — 라우터가 원본 자료를 따로 실어 넘긴다.
 MASS_HAUL_ID = "mass_haul"
-WATERSHED_ID = "watershed"
 COVER_ID = "cover"
 # 표준 횡단면도 — 노선 자료가 아니라 B06 표준 횡단면 설정값으로 그리는 한 장.
 CROSS_STANDARD_ID = "cross_standard"
@@ -156,7 +156,6 @@ def _drawing_list(
         (COVER_ID, "cover", "표지"),
         (CROSS_STANDARD_ID, "cross_standard", STANDARD_LABEL),
         (MASS_HAUL_ID, "mass_haul", "토적도(유토곡선)"),
-        (WATERSHED_ID, "watershed", "유역도(배수 유역도)"),
     ):
         drawings.append(
             DesignDrawingItem(
@@ -164,12 +163,6 @@ def _drawing_list(
                 kind=kind,
                 label=label,
                 confirmed=bool(manifest_drawings.get(drawing_id, {}).get("confirmed")),
-                # 배수유역도는 평면도 묶음 안 항목 — 축척(1/6,000 한 장)이 달라 종류는 아니다.
-                **(
-                    {"plan_kind": WATERSHED_ID, "plan_kind_name": "배수유역도"}
-                    if drawing_id == WATERSHED_ID
-                    else {}
-                ),
             )
         )
     # 표준도(구조물도)는 2026-09-13 B08 「구조물도」 탭으로 이관 — 사용자 확정 ③, PLAN 3장 ④.
@@ -405,7 +398,7 @@ def _read_drawing(
         # 포맷 버전이 다르면(테이블·레이어 구성 변경 전 저장본) 캐시를 버리고
         # 아래에서 원본 기준으로 재생성한다. 확정 상태도 무효로 응답해 재확정 유도.
         if saved.get("format") == DRAWING_FORMAT:
-            if drawing_id in (COVER_ID, MASS_HAUL_ID, WATERSHED_ID, CROSS_STANDARD_ID):
+            if drawing_id in (COVER_ID, MASS_HAUL_ID, CROSS_STANDARD_ID):
                 kind = drawing_id  # id와 kind가 같은 단장 도면
             elif PLAN_KIND_ID.fullmatch(drawing_id):
                 kind = "plan"
@@ -451,36 +444,22 @@ def _read_drawing(
         if not isinstance(stored_design, dict):
             raise FileNotFoundError("계획평면도 자료가 없습니다.")
         label = str(stored_design.get("label") or drawing_id)
-        return (
-            "plan",
-            label,
-            build_plan_kind_drawing(
-                drawing_id, label, stored_design["box"], stored_design.get("pieces") or {}
-            ),
-            False,
-            None,
-        )
-
-    if drawing_id == WATERSHED_ID:
-        # stored_design = watershed_source()가 모아 준 노선·유역·배경 좌표(사업지 CRS).
-        if not isinstance(stored_design, dict):
-            raise FileNotFoundError("배수 유역 산출물이 없습니다.")
-        longitudinal = _read_json(longitudinal_path)
-        interval = infer_station_interval(longitudinal.get("stations") or [])
-        return (
-            "watershed",
-            "유역도(배수 유역도)",
-            build_watershed_drawing(
+        if stored_design.get("layout") == WATERSHED_LAYOUT:
+            # 유역도 양식 — watershed_source()가 모아 준 노선·유역·배경 좌표(사업지 CRS).
+            longitudinal = _read_json(longitudinal_path)
+            drawing = build_watershed_drawing(
                 drawing_id,
                 stored_design.get("route_xy") or [],
                 stored_design.get("basins") or [],
                 stored_design.get("contours") or [],
                 stored_design.get("streams") or [],
-                interval,
-            ),
-            False,
-            None,
-        )
+                infer_station_interval(longitudinal.get("stations") or []),
+            )
+        else:
+            drawing = build_plan_kind_drawing(
+                drawing_id, label, stored_design["box"], stored_design.get("pieces") or {}
+            )
+        return "plan", label, drawing, False, None
 
     if _LONG_ID.fullmatch(drawing_id):
         source = _read_json(longitudinal_path)

B07_DesignDetail/B07_DesignDetail_Router_Support_Io.py

@@ -20,7 +20,6 @@ _CROSS_ID = re.compile(r"^cross_(\d+)m$")
 _LONG_ID = re.compile(r"^longitudinal(?:_(\d+))?$")
 # 노선 전장에 한 장씩만 나오는 도면 — 라우터가 원본 자료를 따로 실어 넘긴다.
 MASS_HAUL_ID = "mass_haul"
-WATERSHED_ID = "watershed"
 COVER_ID = "cover"
 
 # ⚠ 빈-도각 목록이 여기 있었다 — 계획평면도·표준 횡단면도·용지도·표준도 일곱 줄.

B07_DesignDetail/B07_DesignDetail_Router_Support_Landuse.py

@@ -19,16 +19,18 @@ from shapely.validation import make_valid
 
 from B07_DesignDetail.B07_DesignDetail_Engine_Cad_MassHaul import balloon_size
 from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Plan import MM
+from B07_DesignDetail.B07_DesignDetail_Engine_Cad_PlanKinds import PARCEL_FONT
 from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import _clip_rings, _geojson_features
 
 LANDUSE_PIECES = ("parcel", "parcel_info", "emd", "sgg")
+# 필지 정보 상자 밑에서 잘라 낼 선 조각 — 배경이 글을 가리지 않게(109-4).
+LABEL_CLIPPED = ("contour", "stream", "parcel", "emd", "sgg")
 
 # B04 가 내려받아 저장하는 지적·행정구역 GeoJSON (전부 WGS84).
 PARCEL_FILE = "연속지적도_bounds.geojson"
 EMD_FILE = "행정구역_읍면동_bounds.geojson"
 SGG_FILE = "행정구역_시군구_bounds.geojson"
 
-PARCEL_FONT = 1.8  # 필지 정보 글 크기(종이 mm)
 ROUTE_CLEAR_M = 5.0  # 라벨이 비켜 갈 노선 버퍼(중심선에서 m)
 _GAP_M = 2.0  # 지시선 끝과 상자 사이 틈(m)
 _RINGS = 5  # 후보 자리 고리 수
@@ -187,6 +189,17 @@ def place_labels(
     return items
 
 
+def label_rects(items: list[dict[str, Any]]) -> list[tuple[float, float, float, float]]:
+    """필지 정보 상자 자리(사업지 m) — 그리는 상자(`_balloon_entities`)와 같은 크기."""
+    rects = []
+    for item in items:
+        width_mm, height_mm = balloon_size(item["lines"], PARCEL_FONT)
+        half_w, half_h = width_mm / MM / 2.0, height_mm / MM / 2.0
+        cx, cy = item["center"]
+        rects.append((cx - half_w, cy - half_h, cx + half_w, cy + half_h))
+    return rects
+
+
 def landuse_pieces(
     project_root: Path,
     crs: str,

B07_DesignDetail/B07_DesignDetail_Router_Support_Plan.py

@@ -1,12 +1,14 @@
 """B07 계획평면도 종류 · 정보 조각 파일 (PLAN 60장).
 
 저장 자리(프로젝트 저장소 `B07_DesignDetail/`):
-    plan_kinds/{종류 id}.json     종류 하나 = {name, pieces, order} — M02 양식 층처럼 파일 하나씩
+    plan_kinds/{종류 id}.json     종류 하나 = {name, pieces, order, layout} — 파일 하나씩
     plan_pieces/{장}/{조각}.json  정보 조각 하나 = 그 장 범위의 기하(사업지 좌표 m)
     plan_marks.json               사용자가 정한 대피소 · 사토장 자리
 
-`plan_kinds/` 가 없으면 기본 넷(지형 · 노선배치도 · 대피소 · 라이다)을 쓴다. 처음 고칠 때
-기본 넷을 파일로 내려 두고 그 위에서 추가 · 업데이트 · 지운다 — 기본 넷도 고치고 지울 수 있다.
+`plan_kinds/` 가 없으면 기본 종류(지형 · 노선배치도 · 대피소 · 라이다 · 용지도 · 배수유역도)를
+쓴다. 양식(layout) = plan(1/1,200 장 나눔 · 조각 고름) · watershed(유역도 1/6,000 한 장 · 조각
+없음). 처음 고칠 때 기본 종류를 파일로 내려 두고 그 위에서 추가 · 업데이트 · 지운다 — 기본 종류도
+고치고 지울 수 있다.
 조각은 서버가 도면을 열 때마다 원자료(B05 노선 · 곡선표 · 구조물, B06 횡단 설계, B04 배경)
 에서 다시 계산해 파일로 쓰고, 도면은 그 파일을 읽어 고른 조각만 얹는다.
 """
@@ -24,7 +26,7 @@ from B05_Profile.B05_Profile_Engine_Sections import (
 from B05_Profile.B05_Profile_Structures_Repository import load_structures
 from B06_Section.B06_Section_Engine_Design import compute_cross_design, curve_widening_args
 from B07_DesignDetail.B07_DesignDetail_Engine_Cad import infer_station_interval, station_no_label
-from B07_DesignDetail.B07_DesignDetail_Engine_Cad_IpTable import ip_table_piece
+from B07_DesignDetail.B07_DesignDetail_Engine_Cad_IpTable import clip_lines, ip_table_piece
 from B07_DesignDetail.B07_DesignDetail_Engine_Cad_Plan import (
     _structure_label,
     plan_area_mm,
@@ -47,6 +49,7 @@ from B07_DesignDetail.B07_DesignDetail_Router_Support_Basin import (
     _sheet_box,
     map_background,
     plan_stations,
+    watershed_source,
 )
 from B07_DesignDetail.B07_DesignDetail_Router_Support_Io import (
     _design_root,
@@ -55,7 +58,9 @@ from B07_DesignDetail.B07_DesignDetail_Router_Support_Io import (
     _write_manifest,
 )
 from B07_DesignDetail.B07_DesignDetail_Router_Support_Landuse import (
+    LABEL_CLIPPED,
     LANDUSE_PIECES,
+    label_rects,
     landuse_pieces,
 )
 from common_util.common_util_json import atomic_write_json
@@ -65,6 +70,8 @@ from config.config_system import DRAWING_SCALE_PLAN
 KIND_ID = re.compile(r"^[a-z][a-z0-9]{0,31}$")
 PLAN_KIND_ID = re.compile(r"^plan_([a-z][a-z0-9]{0,31})(?:_(\d+))?$")
 _NAME_MAX = 40
+WATERSHED_LAYOUT = "watershed"
+_LAYOUTS = ("plan", WATERSHED_LAYOUT)
 _REFUGE_TYPES = {"refuge": "대피소", "spoil_bank": "사토장"}
 _REFUGE_OFFSET_M = 8.0  # 대피소 · 사토장 라벨을 중심선에서 띄우는 거리(좌측)
 
@@ -80,16 +87,24 @@ def _kinds_dir(project_root: Path) -> Path:
     return _design_root(project_root) / "plan_kinds"
 
 
-# 이관 표시 — 있으면 용지도 종류를 이미 더해 준 폴더(지운 뒤 되살리지 않음).
-_LANDUSE_MARK = "_landuse_added"
+# 이관 표시 `_{id}_added` — 있으면 그 기본 종류를 이미 더해 준 폴더(지운 뒤 되살리지 않음).
+_ADDED_ONCE = ("landuse", "watershed")
 
 
-def _add_landuse_once(folder: Path) -> None:
-    """93장 앞에 종류 파일을 내린 프로젝트 — 기본 종류 「용지도」를 한 번 더한다."""
-    mark = folder / _LANDUSE_MARK
-    if mark.exists():
+def _document(kind: dict[str, Any], order: int) -> dict[str, Any]:
+    return {
+        "name": kind["name"],
+        "pieces": list(kind["pieces"]),
+        "order": order,
+        "layout": kind.get("layout", "plan"),
+    }
+
+
+def _add_defaults_once(folder: Path) -> None:
+    """기본 종류가 늘기 전에 종류 파일을 내린 프로젝트 — 늘어난 기본 종류를 한 번 더한다."""
+    pending = [kind_id for kind_id in _ADDED_ONCE if not (folder / f"_{kind_id}_added").exists()]
+    if not pending:
         return
-    landuse = next(kind for kind in DEFAULT_KINDS if kind["id"] == "landuse")
     documents = []
     for path in folder.glob("*.json"):
         try:
@@ -97,21 +112,23 @@ def _add_landuse_once(folder: Path) -> None:
         except (OSError, ValueError):
             continue
     names = {str(document.get("name")) for document in documents}
-    if not (folder / "landuse.json").exists() and landuse["name"] not in names:
-        order = max((int(document.get("order") or 0) for document in documents), default=-1) + 1
-        atomic_write_json(
-            folder / "landuse.json",
-            {"name": landuse["name"], "pieces": list(landuse["pieces"]), "order": order},
-        )
-    mark.touch()
+    order = max((int(document.get("order") or 0) for document in documents), default=-1) + 1
+    for kind_id in pending:
+        kind = next(kind for kind in DEFAULT_KINDS if kind["id"] == kind_id)
+        if not (folder / f"{kind_id}.json").exists() and kind["name"] not in names:
+            atomic_write_json(folder / f"{kind_id}.json", _document(kind, order))
+            order += 1
+        (folder / f"_{kind_id}_added").touch()
 
 
 def list_kinds(project_root: Path) -> list[dict[str, Any]]:
-    """종류 목록 [{id, name, pieces}] — 차례대로. 파일이 없으면 기본 종류."""
+    """종류 목록 [{id, name, pieces, layout}] — 차례대로. 파일이 없으면 기본 종류."""
     folder = _kinds_dir(project_root)
     if not folder.is_dir():
-        return [{**kind, "pieces": list(kind["pieces"])} for kind in DEFAULT_KINDS]
-    _add_landuse_once(folder)
+        return [
+            {"layout": "plan", **kind, "pieces": list(kind["pieces"])} for kind in DEFAULT_KINDS
+        ]
+    _add_defaults_once(folder)
     rows: list[tuple[int, str, dict[str, Any]]] = []
     for path in folder.glob("*.json"):
         if not KIND_ID.fullmatch(path.stem):
@@ -123,67 +140,76 @@ def list_kinds(project_root: Path) -> list[dict[str, Any]]:
         stored = set()
         for piece in document.get("pieces") or []:
             stored.update(LEGACY_PIECES.get(piece, (piece,)))
-        pieces = [piece for piece in PIECE_IDS if piece in stored]
+        layout = document.get("layout") if document.get("layout") in _LAYOUTS else "plan"
+        pieces = [] if layout == WATERSHED_LAYOUT else [p for p in PIECE_IDS if p in stored]
         rows.append(
             (
                 int(document.get("order") or 0),
                 path.stem,
-                {"id": path.stem, "name": str(document.get("name") or path.stem), "pieces": pieces},
+                {
+                    "id": path.stem,
+                    "name": str(document.get("name") or path.stem),
+                    "pieces": pieces,
+                    "layout": layout,
+                },
             )
         )
     return [row for _order, _id, row in sorted(rows, key=lambda item: item[:2])]
 
 
 def _materialize(project_root: Path) -> list[dict[str, Any]]:
-    """기본 넷을 파일로 내려 둔다(이미 있으면 그대로) — 고치기 전에 한 번."""
+    """기본 종류를 파일로 내려 둔다(이미 있으면 그대로) — 고치기 전에 한 번."""
     kinds = list_kinds(project_root)
     folder = _kinds_dir(project_root)
     if not folder.is_dir():
         for order, kind in enumerate(kinds):
-            atomic_write_json(
-                folder / f"{kind['id']}.json",
-                {"name": kind["name"], "pieces": kind["pieces"], "order": order},
-            )
-        (folder / _LANDUSE_MARK).touch()
+            atomic_write_json(folder / f"{kind['id']}.json", _document(kind, order))
+        for kind_id in _ADDED_ONCE:
+            (folder / f"_{kind_id}_added").touch()
     return kinds
 
 
-def _checked(name: str, pieces: list[str]) -> tuple[str, list[str]]:
+def _checked(name: str, pieces: list[str], layout: str = "plan") -> tuple[str, list[str]]:
     text = str(name or "").strip()
     if not text or len(text) > _NAME_MAX:
         raise ValueError(f"종류 이름은 1~{_NAME_MAX}자로 적어 주세요.")
+    if layout not in _LAYOUTS:
+        raise ValueError("올바르지 않은 양식입니다.")
+    if layout == WATERSHED_LAYOUT:
+        return text, []  # 유역도 양식은 그림이 정해져 있다 — 조각을 고르지 않음
     chosen = [piece for piece in PIECE_IDS if piece in set(pieces or [])]
     if not chosen:
         raise ValueError("얹을 정보를 하나 이상 고르세요.")
     return text, chosen
 
 
-def add_kind(project_root: Path, name: str, pieces: list[str]) -> dict[str, Any]:
-    text, chosen = _checked(name, pieces)
+def add_kind(
+    project_root: Path, name: str, pieces: list[str], layout: str = "plan"
+) -> dict[str, Any]:
+    text, chosen = _checked(name, pieces, layout)
     kinds = _materialize(project_root)
     if any(kind["name"] == text for kind in kinds):
         raise ValueError(f"같은 이름의 종류가 이미 있습니다: {text}")
-    kind_id = f"k{uuid.uuid4().hex[:8]}"
-    atomic_write_json(
-        _kinds_dir(project_root) / f"{kind_id}.json",
-        {"name": text, "pieces": chosen, "order": len(kinds)},
-    )
-    return {"id": kind_id, "name": text, "pieces": chosen}
+    kind = {"id": f"k{uuid.uuid4().hex[:8]}", "name": text, "pieces": chosen, "layout": layout}
+    atomic_write_json(_kinds_dir(project_root) / f"{kind['id']}.json", _document(kind, len(kinds)))
+    return kind
 
 
 def update_kind(project_root: Path, kind_id: str, name: str, pieces: list[str]) -> dict[str, Any]:
-    """종류 이름 · 조각을 고친다(차례는 그대로). 그 종류의 확정본은 풀어 새 조각으로 다시 그린다."""
+    """종류 이름 · 조각을 고친다(차례 · 양식은 그대로). 그 종류의 확정본은 풀어 다시 그린다."""
     if not KIND_ID.fullmatch(kind_id):
         raise ValueError("올바르지 않은 종류 id 입니다.")
-    text, chosen = _checked(name, pieces)
     kinds = _materialize(project_root)
+    current = next((kind for kind in kinds if kind["id"] == kind_id), None)
+    path = _kinds_dir(project_root) / f"{kind_id}.json"
+    if current is None or not path.is_file():
+        raise FileNotFoundError("고칠 종류를 찾을 수 없습니다.")
+    text, chosen = _checked(name, pieces, current["layout"])
     if any(kind["name"] == text and kind["id"] != kind_id for kind in kinds):
         raise ValueError(f"같은 이름의 종류가 이미 있습니다: {text}")
-    path = _kinds_dir(project_root) / f"{kind_id}.json"
-    if not path.is_file():
-        raise FileNotFoundError("고칠 종류를 찾을 수 없습니다.")
     order = int(_read_json(path).get("order") or 0)
-    atomic_write_json(path, {"name": text, "pieces": chosen, "order": order})
+    kind = {"id": kind_id, "name": text, "pieces": chosen, "layout": current["layout"]}
+    atomic_write_json(path, _document(kind, order))
     manifest = _read_manifest(project_root)
     released = False
     for drawing_id, entry in manifest["drawings"].items():
@@ -193,7 +219,7 @@ def update_kind(project_root: Path, kind_id: str, name: str, pieces: list[str])
             released = True
     if released:
         _write_manifest(project_root, manifest)
-    return {"id": kind_id, "name": text, "pieces": chosen}
+    return kind
 
 
 def delete_kind(project_root: Path, kind_id: str) -> None:
@@ -449,6 +475,8 @@ def build_pieces(
         pieces.update(
             landuse_pieces(project_root, context.crs, box, [(x, y) for _c, x, y in route])
         )
+        if "parcel_info" in wanted:
+            clip_lines(pieces, label_rects(pieces["parcel_info"]["items"]), LABEL_CLIPPED)
     if "ip_table" in wanted:
         pieces["ip_table"] = ip_table_piece(
             pieces, _load_design_curves(project_root), route, box, chunk, total
@@ -477,6 +505,9 @@ def plan_kind_source(
     )
     if kind is None:
         raise FileNotFoundError("계획평면도 종류를 찾을 수 없습니다.")
+    if kind["layout"] == WATERSHED_LAYOUT:
+        # 유역도 양식 — B04 배수유역 산출물 + 도엽 배경(사업지 CRS) 한 장.
+        return {"layout": WATERSHED_LAYOUT, "label": kind["name"], **watershed_source(context)}
     number = int(match.group(2)) if match.group(2) else 1
     pieces, box, chunk, total = build_pieces(
         context, longitudinal, longitudinal_path, designs, number, kind["pieces"]
@@ -494,6 +525,16 @@ def plan_kind_items(project_root: Path, longitudinal: dict[str, Any]) -> list[di
     sheets = plan_chunks(plan_stations(longitudinal))
     items = []
     for kind in list_kinds(project_root):
+        if kind["layout"] == WATERSHED_LAYOUT:  # 1/6,000 한 장 — 장 나눔 없음
+            items.append(
+                {
+                    "id": f"plan_{kind['id']}",
+                    "label": kind["name"],
+                    "plan_kind": kind["id"],
+                    "plan_kind_name": kind["name"],
+                }
+            )
+            continue
         title = plan_title(kind["name"])
         for chunk in sheets:
             single = len(sheets) <= 1

B07_DesignDetail/B07_DesignDetail_UI_Panels.ts

@@ -29,7 +29,7 @@ export const DRAWING_GROUPS: readonly {
   idPrefix?: string;
 }[] = [
   { label: "표지", kind: "cover" },
-  // 종류(지형 · 노선배치도 · 대피소 · 라이다 · 용지도 · 사용자 추가) + 배수유역도를 한 묶음으로.
+  // 종류(지형 · 노선배치도 · 대피소 · 라이다 · 용지도 · 배수유역도 · 사용자 추가)를 한 묶음으로.
   { label: "평면도", kind: "plan" },
   { label: "종단도", kind: "longitudinal" },
   // 표준 횡단면도는 횡단도 묶음 맨 위 한 줄(93-5).
@@ -89,7 +89,7 @@ export function buildDrawingSidePanel(
   for (const group of DRAWING_GROUPS) {
     if (group.kind === "plan") {
       // 종류를 다 지워도 묶음은 남긴다 — 그 안에서 다시 더한다.
-      const plans = drawings.filter((item) => item.kind === "plan" || item.kind === "watershed");
+      const plans = drawings.filter((item) => item.kind === "plan");
       panel.append(buildPlanSection(plans, drawingButton, plan));
       continue;
     }

B07_DesignDetail/B07_DesignDetail_UI_PlanKinds.ts

@@ -4,11 +4,11 @@
  * 사용자 추가)별 도면 단추, 종류 지우기 · 추가 · 업데이트, 대피소 · 사토장 자리 (PLAN 60 · 67장).
  *
  * 종류 = 정보 조각 고르기 목록이다. 고치면 서버 파일이 바뀌고 `onChanged` 로 화면을 다시 세운다.
- * 체크박스는 공용(`ui_template_checkbox`) · 측점 입력은 B05 구조물 폼과 같은 측점 NO + 거리 두 칸.
+ * 드롭다운 · 체크박스는 공용(`createSelectField` · `ui_template_checkbox`) · 측점 입력은 B05 구조물 폼과 같은 측점 NO + 거리 두 칸.
  * ========================================================================== */
 
 import { createCheckbox } from "@ui/ui_template_checkbox";
-import { showToast } from "@ui/ui_template_elements";
+import { createSelectField, showToast } from "@ui/ui_template_elements";
 import { stationFields } from "../B05_Profile/B05_Profile_UI_Structures_Fields";
 import {
   addPlanKind,
@@ -17,6 +17,7 @@ import {
   savePlanMarks,
   updatePlanKind,
   type DesignDrawingItem,
+  type PlanKindLayout,
   type PlanKindsState,
   type PlanMark,
 } from "./B07_DesignDetail_Api_Fetch";
@@ -51,15 +52,31 @@ async function run(action: () => Promise<unknown>, controls: PlanKindsControls):
   }
 }
 
-/** 종류 — 공통 항목. 종류를 고르면 든 조각이 체크로 보이고 [업데이트] · 「새 종류」면 [추가]. */
+/** 양식 — 평면도(조각 고름 · 1/1,200 장 나눔) · 유역도(1/6,000 한 장 · 그림 고정). */
+const LAYOUTS: { value: PlanKindLayout; text: string }[] = [
+  { value: "plan", text: "평면도" },
+  { value: "watershed", text: "유역도" },
+];
+
+/** 종류 — 공통 항목. 종류를 고르면 든 조각이 체크로 보이고 [업데이트] · 「새 종류」면 양식 고르고 [추가]. */
 function kindForm(state: PlanKindsState, controls: PlanKindsControls): HTMLElement {
   const form = el("div", "b07-plan-tools__block");
   form.append(el("strong", "", "종류"));
-  const pick = el("select", "b07-plan-tools__kind");
-  pick.append(
-    ...state.kinds.map((kind) => new Option(kind.name, kind.id)),
-    new Option("새 종류", ""),
-  );
+  const pick = createSelectField({
+    options: [
+      ...state.kinds.map((kind) => ({ value: kind.id, text: kind.name })),
+      { value: "", text: "새 종류" },
+    ],
+    compact: true,
+    ariaLabel: "종류",
+    onChange: () => show(),
+  });
+  const layout = createSelectField({
+    options: LAYOUTS,
+    compact: true,
+    ariaLabel: "양식",
+    onChange: () => showPieces(),
+  });
   const name = el("input", "b07-plan-tools__name");
   name.type = "text";
   name.placeholder = "종류 이름";
@@ -69,27 +86,35 @@ function kindForm(state: PlanKindsState, controls: PlanKindsControls): HTMLEleme
   pieceList.append(...boxes.map((box) => box.root));
   const action = el("button", "b07-plan-tools__button");
   action.type = "button";
+  // 유역도 양식은 그림이 정해져 있어 얹을 정보를 고르지 않는다.
+  const showPieces = (): void => {
+    pieceList.hidden = layout.select.value === "watershed";
+  };
   const show = (): void => {
-    const kind = state.kinds.find((item) => item.id === pick.value);
+    const kind = state.kinds.find((item) => item.id === pick.select.value);
     name.value = kind?.name ?? "";
     boxes.forEach(({ input }) => (input.checked = kind?.pieces.includes(input.value) ?? false));
+    // 양식은 새로 만들 때만 고른다 — 있는 종류는 그 양식을 보이기만.
+    layout.select.value = kind?.layout ?? "plan";
+    layout.select.disabled = Boolean(kind);
     action.textContent = kind ? "업데이트" : "추가";
+    showPieces();
   };
-  pick.addEventListener("change", show);
   show();
   action.addEventListener("click", () => {
     const pieces = boxes.filter((box) => box.input.checked).map((box) => box.input.value);
-    const kindId = pick.value;
+    const kindId = pick.select.value;
     const label = name.value.trim();
+    const chosen = layout.select.value as PlanKindLayout;
     void run(
       () =>
         kindId
           ? updatePlanKind(controls.projectId, kindId, label, pieces)
-          : addPlanKind(controls.projectId, label, pieces),
+          : addPlanKind(controls.projectId, label, pieces, chosen),
       controls,
     );
   });
-  form.append(pick, name, pieceList, action);
+  form.append(pick.root, layout.root, name, pieceList, action);
   return form;
 }
 
@@ -173,8 +198,7 @@ export function buildPlanSection(
       makeButton(drawing, sheets.length > 1 ? `${name} ${index + 1}장` : name),
     );
     head.append(sheets.length > 1 ? el("span", "b07-plan-kind__name", name) : buttons[0]);
-    // × 는 종류만 — 배수유역도는 묶음 안 고정 항목(지우면 서버가 404).
-    if (controls && sheets[0].kind === "plan") {
+    if (controls) {
       const remove = el("button", "b07-plan-tools__remove", "×");
       remove.type = "button";
       remove.title = `「${name}」 종류 지우기`;

B07_DesignDetail/B07_DesignDetail_UI_Style.css

@@ -279,7 +279,10 @@
   grid-template-columns: repeat(auto-fit, minmax(110px, 1fr));
 }
 
-.b07-plan-tools__kind,
+.b07-plan-tools__pieces[hidden] {
+  display: none;
+}
+
 .b07-plan-tools__name {
   min-width: 0;
 }